From fc6a1b2df07e85d9fe92ed72da061853ebac7cc5 Mon Sep 17 00:00:00 2001 From: anilhelvaci Date: Wed, 6 Dec 2023 03:56:29 +0300 Subject: [PATCH 1/4] init work --- .../assets/assets-core-eval.js | 186 ++++ .../assets/bundle-assetsFaucet-json-meta.json | 122 +++ .../assets/bundle-assetsFaucet.json | 1 + .../assets/bundle-crabble-json-meta.json | 814 ++++++++++++++++++ .../assets/bundle-crabble.json | 1 + .../bundle-crabbleGovernor-json-meta.json | 498 +++++++++++ .../assets/bundle-crabbleGovernor.json | 1 + .../64:crabble-start/assets/core-eval.js | 232 +++++ .../64:crabble-start/assets/deployAssets.js | 87 ++ .../assets/proposal-permit.json | 15 + .../assets/upgrade-core-eval.js | 39 + .../64:crabble-start/test-crabble-start.js | 437 ++++++++++ 12 files changed, 2433 insertions(+) create mode 100644 proposals/64:crabble-start/assets/assets-core-eval.js create mode 100644 proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json create mode 100644 proposals/64:crabble-start/assets/bundle-assetsFaucet.json create mode 100644 proposals/64:crabble-start/assets/bundle-crabble-json-meta.json create mode 100644 proposals/64:crabble-start/assets/bundle-crabble.json create mode 100644 proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json create mode 100644 proposals/64:crabble-start/assets/bundle-crabbleGovernor.json create mode 100644 proposals/64:crabble-start/assets/core-eval.js create mode 100644 proposals/64:crabble-start/assets/deployAssets.js create mode 100644 proposals/64:crabble-start/assets/proposal-permit.json create mode 100644 proposals/64:crabble-start/assets/upgrade-core-eval.js create mode 100644 proposals/64:crabble-start/test-crabble-start.js diff --git a/proposals/64:crabble-start/assets/assets-core-eval.js b/proposals/64:crabble-start/assets/assets-core-eval.js new file mode 100644 index 00000000..c8b79d9e --- /dev/null +++ b/proposals/64:crabble-start/assets/assets-core-eval.js @@ -0,0 +1,186 @@ +/* eslint-disable no-undef */ +const startAssetsFaucet = async ({ + consume: { zoe, agoricNamesAdmin, contractKits, board, chainStorage }, +}) => { + const boardAux = E(chainStorage).makeChildNode('boardAux'); + + const logger = (log) => { + console.log('[ASSET_CRABBLE_CORE_EVAL]', log); + }; + + const publishBrandInfo = async (brand, marshaller) => { + const [id, displayInfo, allegedName] = await Promise.all([ + E(board).getId(brand), + E(brand).getDisplayInfo(), + E(brand).getAllegedName(), + ]); + const node = E(boardAux).makeChildNode(id); + const aux = await E(marshaller).toCapData( + harden({ allegedName, displayInfo }), + ); + await E(node).setValue(JSON.stringify(aux)); + }; + + const assetsFaucetBundleID = 'ddc23eddf3926ed5b0a6f861c794ffd8fb80ca49f1c9dbf0656b5642060e0c6567ef2d131968b29792a7651fe68eec07ac2ed519650f888a587bc95f72674628'; + + const crabbleIstTerms = { + keyword: 'CrabbleIST', + assetKind: 'nat', + displayInfo: { decimalPlaces: 6 }, + }; + + const chainboardCollectionTerms = { + keyword: 'ChainboardCollection', + assetKind: 'set', + }; + + const crabbleCollectionTerms = { + keyword: 'CrabbleCollection', + assetKind: 'set', + }; + + logger('Get faucet contract installation'); + const assetsFaucetInstallation = await E(zoe).installBundleID( + `b1-${assetsFaucetBundleID}`, + ); + + logger({ + assetsFaucetInstallation, + }); + + logger('Get agoricNamesAdmin'); + const issuerAdminP = E(agoricNamesAdmin).lookupAdmin('issuer'); + const brandAdminP = E(agoricNamesAdmin).lookupAdmin('brand'); + const instanceAdminP = E(agoricNamesAdmin).lookupAdmin('instance'); + + logger('Starting Faucet contracts'); + const { + creatorFacet: crabbleIstCreatorFacet, + publicFacet: crabbleIstPublicFacet, + instance: crabbleIstInstance, + } = await E(zoe).startInstance( + assetsFaucetInstallation, + {}, + crabbleIstTerms, + {}, + 'CrabbleISTFaucet', + ); + + const { + creatorFacet: chainboardCollectionCreatorFacet, + publicFacet: chainboardCollectionPublicFacet, + instance: chainboardCollectionInstance, + } = await E(zoe).startInstance( + assetsFaucetInstallation, + {}, + chainboardCollectionTerms, + {}, + 'ChainboardCollectionFaucet', + ); + + const { + creatorFacet: crabbleCollectionCreatorFacet, + publicFacet: crabbleCollectionPublicFacet, + instance: crabbleCollectionInstance, + } = await E(zoe).startInstance( + assetsFaucetInstallation, + {}, + crabbleCollectionTerms, + {}, + 'CrabbleCollectionFaucet', + ); + + logger({ + crabbleIstCreatorFacet, + crabbleIstPublicFacet, + crabbleIstInstance, + chainboardCollectionCreatorFacet, + chainboardCollectionPublicFacet, + chainboardCollectionInstance, + crabbleCollectionCreatorFacet, + crabbleCollectionPublicFacet, + crabbleCollectionInstance, + }); + + logger('Updating agoricNames with assets issuers and brands'); + const crabbleIstIssuerP = E(crabbleIstPublicFacet).getIssuer(); + const chainboardCollectionIssuerP = E( + chainboardCollectionPublicFacet, + ).getIssuer(); + const crabbleCollectionIssuerP = E(crabbleCollectionPublicFacet).getIssuer(); + + const [ + crabbleIstIssuer, + crabbleIstBrand, + chainboardCollectionIssuer, + chainboardCollectionBrand, + crabbleCollectionIssuer, + crabbleCollectionBrand, + ] = await Promise.all([ + crabbleIstIssuerP, + E(crabbleIstIssuerP).getBrand(), + chainboardCollectionIssuerP, + E(chainboardCollectionIssuerP).getBrand(), + crabbleCollectionIssuerP, + E(crabbleCollectionIssuerP).getBrand(), + ]); + await Promise.all([ + E(issuerAdminP).update('CrabbleIST', crabbleIstIssuer), + E(brandAdminP).update('CrabbleIST', crabbleIstBrand), + E(issuerAdminP).update('ChainboardCollection', chainboardCollectionIssuer), + E(brandAdminP).update('ChainboardCollection', chainboardCollectionBrand), + E(issuerAdminP).update('CrabbleCollection', crabbleCollectionIssuer), + E(brandAdminP).update('CrabbleCollection', crabbleCollectionBrand), + ]); + + logger('Updating agoricNames with contract instances'); + await Promise.all([ + E(instanceAdminP).update('CrabbleISTFaucet', crabbleIstInstance), + E(instanceAdminP).update( + 'ChainboardCollectionFaucet', + chainboardCollectionInstance, + ), + E(instanceAdminP).update( + 'CrabbleCollectionFaucet', + crabbleCollectionInstance, + ), + ]); + + logger('Publishing brand info to boardAux...'); + const marshaller = await E(board).getPublishingMarshaller(); + await Promise.all([ + publishBrandInfo(crabbleIstBrand, marshaller), + publishBrandInfo(chainboardCollectionBrand, marshaller), + publishBrandInfo(crabbleCollectionBrand, marshaller), + ]); + + logger('Record faucet contracts kits on contractKits'); + const crabbleIstKit = { + crabbleIstCreatorFacet, + crabbleIstPublicFacet, + crabbleIstInstance, + }; + + const chainboardCollectionKit = { + chainboardCollectionCreatorFacet, + chainboardCollectionPublicFacet, + chainboardCollectionInstance, + }; + + const crabbleCollectionKit = { + crabbleCollectionCreatorFacet, + crabbleCollectionPublicFacet, + crabbleCollectionInstance, + }; + + await Promise.all([ + E(contractKits).init(crabbleIstInstance, crabbleIstKit), + E(contractKits).init(chainboardCollectionInstance, chainboardCollectionKit), + E(contractKits).init(crabbleCollectionInstance, crabbleCollectionKit), + ]); + + logger('Completed'); +}; + +harden(startAssetsFaucet); +startAssetsFaucet; diff --git a/proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json b/proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json new file mode 100644 index 00000000..1e56b02d --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json @@ -0,0 +1,122 @@ +{ + "bundleFileName": "bundle-assetsFaucet.json", + "bundleTime": "2023-12-04T09:21:55.049Z", + "moduleSource": { + "relative": "../../assetsFaucet/src/assetsFaucet.js", + "absolute": "/Users/anil/WebstormProjects/agoric-samples/crabbleProtocol/source_code/assetsFaucet/src/assetsFaucet.js" + }, + "contents": [ + { + "relativePath": "", + "mtime": "2023-12-04T07:39:35.034Z" + }, + { + "relativePath": "../../../node_modules/@endo/far/src/index.js", + "mtime": "2023-11-07T14:22:41.230Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/no-shim.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/index.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/E.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/exports.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/error.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/iter-helpers.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/make-far.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/makeTagged.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/passStyle-helpers.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/passStyleOf.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/remotable.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/symbol.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/typeGuards.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/types.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/track-turns.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/copyArray.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/copyRecord.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/safe-promise.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/tagged.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/index.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/env-options/index.js", + "mtime": "2023-11-07T14:22:43.206Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/is-promise.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/memo-race.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/promise-executor-kit.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/types.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/env-options/src/env-options.js", + "mtime": "2023-11-07T14:22:43.206Z" + } + ] +} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-assetsFaucet.json b/proposals/64:crabble-start/assets/bundle-assetsFaucet.json new file mode 100644 index 00000000..db099ea3 --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-assetsFaucet.json @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"ddc23eddf3926ed5b0a6f861c794ffd8fb80ca49f1c9dbf0656b5642060e0c6567ef2d131968b29792a7651fe68eec07ac2ed519650f888a587bc95f72674628"} diff --git a/proposals/64:crabble-start/assets/bundle-crabble-json-meta.json b/proposals/64:crabble-start/assets/bundle-crabble-json-meta.json new file mode 100644 index 00000000..5eae2451 --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-crabble-json-meta.json @@ -0,0 +1,814 @@ +{ + "bundleFileName": "bundle-crabble.json", + "bundleTime": "2023-12-04T09:21:52.263Z", + "moduleSource": { + "relative": "../../contract/src/crabble.js", + "absolute": "/Users/anil/WebstormProjects/agoric-samples/crabbleProtocol/source_code/contract/src/crabble.js" + }, + "contents": [ + { + "relativePath": "", + "mtime": "2023-12-04T07:53:53.636Z" + }, + { + "relativePath": "../assertionHelpers.js", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../catalog.js", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../rental.js", + "mtime": "2023-12-04T07:39:35.036Z" + }, + { + "relativePath": "../utils.js", + "mtime": "2023-12-04T07:39:35.036Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/index.js", + "mtime": "2023-09-29T12:47:53.776Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/index.js", + "mtime": "2023-09-29T12:48:23.825Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/index.js", + "mtime": "2023-09-29T12:48:23.873Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/index.js", + "mtime": "2023-09-29T12:47:53.967Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/recorder.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../../../node_modules/@endo/far/src/index.js", + "mtime": "2023-11-07T14:22:41.230Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/safeMath.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../bidsManager.js", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../bidKit.js", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../constants.js", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../leaseKit.js", + "mtime": "2023-12-04T07:39:35.036Z" + }, + { + "relativePath": "../rentalKit.js", + "mtime": "2023-12-04T07:39:35.036Z" + }, + { + "relativePath": "../typeGuards.js", + "mtime": "2023-12-04T07:39:35.036Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/time/index.js", + "mtime": "2023-09-29T12:47:53.942Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/exported.js", + "mtime": "2023-09-29T12:48:23.893Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/atomicTransfer.js", + "mtime": "2023-09-29T12:48:23.894Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/topics.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/makeHandle.js", + "mtime": "2023-09-29T12:47:53.972Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/exo-utils.js", + "mtime": "2023-09-29T12:48:23.872Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/vat-data-bindings.js", + "mtime": "2023-09-29T12:48:23.873Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/index.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/constants.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governParam.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/paramManager.js", + "mtime": "2023-09-29T12:48:23.824Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/typedParamManager.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernor.js", + "mtime": "2023-09-29T12:48:23.824Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractHelper.js", + "mtime": "2023-09-29T12:48:23.824Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/question.js", + "mtime": "2023-09-29T12:47:53.875Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/types-ambient.js", + "mtime": "2023-09-29T12:48:23.825Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/validators.js", + "mtime": "2023-09-29T12:48:23.825Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/exported.js", + "mtime": "2023-09-29T12:47:53.775Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/SwingSet/src/vats/network/types.js", + "mtime": "2023-09-29T12:48:23.791Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/amountMath.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/issuerKit.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.781Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/bondingCurves.js", + "mtime": "2023-09-29T12:48:23.894Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/durability.js", + "mtime": "2023-09-29T12:48:23.894Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/priceAuthority.js", + "mtime": "2023-09-29T12:48:23.894Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/priceQuote.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/ratio.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/stateMachine.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/statistics.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/zoeHelpers.js", + "mtime": "2023-09-29T12:48:23.895Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/no-shim.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/index.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/assert/src/assert.js", + "mtime": "2023-09-29T12:47:53.836Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/index.js", + "mtime": "2023-09-29T12:47:53.895Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/index.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/tools/testSupports.js", + "mtime": "2023-09-29T12:47:53.902Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/no-shim.js", + "mtime": "2023-09-29T07:30:46.568Z" + }, + { + "relativePath": "../leaseHolder.js", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../bidHolder.js", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/nat/src/index.js", + "mtime": "2023-09-29T07:30:52.810Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.897Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/far/src/index.js", + "mtime": "2023-09-29T07:30:45.835Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractFacet/types.js", + "mtime": "2023-09-29T12:48:23.893Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/types.js", + "mtime": "2023-09-29T12:47:53.968Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/exported.js", + "mtime": "2023-09-29T12:47:53.970Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/types.js", + "mtime": "2023-09-29T12:47:53.972Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/zoeService/types.js", + "mtime": "2023-09-29T12:47:53.973Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/tools/types-ambient.js", + "mtime": "2023-09-29T12:47:53.986Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/exported.js", + "mtime": "2023-09-29T12:47:53.899Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/exported.js", + "mtime": "2023-09-29T12:47:53.911Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/SwingSet/exported.js", + "mtime": "2023-09-29T12:47:53.792Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractFacet/rightsConservation.js", + "mtime": "2023-09-29T12:47:53.966Z" + }, + { + "relativePath": "../rentalHolder.js", + "mtime": "2023-12-04T07:39:35.036Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/time/src/timeMath.js", + "mtime": "2023-09-29T12:48:23.869Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/time/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.869Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyMap.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyWeakMap.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarMapStore.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarSetStore.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakMapStore.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakSetStore.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/store-utils.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/index.js", + "mtime": "2023-09-29T07:31:07.143Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/index.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/assertions.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/cleanProposal.js", + "mtime": "2023-09-29T12:48:23.893Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/index.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/typeGuards.js", + "mtime": "2023-09-29T12:47:53.875Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernorKit.js", + "mtime": "2023-09-29T12:48:23.824Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/displayInfo.js", + "mtime": "2023-09-29T12:47:53.775Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/paymentLedger.js", + "mtime": "2023-09-29T12:48:23.781Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/types-ambient.js", + "mtime": "2023-09-29T12:48:23.781Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copyBagMathHelpers.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copySetMathHelpers.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/natMathHelpers.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/setMathHelpers.js", + "mtime": "2023-09-29T12:47:53.776Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/index.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractFacet/offerSafety.js", + "mtime": "2023-09-29T12:47:53.966Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/E.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/exports.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/config.js", + "mtime": "2023-09-29T12:47:53.895Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/debug.js", + "mtime": "2023-09-29T12:47:53.895Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/method-tools.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/utils.js", + "mtime": "2023-09-29T12:47:53.897Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/error.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/iter-helpers.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/make-far.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/makeTagged.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/passStyle-helpers.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/passStyleOf.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/remotable.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/symbol.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/typeGuards.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/types.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/E.js", + "mtime": "2023-09-29T07:30:46.568Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/assert/src/types.js", + "mtime": "2023-09-29T12:47:53.836Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/asyncIterableAdaptor.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/notifier.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/publish-kit.js", + "mtime": "2023-09-29T12:48:23.846Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/stored-notifier.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/storesub.js", + "mtime": "2023-09-29T12:48:23.846Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscribe.js", + "mtime": "2023-09-29T12:48:23.846Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscriber.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/types-ambient.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/testing-utils.js", + "mtime": "2023-09-29T12:47:53.896Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/index.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/callSpread/types.js", + "mtime": "2023-09-29T12:47:53.970Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/loan/types.js", + "mtime": "2023-09-29T12:48:23.896Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/types.js", + "mtime": "2023-09-29T12:47:53.971Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/types.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/internal-types.js", + "mtime": "2023-09-29T12:48:23.897Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-makers.js", + "mtime": "2023-09-29T07:31:07.143Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/checkKey.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/compareKeys.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copyBag.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copySet.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-bag-operators.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-set-operators.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/patterns/patternMatchers.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/types.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/utils.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/objArrayConversion.js", + "mtime": "2023-09-29T12:47:53.972Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/deeplyFulfilled.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodePassable.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToCapData.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-justin.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-stringify.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/rankOrder.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/types.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governFilter.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governApi.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/payment.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/purse.js", + "mtime": "2023-09-29T12:47:53.776Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/is-promise.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/promise-executor-kit.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/memo-race.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/types.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../node_modules/@endo/eventual-send/src/track-turns.js", + "mtime": "2023-11-07T14:22:39.358Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/stream/index.js", + "mtime": "2023-09-29T07:30:53.746Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/main.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/copyArray.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/copyRecord.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/safe-promise.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/pass-style/src/tagged.js", + "mtime": "2023-11-07T14:22:43.840Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/index.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/track-turns.js", + "mtime": "2023-09-29T07:30:46.568Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/lib-chainStorage.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/upgrade-api.js", + "mtime": "2023-09-29T12:47:53.897Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/topic.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/error.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/iter-helpers.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/make-far.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/makeTagged.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyle-helpers.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyleOf.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/remotable.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/symbol.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/typeGuards.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/types.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-tools.js", + "mtime": "2023-09-29T07:31:07.143Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToSmallcaps.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/main.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/main.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/transientNotifier.js", + "mtime": "2023-09-29T12:47:53.776Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/callback.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zone/src/index.js", + "mtime": "2023-09-29T12:48:23.911Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/is-promise.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/memo-race.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/promise-executor-kit.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/promise-kit/src/types.js", + "mtime": "2023-11-07T14:22:40.138Z" + }, + { + "relativePath": "../../../node_modules/@endo/env-options/index.js", + "mtime": "2023-11-07T14:22:43.206Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyArray.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyRecord.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/safe-promise.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/tagged.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/E.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/async-generate.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/makers.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/async-tools.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zone/src/heap.js", + "mtime": "2023-09-29T12:48:23.911Z" + }, + { + "relativePath": "../../../node_modules/@endo/env-options/src/env-options.js", + "mtime": "2023-11-07T14:22:43.206Z" + } + ] +} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-crabble.json b/proposals/64:crabble-start/assets/bundle-crabble.json new file mode 100644 index 00000000..4d2fec6f --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-crabble.json @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"9ef6df6021cabaece3a53065bbc4e1f68f0e109498861b814e26077422c89a5c1f7a6717875f7c9b35197cb36ba87dd424d927ef9230c9227bb7fdf4dcd0cdf0"} diff --git a/proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json b/proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json new file mode 100644 index 00000000..b68e5ce2 --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json @@ -0,0 +1,498 @@ +{ + "bundleFileName": "bundle-crabbleGovernor.json", + "bundleTime": "2023-12-04T09:21:53.975Z", + "moduleSource": { + "relative": "../../contract/src/crabbleGovernor.js", + "absolute": "/Users/anil/WebstormProjects/agoric-samples/crabbleProtocol/source_code/contract/src/crabbleGovernor.js" + }, + "contents": [ + { + "relativePath": "", + "mtime": "2023-12-04T07:39:35.035Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governParam.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernorKit.js", + "mtime": "2023-09-29T12:48:23.824Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/index.js", + "mtime": "2023-09-29T12:47:53.895Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/time/index.js", + "mtime": "2023-09-29T12:47:53.942Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/index.js", + "mtime": "2023-09-29T12:48:23.873Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/durability.js", + "mtime": "2023-09-29T12:48:23.894Z" + }, + { + "relativePath": "../../node_modules/@endo/eventual-send/src/no-shim.js", + "mtime": "2023-11-07T14:22:46.391Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/question.js", + "mtime": "2023-09-29T12:47:53.875Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/typeGuards.js", + "mtime": "2023-09-29T12:47:53.875Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/index.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/no-shim.js", + "mtime": "2023-09-29T07:30:46.568Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/index.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/time/src/timeMath.js", + "mtime": "2023-09-29T12:48:23.869Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/time/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.869Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/config.js", + "mtime": "2023-09-29T12:47:53.895Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/debug.js", + "mtime": "2023-09-29T12:47:53.895Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/method-tools.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/utils.js", + "mtime": "2023-09-29T12:47:53.897Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governApi.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governFilter.js", + "mtime": "2023-09-29T12:47:53.874Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/assert/src/assert.js", + "mtime": "2023-09-29T12:47:53.836Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/exo-utils.js", + "mtime": "2023-09-29T12:48:23.872Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/vat-data-bindings.js", + "mtime": "2023-09-29T12:48:23.873Z" + }, + { + "relativePath": "../../node_modules/@endo/eventual-send/src/E.js", + "mtime": "2023-11-07T14:22:46.391Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/makeHandle.js", + "mtime": "2023-09-29T12:47:53.972Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyMap.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyWeakMap.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarMapStore.js", + "mtime": "2023-09-29T12:48:23.855Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarSetStore.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakMapStore.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakSetStore.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/store-utils.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/index.js", + "mtime": "2023-09-29T07:31:07.143Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/index.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/index.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.897Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/nat/src/index.js", + "mtime": "2023-09-29T07:30:52.810Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/deeplyFulfilled.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodePassable.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToCapData.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-justin.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-stringify.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/rankOrder.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/types.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/index.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/E.js", + "mtime": "2023-09-29T07:30:46.568Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/far/src/index.js", + "mtime": "2023-09-29T07:30:45.835Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/index.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/stream/index.js", + "mtime": "2023-09-29T07:30:53.746Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/main.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/assert/src/types.js", + "mtime": "2023-09-29T12:47:53.836Z" + }, + { + "relativePath": "../../node_modules/@endo/eventual-send/src/track-turns.js", + "mtime": "2023-11-07T14:22:46.391Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/src/types.js", + "mtime": "2023-09-29T12:48:23.856Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-makers.js", + "mtime": "2023-09-29T07:31:07.143Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/index.js", + "mtime": "2023-09-29T12:47:53.776Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/asyncIterableAdaptor.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/notifier.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/publish-kit.js", + "mtime": "2023-09-29T12:48:23.846Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/stored-notifier.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/storesub.js", + "mtime": "2023-09-29T12:48:23.846Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscribe.js", + "mtime": "2023-09-29T12:48:23.846Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscriber.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/checkKey.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/compareKeys.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copyBag.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copySet.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-bag-operators.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-set-operators.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/patterns/patternMatchers.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/types.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/utils.js", + "mtime": "2023-09-29T07:30:53.579Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToSmallcaps.js", + "mtime": "2023-09-29T07:30:46.169Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/iter-helpers.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/error.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/make-far.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/makeTagged.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyle-helpers.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyleOf.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/remotable.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/symbol.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/typeGuards.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/types.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/track-turns.js", + "mtime": "2023-09-29T07:30:46.568Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/is-promise.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/memo-race.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/promise-executor-kit.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/types.js", + "mtime": "2023-09-29T07:30:49.638Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/main.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/main.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-tools.js", + "mtime": "2023-09-29T07:31:07.143Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/types-ambient.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/amountMath.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/issuerKit.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/typeGuards.js", + "mtime": "2023-09-29T12:48:23.781Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/lib-chainStorage.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/topic.js", + "mtime": "2023-09-29T12:47:53.900Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/upgrade-api.js", + "mtime": "2023-09-29T12:47:53.897Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyArray.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyRecord.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/safe-promise.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/tagged.js", + "mtime": "2023-09-29T07:30:52.015Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/E.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/async-generate.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/makers.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/async-tools.js", + "mtime": "2023-09-29T11:16:36.561Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copyBagMathHelpers.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copySetMathHelpers.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/natMathHelpers.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/setMathHelpers.js", + "mtime": "2023-09-29T12:47:53.776Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/displayInfo.js", + "mtime": "2023-09-29T12:47:53.775Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/paymentLedger.js", + "mtime": "2023-09-29T12:48:23.781Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/types-ambient.js", + "mtime": "2023-09-29T12:48:23.781Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/internal/src/callback.js", + "mtime": "2023-09-29T12:48:23.844Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zone/src/index.js", + "mtime": "2023-09-29T12:48:23.911Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/payment.js", + "mtime": "2023-09-29T12:48:23.780Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/purse.js", + "mtime": "2023-09-29T12:47:53.776Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/store/exported.js", + "mtime": "2023-09-29T12:47:53.911Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/zone/src/heap.js", + "mtime": "2023-09-29T12:48:23.911Z" + }, + { + "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/transientNotifier.js", + "mtime": "2023-09-29T12:47:53.776Z" + } + ] +} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-crabbleGovernor.json b/proposals/64:crabble-start/assets/bundle-crabbleGovernor.json new file mode 100644 index 00000000..ede76b87 --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-crabbleGovernor.json @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"UEsDBAoAAAAAAAAAAACUChBb/gsBAP4LAQAUAAAAY29tcGFydG1lbnQtbWFwLmpzb257CiAgImVudHJ5IjogewogICAgImNvbXBhcnRtZW50IjogImNyYWJibGUtY29udHJhY3QtdjAuMS4wIiwKICAgICJtb2R1bGUiOiAiLi9zcmMvY3JhYmJsZUdvdmVybm9yLmpzIgogIH0sCiAgImNvbXBhcnRtZW50cyI6IHsKICAgICJAYWdvcmljL2Fzc2VydC12MC42LjAiOiB7CiAgICAgICJuYW1lIjogIkBhZ29yaWMvYXNzZXJ0IiwKICAgICAgImxhYmVsIjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL2Fzc2VydC12MC42LjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGFnb3JpYy9hc3NlcnQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9hc3NlcnQtdjAuNi4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvYXNzZXJ0LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Fzc2VydC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvYXNzZXJ0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYWE2NDc1OTNlOWZjZGM3NTEwOTIxMGUyNjZiOGU3YTljMGU5OWQwMTM2ZjczYjk5MmExNWM0NmE5ZTg3ZDAxYzljZDZmMGEyZjhhZTVhODBjNGJiYjVlYjBjYWYzNWY0MmMwNDI4ZTljY2YyMjk4NTNkMzVjMGU5NGUyYjMyMzciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOTEyMWQxNWRjYjEwZjg1Zjc3YjQwZDQ4ZWU4N2Q1ZDVkNzZmOWQ0OTAyZTBlOGM3ZDg4YzMxN2MwYjJmZTNhMmIwZGVlZmZhNzg3NjI5NDExOGZkZjY1MWFlNGZhYzg3MzkxNzU2OTE3MjdkYzc0OTIzNGMxNDQ1Mjg1YTg0NWEiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL2VydHAiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAibG9jYXRpb24iOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGFnb3JpYy9hc3NlcnQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9hc3NlcnQtdjAuNi4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvYXNzZXJ0LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvZXJ0cCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL3N1YnNjcmliZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3Vic2NyaWJlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvdG9vbHMvdGVzdFN1cHBvcnRzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi90b29scy90ZXN0U3VwcG9ydHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zdG9yZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3RvcmUvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3dpbmdzZXQtdmF0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3dpbmdzZXQtdmF0LXYwLjMyLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MC44LjUiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3NoaW0uanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9hbW91bnRNYXRoLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9hbW91bnRNYXRoLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMDI1ZGE2MDA5NWJjYWIyYThmNmYzNWU0NGU4Y2EzZjJmMWRlM2JkZGJkNDJhYmEwZDgyZjU4ODAwNDYzOGRmYWE2YjI0MTc5NWY1OWYwY2Y2MTQ5ZGMyMmFmYzhiMmNlNTdmNTY2MDI4MDc2NjdiNDg3OWMyYzdhNGY1NWI2MmEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZGlzcGxheUluZm8uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2Rpc3BsYXlJbmZvLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODdmZDM2YTY0MjkxZGJjM2IyYmQ5NDkzMzBkODM5Nzk2MzRjNjE1YzhiOTBkZWE0ZWQ2M2ZjNGVmYjc2ZjI2MjhiN2U3Mjc3OGFhM2U3NDcxNDU0MTg5YTgzMzViZTJmYjJmMjRkMTk4MWQ1NDA3YzFjNTI4ZWFiYzZhYmYwMmQiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMzNhODE0Mzc4ZjQxZTFiOGU2YmM1NjdkM2JmZDRiNGE3OGU4N2U0N2JhN2Y1MTllOTU4MDIxZWE3ZjBhMTJhZTlhYzlmNzY2YjQ3MDUyOGQ0OTg4YTc2ODgxOGYwYmFiMWExNGFjMDE1MTkwZDU0MzFjOGU1NWMxZjMzYzVjY2YiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaXNzdWVyS2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pc3N1ZXJLaXQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIzZTg5MmJmMmE1MzhmMmQ1ZmI1ZDJmMGEyYTY2OWY5NGZhZjE2ZmVlNjdiNGRkMGFlMWMyMjNjOWZjNzZlOWJmMTZmZTc3Njk4NzZlZDYyOWJkMWVhYmQ0ZGQyMmJiZDdhN2M4ZjQ4NTVjNzcyMmEzZDU0ZjlmNzMxODc2ZGJmYiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXRoSGVscGVycy9jb3B5QmFnTWF0aEhlbHBlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21hdGhIZWxwZXJzL2NvcHlCYWdNYXRoSGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImU4YmU4ZGMzNjE0ZGJlMzU3YTM4YWVmM2U4NzVhMWNmNDczMTQ4ZTQ5YjM3MThmODBkODY3NWNmM2Y3YWY3ZDA3MjM5YTFhNzA4NGRlNmE3ZDY2NDEyM2M2MWI5NjI1ODk2ZDMzNzkxNDE0YWI0ZDA1MGI2ZDc2ZTBlODFiMzc3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21hdGhIZWxwZXJzL2NvcHlTZXRNYXRoSGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWF0aEhlbHBlcnMvY29weVNldE1hdGhIZWxwZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYTExMzYxYzg4M2NkYjgwMmM5ZTE5NGJjYWExNWI1NWVjYjk0N2Y0NWFkMjI0MDRmM2M5OWNjY2M0NmZkYzAwNmRiOGI2ZDE2ZjlmODkzZGJmZmEzYTIzOGRkMDhjMDkyYjk5Yjg4ZDAzMzVkZWI1ZDFhNDRlN2Q3ZDUyNGQ5NmUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWF0aEhlbHBlcnMvbmF0TWF0aEhlbHBlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21hdGhIZWxwZXJzL25hdE1hdGhIZWxwZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZTkyZTYwNzEzZTg1NWQ2MDQ0MWY4YTQ4N2ExNTg5ZjdjZTk5NWI3OTJkOWI5NzQ3MWUwYzE5ZjRlNjJmYTY1MjIyOTk0ZDBjMTkyYTk4Zjk4MmQ0NDBkMDY5MzMzODJmYzRjNDdhNjE0ZGQ1M2M3MjU0YTRhNjE3ZDg2OWJmMzMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWF0aEhlbHBlcnMvc2V0TWF0aEhlbHBlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21hdGhIZWxwZXJzL3NldE1hdGhIZWxwZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjY0OGJkNDZkZjk5Y2Q4MGEwZjAxMjFmZGQ0OGJiODdlZDk2MjY5MzYwOGZiMWEzYTRhNmMwOTRiNTcyOWEwZDk2ZjQwZjBmMjFiZDc0NjE2ZTkyYTQxZmM3Y2M1ZTExNWUyNzFkYjFkZjc3YTY0YjRjYTI1MWIyNDliNWQxZGIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcGF5bWVudC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGF5bWVudC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjZmZDdmOTliOGJlY2E2OTMyZjdjMzdiNmE1NDI4ZjE1N2QxNGIzNjczZjViMTg5NTNjZGIzODU3OWE4Y2Q0NjExOTk3NTk3ZGIyMzNhM2MwZGE0YjAyYWUyYWEwMmI0N2JlOTMzN2QzZjNiYzkyMjg0YWE2ZGVlOGY2MTY5NWI3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3BheW1lbnRMZWRnZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3BheW1lbnRMZWRnZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJiOTJjNGI1MzY2OTA5YWUxYTJlZjI5ODFiNmZiMDM5Mjc3MjBkYmJkMWEzMmUxMDM3YTBiY2ZlYTQ5YjMwOTI4NTExMWYxMGRiMTIwMWIwOGZkM2FiNzVmOTAzNGQ4OTljOGZhY2FkYzA3ZjBmNWE0NzY2ZGJlMTM4MTQwZmJhMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wdXJzZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcHVyc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjZDdkZGE2YTg0MTgwYzY4ZTZkMDk3MmE2OGRjOGRlYmI1MTViOTJjZTgwYzIxODgxNmU1MzFmMjRkYTY0OGY1NTVmNmY2YzJkYmI4MjAwZTk0MzU5YWQ2MWMwNDYwMjY5YTRkNGMwNjVhOTA1ZGE5NGUwNTdkM2FmNTYyNWUyMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90cmFuc2llbnROb3RpZmllci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHJhbnNpZW50Tm90aWZpZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhMTFiMmE2ZjI5YWQ0OTZiYmFkMGM1OTg4MmRkYzQ5MGYzZWJlYzk2MDZiNTFlMGI3MGJlNTU4NTExMmQzMmU0OWVkYWI4ZWM3YWE1N2ZmMmJkN2U0NjNmNTg3ZmU2NGMwNmFjOGQ1Yzg2MTAyMWRiNzVkYzAzOGMzZTQ0ZTU1OSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlR3VhcmRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlR3VhcmRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZThlNmIyMDVjOTkwZDI3MDNlNmExODRjMWEzZGYwMWU4ZjRlZWE5OTI3YmViMTIwMjFhYjZkMGUxODM1MDg3NTU5NmY1ODI4YjQwZTM3NGI1MWY1Y2Y3ZWU2MjU5MWRiZDI1YzFiNDY5YjdkNThjOTExNTg4OGEzZWE1Y2Q0MDIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZXMtYW1iaWVudC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMtYW1iaWVudC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjkwMjFmNTRiOWFmYzAyNWNhMGU5MGQyZGMyZTBiZWQyZmIwOGIwNjNjNmQ2OGE0NGIxZWMyZWI3ODM5MDc2OTZjMmU0YjNjZDgwNTYwNTFkYzEzMThkNmI0NWFjNTczMTJhZjdmM2Y5ZDg0NDJiMmJlZjQwMjc2YWNmNjI0NGMxIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMCI6IHsKICAgICAgIm5hbWUiOiAiQGFnb3JpYy9nb3Zlcm5hbmNlIiwKICAgICAgImxhYmVsIjogIkBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2VydHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2dvdmVybmFuY2UiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2ludGVybmFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvc3Vic2NyaWJlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zdWJzY3JpYmUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci90b29scy90ZXN0U3VwcG9ydHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZ3NldC12YXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zd2luZ3NldC12YXQtdjAuMzIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdGltZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy92YXRzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0cy12MC4xNS4yLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvem9lU2VydmljZS96b2UuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b2Uvc3JjL21ha2VIYW5kbGUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL21ha2VIYW5kbGUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b2Uvc3JjL3R5cGVHdWFyZHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL3R5cGVHdWFyZHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vY2FwdHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vY2FwdHAtdjMuMS4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MC44LjUiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3NoaW0uanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuQXBpLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuQXBpLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDdmOWViZjA0ZjMxNGRiYmE0N2RmYWVjNzYzOGQ2ZGQwMzc4M2Q3YWRjMTJjMzMyYTE3ZmQ1ZmI0YmRkN2I4NGZjN2Y0ODQyOTI3OTJiMDM2OTE1NGE2MmViZTgyOGY1OGVlN2IzMjk1YmYwMjMyMzIyOTk0MmVjNDM5NGJhMGQiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkZpbHRlci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkZpbHRlci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImFjZjk0YWMwNTcxMTZlNjkyYzYxNTljYjhlZDQyYmI5ZTlhODA1OGE0YzhmYTVhYWE2MDcyMmI1ZWUzMzcwYjY5ZTYzNjliNWJhNjNlNWU3MzcyM2NhMWZlOTQ3OTgxZTY0Nzk0ZjA0NGM4OWM2MWQ5MjFkODRjZmU4OGVlYjlhIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVyblBhcmFtLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiY2Y4MTIwZmJkMzQxNTA2YWVkMTlmN2FjMjdlODdlOTM5NGE5NTRiMWU1MjIyY2UwZGU2MzkyMTA4ZGJkNTAwYWVlYWQxNWMxYTMyMzEyMzNmNjUzMmUxNDQwZDQxZmMzYTM2M2Y0MDg5OTE1YWU0MTUxNTg0OTFhODg1MjJiNmIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RHb3Zlcm5vcktpdC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RHb3Zlcm5vcktpdC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjhkYzViODA2NmIxY2NiNGQ2MzBmMTk3OWNhMjBiOTg2MWYzNmU3NWNjOTFkNjYwNGI2ZjhiODY0NjI1YWExZmZhNDBiNjBjZGNlZGY5NTEwNTc5NmRhNzg2YTI5MzZkNDFhZGU5M2VlMjJlZTBkZWFhNDVlN2IzYmQxMjNlNTZkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3F1ZXN0aW9uLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9xdWVzdGlvbi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjBjZDU3MTdlYmFiYTU0ZDU5ZDQ0MzVhYjM2ZWZmNmM0ODJhMWM3YWI2ZjBkZTE1ODFhZjM1OTc0M2I5NTEwZGM1ODE1ZWRmYjBmYzc2Y2M5Y2ExYzRiMTJkMGYxM2JlZTY1ODFmNTMwMzM0MWQ0NDM2ZjRiMDM5MmQ5YTZmNWYyIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVHdWFyZHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVHdWFyZHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyNGFiYWIzMDBlYTcyYWQ4NmNlMzkzZjE0ZGM0YTBlODZlZjc3OTljMzcxNWRlYzhkYTg5ZjQ0YzJmZDU3NDc3ZmI0YTcxMTdhM2FlYWE0NDNiZjgwY2M1ZjNmNDI4OTBiNzkxNGU2ZjEzZTY0MjRlZjk3NmMzOGMzMzE2ZjZjZCIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiOiB7CiAgICAgICJuYW1lIjogIkBhZ29yaWMvaW50ZXJuYWwiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiLAogICAgICAibG9jYXRpb24iOiAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9uZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b25lL2R1cmFibGUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZHVyYWJsZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvbmUvaGVhcC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9oZWFwLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9uZS92aXJ0dWFsLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3ZpcnR1YWwuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbWFyc2hhbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXR0ZXJucy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vc3RyZWFtIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3N0cmVhbS12MC4zLjI1IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9zdHJlYW0vcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3N0cmVhbS12MC4zLjI1IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiYW55bG9nZ2VyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImFueWxvZ2dlci12MC4yMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9hbnlsb2dnZXIuanMiCiAgICAgICAgfSwKICAgICAgICAiamVzc2llLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImplc3NpZS5qcy12MC4zLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9tYWluLmpzIgogICAgICAgIH0sCiAgICAgICAgImplc3NpZS5qcy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiamVzc2llLmpzLXYwLjMuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NhbGxiYWNrLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jYWxsYmFjay5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjUwZmMwOTIwNzdlYjlkMTRjYWY1ZmQ0NTMxYjgwNDQ3MjdiZGFhNjU1NGM0ZDJmY2E4Zjc2ZjliMmRiYTJkZDRiYTM5MDljNTE3MzlmNDBmYjkwMjk4OWZkY2EwYjVkZTY1MmQ5NmJkMmY4Yjc3Y2U1MDU4YThkMDI1YjhlYzhiIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbmZpZy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29uZmlnLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOGEzMThlMTM3OWJlN2E4ODcyZGQ4ZGE5ZTdmYWEwZDc5MjA1YjVjODk5YzU0MTBmYjkwYTRiYzg5NWI3NTg1NWNjNzJhN2E5ZmRlMzVkYTBhMDc1ZDA2Y2E3N2E1ZjAwZGM4YjZiYjQwMDljZTNmMTk0M2Q5YmRjY2NiYmNkNTAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZGVidWcuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2RlYnVnLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZTAwMWVhY2E0YjNiMjQ0Nzk2YWY3MWFkNDk5MWViMDlmOTAwZGE4YWQ0NjgwNGMyMmIwODFhODYxOTRlNDYxYjE1MTI0NTVlZjIzYTVmYWIxMmUzN2ZkNjM5ZjUwN2YxOTI1NmI4Y2UxMDUzZmRjZDg3MDllMjJhZmY2M2FhZjAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiN2ExMmUzYjg3OWZiMzk0NTQzOGQ4MjcxM2E5NWJkNzcxMjk3NDhkNzBmOTYxZDE1ZWVkY2IyYTRjNDU4ZmNmYmJiOWM3MDllNTAxY2U3N2ViMzM1MmI2Yzg3YjNiY2M3MWIwNjVhZWJlZTcwMjFiODY0NjQxNDRmNjgxMTRiZWMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbGliLWNoYWluU3RvcmFnZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbGliLWNoYWluU3RvcmFnZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjg2NzNlMzliMGVkZTUyNzI4YjlmMjU1MTUwMjJiYjlkY2I5MGNkMjNlYzA1MjNiN2IwOTI5MTkzYmE5MWMxNmYxMjM3MWZkYWZhMjY2MDA5M2IwMGUzYzhmNWY4YjE0ZGIzOGUyZTI1NTI1MmZlMTI3NDBjMDNiYzI1NDJlNmZmIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ldGhvZC10b29scy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWV0aG9kLXRvb2xzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNDM2NDM3OWFjZTI2NTJkOTBiZWY0YWNkMDkzZDllMWFiMjNiNTAxNzZkOWVkNzA1YWRiYmZmOGEwMjU4MmE5Y2M4MTVhMTk5NTNkZTdmNmI2ZmFmYTgyYjM2NDk2NmNmZTQ4ZTUyOGFhMGY1NDRhOGZiOGU1NDcxZDA0OGYzOTEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImQwNDdiMGQ5NWY1OWVlM2I2ZjEwNDE3OGNmNzNmY2I2Y2M3YjUyYmM1MzEyMWExODgzMTU1ZDE0ZmNjMzY3YzUwNWE5NmI4MjgzYzdmYmExNzAyZGMzZjJjZjNiM2U3OGM2NTI1MDJkNzlhZTNmNDY1Njg2YzJjOTI4YmVlZDYzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3VwZ3JhZGUtYXBpLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy91cGdyYWRlLWFwaS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjIwMWViMzNkNzI0ZTE3ZjBhMGJiNGY3N2FmMTczMzJhZTVlNmI5YzhhZWY4ODcyZTJhM2RmMWFiZWVkMjA1ODQ4MjIxOTJlMTZkOWM0N2JkMDhmN2ZkYzJkMTU1MDc2ZGMzNWFjMDQ4MzA2MDkxNGZlNmEwODAyYWFjNGVkNGMyIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3V0aWxzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy91dGlscy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjdiMTE0YmJlM2E0OWIzOWQ4ZjVkNDZmYjYwNTVlMzljMWFkMDEyOThiNzRkYjg0YzM5ZmQxOTAwZWNjNDk1ZTk1NjhiMGE0OTA4Njg0NjA1YWIwZmQ5ZjgyYjk0N2U3ZjMxNDFhODY5OTViNDZlNmUyOWZiMzUwODgwMjQ0MWJiIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCI6IHsKICAgICAgIm5hbWUiOiAiQGFnb3JpYy9ub3RpZmllciIsCiAgICAgICJsYWJlbCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAYWdvcmljL2Fzc2VydCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2Fzc2VydC12MC42LjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9hc3NlcnQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvaW50ZXJuYWwvc3JjL2xpYi1jaGFpblN0b3JhZ2UuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9saWItY2hhaW5TdG9yYWdlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvaW50ZXJuYWwvc3JjL3VwZ3JhZGUtYXBpLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvdXBncmFkZS1hcGkuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvc3Vic2NyaWJlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zdWJzY3JpYmUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci90b29scy90ZXN0U3VwcG9ydHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZy1zdG9yZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N3aW5nLXN0b3JlLXYwLjkuMi11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3dpbmdzZXQtdmF0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3dpbmdzZXQtdmF0LXYwLjMyLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbWFyc2hhbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvYXN5bmNJdGVyYWJsZUFkYXB0b3IuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODA5Y2JlZWNiMmJkYTE3ZDVmNWRlNWQ3ODQ2YjAyZTVhMjNkN2Y1NGI5MDNkNDhhMTA0ZWIyNjNmY2YzNTI5OWFjZWE0YTNlYjFkNTdjNzUwYmQzZjRmZmFmOTJiYTkyMDcwYzVmYmE1MjZmYmQ0MTE1YjBhOTlkNWQwZGVhNDgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZTVjY2E0Y2M2NDVjZWUxNGUxMmE0NWY2ODhhMjc1MGYyM2MyYjgxMTQwOWJlN2YzNjlmZjA3ZjE3YjlkYTAyMzY0YThlNzNlMGMxOGFkMzQzMWM3ZTBjMWFlMDlmOTlkYzg0N2RiMzI1YWZiYTA2MmI2NWVhNmVkYTAyMmFlMjUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbm90aWZpZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL25vdGlmaWVyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmY1NjZjNmYyMDA3ZjNmNzkxMzI2MTYxY2JkMjA0MTk2YjQ1OTFlZWYwOTUyOTY0MmFmODRkZjBhM2RiZDdmNzNjMGZkNGViMTY2ZmE0YjdkOTY0NGY3ZWYxZDY3OGY3OWNlOTI3ZWY0NTZjYTcwMTE1N2YyYTE1MjI2NzNjMzIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcHVibGlzaC1raXQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3B1Ymxpc2gta2l0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYWU1MmY4OGVhNTQzYzFhOTIyZDFmNzEzZjk0NzAxNDg3MzRlOTEwODhhZDViMGZlZmE2ZjFiZjJhMzFiODdlNDNiNTMzOTg0NDkwMmFlMmQxZGIyNTQyYjZiNzgwOTZmYjY5NmVmYTQ2NDZkYzBjZjEwM2QyODBkYmM5YjVhZTAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3RvcmVkLW5vdGlmaWVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zdG9yZWQtbm90aWZpZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxNTFjNWVhYmNlMTdiMzdhNzQ4YTFhNTAyMDg2YWVhMGQ1YTQwZjQzYWQ4MTFjMzdiNzMwZDAwNGMwNmMwN2EzMWFjN2Q1ODdjOTk2Yjc3OTViNjYyN2UxMzk0NTZiM2UwZDZhYzJiNTAzNzU0NDA5Mzg2YjM2YzE2OWI1MzRjOSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdG9yZXN1Yi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc3RvcmVzdWIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3YzU0MDliNzUzZGU2N2M4NTk3OTM1ZmZmNDBiYmFmNGI2YjQ3ODA2ZmVkYjdlZmQ1YTQ5YzhmMmJmMDlhOWVmM2ExNWMxZTc2MzdkMWIzZWY1MjhjODlkZDEwMDZkNzNmZWI4Y2QxNTUyZDIxMDE1NzZmOTIyY2RmYTM3YmExMiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdWJzY3JpYmUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N1YnNjcmliZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFmZjg3OTQ2ZDMxNWIzYTc2ZWMwNzFlZjNmZjQ4MTNhYmY4M2Y3MTQ0NTEyNGQ4Mjg4YTMwZmVkZWMzMTY3MGM2NmRjZTBmNTNhNjc5MDVhYzNkNDc5YThiMjA3OTFkOGI2OWFjOTIyMTIyMTJmYzU4NTA4M2I0NWE4ZTAxY2Q2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3N1YnNjcmliZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N1YnNjcmliZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxNjE4ZmM2ZjVlNzFlNWUxYjdmMDY0NTE5ZThjNWU3OTY1MGM2ZGRmNTYyOTI3YTI2YTJlZjc0NWY1NGE1NjFlNzMzN2E1MzY5MDZjNDAxZmYyNmEyMjZkYmUwMDQ2YWIzZDZhN2Y2MmQ2OTM1ODg1NjU0N2IxYzc1ZmMzYTQyZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90b3BpYy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdG9waWMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5N2EwZTA0YTRhZWYzMjI1NmQyMThiODRiMjUyZGY4MjFkMDI1YjkwYmExZTM3NDU1N2U2MzU5YmVjMGUzMjE1MDM4MDM4YWY5ZmRmMDYxMDExMGI3NTg4OWU4MTRmN2ZjMGU1YzA4MmQ1NzhmNDI0MzMxZTI0NjFmZTZmNzc0NSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy1hbWJpZW50LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy1hbWJpZW50LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmUxN2I5ZGI2NzNjNGExM2YzZTdlZjlhMGNiY2VmMTc5MjdmMTZlMTkzYzQzODA5YzhjNmJiYWY0YjU1ZTZkOTAxNjBkMzIyZmM3NTllOTY1MDQ0NWU5Mzc3MjNiMTRlYWRhMjlkYjYxNzNkMmJkZDVhZmI5YTM1YzM5ZjQ2M2UiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL3N0b3JlIiwKICAgICAgImxhYmVsIjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2ludGVybmFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zdG9yZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9leG8iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXhvLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXhvL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9leG8tdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXhvL3Rvb2xzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V4by12MC4yLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MC44LjUiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGFzcy1zdHlsZS90b29scy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXR0ZXJucy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBmYXN0LWNoZWNrL2F2YS12MS4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2xpYi9lc20vYXZhLWZhc3QtY2hlY2suanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZmFzdC1jaGVjay9hdmEtdjEuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJleHBvcnRlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFhYTQ2MGJiYTc2NDQ0M2Q1Y2FmYjMzZjUyMjc5M2JiZTI5ZThkMjRmMmM1ZTc3YzdiNmExZWMwNDE1MGFmODAwYzdiZjFjMDVmZTUwNDUwZGZkMjk4Y2NkOTJhNzk4NjAxYjFiNDhhMmZjNDRhOWY5YmRiYjY4ZTA5MGNlYTI0IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjExNTgzZjY0NzZiMjA3YjgyYTE5NDU0NjcxZjQ5NmVkMTI3MGM3ZGFkMTEyMDE4MjEyZmQ5YTFhNTkyMmI1OTFmZTVhNWE0ZTJhZmRlYjNiNTE5N2ZlNDA4MjBkOTgyZjlhOWEwNWY0NDIzMGE1ZTNmNWE5NWRiMDIxNDY5OGEwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2xlZ2FjeS9sZWdhY3lNYXAuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2xlZ2FjeS9sZWdhY3lNYXAuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3YTY0ZmFiOWFkYWE1NTE4MTg4YjgzYjZlNGJlMjEwYmNkOTU3MGI4ODFlN2FhYmQ2NzljYjk3ZGFmNzdhYzhmOTM3MGE0MTQwMTg4MGQ4ZTkyMzA4M2RkZGEzMGI3NWJmYzQ0M2Y2ZDExMDk0NmE1YjcxOTJkNDEwNjc1NzQ0MyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9sZWdhY3kvbGVnYWN5V2Vha01hcC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbGVnYWN5L2xlZ2FjeVdlYWtNYXAuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxY2M5YmI2ZmFmMmMyOGMxMjY0NzlkNDcxZDUwN2U4NmUwYTIwZjc4OWIwY2Y5MzVjMmYzNDRiZGQ3ZTE4MDA3ZjliY2M2MzViN2UxMjMyNDVjY2FhNGU1ZGNkMzlhZDJmMjAyMGZjNjQ0OWIzYmEzZTlkZDBkZDFjYWU5ZmJmMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdG9yZXMvc2NhbGFyTWFwU3RvcmUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N0b3Jlcy9zY2FsYXJNYXBTdG9yZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImExOGQwMmI0ZWNmZGE5MzExN2NlOWFlM2Y1N2NhYTc3ZWIyYmFmZTNhNzNmZDBmNjgxMmY2ZWFkMmYyNThkZTdkZjUwMzA4MTllNzk4MTc5ZTBjNWNmYmQwMWNiMTA0OTE3MjFmOTUxYTdlMmFlZjAzYjZmYjJhODgzMzhmOTdmIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc3RvcmVzL3NjYWxhclNldFN0b3JlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjM5OWFhZjY2NTU5OGQ0YWZkYzdjYWE5ZTU2NGJlYTgzYWMzODFmMzkwNTcwNzhiM2RhNmExMmZmZWFlMWQ1NTFjZjdjMmNmYTExYzM2OWI3MWM3NjhjYTk3ZmUwNjk4NDZjZTE4YjliNzE4NzZkN2YwNWMwYmE3NTAxN2VhY2QiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjZkNGE5M2NiYmQ3NGExMWFjNTUzNTRmYWRjNGZlNDIxZDdhZDlhNDMzODBiYmMxNGViZWM4YTJkMjk1ZjJiMGQwOWZkNDJmZWMxZjUzOWZmZWNiMTkxZDlhZTk5NGQ3ODRmMWE5MDFhM2YzMjFlMzk5NDRlZWExOGJlNTdmZjVkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyZTlhMGVkZmQ1MTIxNzM4YzNlNWU0OTdiZDk3ZDYzYmE3ZjRlNjYwYWU0NDc0NjY5ZjY3ZjVlOTU4Y2E0ZjdhMDhkNDExYTE3OTBkODg2NDg5MGU3Y2E1MjU5OGUxNDc2ZTM4ZDczNzAxYjQ4YzkwNmY4MjMyNGVjN2U0ZjgyMiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdG9yZXMvc3RvcmUtdXRpbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N0b3Jlcy9zdG9yZS11dGlscy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjBmZTE2YTZkODEyOGI1MGEyOGIzOWNkZjk2YTg3ZDFiMjEyYTZiYmYwNmY3NTIwMmY2OGQ1ZTVhOGMwOTJiMGEyZmY1ZmM0Y2Y4NjIzOWQxNDRkZTE0NDQ1ZGZlOWU4ZDU2MDY4ZDljZDZkZTUwYzVkNzdiMzFlNDk5NTdkM2M3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImEwODFkODQ0Njk4NDJhNTY3MjlhNTVlZWI1NDEyYzdmMmZmYzVjYjYyZTM3ZjBkMzM1YzUxMzZlYThkNzliODc5ODI2MDAwZGE0ZWJjMGJjZjdiN2I1MzdhNzc0ODJhMWU1MDQ5ZjA1NTdlNDY0MTA4Y2ZkNzUzMWFhNmE0NDQzIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL3RpbWUiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy90aW1lLXYwLjMuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy90aW1lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjVkZmQ0ZWFiNzJhNmM4YTg3ZWI3ODYzZTdkMTZmZGExMDc4ZDA4OGU0OGVkNTUyYmJlN2NhYmM1Y2VkOThjOTY1YjgyMGRmNDc4NzI4NTk3NDVhZjczNDg0ZDFkOGIyMTUzNWM2ZmYxZmM0YjVlNzU0ZTY2MTBkM2QxZjM3NDYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdGltZU1hdGguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3RpbWVNYXRoLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNmIyMWM4Zjk5M2E4OTdmNDc5ZTg4MmUzNTQwODA0Yjk4ZTkxMmQzNjlhODY3Y2M5MDQ3MzY3ODA5MjcxZGMxNzkxMmMxYThkNzY2NGIxYTk4MzYzNzBjNjdlN2JmYTRhNTllZjRhZjAxOTY3ZjUzMDQzZTk0NWRhNTlkOWExZDAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI3MjI0MTczYjZkNTFmZDI5ZTk4ZDNlZWZjY2I5NDA1MjQ3MTM1ODdhYjg4NDI1Mjk4YTkyYTBjNGIxYWY3MDVlYmE0ZmExOTI5YTNjN2YwYjE0ZDhmNmMzYTEzODdlODdmMjYyZWYyOTkzNjg5OTk2MWQzNTg2NDVmMWQ4ZmE4IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMCI6IHsKICAgICAgIm5hbWUiOiAiQGFnb3JpYy92YXQtZGF0YSIsCiAgICAgICJsYWJlbCI6ICJAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAYWdvcmljL2Fzc2VydCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2Fzc2VydC12MC42LjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9hc3NlcnQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3RvcmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZXhvLXV0aWxzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9leG8tdXRpbHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJkZjI5YzBmZDc4MTBjMzdjOWNjZjQwODY3YTAxOTk1ZTU2YmM3MzgyZjQ2OTU2OWI0OGE1OTVlZTY1NzY3ZGU3Yzc0MGFiN2FlOWUzMzBlMDk0YzQzNWFhZGI4Mjg4ZTBhNWYwOGM5NmRmNDZmZGM3ZDM2OWYyMDI1NDlhZTAyMCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJkMDdjNTNjZWEyZGU3MTVlMTk2YzZiZmM3MzMzZWFmZThkYWU3ZjhiNzJmNjc1MzUyMzM5MWVjOGQ1NzY3NjMyNTk2MTA2OTY1MWMzNzNjMzY0ZTI2M2NmZjJiMTUwMjQwZjAzZmQyMGQ2ZDAzOGQ2NzVlOGZhZGY5YmRhZmViNyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy92YXQtZGF0YS1iaW5kaW5ncy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdmF0LWRhdGEtYmluZGluZ3MuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjNmUxYzhlYThjYWFkZmU5MDQ0M2RkNWYzZTBjNzNlMmZkY2M4OTE0NDgwZDkxMmEzZmUxZWM5YmRmNjBhYmM2NGM2MzRmYWFmOGYzM2UwZGE3OTc3NmVlMTNlOTMzZGQ5ZmE5NGYzNzVjZGRlMGFkNzk5YTVmODBiY2YyM2Q4ZiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCI6IHsKICAgICAgIm5hbWUiOiAiQGFnb3JpYy96b2UiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2VydHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2ludGVybmFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvc3Vic2NyaWJlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zdWJzY3JpYmUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci90b29scy90ZXN0U3VwcG9ydHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZ3NldC12YXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zd2luZ3NldC12YXQtdjAuMzIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdGltZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b2UiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL3pvZVNlcnZpY2Uvem9lLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi41LjEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9idW5kbGUtc291cmNlL2NhY2hlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2J1bmRsZS1zb3VyY2UtdjIuNS4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9jYWNoZS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9idW5kbGUtc291cmNlL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2J1bmRsZS1zb3VyY2UtdjIuNS4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9idW5kbGUtc291cmNlL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9idW5kbGUtc291cmNlLXYyLjUuMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2NhcHRwIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NhcHRwLXYzLjEuMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMTgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9pbXBvcnQtYnVuZGxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2ltcG9ydC1idW5kbGUtdjAuMy40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbWFyc2hhbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3BhdHRlcm5zIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3BhdHRlcm5zLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3BhdHRlcm5zLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvc2hpbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdFN1cHBvcnQvZHVyYWJpbGl0eS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFiODg5YTNiZWUwZjYzNWIzMzNlYjA1OTJkMDhmMDhiOTY3YWMxYmY4MDMwYjdkMGMxYjM2OTM4YTQwOGQ1NTMzYWFhYTE3MWY5NWNhOWRkMGE2NzIyNjc4NDc0NjI1YjU5MGJjMjFiZDJiNDZhYTk2M2Y0NTUzOGY5MjRmZTY5IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2VIYW5kbGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2VIYW5kbGUuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0NGRlMzk1MzMwNDAxMTkwMWQ5MDUxMzIwMGI5ODYwZmQ1ZjUyYTljNjlkMWY0MjEwODUzNWU4MDVkMTcxYTAxNjEyMWZmY2JhNDg5OTkxMmQ5OWJlOGZkMjI3YjJlMDJkZmNhYjE0ZmZkY2EyOGIyZGJjMzg1OWIyNzBhZGE1ZSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlR3VhcmRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlR3VhcmRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDljYmY2NGYxZjA5ZWVlODIyNTY2MGI3ODMzNzY3ZTg3NTk2ZGRiMjExZGQxN2I5ZmU5MmQ3YWEwZjcwYTMyZmU0NGNiODljNzJhM2ZjNTkwYTMxYWFiNGI3MjZlNmI0YmE2NTZjMWI3ZDIzNWY0MmZjZTkwOTAwNzI4MGFhNTciCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAiOiB7CiAgICAgICJuYW1lIjogIkBhZ29yaWMvem9uZSIsCiAgICAgICJsYWJlbCI6ICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGFnb3JpYy9zdG9yZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdmF0LWRhdGEiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvbmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9uZS9kdXJhYmxlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2R1cmFibGUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b25lL2hlYXAuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaGVhcC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvbmUvdmlydHVhbC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi92aXJ0dWFsLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2hlYXAuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2hlYXAuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0YmUwMDFiZDZjZDI2MzVlNmFmZmU1N2M0Yjk3MzA1ODUyOGUzM2Q1ZjljMGNmYjI1YWI0Mzg0MzQ2ODYwNDQ3OTM3N2YzNmYyZGE2ZDE2NDc5Y2IxN2QzZjFjMjc4OTBjZGVjMTUzNGY1YWVhOTcyNzJlOWMyY2E5NzFhZDIwNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1NmZjYTA2ZWFmOWE0MjY0OTQ4YWM0MjNiYTBmYWY5OGFjYmY1NDU0MDIyNzM3OTYzNDhkZDQ3ZTNjMDJkYzQwNTc2NWViYTA3NTE5Mjc1Zjg5NDY1OTExM2JmYTE4ZTAzOWIwMTQzZTdmNDViZTM5MjI0MTIxODJlOGYzOTg1YiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44IjogewogICAgICAibmFtZSI6ICJAZW5kby9ldmVudHVhbC1zZW5kIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTQuOCIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE0LjgiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE0LjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL0UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL0UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwYjI5MmIyYzNiNGExNmQxZjZiOGEyZjZjZjVlMDYwOTFjNGRiN2ZkZjBmNzQxNzVlOWRjMjAwYjQyZTRlYTEwZmFjZGVmNGM5M2MxM2Y1ZDE1YTJhOTBkNzc5NmU2MWZmOTY3YWM4NTg2ZWVlNzZhMTQ5YjJkODdiOGJkNWFmNiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9uby1zaGltLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9uby1zaGltLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYjU0YjkxZWU5YTBmMTE0ZDk3NTJmZWI5MjYzN2IyOWJmOGIxZDZjYmIyZmVhYjAxNjMyNWYxNmU3Yjk1YzA2ZTBiZTc1ZWY2NDIzMzNkMDgxNzM2MTRhNmEwMmRlZTExNmEwNzkwMGQ1ZTRlNTkxMjc2NWNjYmViYzBlYTk2YzAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHJhY2stdHVybnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3RyYWNrLXR1cm5zLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYjEzMDkzZTM3OWRmN2JjZjY4OGU4Mzg0NjIwMjdmMTc1Njk5N2ViZDQ0YzUzOGRhNzU3MGQxZWE4ZDZlYjZmMTZmZjc0NTk1ZTRjMjM2Zjg5NjZkZjg0YWQ3NDBhYWFiMDQxZWJjZjM0ZWVkM2I2YjE0ODI4MTdkY2U3MTMwYmEiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9FLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9FLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYzUzNjg0ODI2Y2I1NjYwOWY2MmI3ZDZiNGRlMzNkYWQyMmMyMGFkYWEyZWIzODgwMGMzNjRjZWM1MDk3MzgzZTk3M2YwNThiMzM1ZDRlNGM0ODAzMGU0MjhmN2I5OGRkYTJiZjIyODhkYmEzMDA4YWNiNTdiNGFlNzIyMDY0Y2IiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbm8tc2hpbS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbm8tc2hpbS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjZlMjgyMDJjZWIyM2UwNjRkNWRjY2JlMDIxYWU3ZDFhNWZkY2NjMDIzNDI3MGRjNTYyNGZkOTFkZjIzNmY5MDdkY2M1ZDI1NDMyNmQxY2QzMmFjNTExNzYwMmQyZmEyMzllNmYzMjAzMzI4MmZkNjdlMjRmMWE3YTRkZTk1NjMzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RyYWNrLXR1cm5zLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90cmFjay10dXJucy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImQ3OWQzYTI5ZWI3YmYzYmE4YTM5ZjJmOGFlZjg1MGE4YTljZmUxMGY5NTcyM2QyNzFkNDRlMjEyMmEyZThkMmRlNDk0MjZjMWM0ZDQ4Y2E1OWM4YmE2ZmYwZGY5Mjk5NTUyOGQzNDllZWZlMWQwZDUwM2JkZmE4MWY4NGZlZTZlIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9leG8tdjAuMi4yIjogewogICAgICAibmFtZSI6ICJAZW5kby9leG8iLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXhvLXYwLjIuMiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9leG8tdjAuMi4yIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V4byI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9leG8tdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9leG8vcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V4by12MC4yLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9leG8vdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXhvLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXR0ZXJucy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImNiMTljMGQ3NGNjNTA4ODI3YjBjOThjMzQ1YmQ1Nzc1NTBlNWVhMjEwYTk1MTUzNzA4MmQzOTA2ZGJkYjdiMGYyODNhYzc2Yjc1MTQ4ZjI0ZGM4ZjI3MjNiMmI1NDg3Njg4ODBiZWJjYmNjYmY4MjBkMDY1YWMwMTVlMzEyZmMxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2V4by1tYWtlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2V4by1tYWtlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhYjZkZjE3Y2VjNzA2MjM3Yjg2ZWZiZTBmM2EzYjllYzhmZTUxNmM1ZTA1MTYwN2I4MTlhZWNiMmU2MGQzMjc1MzAzMzVjZTkxZmFiNzc4ZmYxZjUxNDVmMGRjNzgzYzhlNjI3N2JlNjZlZTg3YjZlNmI1MDA0YWU1ZjhmY2ZiNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9leG8tdG9vbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2V4by10b29scy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjg2NmJkYzNlYjM1ZTBiZDE5ODcyM2Q0YTU2OTAyNDY4MjZmNGYwZDY4YzBkN2M1NDhmNDkzOGFkM2M5NWI0Y2JmOGI5MTgzMjZhODRiYjAwYjRiMDQ4M2Q3ODU0NmY2NzYwZmIzNGI2ZTQ3NWVkMmVlYzgwOTY4NTMyYjZkZjNiIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9mYXItdjAuMi4xOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZmFyIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMTgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjY4NzQ5N2UzYmY2OGM1Mjc5ZjM2ZDQwZTI4ZTRhNzQzOTcxNTg0MDMxZjY0MGVlNDk3MmQ5MjU1YTI5ZTkxYmFkMThmZDQ2OTljNGJkY2IzYjM2ODJjMTk2NWQ3NmMyOTlkNDdmYjU4MmQyNjI4YmZmYzRmY2I3YzBmM2Q2ZjFjIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9tYXJzaGFsLXYwLjguNSI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vbWFyc2hhbCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbWFyc2hhbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGFzcy1zdHlsZS90b29scy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjJlYzJmNzZiZmVlMzdmNDRhOGQzYWYyN2IyNzg2NmE3ZDMzZjc4NjllYTg3Mjg1ZTRmY2ZmMWMzZDA3NjRjMWJjM2E1ZGMxNzUzMWM3MWQzM2UxZWM2NGI3NTk2MGNiYWY3ZmVlZTA0YjdkNWNmMzA1YmI4MDRkMzA1YTc4MGE2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2RlZXBseUZ1bGZpbGxlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZGVlcGx5RnVsZmlsbGVkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTM1YTY5NjJkNzJkOWQyNDA1MWI5NzQ5OTMyMzI3MTllZjZkOTY0OGJhZWYzODMyMmE2MzU4NzAxMThkNjgyYTNjOTY2MmIxMDIwNTc1ZTM4YWJhZDA2Y2Q1NDNjYzIxZmYxMmRlZTUxZmFhMjQ3YTYzNDk2YTdkNzcyOGMyNzIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2VuY29kZVBhc3NhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGEwMmVjMWIxYjEzZWM4ZTFlN2JkNzVmZjA3YTAzZGVlZTUxODhmY2Q2MjAxZTRiNWEwY2M0ZmE0YjYxNTUzZWQwZTJiODI0YjkxMzJjNWVkOWZkNzA5MDBiYWIxNmZkM2MxNGE0NzFiMDAzYzI1Y2UyNjFhZjQyMDMzMWFlNDkiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbmNvZGVUb0NhcERhdGEuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5YThkZDJhMmZmOGFiMDVkODEyNTg5N2YxNzJhYTBhOWZhNDI5NmRhZjgyOWY0NjgyNjdiNTkzZDQ1YTg2YzBlNDc4ODI0ZGQwYWJmNTVkZjE4ZDgwZjE3OTAzMjY0ODZhNTNjNTAwY2ZkNzU5N2ZkN2JiM2ZmYzU4MGY1NDdmOSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZW5jb2RlVG9TbWFsbGNhcHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3YjIzM2E1YzU2MjIyMTI0YWFiNWRlNDllMjFmNzZkNjdiNmUzY2YxZGUwZjI0NWYyMWI4NmJmYjQzNmMwMjBmNTBjMGNjNTkwYTk2YTBkYmFhOTNlNmQzOTQzOTU1ODFmZTc2OTE0OTAwMzQ3NTQ3NTg4MmUyMjNhNjcwMzQ1YyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1qdXN0aW4uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJiYjgyZDU5NWQyYWZkNWQ5YzAyYzVjYmUwMmU3ZjdjOTYwODdjNjBjZDA5MDkxYjk5NzgyYmQ4YTdjMTI2YjIzOTI2MmU5OGQwZjQ2MGE0ODk4MWI1Y2YzNTExYjdiNzhjZDBmMDAxYjJmYTBlNWU5MzgxNDM1ZGExNmRiMTY3YyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1zdHJpbmdpZnkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJmZDYzMmQ2NGY3NjM5ZGIyNzkwMDc2ZjdmNTkzMWI0NWNjZTJkODQzODdjZGEyYzc4YzkxYTQyMjlmODE2MzQ0MTc2YmI0NzAwOGUxOTc3MDRmNmI3ZGFhZmQyNzQzZGViNDVhZDA2YzViYzZiODhjMDM4ZGYwZTZkZmJhMjdmMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXJzaGFsLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDI2MTQ3MDcxNGQ2NWQzM2NlNmM4ZGZkOWRiNGNjYmZjYTRiYzg4YjMxOTk5YmYwMTk3Yjk1YmQwMjczZmNhZWMzOWM0ZTg2NjY5Zjk3NzBiYTcxMmIwYjViNmNkMjMyM2Q1YmM0YmEyZjUwYzdiZTFkNTczN2ZlOWE0N2Y2MDMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmFua09yZGVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yYW5rT3JkZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1ZjA4NmE2MGNkMGYzOWQ3MjYwYjg3ZjliYTIwMDA3MmIxOWZhY2M3NGJjYzBhNjI3NmNkMGIxMGZhMzlkOTFjOWZlN2UzNzk4Yzc4MDA4YTBmYTFiMjdjZWM0NTYyM2U1YTJhYWU4MWM1NDU2MDMwZGQxNDc1Yjg5NTFmMTJiNCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5OGE4NTFiZGJmMmY0ZGQwOWExM2I1MjExMzBlMjk5ZjlkMTk1NWFlMTkyOTE2MjdjZDI4ZGY0ZmI1ZDQ4NzhlY2RmN2NlMmIyMmE1NjcwYjQzOTdiZjQ5MGI4MGQ4OTgyNDgxZGI1Y2ViMjI0YjEwYWZkZWZlNWM0NDUwNjI2NSIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vbmF0LXY0LjEuMjciOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL25hdCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODI1MDgyZjRjOGNhNmFhN2VjZmFiOTBhYzExNjVhZmQ1OGM3MDBjMDVmYjQ2YzM4MGE4ZWE0MjdkMGNiN2MwMmFkYjEzMzYzNTBiNzM0NGY2OTI1NjFjMmE5OGZhMjdmZGRkMTk0YzNhNjEzNTVmZmQ4MmI0ZjczN2ViYTk0OTkiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIjogewogICAgICAibmFtZSI6ICJAZW5kby9wYXNzLXN0eWxlIiwKICAgICAgImxhYmVsIjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGFzcy1zdHlsZS90b29scy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBmYXN0LWNoZWNrL2F2YS12MS4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2xpYi9lc20vYXZhLWZhc3QtY2hlY2suanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZmFzdC1jaGVjay9hdmEtdjEuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc2YjczMjAzYjNhYzFlNzYwMTA4NzJmMTY2NDU3ZDU1NTMyOGY0NTljZjUwYTU3MmZmYTAxMDQxZWMwOTMzYTdmNTc5MTcwYWNlMGI2ZTc2YWY3OTJlMTJiYmJlMWFmNTViZDZkMmM2OGM0ZWYxMWI0MGRkYTk0ZWZkYzYxYjczIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvcHlBcnJheS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29weUFycmF5LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMzM4YmI2MGY3ODU0YjRhN2I2MWExZmQzM2IyNGE3ZTlkMDU4ZGE3OTBlNmYwYTI5NjQ0M2Y3MDlmMjA2ZmVmNzMxNTBiN2UyZGVkNzk5YzYzOWI1ODg0OGRjNDVhNGYzZmNhYTk5YTBmMWU3MjVhMmFkOWE0M2RjZTY5MDgzOTEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29weVJlY29yZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29weVJlY29yZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0YjgxMjVkMDlkNzNiMDI1YzgzOWY2MjUxZGNjMDZhNTNkY2QyNWFlOTE4Yzk3M2UzNjAxNjExNjMwOGE0OGMxODMwYWQzMzg3M2Q5YjhlZWUwNmFkNTBiODI5ZDQ1MDM2ZThjNDg2MDM2MzllMmE1NDgyZWUyYmE5Y2RkMzBmIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Vycm9yLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lcnJvci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc0ZTYyNzI3Y2NhOGNmM2MyYjVhM2E3OGE1YjI3OWYzNjc5M2EzOGQzNjcxODE1MmFjYTViMWUxODY2NjViMzA2MzhkZDEyNGExYmI4Y2M5NDRjMTExYTcxMjY4NmI0NGQwZjdjYWFiNGYyZjVmMDI3M2EwNGY0Mjc2ZjI3MzhjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2l0ZXItaGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaXRlci1oZWxwZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNDc2ZWJmMzRlNzNkMDUwMzkzNzQ3ZTllYWYzNWQ5NzA3YTE5MDVkNGNjMWM1MTBhNGYxOWUxNWZjMzUwZWNiMWRiNDliMmY1MWY4NGZhYWVjYjliNjdhZjU0OGFjYzJlNTEyZmFiMmZhMTYxMGIzNjhkZDFhMTc5ZWEwZjMzNGUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWFrZS1mYXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2UtZmFyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDhlZWRhMzZkZWRjYWJjZWZmYTlmMjZlNjM1MjVlNjg4NzFhMzJjYmVkY2Q3YzFhZDZiNmQ1OTQzNjZiMjcyNDhjMWQ0MzZlMWY5ZGNmM2IwOTcxMDdlMzgwMWQyMjk4MTQ0NWM4YzMzMmNiZDA1MzAwNzU5OWRlNTMyYmFmMTIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWFrZVRhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFrZVRhZ2dlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjJkMGU0YmM2ZTQ3ZTNmNjQ3OTQ2ZTFhNGI5YTBjZWE2NDdjMzUzMDdlOTU1M2U1OGYzYzEzMjE2MTgzNmI5ZDNiOGM3ZTcwMWIzZTY4NjA3MWI2MDFmNGIwYjgwMjMzMjZmOWJhNDg3YWVjODAyNTJjOTVjYWFkOGZkOTk2MTQwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXNzU3R5bGUtaGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQ5NWFlZDg3NGI0OTU3NjQ4ZjBlNTVjOGM3NTkyZGM3ZTFiNjUzMDc5ZTI1ODY1OTViZGNmODkzN2Y3MjJjMmJlODY3YWRjYTE2M2QwNDA0MzI1MTA2NjEzMGUwMmRkYzhjYjc2NjNjZjhkODc2NGIxMGJmNmEyNmE5NjI0ZjEzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Bhc3NTdHlsZU9mLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXNzU3R5bGVPZi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjdjMGM3OGIwNmZmZjJiMTc1ZDg0M2E5YjEzZmY4NzM5NzBjNmMyZWViMmUwYTJhMjA3ZTlhY2IyNWE5YjBhNjIxZDRlYzhkMjFlMGNjYTg4M2QyMDExYmZlZTA3ZjdkYjcyOGUyZWMwYjQ1YjI0ZDI1OGVjYmZlMGRlZTAwMzUyIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3JlbW90YWJsZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmVtb3RhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTU4NDJmZTgyNTFkNGUwOTZmMTNjYmU1ZWJmN2UwYjMwYzZiNTMwYTAwYjM0ZmEwN2JlODA0ZDVkN2I0MDBhMDJiMjZmZjQyNjhiMTRkZDg3N2U5NmUxYWUzM2FkMDhlZjJhYjg4MTI5NjMyZDYyODc1OTUyZWFmZDAxNzIxMWMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc2FmZS1wcm9taXNlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zYWZlLXByb21pc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5YjczNDFmODllZjdkYWE1YTNhMDE4MGUxYmZmNzFjNTJkMDg4NzFlYjBhZmNlNTc3NDcwM2Q5NTE4MmRkMGMwMmMwNTA4MzNlZjYxOTliZjMxMmFjNWMwMmRiZTQ1MjNlNGQ4YTBmMTk2OTEyNWVjNzc1OTZjY2I3NjUwM2ZjNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zeW1ib2wuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N5bWJvbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI5OTE5Yjc4ZDA3MzY5YzY3Y2JlNjhlODY4MGIyYzkxOWQ2MDlkMmRiY2JiMjFkMmM4MGNmZjI2MmEzNjQ1MzQ3YTUzMGU3MzkxZDQxZTc4YTQ0OGQ3NTE4MzI2YTFjZTNlY2I5Yzk5ZDE2MzQzOTAxNjM5NjU0OTJhZGUwNDljIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdGFnZ2VkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDM5ZjMwNWJjNzlmMWRiOWE2Y2ZiZjk1MjUxOTI1YjJlZTU2YmQyOWJiMTU1N2YyNDQ2OThmYzIzNWQwYWY5ZTcyN2FjNTcyMDIyNmUzMmRjODBmYzhhZjM2MTdiMGE0ZDUzY2U3NzJlNzAzZTI1ZmYwYjllYmVkNzRjNzU3MzkiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk0MTcwYzRlMTZkNTM3OTVhODQ3OWQwYzFhNzlkMTliMTkwZDkyMmUxNjMwMWU3YTBiYjhiODE2ZDNjNDliZDI1ZmUwYjg0ZTg3OWRhNzgwYzNmYzA2NDFhZDY5Y2M1N2RkMWU3OTVlY2U3ZThiYjI4MTJmNzQzMDU4YWZmMDIwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk4YTg1MWJkYmYyZjRkZDA5YTEzYjUyMTEzMGUyOTlmOWQxOTU1YWUxOTI5MTYyN2NkMjhkZjRmYjVkNDg3OGVjZGY3Y2UyYjIyYTU2NzBiNDM5N2JmNDkwYjgwZDg5ODI0ODFkYjVjZWIyMjRiMTBhZmRlZmU1YzQ0NTA2MjY1IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9wYXR0ZXJucy12MC4yLjIiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3BhdHRlcm5zIiwKICAgICAgImxhYmVsIjogIkBlbmRvL3BhdHRlcm5zLXYwLjIuMiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9wYXR0ZXJucy12MC4yLjIiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MC44LjUiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3BhdHRlcm5zIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3BhdHRlcm5zLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3BhdHRlcm5zLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvc2hpbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0YzExMDU1ZmNhNTg0YWY0ZDQ3Mzk5YzU0YmM1MGQ4MWFhNjhjNjAzYTU1MGJmNjlhMDliMjdjODlmNjg1ZTk3NDQ1NDVhNzUzYWQ1ZThmZTMzMzFhZGJkOWQ0ZGNhMTQzYTU4N2RkNjA5MzRmYjQxYzgyZjRhMWU5ZWIxZGU1MCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9rZXlzL2NoZWNrS2V5LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9rZXlzL2NoZWNrS2V5LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNWU3MmE1ZGNkNjRlMWQ3ZDI1NDVjZTMwY2MzNzAyNDg0MzkwYzlkNWNkZGI5ZDA1Y2VhMzM2ZTg4ZWU4ZTkzM2JjMzE1MDNjNGMyNWMzN2UwYTFjYWM4Y2RlMzFjYmJmNDc4MTg2NGQwZDg5ZDcxZmVlNTg0ZjU5YjAxOTM0MjEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMva2V5cy9jb21wYXJlS2V5cy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMva2V5cy9jb21wYXJlS2V5cy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImQyZDM3Mjg3YTJlYWM5ZjQxY2M0NGE5MjAxZjk5ZGYyMjFhNjc2YTQ3Y2U3OWQ4MDYwYjdjNTY3YzJlNjNmN2RlYmQ5MjZmZmUzNTIyM2VhN2YzNTlmZjZhOWIzMGE4MzY4YTM5NmFiNmRkZmM0YjhiMTIyNjQxZjg1YzliOGU3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2tleXMvY29weUJhZy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMva2V5cy9jb3B5QmFnLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmRlNGY4MmYyYzRkNDlkYjNhOTgxNGJkYmNmMWVjNjRkNzFkOGZhZDUyMWUxMTBlNjgxMmQzYjM3M2VkOTI4Yjg2MWQ3NWYwN2E2N2UzY2Y0YzNmZWQ2YWRlNDU1N2JiZjRhZDk0NTczNWEyMzhkZWRkZDA1M2MwOTMyZTZhMDYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMva2V5cy9jb3B5U2V0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9rZXlzL2NvcHlTZXQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0ZWFiN2VjMjg0Y2FkZTFiMDRkZjRmM2JlNjg2YzE3MmIwNDM5MWYwZWVkODU0OGU0OWY5MzFiM2MyYzRjNTE4M2U4NDExZWU2NWEwYjliNmRmYjVmZGYxYWRiOGU0YTM2MTI1MGFlMDE5MWUyZWM2MGM1ODE0MThlOGNhNTA0NyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9rZXlzL21lcmdlLWJhZy1vcGVyYXRvcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2tleXMvbWVyZ2UtYmFnLW9wZXJhdG9ycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjhiOTg5MmIzYTI1YmY2YmFkMzIzNWQ2YTM3NjU2ZjExYTQzZTQ0YTM4ZmU4ZDVjOGU0MzViMWYwOWNiZjJiNDJmNmFkNjQ5NDQ2NGQ1N2FkMTk0N2Y3OGM4YTEwMTk2YmJkOGY1MGI2NGUyNTEwNjc2M2VkYTkzZGUyN2FkZWJkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2tleXMvbWVyZ2Utc2V0LW9wZXJhdG9ycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMva2V5cy9tZXJnZS1zZXQtb3BlcmF0b3JzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGIxYjQxN2M2ZGQ5MzJkYjgxZjlkYTExNGMwMjBjN2QwMjc4YmYxMmJhOGM0NjA3ZmY0MGFiYzVlMzAxNTk1MWRjZGZiYTJlMDFhMDE1M2Y0ZDBmZjlhMzc1NGViYzAwNDYwNzdmN2E4NDIzMTdiMzFiYjdhM2YxY2IwZmM5MjMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcGF0dGVybnMvcGF0dGVybk1hdGNoZXJzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXR0ZXJucy9wYXR0ZXJuTWF0Y2hlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjMjc2YzZmYmM2M2I1YmJmODNhY2YwZTk5MzE3ZTkwMzVmZjM4ZDA0YTdiNjFiMjlmODAwMzUzODUwMWZlY2RmMmJlOTk3NmFkZjllMjJhOTAwOWFiNGY1MTFiOThlN2VmYzY0OWZhNzNlMmE5YWMzMjM2M2NjZGU4YWFhNTEzYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5OGE4NTFiZGJmMmY0ZGQwOWExM2I1MjExMzBlMjk5ZjlkMTk1NWFlMTkyOTE2MjdjZDI4ZGY0ZmI1ZDQ4NzhlY2RmN2NlMmIyMmE1NjcwYjQzOTdiZjQ5MGI4MGQ4OTgyNDgxZGI1Y2ViMjI0YjEwYWZkZWZlNWM0NDUwNjI2NSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy91dGlscy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdXRpbHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxMTRiM2E0MDQzODIyZjhmYmZkMjJhYjYwMTljYzFhN2U2MGFkY2Y3YTU3ZDcwZDI3ZThlZjFjMTEyMjYyNzVmN2UzMTM3NmQ4NDM2YTE0Nzk5OGNhOWEwNDYwNzY5MjFkMzY3MmVjOTFkZjZkNmYzMjExMDViY2RhYjNkNjczMCIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vcHJvbWlzZS1raXQiLAogICAgICAibGFiZWwiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvc2hpbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgInNlcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJzZXMtdjAuMTguNCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAic2VzL2xvY2tkb3duIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJzZXMvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAic2VzL3Rvb2xzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi90b29scy5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMjlmZmU1NWEzMTAzNzNhNDU3YWE5ZDA3NzE2MTE4NTA1NGViMzZmODM1MzI4ZmNhMTRlZmQxMTQ1MWM2MTUwMmExMjBiODNjNzQ4MjA0ZmEwODc3YWZjNzA1MmViMjJhNGQ3YjBlMWIwYjYxOGRiOTAyMTdkNmU4Y2U3N2EyOTIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaXMtcHJvbWlzZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaXMtcHJvbWlzZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjE4MTRkZDE0M2RmZjczZGUzZWU0YzFmMDc3MDdlNTc3Y2FhY2FhM2FiZjRiMDU5MGNkZWRlMTBiOTE5OWE5MmQ3OTdmMGMxMWJiNzM4Mjk1YzQ5ZjFlN2VmOTBmM2QxMTZlMjhlNzRjMDg2NzM0ZWJjYThiY2RhMWRjOTM5ZDQ3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21lbW8tcmFjZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWVtby1yYWNlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZWVhNTVmYTJjYzFiNzM2ZTAyYmI4MzIyNDZkY2M2ZmNkNGEwYTFlYmMyNDFlMzgxZWY2ZjY0YmQ4ZWM0NmExNWQzZjc5N2VjMjJhMzVjOWM1Yzk1MTQyNGUzOWZkNmE2ODdjZGI0MTU1YzhkYjcxZjZlZmU3ZDNmZTk3ZTk0NWEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNzVlODMzNmNiYzQxY2QyZjYzMTE3N2MwNjEwOWNmM2Y4YjUxODE0Y2IzM2UyMjA4MmM4ZTllZWUwNzJlYzQ4OTE5ZDA4ZDQzZDI5ZDU2NTUxODI2Yzg5NTEzNTgzNTRkNjhlNWFhMDk2YzZhYTU2NjEzNDllMGZhMTA4MTZmNzkiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOThhODUxYmRiZjJmNGRkMDlhMTNiNTIxMTMwZTI5OWY5ZDE5NTVhZTE5MjkxNjI3Y2QyOGRmNGZiNWQ0ODc4ZWNkZjdjZTJiMjJhNTY3MGI0Mzk3YmY0OTBiODBkODk4MjQ4MWRiNWNlYjIyNGIxMGFmZGVmZTVjNDQ1MDYyNjUiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL3N0cmVhbS12MC4zLjI1IjogewogICAgICAibmFtZSI6ICJAZW5kby9zdHJlYW0iLAogICAgICAibGFiZWwiOiAiQGVuZG8vc3RyZWFtLXYwLjMuMjUiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vc3RyZWFtLXYwLjMuMjUiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvc2hpbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3N0cmVhbSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9zdHJlYW0tdjAuMy4yNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vc3RyZWFtL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9zdHJlYW0tdjAuMy4yNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgInNlcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJzZXMtdjAuMTguNCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAic2VzL2xvY2tkb3duIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJzZXMvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAic2VzL3Rvb2xzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi90b29scy5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMDA5NDEzMmNiOWFjZTdmMmFhOGZiMjRhODVhODYwZDQ4ZGQ3YzNlNTQ0MDAxZmVjZmVkMGE5N2RjMWEzN2MyZmUzZDNkMWMwZTQ0MDk5MGE4NjBlNWY0M2U3ZTZiNTdlM2EwZTE0NjAyNGIwNWQ5ODgzMDZjNmY5MDY4YjVhMmYiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgImNyYWJibGUtY29udHJhY3QtdjAuMS4wIjogewogICAgICAibmFtZSI6ICJjcmFiYmxlLWNvbnRyYWN0IiwKICAgICAgImxhYmVsIjogImNyYWJibGUtY29udHJhY3QtdjAuMS4wIiwKICAgICAgImxvY2F0aW9uIjogImNyYWJibGUtY29udHJhY3QtdjAuMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2RlcGxveS1zY3JpcHQtc3VwcG9ydCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2RlcGxveS1zY3JpcHQtc3VwcG9ydC12MC4xMC40LXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaGVscGVycy5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2VydHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2dvdmVybmFuY2UiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2dvdmVybmFuY2Uvc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2dvdmVybmFuY2Uvc3JjL2NvbnRyYWN0R292ZXJub3JLaXQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9jb250cmFjdEdvdmVybm9yS2l0LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvaW50ZXItcHJvdG9jb2wiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9pbnRlci1wcm90b2NvbC12MC4xNi4yLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL3N1YnNjcmliZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3Vic2NyaWJlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvdG9vbHMvdGVzdFN1cHBvcnRzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi90b29scy90ZXN0U3VwcG9ydHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zbWFydC13YWxsZXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zbWFydC13YWxsZXQtdjAuNS40LXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy90aW1lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdmF0LWRhdGEiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdHMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXRzLXYwLjE1LjItdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy96b2VTZXJ2aWNlL3pvZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L2R1cmFiaWxpdHkuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi44LjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9idW5kbGUtc291cmNlL2NhY2hlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2J1bmRsZS1zb3VyY2UtdjIuOC4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9jYWNoZS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9idW5kbGUtc291cmNlL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2J1bmRsZS1zb3VyY2UtdjIuOC4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9idW5kbGUtc291cmNlL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9idW5kbGUtc291cmNlLXYyLjguMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9tYXJzaGFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL21hcnNoYWwtdjAuNi45IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJhZ29yaWMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiYWdvcmljLXYwLjIxLjItdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9tYWluLmpzIgogICAgICAgIH0sCiAgICAgICAgImNyYWJibGUtY29udHJhY3QiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiY3JhYmJsZS1jb250cmFjdC12MC4xLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NyYWJibGVHb3Zlcm5vci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY3JhYmJsZUdvdmVybm9yLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZTg0ZjhmMmJkMWYxNTM3M2QzNmMyNzg1MzdlYjU2NzZmMWJlNjA5ZDg3YTE2ODEzNDFkMjIzZmMzNzIzMjU5NzdkYmZjNDgzNWZhYjNkY2NlZmVhZmQ1MjllNmNiMzlhY2FlMWNkNDQ2YTFiMDA3NWFhOGY1NGUwMWY3MDhmMDEiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgImplc3NpZS5qcy12MC4zLjIiOiB7CiAgICAgICJuYW1lIjogImplc3NpZS5qcyIsCiAgICAgICJsYWJlbCI6ICJqZXNzaWUuanMtdjAuMy4yIiwKICAgICAgImxvY2F0aW9uIjogImplc3NpZS5qcy12MC4zLjIiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiamVzc2llLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImplc3NpZS5qcy12MC4zLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9tYWluLmpzIgogICAgICAgIH0sCiAgICAgICAgImplc3NpZS5qcy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiamVzc2llLmpzLXYwLjMuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21haW4uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21haW4uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwMWRjYmUzNGY0YzIyNGQ2ZDZmZmRkZWNiM2RlNWJkZjJmZjMxMzg2NjdmNTZmNDk5NTU2OWYwYzJkOWZjZTNiNGRlYzQzM2YwZDQ1NmExOGI5NWQ3ZjNmMjM3YzExOTZjNDg3YmM0NGU0NDZmMjk1Y2Y2M2QyZDU4M2Q3ODg4OSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yaW5nMC9FLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yaW5nMC9FLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMzIxMjRiY2NjODQ2MDE5MDA2MWY0Y2RiZDhkZjQ5YmQ3MjNkMWM2NTVhYjk5ZDAyNjc2ZjhhMTExYTBmNzRlNDc2MmNhYzQzZWNkZWViODVkMjkzZjM3YzgyZWJjMjVmYzRlMDUyYzk5MjM3OGJjN2ViZTEwZTY4MWNkODMwMzciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzAvYXN5bmMtZ2VuZXJhdGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JpbmcwL2FzeW5jLWdlbmVyYXRlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOWE5NWQxZGJjYzhmNGJlODE0MjA0ZjY4MzJjMWVhYzMwNjIxZmNjYjAzMjhjMGVjNDFlYTVhMDM5MTQ5OThjOGVmZjkwMTllZmY2NWFkNjYyODljMDE1OTE4MWQ5YjQ5ZGIyY2Q5NmYzZmI1OWUyMWFkYjg0ZDlhNGMwZTg5N2YiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzAvbWFpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmluZzAvbWFpbi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImJmNzE2Mzc4MmY2NzJmNjI4NDQ5MjViNmJiNGZkOWQwMTdiOGI2NDJmZjMzNjQ0ZjI1OWVlMDA3ZTJiYjVhODFiMjRiZmUwNjQxNzQwNWIwNTA1MTlmYjUzYzIwYTgzZjI5ZGUxMmY4M2MzYjlkNjk2Y2Y3Zjg0ZTk4ZGU1MTE4IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3JpbmcwL21ha2Vycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmluZzAvbWFrZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODM1N2JiZjZiMTFiYmNiY2EzYjk1OWM1ZWUxYWVhNGZhZWMzNGZlMzQ2YjgzODE5NDAyZTkzZGZiYmRlN2ZmOGZkY2UzOWUxZjYwOGRiYjc2NTQwYTgxY2E0OThlZmQ0NjkyOWY0MWU3ODllMjliYjZkYWY2N2FkM2MxNzVhNWYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzEvYXN5bmMtdG9vbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JpbmcxL2FzeW5jLXRvb2xzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNzBiZjEyMWE3YTU2OTUxNGMyZTBjMWFhNTFkMTZlM2UwZDEzYWM1ZWFmOTAxNTNhMWMyNTdjNjlhY2JhY2FiMGY0YTJkYzYxNTAzYjMzNzJlYjBhOTgwNmE2MTUyNjUxZjcwMTlhMzdiZTkyZGU4NGQ4YTIyNTVlN2YzMzEwNzEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzEvbWFpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmluZzEvbWFpbi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFlMTQ0OTBjZTUzYWY0MmJlNTI0NmM3MTY5Mjg4MzQ2NmY3MTRlODk4MjRjNzMzYmM0MzNlYTI5NWIyMjI5Y2Q0ZjdjM2I4YmEwMmM2OTk3YzcyZmYwMjc5NGExMjY3ZTllNWU0ZjEzYTI1ZGM0NmJkZTRkZmU1MjNjZGU1NTQ4IgogICAgICAgIH0KICAgICAgfQogICAgfQogIH0KfVBLAwQKAAAAAAAAAAAAOYpWAjsLAAA7CwAAIwAAAEBhZ29yaWMvYXNzZXJ0LXYwLjYuMC9zcmMvYXNzZXJ0LmpzeyJpbXBvcnRzIjpbIi4vdHlwZXMuanMiXSwiZXhwb3J0cyI6WyJGYWlsIiwiTm9uTnVsbGlzaCIsImFuIiwiYXNzZXJ0IiwiZGV0YWlscyIsImlkZW50Q2hlY2tlciIsIm1ha2VBc3NlcnQiLCJxIiwicXVvdGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3R5cGVzLmpzXCIsIFtdXV0pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShhbiwgJ25hbWUnLCB7dmFsdWU6IFwiYW5cIn0pOyRo4oCNX29uY2UuYW4oYW4pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuXG5jb25zdHtmcmVlemV9PU9iamVjdDtcblxuLyoqIEB0eXBlIHtBc3NlcnR9ICovXG5jb25zdCBnbG9iYWxBc3NlcnQ9Z2xvYmFsVGhpcy5hc3NlcnQ7JGjigI1fb25jZS5nbG9iYWxBc3NlcnQoZ2xvYmFsQXNzZXJ0KTtcblxuaWYoZ2xvYmFsQXNzZXJ0PT09dW5kZWZpbmVkKXtcbnRocm93IEVycm9yKFxuIGBDYW5ub3QgaW5pdGlhbGl6ZSBAYWdvcmljL2Fzc2VydCwgbWlzc2luZyBnbG9iYWxUaGlzLmFzc2VydCwgaW1wb3J0ICdzZXMnIGJlZm9yZSAnQGFnb3JpYy9hc3NlcnQnYCk7XG5cbiB9XG5cbmNvbnN0IG1pc3Npbmc9LyoqIEB0eXBlIHtjb25zdH0gKi9bXG4nZmFpbCcsXG4nZXF1YWwnLFxuJ3R5cGVvZicsXG4nc3RyaW5nJyxcbidub3RlJyxcbidkZXRhaWxzJyxcbidGYWlsJyxcbidxdW90ZScsXG4nbWFrZUFzc2VydCddLlxuZmlsdGVyKChuYW1lKT0+Z2xvYmFsQXNzZXJ0W25hbWVdPT09dW5kZWZpbmVkKTtcbmlmKG1pc3NpbmcubGVuZ3RoPjApe1xudGhyb3cgRXJyb3IoXG4gYENhbm5vdCBpbml0aWFsaXplIEBhZ29yaWMvYXNzZXJ0LCBtaXNzaW5nIGdsb2JhbFRoaXMuYXNzZXJ0IG1ldGhvZHMgJHttaXNzaW5nLmpvaW4oXG4nLCAnKVxuIH1gKTtcblxuIH1cblxuY29uc3R7ZGV0YWlscyxGYWlsLHF1b3RlLG1ha2VBc3NlcnR9PWdsb2JhbEFzc2VydDskaOKAjV9vbmNlLmRldGFpbHMoZGV0YWlscyk7JGjigI1fb25jZS5GYWlsKEZhaWwpOyRo4oCNX29uY2UucXVvdGUocXVvdGUpOyRo4oCNX29uY2UubWFrZUFzc2VydChtYWtlQXNzZXJ0KTtcblxuXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VCB8IG51bGwgfCB1bmRlZmluZWR9IHZhbFxuICogQHBhcmFtIHtzdHJpbmd9IFtvcHREZXRhaWxzXVxuICogQHJldHVybnMge1R9XG4gKi9cbmNvbnN0ICAgICAgICBOb25OdWxsaXNoPSh2YWwsb3B0RGV0YWlscz0gYHVuZXhwZWN0ZWQgJHtxdW90ZSh2YWwpfWApPT57XG5pZih2YWwhPW51bGwpe1xuLyogVGhpcyBgIT0gbnVsbGAgaWRpb20gY2hlY2tzIHRoYXQgYHZhbGAgaXMgbmVpdGhlciBgbnVsbGAgbm9yIGB1bmRlZmluZWRgLiovXG5yZXR1cm4gdmFsO1xuIH1cbmFzc2VydC5mYWlsKG9wdERldGFpbHMpO1xuIH07JGjigI1fb25jZS5Ob25OdWxsaXNoKE5vbk51bGxpc2gpO1xuaGFyZGVuKE5vbk51bGxpc2gpO1xuXG4vKipcbiAqIFByZXBlbmQgdGhlIGNvcnJlY3QgaW5kZWZpbml0ZSBhcnRpY2xlIG9udG8gYSBub3VuLCB0eXBpY2FsbHkgYSB0eXBlb2YgcmVzdWx0XG4gKiBlLmcuLCBcImFuIE9iamVjdFwiIHZzLiBcImEgTnVtYmVyXCJcbiAqXG4gKiBAZGVwcmVjYXRlZFxuICogQHBhcmFtIHtzdHJpbmd9IHN0ciBUaGUgbm91biB0byBwcmVwZW5kXG4gKiBAcmV0dXJucyB7c3RyaW5nfSBUaGUgbm91biBwcmVwZW5kZWQgd2l0aCBhL2FuXG4gKi9cbmZ1bmN0aW9uIGFuKHN0cil7XG5zdHI9IGAke3N0cn1gO1xuaWYoc3RyLmxlbmd0aD49MSYmJ2FlaW91QUVJT1UnLmluY2x1ZGVzKHN0clswXSkpe1xucmV0dXJuIGBhbiAke3N0cn1gO1xuIH1cbnJldHVybiBgYSAke3N0cn1gO1xuIH1cbmZyZWV6ZShhbik7XG5cblxuLyoqXG4gKiBJbiB0aGUgYGFzc2VydEZvb2AvYGlzRm9vYC9gY2hlY2tGb29gIHBhdHRlcm4sIGBjaGVja0Zvb2AgaGFzIGEgYGNoZWNrYFxuICogcGFyYW1ldGVyIG9mIHR5cGUgYENoZWNrZXJgLiBgYXNzZXJ0Rm9vYCBjYWxscyBgY2hlY2tGb29gIHBhc3Nlc1xuICogYGFzc2VydENoZWNrZXJgIGFzIHRoZSBgY2hlY2tgIGFyZ3VtZW50LiBgaXNGb29gIHBhc3NlcyBgaWRlbnRDaGVja2VyYFxuICogYXMgdGhlIGBjaGVja2AgYXJndW1lbnQuIGBpZGVudENoZWNrZXJgIGFjdHMgcHJlY2lzZWx5IGxpa2UgYW5cbiAqIGlkZW50aXR5IGZ1bmN0aW9uLCBidXQgaXMgdHlwZWQgYXMgYSBgQ2hlY2tlcmAgdG8gaW5kaWNhdGUgaXRzXG4gKiBpbnRlbmRlZCB1c2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpZGVudENoZWNrZXI9KGNvbmQsX2RldGFpbHMpPT5jb25kOyRo4oCNX29uY2UuaWRlbnRDaGVja2VyKGlkZW50Q2hlY2tlcik7XG5oYXJkZW4oaWRlbnRDaGVja2VyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnQiOlsiZ2xvYmFsQXNzZXJ0Il0sImRldGFpbHMiOlsiZGV0YWlscyJdLCJGYWlsIjpbIkZhaWwiXSwicXVvdGUiOlsicXVvdGUiXSwicSI6WyJxdW90ZSJdLCJtYWtlQXNzZXJ0IjpbIm1ha2VBc3NlcnQiXSwiYW4iOlsiYW4iXSwiTm9uTnVsbGlzaCI6WyJOb25OdWxsaXNoIl0sImlkZW50Q2hlY2tlciI6WyJpZGVudENoZWNrZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABbmH7NouAADaLgAAIgAAAEBhZ29yaWMvYXNzZXJ0LXYwLjYuMC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAdHMtY2hlY2sqL1xuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuLyogQmFzZWQgb24qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2Jsb2IvSEVBRC9wYWNrYWdlcy9zZXMvc3JjL2Vycm9yL3R5cGVzLmpzKi9cbi8qIENvb3JkaW5hdGUgZWRpdHMgdW50aWwgd2UgcmVmYWN0b3IgdG8gYXZvaWQgdGhpcyBkdXBsaWNhdGlvbiovXG4vKiBBdCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzI3NzQqL1xuLyogaXMgYSByZWNvcmQgb2YgYSBmYWlsZWQgYXR0ZW1wdCB0byByZW1vdmUgdGhpcyBkdXBsaWNhdGlvbi4qL1xuXG4vKipcbiAqIEBjYWxsYmFjayBCYXNlQXNzZXJ0XG4gKiBUaGUgYGFzc2VydGAgZnVuY3Rpb24gaXRzZWxmLlxuICpcbiAqIEBwYXJhbSB7Kn0gZmxhZyBUaGUgdHJ1dGh5L2ZhbHN5IHZhbHVlXG4gKiBAcGFyYW0ge0RldGFpbHN9IFtvcHREZXRhaWxzXSBUaGUgZGV0YWlscyB0byB0aHJvd1xuICogQHBhcmFtIHtFcnJvckNvbnN0cnVjdG9yfSBbRXJyb3JDb25zdHJ1Y3Rvcl0gQW4gb3B0aW9uYWwgYWx0ZXJuYXRlIGVycm9yXG4gKiBjb25zdHJ1Y3RvciB0byB1c2UuXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBmbGFnfVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQXNzZXJ0TWFrZUVycm9yT3B0aW9uc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IFtlcnJvck5hbWVdXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0TWFrZUVycm9yXG4gKlxuICogVGhlIGBhc3NlcnQuZXJyb3JgIG1ldGhvZCwgcmVjb3JkaW5nIGRldGFpbHMgZm9yIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBvcHRpb25hbCBgb3B0RGV0YWlsc2AgY2FuIGJlIGEgc3RyaW5nLlxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc10gVGhlIGRldGFpbHMgb2Ygd2hhdCB3YXMgYXNzZXJ0ZWRcbiAqIEBwYXJhbSB7RXJyb3JDb25zdHJ1Y3Rvcn0gW0Vycm9yQ29uc3RydWN0b3JdIEFuIG9wdGlvbmFsIGFsdGVybmF0ZSBlcnJvclxuICogY29uc3RydWN0b3IgdG8gdXNlLlxuICogQHBhcmFtIHtBc3NlcnRNYWtlRXJyb3JPcHRpb25zfSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHtFcnJvcn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRGYWlsXG4gKlxuICogVGhlIGBhc3NlcnQuZmFpbGAgbWV0aG9kLlxuICpcbiAqIEZhaWwgYW4gYXNzZXJ0aW9uLCByZWNvcmRpbmcgZnVsbCBkZXRhaWxzIHRvIHRoZSBjb25zb2xlIGFuZFxuICogcmFpc2luZyBhbiBleGNlcHRpb24gd2l0aCBhIG1lc3NhZ2UgaW4gd2hpY2ggYGRldGFpbHNgIHN1YnN0aXR1dGlvbiB2YWx1ZXNcbiAqIGhhdmUgYmVlbiBtYXNrZWQuXG4gKlxuICogVGhlIG9wdGlvbmFsIGBvcHREZXRhaWxzYCBjYW4gYmUgYSBzdHJpbmcgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5XG4gKiB3aXRoIHRoZSBub2RlanMgYXNzZXJ0aW9uIGxpYnJhcnkuXG4gKiBAcGFyYW0ge0RldGFpbHN9IFtvcHREZXRhaWxzXSBUaGUgZGV0YWlscyBvZiB3aGF0IHdhcyBhc3NlcnRlZFxuICogQHBhcmFtIHtFcnJvckNvbnN0cnVjdG9yfSBbRXJyb3JDb25zdHJ1Y3Rvcl0gQW4gb3B0aW9uYWwgYWx0ZXJuYXRlIGVycm9yXG4gKiBjb25zdHJ1Y3RvciB0byB1c2UuXG4gKiBAcmV0dXJucyB7bmV2ZXJ9XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0RXF1YWxcbiAqIFRoZSBgYXNzZXJ0LmVxdWFsYCBtZXRob2RcbiAqXG4gKiBBc3NlcnQgdGhhdCB0d28gdmFsdWVzIG11c3QgYmUgYE9iamVjdC5pc2AuXG4gKiBAcGFyYW0geyp9IGFjdHVhbCBUaGUgdmFsdWUgd2UgcmVjZWl2ZWRcbiAqIEBwYXJhbSB7Kn0gZXhwZWN0ZWQgV2hhdCB3ZSB3YW50ZWRcbiAqIEBwYXJhbSB7RGV0YWlsc30gW29wdERldGFpbHNdIFRoZSBkZXRhaWxzIHRvIHRocm93XG4gKiBAcGFyYW0ge0Vycm9yQ29uc3RydWN0b3J9IFtFcnJvckNvbnN0cnVjdG9yXSBBbiBvcHRpb25hbCBhbHRlcm5hdGUgZXJyb3JcbiAqIGNvbnN0cnVjdG9yIHRvIHVzZS5cbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5cbi8qIFR5cGUgYWxsIHRoZSBvdmVybG9hZHMgb2YgdGhlIGFzc2VydFR5cGVvZiBmdW5jdGlvbi4qL1xuLyogVGhlcmUgbWF5IGV2ZW50dWFsbHkgYmUgYSBiZXR0ZXIgd2F5IHRvIGRvIHRoaXMsIGJ1dCovXG4vKiB0aGVtcyB0aGUgYnJlYWtzIHdpdGggVHlwZXNjcmlwdCA0LjAuKi9cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFR5cGVvZkJpZ2ludFxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuXG4gKiBAcGFyYW0geydiaWdpbnQnfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIGJpZ2ludH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRUeXBlb2ZCb29sZWFuXG4gKiBAcGFyYW0ge2FueX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7J2Jvb2xlYW4nfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIGJvb2xlYW59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0VHlwZW9mRnVuY3Rpb25cbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHBhcmFtIHsnZnVuY3Rpb24nfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIEZ1bmN0aW9ufVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFR5cGVvZk51bWJlclxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuXG4gKiBAcGFyYW0geydudW1iZXInfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIG51bWJlcn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRUeXBlb2ZPYmplY3RcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHBhcmFtIHsnb2JqZWN0J30gdHlwZW5hbWVcbiAqIEBwYXJhbSB7RGV0YWlsc30gW29wdERldGFpbHNdXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBzcGVjaW1lbiBpcyBSZWNvcmQ8YW55LCBhbnk+IHwgbnVsbH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRUeXBlb2ZTdHJpbmdcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHBhcmFtIHsnc3RyaW5nJ30gdHlwZW5hbWVcbiAqIEBwYXJhbSB7RGV0YWlsc30gW29wdERldGFpbHNdXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBzcGVjaW1lbiBpcyBzdHJpbmd9XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0VHlwZW9mU3ltYm9sXG4gKiBAcGFyYW0ge2FueX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7J3N5bWJvbCd9IHR5cGVuYW1lXG4gKiBAcGFyYW0ge0RldGFpbHN9IFtvcHREZXRhaWxzXVxuICogQHJldHVybnMge2Fzc2VydHMgc3BlY2ltZW4gaXMgc3ltYm9sfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFR5cGVvZlVuZGVmaW5lZFxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuXG4gKiBAcGFyYW0geyd1bmRlZmluZWQnfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIHVuZGVmaW5lZH1cbiAqL1xuXG4vKipcbiAqIFRoZSBgYXNzZXJ0LnR5cGVvZmAgbWV0aG9kXG4gKlxuICogQHR5cGVkZWYge0Fzc2VydFR5cGVvZkJpZ2ludCAmIEFzc2VydFR5cGVvZkJvb2xlYW4gJiBBc3NlcnRUeXBlb2ZGdW5jdGlvbiAmIEFzc2VydFR5cGVvZk51bWJlciAmIEFzc2VydFR5cGVvZk9iamVjdCAmIEFzc2VydFR5cGVvZlN0cmluZyAmIEFzc2VydFR5cGVvZlN5bWJvbCAmIEFzc2VydFR5cGVvZlVuZGVmaW5lZH0gQXNzZXJ0VHlwZW9mXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0U3RyaW5nXG4gKiBUaGUgYGFzc2VydC5zdHJpbmdgIG1ldGhvZC5cbiAqXG4gKiBgYXNzZXJ0LnN0cmluZyh2KWAgaXMgZXF1aXZhbGVudCB0byBgYXNzZXJ0LnR5cGVvZih2LCAnc3RyaW5nJylgLiBXZVxuICogc3BlY2lhbCBjYXNlIHRoaXMgb25lIGJlY2F1c2UgaXQgaXMgdGhlIG1vc3QgZnJlcXVlbnRseSB1c2VkLlxuICpcbiAqIEFzc2VydCBhbiBleHBlY3RlZCB0eXBlb2YgcmVzdWx0LlxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuIFRoZSB2YWx1ZSB0byBnZXQgdGhlIHR5cGVvZlxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc10gVGhlIGRldGFpbHMgdG8gdGhyb3dcbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIHN0cmluZ31cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnROb3RlXG4gKiBUaGUgYGFzc2VydC5ub3RlYCBtZXRob2QuXG4gKlxuICogQW5ub3RhdGUgYW4gZXJyb3Igd2l0aCBkZXRhaWxzLCBwb3RlbnRpYWxseSB0byBiZSB1c2VkIGJ5IGFuXG4gKiBhdWdtZW50ZWQgY29uc29sZSBzdWNoIGFzIHRoZSBjYXVzYWwgY29uc29sZSBvZiBgY29uc29sZS5qc2AsIHRvXG4gKiBwcm92aWRlIGV4dHJhIGluZm9ybWF0aW9uIGFzc29jaWF0ZWQgd2l0aCBsb2dnZWQgZXJyb3JzLlxuICpcbiAqIEBwYXJhbSB7RXJyb3J9IGVycm9yXG4gKiBAcGFyYW0ge0RldGFpbHN9IGRldGFpbHNOb3RlXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHR5cGVkZWYge3t9fSBEZXRhaWxzVG9rZW5cbiAqIEEgY2FsbCB0byB0aGUgYGRldGFpbHNgIHRlbXBsYXRlIGxpdGVyYWwgbWFrZXMgYW5kIHJldHVybnMgYSBmcmVzaCBkZXRhaWxzXG4gKiB0b2tlbiwgd2hpY2ggaXMgYSBmcm96ZW4gZW1wdHkgb2JqZWN0IGFzc29jaWF0ZWQgd2l0aCB0aGUgYXJndW1lbnRzIG9mIHRoYXRcbiAqIGBkZXRhaWxzYCB0ZW1wbGF0ZSBsaXRlcmFsIGV4cHJlc3Npb24uXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nIHwgRGV0YWlsc1Rva2VufSBEZXRhaWxzXG4gKiBFaXRoZXIgYSBwbGFpbiBzdHJpbmcsIG9yIG1hZGUgYnkgdGhlIGBkZXRhaWxzYCB0ZW1wbGF0ZSBsaXRlcmFsIHRhZy5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN0cmluZ2FibGVQYXlsb2FkXG4gKiBIb2xkcyB0aGUgcGF5bG9hZCBwYXNzZWQgdG8gcXVvdGUgc28gdGhhdCBpdHMgcHJpbnRlZCBmb3JtIGlzIHZpc2libGUuXG4gKiBAcHJvcGVydHkgeygpID0+IHN0cmluZ30gdG9TdHJpbmcgSG93IHRvIHByaW50IHRoZSBwYXlsb2FkXG4gKi9cblxuLyoqXG4gKiBUbyBcImRlY2xhc3NpZnlcIiBhbmQgcXVvdGUgYSBzdWJzdGl0dXRpb24gdmFsdWUgdXNlZCBpbiBhXG4gKiBgYGAgZGV0YWlsc2AuLi5gIGBgYCB0ZW1wbGF0ZSBsaXRlcmFsLCBlbmNsb3NlIHRoYXQgc3Vic3RpdHV0aW9uIGV4cHJlc3Npb25cbiAqIGluIGEgY2FsbCB0byBgcXVvdGVgLiBUaGlzIG1ha2VzIHRoZSB2YWx1ZSBhcHBlYXIgcXVvdGVkXG4gKiAoYXMgaWYgd2l0aCBgSlNPTi5zdHJpbmdpZnlgKSBpbiB0aGUgbWVzc2FnZSBvZiB0aGUgdGhyb3duIGVycm9yLiBUaGVcbiAqIHBheWxvYWQgaXRzZWxmIGlzIHN0aWxsIHBhc3NlZCB1bnF1b3RlZCB0byB0aGUgY29uc29sZSBhcyBpdCB3b3VsZCBiZVxuICogd2l0aG91dCBgcXVvdGVgLlxuICpcbiAqIEZvciBleGFtcGxlLCB0aGUgZm9sbG93aW5nIHdpbGwgcmV2ZWFsIHRoZSBleHBlY3RlZCBza3kgY29sb3IsIGJ1dCBub3QgdGhlXG4gKiBhY3R1YWwgaW5jb3JyZWN0IHNreSBjb2xvciwgaW4gdGhlIHRocm93biBlcnJvcidzIG1lc3NhZ2U6XG4gKiBgYGBqc1xuICogc2t5LmNvbG9yID09PSBleHBlY3RlZENvbG9yIHx8IEZhaWxgJHtza3kuY29sb3J9IHNob3VsZCBiZSAke3F1b3RlKGV4cGVjdGVkQ29sb3IpfWA7XG4gKiBgYGBcbiAqXG4gKiBUaGUgbm9ybWFsIGNvbnZlbnRpb24gaXMgdG8gbG9jYWxseSByZW5hbWUgYGRldGFpbHNgIHRvIGBYYCBhbmQgYHF1b3RlYCB0byBgcWBcbiAqIGxpa2UgYGNvbnN0IHsgZGV0YWlsczogWCwgcXVvdGU6IHEgfSA9IGFzc2VydDtgLCBzbyB0aGUgYWJvdmUgZXhhbXBsZSB3b3VsZCB0aGVuIGJlXG4gKiBgYGBqc1xuICogc2t5LmNvbG9yID09PSBleHBlY3RlZENvbG9yIHx8IEZhaWxgJHtza3kuY29sb3J9IHNob3VsZCBiZSAke3EoZXhwZWN0ZWRDb2xvcil9YDtcbiAqIGBgYFxuICpcbiAqIEBjYWxsYmFjayBBc3NlcnRRdW90ZVxuICogQHBhcmFtIHsqfSBwYXlsb2FkIFdoYXQgdG8gZGVjbGFzc2lmeVxuICogQHBhcmFtIHsoc3RyaW5nfG51bWJlcil9IFtzcGFjZXNdXG4gKiBAcmV0dXJucyB7U3RyaW5nYWJsZVBheWxvYWR9IFRoZSBkZWNsYXNzaWZpZWQgcGF5bG9hZFxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFJhaXNlXG4gKlxuICogVG8gbWFrZSBhbiBgYXNzZXJ0YCB3aGljaCB0ZXJtaW5hdGVzIHNvbWUgbGFyZ2VyIHVuaXQgb2YgY29tcHV0YXRpb25cbiAqIGxpa2UgYSB0cmFuc2FjdGlvbiwgdmF0LCBvciBwcm9jZXNzLCBjYWxsIGBtYWtlQXNzZXJ0YCB3aXRoIGEgYFJhaXNlYFxuICogY2FsbGJhY2ssIHdoZXJlIHRoYXQgY2FsbGJhY2sgYWN0dWFsbHkgcGVyZm9ybXMgdGhhdCBsYXJnZXIgdGVybWluYXRpb24uXG4gKiBJZiBwb3NzaWJsZSwgdGhlIGNhbGxiYWNrIHNob3VsZCBhbHNvIHJlcG9ydCBpdHMgYHJlYXNvbmAgcGFyYW1ldGVyIGFzXG4gKiB0aGUgYWxsZWdlZCByZWFzb24gZm9yIHRoZSB0ZXJtaW5hdGlvbi5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSByZWFzb25cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBNYWtlQXNzZXJ0XG4gKlxuICogTWFrZXMgYW5kIHJldHVybnMgYW4gYGFzc2VydGAgZnVuY3Rpb24gb2JqZWN0IHRoYXQgc2hhcmVzIHRoZSBib29ra2VlcGluZ1xuICogc3RhdGUgZGVmaW5lZCBieSB0aGlzIG1vZHVsZSB3aXRoIG90aGVyIGBhc3NlcnRgIGZ1bmN0aW9uIG9iamVjdHMgbWFkZSBieVxuICogYG1ha2VBc3NlcnRgLiBUaGlzIHN0YXRlIGlzIHBlci1tb2R1bGUtaW5zdGFuY2UgYW5kIGlzIGV4cG9zZWQgYnkgdGhlXG4gKiBgbG9nZ2VkRXJyb3JIYW5kbGVyYCBhYm92ZS4gV2UgcmVmZXIgdG8gYGFzc2VydGAgYXMgYSBcImZ1bmN0aW9uIG9iamVjdFwiXG4gKiBiZWNhdXNlIGl0IGNhbiBiZSBjYWxsZWQgZGlyZWN0bHkgYXMgYSBmdW5jdGlvbiwgYnV0IGFsc28gaGFzIG1ldGhvZHMgdGhhdFxuICogY2FuIGJlIGNhbGxlZC5cbiAqXG4gKiBJZiBgb3B0UmFpc2VgIGlzIHByb3ZpZGVkLCB0aGUgcmV0dXJuZWQgYGFzc2VydGAgZnVuY3Rpb24gb2JqZWN0IHdpbGwgY2FsbFxuICogYG9wdFJhaXNlKHJlYXNvbilgIGJlZm9yZSB0aHJvd2luZyB0aGUgZXJyb3IuIFRoaXMgZW5hYmxlcyBgb3B0UmFpc2VgIHRvXG4gKiBlbmdhZ2UgaW4gZXZlbiBtb3JlIHZpb2xlbnQgdGVybWluYXRpb24gYmVoYXZpb3IsIGxpa2UgdGVybWluYXRpbmcgdGhlIHZhdCxcbiAqIHRoYXQgcHJldmVudHMgZXhlY3V0aW9uIGZyb20gcmVhY2hpbmcgdGhlIGZvbGxvd2luZyB0aHJvdy4gSG93ZXZlciwgaWZcbiAqIGBvcHRSYWlzZWAgcmV0dXJucyBub3JtYWxseSwgd2hpY2ggd291bGQgYmUgdW51c3VhbCwgdGhlIHRocm93IGZvbGxvd2luZ1xuICogYG9wdFJhaXNlKHJlYXNvbilgIHdvdWxkIHN0aWxsIGhhcHBlbi5cbiAqXG4gKiBAcGFyYW0ge1JhaXNlfSBbb3B0UmFpc2VdXG4gKiBAcGFyYW0ge2Jvb2xlYW59IFt1bnJlZGFjdGVkXVxuICogQHJldHVybnMge0Fzc2VydH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsodGVtcGxhdGU6IFRlbXBsYXRlU3RyaW5nc0FycmF5IHwgc3RyaW5nW10sIC4uLmFyZ3M6IGFueSkgPT4gRGV0YWlsc1Rva2VufSBEZXRhaWxzVGFnXG4gKlxuICogVXNlIHRoZSBgZGV0YWlsc2AgZnVuY3Rpb24gYXMgYSB0ZW1wbGF0ZSBsaXRlcmFsIHRhZyB0byBjcmVhdGVcbiAqIGluZm9ybWF0aXZlIGVycm9yIG1lc3NhZ2VzLiBUaGUgYXNzZXJ0aW9uIGZ1bmN0aW9ucyB0YWtlIHN1Y2ggbWVzc2FnZXNcbiAqIGFzIG9wdGlvbmFsIGFyZ3VtZW50czpcbiAqIGBgYGpzXG4gKiBhc3NlcnQoc2t5LmlzQmx1ZSgpLCBkZXRhaWxzYCR7c2t5LmNvbG9yfSBzaG91bGQgYmUgXCJibHVlXCJgKTtcbiAqIGBgYFxuICogb3IgZm9sbG93aW5nIHRoZSBub3JtYWwgY29udmVudGlvbiB0byBsb2NhbGx5IHJlbmFtZSBgZGV0YWlsc2AgdG8gYFhgXG4gKiBhbmQgYHF1b3RlYCB0byBgcWAgbGlrZSBgY29uc3QgeyBkZXRhaWxzOiBYLCBxdW90ZTogcSB9ID0gYXNzZXJ0O2A6XG4gKiBgYGBqc1xuICogYXNzZXJ0KHNreS5pc0JsdWUoKSwgWGAke3NreS5jb2xvcn0gc2hvdWxkIGJlIFwiYmx1ZVwiYCk7XG4gKiBgYGBcbiAqIEhvd2V2ZXIsIG5vdGUgdGhhdCBpbiBtb3N0IGNhc2VzIGl0IGlzIHByZWZlcmFibGUgdG8gaW5zdGVhZCB1c2UgdGhlIGBGYWlsYFxuICogdGVtcGxhdGUgbGl0ZXJhbCB0YWcgKHdoaWNoIGhhcyB0aGUgc2FtZSBpbnB1dCBzaWduYXR1cmUgYXMgYGRldGFpbHNgXG4gKiBidXQgYXV0b21hdGljYWxseSBjcmVhdGVzIGFuZCB0aHJvd3MgYW4gZXJyb3IpOlxuICogYGBganNcbiAqIHNreS5pc0JsdWUoKSB8fCBGYWlsYCR7c2t5LmNvbG9yfSBzaG91bGQgYmUgXCJibHVlXCJgO1xuICogYGBgXG4gKlxuICogVGhlIGRldGFpbHMgdGVtcGxhdGUgdGFnIHJldHVybnMgYSBgRGV0YWlsc1Rva2VuYCBvYmplY3QgdGhhdCBjYW4gcHJpbnRcbiAqIGl0c2VsZiB3aXRoIHRoZSBmb3JtYXR0ZWQgbWVzc2FnZSBpbiB0d28gd2F5cy5cbiAqIEl0IHdpbGwgcmVwb3J0IGZ1bGwgZGV0YWlscyB0byB0aGUgY29uc29sZSwgYnV0XG4gKiBtYXNrIGVtYmVkZGVkIHN1YnN0aXR1dGlvbiB2YWx1ZXMgd2l0aCB0aGVpciB0eXBlb2YgaW5mb3JtYXRpb24gaW4gdGhlIHRocm93biBlcnJvclxuICogdG8gcHJldmVudCByZXZlYWxpbmcgc2VjcmV0cyB1cCB0aGUgZXhjZXB0aW9uYWwgcGF0aC4gSW4gdGhlIGV4YW1wbGVcbiAqIGFib3ZlLCB0aGUgdGhyb3duIGVycm9yIG1heSByZXZlYWwgb25seSB0aGF0IGBza3kuY29sb3JgIGlzIGEgc3RyaW5nLFxuICogd2hlcmVhcyB0aGUgc2FtZSBkaWFnbm9zdGljIHByaW50ZWQgdG8gdGhlIGNvbnNvbGUgcmV2ZWFscyB0aGF0IHRoZVxuICogc2t5IHdhcyBncmVlbi4gVGhpcyBtYXNraW5nIGNhbiBiZSBkaXNhYmxlZCBmb3IgYW4gaW5kaXZpZHVhbCBzdWJzdGl0dXRpb24gdmFsdWVcbiAqIHVzaW5nIGBxdW90ZWAuXG4gKlxuICogVGhlIGByYXdgIHByb3BlcnR5IG9mIGFuIGlucHV0IHRlbXBsYXRlIGFycmF5IGlzIGlnbm9yZWQsIHNvIGEgc2ltcGxlXG4gKiBhcnJheSBvZiBzdHJpbmdzIG1heSBiZSBwcm92aWRlZCBkaXJlY3RseS5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsodGVtcGxhdGU6IFRlbXBsYXRlU3RyaW5nc0FycmF5IHwgc3RyaW5nW10sIC4uLmFyZ3M6IGFueSkgPT4gbmV2ZXJ9IEZhaWxUYWdcbiAqXG4gKiBVc2UgdGhlIGBGYWlsYCBmdW5jdGlvbiBhcyBhIHRlbXBsYXRlIGxpdGVyYWwgdGFnIHRvIGVmZmljaWVudGx5XG4gKiBjcmVhdGUgYW5kIHRocm93IGEgYGRldGFpbHNgLXN0eWxlIGVycm9yIG9ubHkgd2hlbiBhIGNvbmRpdGlvbiBpcyBub3Qgc2F0aXNmaWVkLlxuICogYGBganNcbiAqIGNvbmRpdGlvbiB8fCBGYWlsYC4uLmNvbXBsYWludC4uLmA7XG4gKiBgYGBcbiAqIFRoaXMgYXZvaWRzIHRoZSBvdmVyaGVhZCBvZiBjcmVhdGluZyB1c3VhbGx5LXVubmVjZXNzYXJ5IGVycm9ycyBsaWtlXG4gKiBgYGBqc1xuICogYXNzZXJ0KGNvbmRpdGlvbiwgZGV0YWlsc2AuLi5jb21wbGFpbnQuLi5gKTtcbiAqIGBgYFxuICogd2hpbGUgaW1wcm92aW5nIHJlYWRhYmlsaXR5IG92ZXIgYWx0ZXJuYXRpdmVzIGxpa2VcbiAqIGBgYGpzXG4gKiBjb25kaXRpb24gfHwgYXNzZXJ0LmZhaWwoZGV0YWlsc2AuLi5jb21wbGFpbnQuLi5gKTtcbiAqIGBgYFxuICpcbiAqIEhvd2V2ZXIsIGR1ZSB0byBjdXJyZW50IHdlYWtuZXNzIGluIFR5cGVTY3JpcHQsIHN0YXRpYyByZWFzb25pbmdcbiAqIGlzIGxlc3MgcG93ZXJmdWwgd2l0aCB0aGUgYHx8YCBwYXR0ZXJucyB0aGFuIHdpdGggYW4gYGFzc2VydGAgY2FsbC5cbiAqIFVudGlsL3VubGVzcyBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUxNDI2IGlzIGZpeGVkLFxuICogZm9yIGB8fGAtc3R5bGUgYXNzZXJ0aW9ucyB3aGVyZSB0aGlzIGxvc3Mgb2Ygc3RhdGljIHJlYXNvbmluZyBpcyBhIHByb2JsZW0sXG4gKiBpbnN0ZWFkIGV4cHJlc3MgdGhlIGFzc2VydGlvbiBhc1xuICogYGBganNcbiAqICAgaWYgKCFjb25kaXRpb24pIHtcbiAqICAgICBGYWlsYC4uLmNvbXBsYWludC4uLmA7XG4gKiAgIH1cbiAqIGBgYFxuICogb3IsIGlmIG5lZWRlZCxcbiAqIGBgYGpzXG4gKiAgIGlmICghY29uZGl0aW9uKSB7XG4gKiAgICAgLy8gYHRocm93YCBpcyBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MsIGJ1dCBpdCBpbXByb3ZlcyBzdGF0aWMgYW5hbHlzaXNcbiAqICAgICB0aHJvdyBGYWlsYC4uLmNvbXBsYWludC4uLmA7XG4gKiAgIH1cbiAqIGBgYFxuICovXG5cbi8qKlxuICogYXNzZXJ0IHRoYXQgZXhwciBpcyB0cnV0aHksIHdpdGggYW4gb3B0aW9uYWwgZGV0YWlscyB0byBkZXNjcmliZVxuICogdGhlIGFzc2VydGlvbi4gSXQgaXMgYSB0YWdnZWQgdGVtcGxhdGUgbGl0ZXJhbCBsaWtlXG4gKiBgYGBqc1xuICogYXNzZXJ0KGV4cHIsIGRldGFpbHNgLi4uLmApO2BcbiAqIGBgYFxuICpcbiAqIFRoZSBsaXRlcmFsIHBvcnRpb25zIG9mIHRoZSB0ZW1wbGF0ZSBhcmUgYXNzdW1lZCBub24tc2Vuc2l0aXZlLCBhc1xuICogYXJlIHRoZSBgdHlwZW9mYCB0eXBlcyBvZiB0aGUgc3Vic3RpdHV0aW9uIHZhbHVlcy4gVGhlc2UgYXJlXG4gKiBhc3NlbWJsZWQgaW50byB0aGUgdGhyb3duIGVycm9yIG1lc3NhZ2UuIFRoZSBhY3R1YWwgY29udGVudHMgb2YgdGhlXG4gKiBzdWJzdGl0dXRpb24gdmFsdWVzIGFyZSBhc3N1bWVkIHNlbnNpdGl2ZSwgdG8gYmUgcmV2ZWFsZWQgdG9cbiAqIHRoZSBjb25zb2xlIG9ubHkuIFdlIGFzc3VtZSBvbmx5IHRoZSB2aXJ0dWFsIHBsYXRmb3JtJ3Mgb3duZXIgY2FuIHJlYWRcbiAqIHdoYXQgaXMgd3JpdHRlbiB0byB0aGUgY29uc29sZSwgd2hlcmUgdGhlIG93bmVyIGlzIGluIGEgcHJpdmlsZWdlZFxuICogcG9zaXRpb24gb3ZlciBjb21wdXRhdGlvbiBydW5uaW5nIG9uIHRoYXQgcGxhdGZvcm0uXG4gKlxuICogVGhlIG9wdGlvbmFsIGBvcHREZXRhaWxzYCBjYW4gYmUgYSBzdHJpbmcgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5XG4gKiB3aXRoIHRoZSBub2RlanMgYXNzZXJ0aW9uIGxpYnJhcnkuXG4gKlxuICogQHR5cGVkZWYgeyBCYXNlQXNzZXJ0ICYge1xuICogICB0eXBlb2Y6IEFzc2VydFR5cGVvZixcbiAqICAgZXJyb3I6IEFzc2VydE1ha2VFcnJvcixcbiAqICAgZmFpbDogQXNzZXJ0RmFpbCxcbiAqICAgZXF1YWw6IEFzc2VydEVxdWFsLFxuICogICBzdHJpbmc6IEFzc2VydFN0cmluZyxcbiAqICAgbm90ZTogQXNzZXJ0Tm90ZSxcbiAqICAgZGV0YWlsczogRGV0YWlsc1RhZyxcbiAqICAgRmFpbDogRmFpbFRhZyxcbiAqICAgcXVvdGU6IEFzc2VydFF1b3RlLFxuICogICBtYWtlQXNzZXJ0OiBNYWtlQXNzZXJ0LFxuICogfSB9IEFzc2VydFxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAFP1hb9GNwAARjcAACwAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvYW1vdW50TWF0aC5qc3siaW1wb3J0cyI6WyIuL21hdGhIZWxwZXJzL2NvcHlCYWdNYXRoSGVscGVycy5qcyIsIi4vbWF0aEhlbHBlcnMvY29weVNldE1hdGhIZWxwZXJzLmpzIiwiLi9tYXRoSGVscGVycy9uYXRNYXRoSGVscGVycy5qcyIsIi4vbWF0aEhlbHBlcnMvc2V0TWF0aEhlbHBlcnMuanMiLCJAYWdvcmljL3N0b3JlIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbIkFtb3VudE1hdGgiLCJBc3NldEtpbmQiLCJhc3NlcnRBc3NldEtpbmQiLCJhc3NlcnRWYWx1ZUdldEhlbHBlcnMiLCJnZXRBc3NldEtpbmQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcGFzc1N0eWxlT2YsYXNzZXJ0UmVtb3RhYmxlLGFzc2VydFJlY29yZCxNLG1hdGNoZXMsbmF0TWF0aEhlbHBlcnMsc2V0TWF0aEhlbHBlcnMsY29weVNldE1hdGhIZWxwZXJzLGNvcHlCYWdNYXRoSGVscGVyczskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcImFzc2VydFJlbW90YWJsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UmVtb3RhYmxlID0gJGjigI1fYSldXSxbXCJhc3NlcnRSZWNvcmRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlY29yZCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJtYXRjaGVzXCIsIFskaOKAjV9hID0+IChtYXRjaGVzID0gJGjigI1fYSldXV1dLFtcIi4vbWF0aEhlbHBlcnMvbmF0TWF0aEhlbHBlcnMuanNcIiwgW1tcIm5hdE1hdGhIZWxwZXJzXCIsIFskaOKAjV9hID0+IChuYXRNYXRoSGVscGVycyA9ICRo4oCNX2EpXV1dXSxbXCIuL21hdGhIZWxwZXJzL3NldE1hdGhIZWxwZXJzLmpzXCIsIFtbXCJzZXRNYXRoSGVscGVyc1wiLCBbJGjigI1fYSA9PiAoc2V0TWF0aEhlbHBlcnMgPSAkaOKAjV9hKV1dXV0sW1wiLi9tYXRoSGVscGVycy9jb3B5U2V0TWF0aEhlbHBlcnMuanNcIiwgW1tcImNvcHlTZXRNYXRoSGVscGVyc1wiLCBbJGjigI1fYSA9PiAoY29weVNldE1hdGhIZWxwZXJzID0gJGjigI1fYSldXV1dLFtcIi4vbWF0aEhlbHBlcnMvY29weUJhZ01hdGhIZWxwZXJzLmpzXCIsIFtbXCJjb3B5QmFnTWF0aEhlbHBlcnNcIiwgWyRo4oCNX2EgPT4gKGNvcHlCYWdNYXRoSGVscGVycyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuLyoqXG4gKiBDb25zdGFudHMgZm9yIHRoZSBraW5kcyBvZiBhc3NldHMgd2Ugc3VwcG9ydC5cbiAqXG4gKiBAdHlwZSB7eyBOQVQ6ICduYXQnLCBTRVQ6ICdzZXQnLCBDT1BZX1NFVDogJ2NvcHlTZXQnLCBDT1BZX0JBRzogJ2NvcHlCYWcnIH19XG4gKi9cbmNvbnN0IEFzc2V0S2luZD1oYXJkZW4oe1xuTkFUOiduYXQnLFxuU0VUOidzZXQnLFxuQ09QWV9TRVQ6J2NvcHlTZXQnLFxuQ09QWV9CQUc6J2NvcHlCYWcnfSk7JGjigI1fb25jZS5Bc3NldEtpbmQoQXNzZXRLaW5kKTtcblxuY29uc3QgYXNzZXRLaW5kTmFtZXM9aGFyZGVuKE9iamVjdC52YWx1ZXMoQXNzZXRLaW5kKS5zb3J0KCkpO1xuXG4vKipcbiAqIEBwYXJhbSB7QXNzZXRLaW5kfSBhbGxlZ2VkQUtcbiAqL1xuY29uc3QgYXNzZXJ0QXNzZXRLaW5kPShhbGxlZ2VkQUspPT57XG5hc3NldEtpbmROYW1lcy5pbmNsdWRlcyhhbGxlZ2VkQUspfHxcbkZhaWwgYFRoZSBhc3NldEtpbmQgJHthbGxlZ2VkQUt9IG11c3QgYmUgb25lIG9mICR7cShhc3NldEtpbmROYW1lcyl9YDtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0QXNzZXRLaW5kKGFzc2VydEFzc2V0S2luZCk7XG5oYXJkZW4oYXNzZXJ0QXNzZXRLaW5kKTtcblxuLyoqXG4gKiBBbW91bnRzIGRlc2NyaWJlIGRpZ2l0YWwgYXNzZXRzLiBGcm9tIGFuIGFtb3VudCwgeW91IGNhbiBsZWFybiB0aGVcbiAqIGJyYW5kIG9mIGRpZ2l0YWwgYXNzZXQgYXMgd2VsbCBhcyBcImhvdyBtdWNoXCIgb3IgXCJob3cgbWFueVwiLiBBbW91bnRzXG4gKiBoYXZlIHR3byBwYXJ0czogYSBicmFuZCAobG9vc2VseSBzcGVha2luZywgdGhlIHR5cGUgb2YgZGlnaXRhbFxuICogYXNzZXQpIGFuZCB0aGUgdmFsdWUgKHRoZSBhbnN3ZXIgdG8gXCJob3cgbXVjaFwiKS4gRm9yIGV4YW1wbGUsIGluXG4gKiB0aGUgcGhyYXNlIFwiNSBidWNrc1wiLCBcImJ1Y2tzXCIgdGFrZXMgdGhlIHJvbGUgb2YgdGhlIGJyYW5kIGFuZCB0aGVcbiAqIHZhbHVlIGlzIDUuIEFtb3VudHMgY2FuIGRlc2NyaWJlIGZ1bmdpYmxlIGFuZCBub24tZnVuZ2libGUgZGlnaXRhbFxuICogYXNzZXRzLiBBbW91bnRzIGFyZSBwYXNzLWJ5LWNvcHkgYW5kIGNhbiBiZSBtYWRlIGJ5IGFuZCBzZW50IHRvXG4gKiBhbnlvbmUuXG4gKlxuICogVGhlIGlzc3VlciBpcyB0aGUgYXV0aG9yaXRhdGl2ZSBzb3VyY2Ugb2YgdGhlIGFtb3VudCBpbiBwYXltZW50c1xuICogYW5kIHB1cnNlcy4gVGhlIGlzc3VlciBtdXN0IGJlIGFibGUgdG8gZG8gdGhpbmdzIHN1Y2ggYXMgYWRkXG4gKiBkaWdpdGFsIGFzc2V0cyB0byBhIHB1cnNlIGFuZCB3aXRoZHJhdyBkaWdpdGFsIGFzc2V0cyBmcm9tIGEgcHVyc2UuXG4gKiBUbyBkbyBzbywgaXQgbXVzdCBrbm93IGhvdyB0byBhZGQgYW5kIHN1YnRyYWN0IGRpZ2l0YWwgYXNzZXRzLlxuICogUmF0aGVyIHRoYW4gaGFyZC1jb2RpbmcgYSBwYXJ0aWN1bGFyIHNvbHV0aW9uLCB3ZSBjaG9zZSB0b1xuICogcGFyYW1ldGVyaXplIHRoZSBpc3N1ZXIgd2l0aCBhIGNvbGxlY3Rpb24gb2YgcG9seW1vcnBoaWMgZnVuY3Rpb25zLFxuICogd2hpY2ggd2UgY2FsbCBgQW1vdW50TWF0aGAuIFRoZXNlIG1hdGggZnVuY3Rpb25zIGluY2x1ZGUgY29uY2VwdHNcbiAqIGxpa2UgYWRkaXRpb24sIHN1YnRyYWN0aW9uLCBhbmQgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvLlxuICpcbiAqIFdlIGFsc28gd2FudCB0byBtYWtlIHN1cmUgdGhlcmUgaXMgbm8gY29uZnVzaW9uIGFzIHRvIHdoYXQga2luZCBvZlxuICogYXNzZXQgd2UgYXJlIHVzaW5nLiBUaHVzLCBBbW91bnRNYXRoIGluY2x1ZGVzIGNoZWNrcyBvZiB0aGVcbiAqIGBicmFuZGAsIHRoZSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHR5cGUgb2YgZGlnaXRhbCBhc3NldC4gSWZcbiAqIHRoZSB3cm9uZyBicmFuZCBpcyB1c2VkIGluIEFtb3VudE1hdGgsIGFuIGVycm9yIGlzIHRocm93biBhbmQgdGhlXG4gKiBvcGVyYXRpb24gZG9lcyBub3Qgc3VjY2VlZC5cbiAqXG4gKiBBbW91bnRNYXRoIHVzZXMgbWF0aEhlbHBlcnMgdG8gZG8gbW9zdCBvZiB0aGUgd29yaywgYnV0IHRoZW4gYWRkc1xuICogdGhlIGJyYW5kIHRvIHRoZSByZXN1bHQuIFRoZSBmdW5jdGlvbiBgdmFsdWVgIGdldHMgdGhlIHZhbHVlIGZyb21cbiAqIHRoZSBhbW91bnQgYnkgcmVtb3ZpbmcgdGhlIGJyYW5kIChhbW91bnQgLT4gdmFsdWUpLCBhbmQgdGhlXG4gKiBmdW5jdGlvbiBgbWFrZWAgYWRkcyB0aGUgYnJhbmQgdG8gcHJvZHVjZSBhbiBhbW91bnQgKHZhbHVlIC0+XG4gKiBhbW91bnQpLiBUaGUgZnVuY3Rpb24gYGNvZXJjZWAgdGFrZXMgYW4gYW1vdW50IGFuZCBjaGVja3MgaXQsXG4gKiByZXR1cm5pbmcgYW4gYW1vdW50IChhbW91bnQgLT4gYW1vdW50KS5cbiAqXG4gKiBFYWNoIGlzc3VlciBvZiBkaWdpdGFsIGFzc2V0cyBoYXMgYW4gYXNzb2NpYXRlZCBicmFuZCBpbiBhXG4gKiBvbmUtdG8tb25lIG1hcHBpbmcuIEluIHVudHJ1c3RlZCBjb250ZXh0cywgc3VjaCBhcyBpbiBhbmFseXppbmdcbiAqIHBheW1lbnRzIGFuZCBhbW91bnRzLCB3ZSBjYW4gZ2V0IHRoZSBicmFuZCBhbmQgZmluZCB0aGUgaXNzdWVyXG4gKiB3aGljaCBtYXRjaGVzIHRoZSBicmFuZC4gVGhlIGlzc3VlciBhbmQgdGhlIGJyYW5kIG11dHVhbGx5IHZhbGlkYXRlXG4gKiBlYWNoIG90aGVyLlxuICovXG5cbmNvbnN0IGhlbHBlcnM9e1xubmF0Om5hdE1hdGhIZWxwZXJzLFxuc2V0OnNldE1hdGhIZWxwZXJzLFxuY29weVNldDpjb3B5U2V0TWF0aEhlbHBlcnMsXG5jb3B5QmFnOmNvcHlCYWdNYXRoSGVscGVyc307XG5cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Ftb3VudFZhbHVlfSBWXG4gKiBAdHlwZSB7KHZhbHVlOiBWKSA9PiBBc3NldEtpbmRGb3JWYWx1ZTxWPn1cbiAqL1xuY29uc3QgYXNzZXJ0VmFsdWVHZXRBc3NldEtpbmQ9KHZhbHVlKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHZhbHVlKTtcbmlmKHBhc3NTdHlsZT09PSdiaWdpbnQnKXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCovXG5yZXR1cm4nbmF0JztcbiB9XG5pZihwYXNzU3R5bGU9PT0nY29weUFycmF5Jyl7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xucmV0dXJuJ3NldCc7XG4gfVxuaWYobWF0Y2hlcyh2YWx1ZSxNLnNldCgpKSl7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xucmV0dXJuJ2NvcHlTZXQnO1xuIH1cbmlmKG1hdGNoZXModmFsdWUsTS5iYWcoKSkpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBjYXN0Ki9cbnJldHVybidjb3B5QmFnJztcbiB9XG4vKiBUT0RPIFRoaXMgaXNuJ3QgcXVpdGUgdGhlIHJpZ2h0IGVycm9yIG1lc3NhZ2UsIGluIGNhc2UgdmFsdWVQYXNzU3R5bGUqL1xuLyogaXMgJ3RhZ2dlZCcuIFdlIHdvdWxkIG5lZWQgdG8gZGlzdGluZ3Vpc2ggd2hhdCBraW5kIG9mIHRhZ2dlZCovXG4vKiBvYmplY3QgaXQgaXMuKi9cbi8qIEFsc28sIHRoaXMga2luZCBvZiBtYW51YWwgbGlzdGluZyBpcyBhIG1haW50ZW5hbmNlIGhhemFyZCB3ZSovXG4vKiAoVE9ETykgd2lsbCBlbmNvdW50ZXIgd2hlbiB3ZSBleHRlbmQgdGhlIG1hdGggaGVscGVycyBmdXJ0aGVyLiovXG50aHJvdyBGYWlsIGB2YWx1ZSAke3ZhbHVlfSBtdXN0IGJlIGEgYmlnaW50LCBjb3B5U2V0LCBjb3B5QmFnLCBvciBhbiBhcnJheSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9O1xuXG4vKipcbiAqIEFzc2VydHMgdGhhdCB2YWx1ZSBpcyBhIHZhbGlkIEFtb3VudE1hdGggYW5kIHJldHVybnMgdGhlIGFwcHJvcHJpYXRlIGhlbHBlcnMuXG4gKlxuICogTWFkZSBhdmFpbGFibGUgb25seSBmb3IgdGVzdGluZywgYnV0IGl0IGlzIGhhcm1sZXNzIGZvciBvdGhlciB1c2VzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QW1vdW50VmFsdWV9IFZcbiAqIEBwYXJhbSB7Vn0gdmFsdWVcbiAqIEByZXR1cm5zIHtNYXRoSGVscGVyczxWPn1cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFZhbHVlR2V0SGVscGVycz0odmFsdWUpPT5cbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCovXG5oZWxwZXJzW2Fzc2VydFZhbHVlR2V0QXNzZXRLaW5kKHZhbHVlKV07XG5cbi8qKiBAdHlwZSB7KGFsbGVnZWRCcmFuZDogQnJhbmQsIGJyYW5kPzogQnJhbmQpID0+IHZvaWR9ICovJGjigI1fb25jZS5hc3NlcnRWYWx1ZUdldEhlbHBlcnMoYXNzZXJ0VmFsdWVHZXRIZWxwZXJzKTtcbmNvbnN0IG9wdGlvbmFsQnJhbmRDaGVjaz0oYWxsZWdlZEJyYW5kLGJyYW5kKT0+e1xuaWYoYnJhbmQhPT11bmRlZmluZWQpe1xuYXNzZXJ0UmVtb3RhYmxlKGJyYW5kLCdicmFuZCcpO1xuYWxsZWdlZEJyYW5kPT09YnJhbmR8fFxuRmFpbCBgYW1vdW50J3MgYnJhbmQgJHtxKGFsbGVnZWRCcmFuZCl9IGRpZCBub3QgbWF0Y2ggZXhwZWN0ZWQgYnJhbmQgJHtxKFxuYnJhbmQpXG4gfWA7XG4gfVxuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSBsZWZ0QW1vdW50XG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gcmlnaHRBbW91bnRcbiAqIEBwYXJhbSB7QnJhbmQ8Sz4gfCB1bmRlZmluZWR9IGJyYW5kXG4gKiBAcmV0dXJucyB7TWF0aEhlbHBlcnM8Kj59XG4gKi9cbmNvbnN0IGNoZWNrTFJBbmRHZXRIZWxwZXJzPShsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kPXVuZGVmaW5lZCk9PntcbmFzc2VydFJlY29yZChsZWZ0QW1vdW50LCdsZWZ0QW1vdW50Jyk7XG5hc3NlcnRSZWNvcmQocmlnaHRBbW91bnQsJ3JpZ2h0QW1vdW50Jyk7XG5jb25zdHt2YWx1ZTpsZWZ0VmFsdWUsYnJhbmQ6bGVmdEJyYW5kfT1sZWZ0QW1vdW50O1xuY29uc3R7dmFsdWU6cmlnaHRWYWx1ZSxicmFuZDpyaWdodEJyYW5kfT1yaWdodEFtb3VudDtcbmFzc2VydFJlbW90YWJsZShsZWZ0QnJhbmQsJ2xlZnRCcmFuZCcpO1xuYXNzZXJ0UmVtb3RhYmxlKHJpZ2h0QnJhbmQsJ3JpZ2h0QnJhbmQnKTtcbm9wdGlvbmFsQnJhbmRDaGVjayhsZWZ0QnJhbmQsYnJhbmQpO1xub3B0aW9uYWxCcmFuZENoZWNrKHJpZ2h0QnJhbmQsYnJhbmQpO1xubGVmdEJyYW5kPT09cmlnaHRCcmFuZHx8XG5GYWlsIGBCcmFuZHMgaW4gbGVmdCAke3EobGVmdEJyYW5kKX0gYW5kIHJpZ2h0ICR7cShcbnJpZ2h0QnJhbmQpXG4gfSBzaG91bGQgbWF0Y2ggYnV0IGRvIG5vdGA7XG5jb25zdCBsZWZ0SGVscGVycz1hc3NlcnRWYWx1ZUdldEhlbHBlcnMobGVmdFZhbHVlKTtcbmNvbnN0IHJpZ2h0SGVscGVycz1hc3NlcnRWYWx1ZUdldEhlbHBlcnMocmlnaHRWYWx1ZSk7XG5sZWZ0SGVscGVycz09PXJpZ2h0SGVscGVyc3x8XG5GYWlsIGBUaGUgbGVmdCAke2xlZnRBbW91bnR9IGFuZCByaWdodCBhbW91bnQgJHtyaWdodEFtb3VudH0gaGFkIGRpZmZlcmVudCBhc3NldEtpbmRzYDtcbnJldHVybiBsZWZ0SGVscGVycztcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge01hdGhIZWxwZXJzPEFzc2V0VmFsdWVGb3JLaW5kPEs+Pn0gaFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IGxlZnRBbW91bnRcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSByaWdodEFtb3VudFxuICogQHJldHVybnMge1tLLCBLXX1cbiAqL1xuY29uc3QgY29lcmNlTFI9KGgsbGVmdEFtb3VudCxyaWdodEFtb3VudCk9Pntcbi8qIEB0cy1leHBlY3QtZXJyb3IgY291bGQgYmUgYXJiaXRyYXJ5IHN1YnR5cGUqL1xucmV0dXJuW2guZG9Db2VyY2UobGVmdEFtb3VudC52YWx1ZSksaC5kb0NvZXJjZShyaWdodEFtb3VudC52YWx1ZSldO1xuIH07XG5cbi8qKlxuICogUmV0dXJucyB0cnVlIGlmIHRoZSBsZWZ0QW1vdW50IGlzIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byB0aGVcbiAqIHJpZ2h0QW1vdW50LiBUaGUgbm90aW9uIG9mIFwiZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvXCIgZGVwZW5kc1xuICogb24gdGhlIGtpbmQgb2YgYW1vdW50LCBhcyBkZWZpbmVkIGJ5IHRoZSBNYXRoSGVscGVycy4gRm9yIGV4YW1wbGUsXG4gKiB3aGV0aGVyIHJlY3RhbmdsZSBBIGlzIGdyZWF0ZXIgdGhhbiByZWN0YW5nbGUgQiBkZXBlbmRzIG9uIHdoZXRoZXIgcmVjdGFuZ2xlXG4gKiBBIGluY2x1ZGVzIHJlY3RhbmdsZSBCIGFzIGRlZmluZWQgYnkgdGhlIGxvZ2ljIGluIE1hdGhIZWxwZXJzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gbGVmdEFtb3VudFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IHJpZ2h0QW1vdW50XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgaXNHVEU9KGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuY29uc3QgaD1jaGVja0xSQW5kR2V0SGVscGVycyhsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kKTtcbnJldHVybiBoLmRvSXNHVEUoLi4uY29lcmNlTFIoaCxsZWZ0QW1vdW50LHJpZ2h0QW1vdW50KSk7XG4gfTtcblxuLyoqXG4gKiBMb2dpYyBmb3IgbWFuaXB1bGF0aW5nIGFtb3VudHMuXG4gKlxuICogQW1vdW50cyBhcmUgdGhlIGNhbm9uaWNhbCBkZXNjcmlwdGlvbiBvZiB0cmFkYWJsZSBnb29kcy4gVGhleSBhcmUgbWFuaXB1bGF0ZWRcbiAqIGJ5IGlzc3VlcnMgYW5kIG1pbnRzLCBhbmQgcmVwcmVzZW50IHRoZSBnb29kcyBhbmQgY3VycmVuY3kgY2FycmllZCBieSBwdXJzZXNcbiAqIGFuZFxuICogcGF5bWVudHMuIFRoZXkgY2FuIGJlIHVzZWQgdG8gcmVwcmVzZW50IHRoaW5ncyBsaWtlIGN1cnJlbmN5LCBzdG9jaywgYW5kIHRoZVxuICogYWJzdHJhY3QgcmlnaHQgdG8gcGFydGljaXBhdGUgaW4gYSBwYXJ0aWN1bGFyIGV4Y2hhbmdlLlxuICovXG5jb25zdCBBbW91bnRNYXRoPXtcbi8qKlxuICogTWFrZSBhbiBhbW91bnQgZnJvbSBhIHZhbHVlIGJ5IGFkZGluZyB0aGUgYnJhbmQuXG4gKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7QnJhbmQ8Sz59IGJyYW5kXG4gKiBAcGFyYW0ge0Fzc2V0VmFsdWVGb3JLaW5kPEs+fSBhbGxlZ2VkVmFsdWVcbiAqIEByZXR1cm5zIHtBbW91bnQ8Sz59XG4gKi9cbi8qIGFsbGVnZWRWYWx1ZSBoYXMgYSBjb25kaXRpb25hbCBleHByZXNzaW9uIGZvciB0eXBlIHdpZGVuaW5nLCB0byBwcmV2ZW50IFYgYmVpbmcgYm91bmQgdG8gYSBhIGxpdGVyYWwgbGlrZSAxbiovXG5tYWtlOihicmFuZCxhbGxlZ2VkVmFsdWUpPT57XG5hc3NlcnRSZW1vdGFibGUoYnJhbmQsJ2JyYW5kJyk7XG5jb25zdCBoPWFzc2VydFZhbHVlR2V0SGVscGVycyhhbGxlZ2VkVmFsdWUpO1xuY29uc3QgdmFsdWU9aC5kb0NvZXJjZShhbGxlZ2VkVmFsdWUpO1xucmV0dXJuIGhhcmRlbih7YnJhbmQsdmFsdWV9KTtcbiB9LFxuLyoqXG4gKiBNYWtlIHN1cmUgdGhpcyBhbW91bnQgaXMgdmFsaWQgZW5vdWdoLCBhbmQgcmV0dXJuIGEgY29ycmVzcG9uZGluZ1xuICogdmFsaWQgYW1vdW50IGlmIHNvLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBicmFuZFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IGFsbGVnZWRBbW91bnRcbiAqIEByZXR1cm5zIHtBbW91bnQ8Sz59XG4gKi9cbmNvZXJjZTooYnJhbmQsYWxsZWdlZEFtb3VudCk9PntcbmFzc2VydFJlbW90YWJsZShicmFuZCwnYnJhbmQnKTtcbmFzc2VydFJlY29yZChhbGxlZ2VkQW1vdW50LCdhbW91bnQnKTtcbmNvbnN0e2JyYW5kOmFsbGVnZWRCcmFuZCx2YWx1ZTphbGxlZ2VkVmFsdWV9PWFsbGVnZWRBbW91bnQ7XG5icmFuZD09PWFsbGVnZWRCcmFuZHx8XG5GYWlsIGBUaGUgYnJhbmQgaW4gdGhlIGFsbGVnZWRBbW91bnQgJHthbGxlZ2VkQW1vdW50fSBpbiAnY29lcmNlJyBkaWRuJ3QgbWF0Y2ggdGhlIHNwZWNpZmllZCBicmFuZCAke2JyYW5kfS5gO1xuLyogV2lsbCB0aHJvdyBvbiBpbmFwcHJvcHJpYXRlIHZhbHVlKi9cbnJldHVybiBBbW91bnRNYXRoLm1ha2UoYnJhbmQsYWxsZWdlZFZhbHVlKTtcbiB9LFxuLyoqXG4gKiBFeHRyYWN0IGFuZCByZXR1cm4gdGhlIHZhbHVlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBicmFuZFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IGFtb3VudFxuICogQHJldHVybnMge0Fzc2V0VmFsdWVGb3JLaW5kPEs+fVxuICovXG5nZXRWYWx1ZTooYnJhbmQsYW1vdW50KT0+QW1vdW50TWF0aC5jb2VyY2UoYnJhbmQsYW1vdW50KS52YWx1ZSxcbi8qKlxuICogUmV0dXJuIHRoZSBhbW91bnQgcmVwcmVzZW50aW5nIGFuIGVtcHR5IGFtb3VudC4gVGhpcyBpcyB0aGVcbiAqIGlkZW50aXR5IGVsZW1lbnQgZm9yIE1hdGhIZWxwZXJzLmFkZCBhbmQgTWF0SGVscGVycy5zdWJ0cmFjdC5cbiAqXG4gKiBAdHlwZSB7e1xuICogICAoYnJhbmQ6IEJyYW5kKTogQW1vdW50PCduYXQnPjtcbiAqICAgPEsgZXh0ZW5kcyBBc3NldEtpbmQ+KGJyYW5kOiBCcmFuZCwgYXNzZXRLaW5kOiBLKTogQW1vdW50PEs+O1xuICogfX1cbiAqL1xubWFrZUVtcHR5OihicmFuZCxhc3NldEtpbmQ9LyoqIEB0eXBlIHtjb25zdH0gKi8nbmF0Jyk9PntcbmFzc2VydFJlbW90YWJsZShicmFuZCwnYnJhbmQnKTtcbmFzc2VydEFzc2V0S2luZChhc3NldEtpbmQpO1xuY29uc3QgdmFsdWU9aGVscGVyc1thc3NldEtpbmRdLmRvTWFrZUVtcHR5KCk7XG5yZXR1cm4gaGFyZGVuKHticmFuZCx2YWx1ZX0pO1xuIH0sXG4vKipcbiAqIFJldHVybiB0aGUgYW1vdW50IHJlcHJlc2VudGluZyBhbiBlbXB0eSBhbW91bnQsIHVzaW5nIGFub3RoZXJcbiAqIGFtb3VudCBhcyB0aGUgdGVtcGxhdGUgZm9yIHRoZSBicmFuZCBhbmQgYXNzZXRLaW5kLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gYW1vdW50XG4gKiBAcmV0dXJucyB7QW1vdW50PEs+fVxuICovXG5tYWtlRW1wdHlGcm9tQW1vdW50OihhbW91bnQpPT57XG5hc3NlcnRSZWNvcmQoYW1vdW50LCdhbW91bnQnKTtcbmNvbnN0e2JyYW5kLHZhbHVlfT1hbW91bnQ7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xuY29uc3QgYXNzZXRLaW5kPWFzc2VydFZhbHVlR2V0QXNzZXRLaW5kKHZhbHVlKTtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCAoaWdub3JlIGIvYyBlcnJvcmluZyBpbiBDSSBidXQgbm90IG15IElERSkqL1xucmV0dXJuIEFtb3VudE1hdGgubWFrZUVtcHR5KGJyYW5kLGFzc2V0S2luZCk7XG4gfSxcbi8qKlxuICogUmV0dXJuIHRydWUgaWYgdGhlIEFtb3VudCBpcyBlbXB0eS4gT3RoZXJ3aXNlIGZhbHNlLlxuICpcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnRcbiAqIEBwYXJhbSB7QnJhbmR9IFticmFuZF1cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5pc0VtcHR5OihhbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuYXNzZXJ0UmVjb3JkKGFtb3VudCwnYW1vdW50Jyk7XG5jb25zdHticmFuZDphbGxlZ2VkQnJhbmQsdmFsdWV9PWFtb3VudDtcbmFzc2VydFJlbW90YWJsZShhbGxlZ2VkQnJhbmQsJ2JyYW5kJyk7XG5vcHRpb25hbEJyYW5kQ2hlY2soYWxsZWdlZEJyYW5kLGJyYW5kKTtcbmNvbnN0IGg9YXNzZXJ0VmFsdWVHZXRIZWxwZXJzKHZhbHVlKTtcbnJldHVybiBoLmRvSXNFbXB0eShoLmRvQ29lcmNlKHZhbHVlKSk7XG4gfSxcbmlzR1RFLFxuLyoqXG4gKiBSZXR1cm5zIHRydWUgaWYgdGhlIGxlZnRBbW91bnQgZXF1YWxzIHRoZSByaWdodEFtb3VudC4gV2UgYXNzdW1lXG4gKiB0aGF0IGlmIGlzR1RFIGlzIHRydWUgaW4gYm90aCBkaXJlY3Rpb25zLCBpc0VxdWFsIGlzIGFsc28gdHJ1ZVxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gbGVmdEFtb3VudFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IHJpZ2h0QW1vdW50XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuaXNFcXVhbDoobGVmdEFtb3VudCxyaWdodEFtb3VudCxicmFuZD11bmRlZmluZWQpPT57XG5jb25zdCBoPWNoZWNrTFJBbmRHZXRIZWxwZXJzKGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQpO1xucmV0dXJuIGguZG9Jc0VxdWFsKC4uLmNvZXJjZUxSKGgsbGVmdEFtb3VudCxyaWdodEFtb3VudCkpO1xuIH0sXG4vKipcbiAqIFJldHVybnMgYSBuZXcgYW1vdW50IHRoYXQgaXMgdGhlIHVuaW9uIG9mIGJvdGggbGVmdEFtb3VudCBhbmQgcmlnaHRBbW91bnQuXG4gKlxuICogRm9yIGZ1bmdpYmxlIGFtb3VudCB0aGlzIG1lYW5zIGFkZGluZyB0aGUgdmFsdWVzLiBGb3Igb3RoZXIga2luZHMgb2ZcbiAqIGFtb3VudCwgaXQgdXN1YWxseSBtZWFucyBpbmNsdWRpbmcgYWxsIG9mIHRoZSBlbGVtZW50cyBmcm9tIGJvdGhcbiAqIGxlZnQgYW5kIHJpZ2h0LlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gbGVmdEFtb3VudFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IHJpZ2h0QW1vdW50XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7QW1vdW50PEs+fVxuICovXG5hZGQ6KGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuY29uc3QgaD1jaGVja0xSQW5kR2V0SGVscGVycyhsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kKTtcbmNvbnN0IHZhbHVlPWguZG9BZGQoLi4uY29lcmNlTFIoaCxsZWZ0QW1vdW50LHJpZ2h0QW1vdW50KSk7XG5yZXR1cm4gaGFyZGVuKHticmFuZDpsZWZ0QW1vdW50LmJyYW5kLHZhbHVlfSk7XG4gfSxcbi8qKlxuICogUmV0dXJucyBhIG5ldyBhbW91bnQgdGhhdCBpcyB0aGUgbGVmdEFtb3VudCBtaW51cyB0aGUgcmlnaHRBbW91bnRcbiAqIChpLmUuIGV2ZXJ5dGhpbmcgaW4gdGhlIGxlZnRBbW91bnQgdGhhdCBpcyBub3QgaW4gdGhlXG4gKiByaWdodEFtb3VudCkuIElmIGxlZnRBbW91bnQgZG9lc24ndCBpbmNsdWRlIHJpZ2h0QW1vdW50XG4gKiAoc3VidHJhY3Rpb24gcmVzdWx0cyBpbiBhIG5lZ2F0aXZlKSwgdGhyb3cgIGFuIGVycm9yLiBCZWNhdXNlIHRoZVxuICogbGVmdCBhbW91bnQgbXVzdCBpbmNsdWRlIHRoZSByaWdodCBhbW91bnQsIHRoaXMgaXMgTk9UIGVxdWl2YWxlbnRcbiAqIHRvIHNldCBzdWJ0cmFjdGlvbi5cbiAqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gS1xuICogQHBhcmFtIHtBbW91bnQ8Sz59IGxlZnRBbW91bnRcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSByaWdodEFtb3VudFxuICogQHBhcmFtIHtCcmFuZDxLPn0gW2JyYW5kXVxuICogQHJldHVybnMge0Ftb3VudDxLPn1cbiAqL1xuc3VidHJhY3Q6KGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuY29uc3QgaD1jaGVja0xSQW5kR2V0SGVscGVycyhsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kKTtcbmNvbnN0IHZhbHVlPWguZG9TdWJ0cmFjdCguLi5jb2VyY2VMUihoLGxlZnRBbW91bnQscmlnaHRBbW91bnQpKTtcbnJldHVybiBoYXJkZW4oe2JyYW5kOmxlZnRBbW91bnQuYnJhbmQsdmFsdWV9KTtcbiB9LFxuLyoqXG4gKiBSZXR1cm5zIHRoZSBtaW4gdmFsdWUgYmV0d2VlbiB4IGFuZCB5IHVzaW5nIGlzR1RFXG4gKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSB4XG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0geVxuICogQHBhcmFtIHtCcmFuZDxLPn0gW2JyYW5kXVxuICogQHJldHVybnMge0Ftb3VudDxLPn1cbiAqL1xubWluOih4LHksYnJhbmQ9dW5kZWZpbmVkKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnkqL1xuaXNHVEUoeCx5LGJyYW5kKT9cbnk6XG5pc0dURSh5LHgsYnJhbmQpP1xueDpcbkZhaWwgYCR7eH0gYW5kICR7eX0gYXJlIGluY29tcGFyYWJsZWAsXG4vKipcbiAqIFJldHVybnMgdGhlIG1heCB2YWx1ZSBiZXR3ZWVuIHggYW5kIHkgdXNpbmcgaXNHVEVcbiAqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gS1xuICogQHBhcmFtIHtBbW91bnQ8Sz59IHhcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSB5XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7QW1vdW50PEs+fVxuICovXG5tYXg6KHgseSxicmFuZD11bmRlZmluZWQpPT5cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1uZXN0ZWQtdGVybmFyeSovXG5pc0dURSh4LHksYnJhbmQpP1xueDpcbmlzR1RFKHkseCk/XG55OlxuRmFpbCBgJHt4fSBhbmQgJHt5fSBhcmUgaW5jb21wYXJhYmxlYH07JGjigI1fb25jZS5BbW91bnRNYXRoKEFtb3VudE1hdGgpO1xuXG5oYXJkZW4oQW1vdW50TWF0aCk7XG5cbi8qKlxuICogQHBhcmFtIHtBbW91bnR9IGFtb3VudFxuICovXG5jb25zdCBnZXRBc3NldEtpbmQ9KGFtb3VudCk9PntcbmFzc2VydFJlY29yZChhbW91bnQsJ2Ftb3VudCcpO1xuY29uc3R7dmFsdWV9PWFtb3VudDtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCAoaWdub3JlIGIvYyBlcnJvcmluZyBpbiBDSSBidXQgbm90IG15IElERSkqL1xucmV0dXJuIGFzc2VydFZhbHVlR2V0QXNzZXRLaW5kKHZhbHVlKTtcbiB9OyRo4oCNX29uY2UuZ2V0QXNzZXRLaW5kKGdldEFzc2V0S2luZCk7XG5oYXJkZW4oZ2V0QXNzZXRLaW5kKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJBc3NldEtpbmQiOlsiQXNzZXRLaW5kIl0sImFzc2VydEFzc2V0S2luZCI6WyJhc3NlcnRBc3NldEtpbmQiXSwiQW1vdW50TWF0aCI6WyJBbW91bnRNYXRoIl0sImdldEFzc2V0S2luZCI6WyJnZXRBc3NldEtpbmQiXSwiYXNzZXJ0VmFsdWVHZXRIZWxwZXJzIjpbImFzc2VydFZhbHVlR2V0SGVscGVycyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABKlADt1QUAANUFAAAtAAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL2Rpc3BsYXlJbmZvLmpzeyJpbXBvcnRzIjpbIi4vdHlwZUd1YXJkcy5qcyIsIkBhZ29yaWMvYXNzZXJ0IiwiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbImNvZXJjZURpc3BsYXlJbmZvIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhaWwsbXVzdE1hdGNoLERpc3BsYXlJbmZvU2hhcGU7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9hc3NlcnRcIiwgW1tcIkZhaWxcIiwgWyRo4oCNX2EgPT4gKEZhaWwgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJEaXNwbGF5SW5mb1NoYXBlXCIsIFskaOKAjV9hID0+IChEaXNwbGF5SW5mb1NoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG4vKipcbiAqIEBwYXJhbSB7QWRkaXRpb25hbERpc3BsYXlJbmZvfSBhbGxlZ2VkRGlzcGxheUluZm9cbiAqIEBwYXJhbSB7QXNzZXRLaW5kfSBhc3NldEtpbmRcbiAqIEByZXR1cm5zIHtEaXNwbGF5SW5mb31cbiAqL1xuY29uc3QgICAgICAgIGNvZXJjZURpc3BsYXlJbmZvPShhbGxlZ2VkRGlzcGxheUluZm8sYXNzZXRLaW5kKT0+e1xubXVzdE1hdGNoKGFsbGVnZWREaXNwbGF5SW5mbyxEaXNwbGF5SW5mb1NoYXBlLCdkaXNwbGF5SW5mbycpO1xuXG5pZihhbGxlZ2VkRGlzcGxheUluZm8uYXNzZXRLaW5kIT09dW5kZWZpbmVkKXtcbmFsbGVnZWREaXNwbGF5SW5mby5hc3NldEtpbmQ9PT1hc3NldEtpbmR8fFxuRmFpbCBgZGlzcGxheUluZm8uYXNzZXRLaW5kIHdhcyBwcmVzZW50ICgke2FsbGVnZWREaXNwbGF5SW5mby5hc3NldEtpbmR9KSBhbmQgZGlkIG5vdCBtYXRjaCB0aGUgYXNzZXRLaW5kIGFyZ3VtZW50ICgke2Fzc2V0S2luZH0pYDtcbiB9XG5jb25zdCBkaXNwbGF5SW5mbz1oYXJkZW4oey4uLmFsbGVnZWREaXNwbGF5SW5mbyxhc3NldEtpbmR9KTtcblxuaWYoZGlzcGxheUluZm8uZGVjaW1hbFBsYWNlcyE9PXVuZGVmaW5lZCl7XG5OdW1iZXIuaXNTYWZlSW50ZWdlcihkaXNwbGF5SW5mby5kZWNpbWFsUGxhY2VzKXx8XG5GYWlsIGBkZWNpbWFsUGxhY2VzICR7ZGlzcGxheUluZm8uZGVjaW1hbFBsYWNlc30gaXMgbm90IGEgc2FmZSBpbnRlZ2VyYDtcbiB9XG5cbnJldHVybiBkaXNwbGF5SW5mbztcbiB9OyRo4oCNX29uY2UuY29lcmNlRGlzcGxheUluZm8oY29lcmNlRGlzcGxheUluZm8pO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImNvZXJjZURpc3BsYXlJbmZvIjpbImNvZXJjZURpc3BsYXlJbmZvIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEMwe9zoAQAA6AEAACcAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiLi9hbW91bnRNYXRoLmpzIiwiLi9pc3N1ZXJLaXQuanMiLCIuL3R5cGVHdWFyZHMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL2Ftb3VudE1hdGguanMiLCIuL2lzc3VlcktpdC5qcyIsIi4vdHlwZUd1YXJkcy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vYW1vdW50TWF0aC5qc1wiLCBbXV0sW1wiLi9pc3N1ZXJLaXQuanNcIiwgW11dLFtcIi4vdHlwZUd1YXJkcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAANV3BKJggAACYIAAAKwAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9pc3N1ZXJLaXQuanN7ImltcG9ydHMiOlsiLi9hbW91bnRNYXRoLmpzIiwiLi9kaXNwbGF5SW5mby5qcyIsIi4vcGF5bWVudExlZGdlci5qcyIsIi4vdHlwZXMtYW1iaWVudC5qcyIsIkBhZ29yaWMvYXNzZXJ0IiwiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvdmF0LWRhdGEiXSwiZXhwb3J0cyI6WyJoYXNJc3N1ZXIiLCJtYWtlRHVyYWJsZUlzc3VlcktpdCIsIm1ha2VJc3N1ZXJLaXQiLCJwcmVwYXJlSXNzdWVyS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydCxhc3NlcnRQYXR0ZXJuLG1ha2VTY2FsYXJCaWdNYXBTdG9yZSxBc3NldEtpbmQsYXNzZXJ0QXNzZXRLaW5kLGNvZXJjZURpc3BsYXlJbmZvLHByZXBhcmVQYXltZW50TGVkZ2VyOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJhc3NlcnRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJhc3NlcnRQYXR0ZXJuXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXR0ZXJuID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIm1ha2VTY2FsYXJCaWdNYXBTdG9yZVwiLCBbJGjigI1fYSA9PiAobWFrZVNjYWxhckJpZ01hcFN0b3JlID0gJGjigI1fYSldXV1dLFtcIi4vYW1vdW50TWF0aC5qc1wiLCBbW1wiQXNzZXRLaW5kXCIsIFskaOKAjV9hID0+IChBc3NldEtpbmQgPSAkaOKAjV9hKV1dLFtcImFzc2VydEFzc2V0S2luZFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0QXNzZXRLaW5kID0gJGjigI1fYSldXV1dLFtcIi4vZGlzcGxheUluZm8uanNcIiwgW1tcImNvZXJjZURpc3BsYXlJbmZvXCIsIFskaOKAjV9hID0+IChjb2VyY2VEaXNwbGF5SW5mbyA9ICRo4oCNX2EpXV1dXSxbXCIuL3BheW1lbnRMZWRnZXIuanNcIiwgW1tcInByZXBhcmVQYXltZW50TGVkZ2VyXCIsIFskaOKAjV9hID0+IChwcmVwYXJlUGF5bWVudExlZGdlciA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gQmFnZ2FnZSAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJc3N1ZXJSZWNvcmRcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBuYW1lXG4gKiBAcHJvcGVydHkge0t9IGFzc2V0S2luZFxuICogQHByb3BlcnR5IHtBZGRpdGlvbmFsRGlzcGxheUluZm99IGRpc3BsYXlJbmZvXG4gKiBAcHJvcGVydHkge1BhdHRlcm59IGVsZW1lbnRTaGFwZVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7SXNzdWVyUmVjb3JkPEs+fSBpc3N1ZXJSZWNvcmRcbiAqIEBwYXJhbSB7QmFnZ2FnZX0gaXNzdWVyQmFnZ2FnZVxuICogQHBhcmFtIHtTaHV0ZG93bldpdGhGYWlsdXJlfSBbb3B0U2h1dGRvd25XaXRoRmFpbHVyZV0gSWYgdGhpcyBpc3N1ZXIgZmFpbHNcbiAqIGluIHRoZSBtaWRkbGUgb2YgYW4gYXRvbWljIGFjdGlvbiAod2hpY2ggYnR3IHNob3VsZCBuZXZlciBoYXBwZW4pLCBpdFxuICogcG90ZW50aWFsbHkgbGVhdmVzIGl0cyBsZWRnZXIgaW4gYSBjb3JydXB0ZWQgc3RhdGUuIElmIHRoaXMgZnVuY3Rpb24gd2FzXG4gKiBwcm92aWRlZCwgdGhlbiB0aGUgZmFpbGVkIGF0b21pYyBhY3Rpb24gd2lsbCBjYWxsIGl0LCBzbyB0aGF0IHNvbWVcbiAqIGxhcmdlciB1bml0IG9mIGNvbXB1dGF0aW9uLCBsaWtlIHRoZSBlbmNsb3NpbmcgdmF0LCBjYW4gYmUgc2h1dGRvd25cbiAqIGJlZm9yZSBhbnl0aGluZyBlbHNlIGlzIGNvcnJ1cHRlZCBieSB0aGF0IGNvcnJ1cHRlZCBzdGF0ZS5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzM0MzRcbiAqIEByZXR1cm5zIHtJc3N1ZXJLaXQ8Sz59XG4gKi9cbmNvbnN0IHNldHVwSXNzdWVyS2l0PShcbntuYW1lLGFzc2V0S2luZCxkaXNwbGF5SW5mbyxlbGVtZW50U2hhcGV9LFxuaXNzdWVyQmFnZ2FnZSxcbm9wdFNodXRkb3duV2l0aEZhaWx1cmU9dW5kZWZpbmVkKT0+XG57XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuYXNzZXJ0QXNzZXRLaW5kKGFzc2V0S2luZCk7XG5cbi8qIEFkZCBhc3NldEtpbmQgdG8gZGlzcGxheUluZm8sIG9yIG92ZXJyaWRlIGlmIHByZXNlbnQqL1xuY29uc3QgY2xlYW5EaXNwbGF5SW5mbz1jb2VyY2VEaXNwbGF5SW5mbyhkaXNwbGF5SW5mbyxhc3NldEtpbmQpO1xuaWYob3B0U2h1dGRvd25XaXRoRmFpbHVyZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKG9wdFNodXRkb3duV2l0aEZhaWx1cmUsJ2Z1bmN0aW9uJyk7XG4gfVxuXG5pZihlbGVtZW50U2hhcGUhPT11bmRlZmluZWQpe1xuYXNzZXJ0UGF0dGVybihlbGVtZW50U2hhcGUpO1xuIH1cblxuLyogQXR0ZW51YXRlIHRoZSBwb3dlcmZ1bCBhdXRob3JpdHkgdG8gbWludCBhbmQgY2hhbmdlIGJhbGFuY2VzKi9cbi8qKiBAdHlwZSB7UGF5bWVudExlZGdlcjxLPn0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY291bGQgYmUgaW5zdGFudGlhdGVkIHdpdGggZGlmZmVyZW50IHN1YnR5cGUgb2YgQXNzZXRLaW5kKi9cbmNvbnN0e2lzc3VlcixtaW50LGJyYW5kLG1pbnRSZWNvdmVyeVB1cnNlfT1wcmVwYXJlUGF5bWVudExlZGdlcihcbmlzc3VlckJhZ2dhZ2UsXG5uYW1lLFxuYXNzZXRLaW5kLFxuY2xlYW5EaXNwbGF5SW5mbyxcbmVsZW1lbnRTaGFwZSxcbm9wdFNodXRkb3duV2l0aEZhaWx1cmUpO1xuXG5cbnJldHVybiBoYXJkZW4oe1xuYnJhbmQsXG5pc3N1ZXIsXG5taW50LFxubWludFJlY292ZXJ5UHVyc2UsXG5kaXNwbGF5SW5mbzpjbGVhbkRpc3BsYXlJbmZvfSk7XG5cbiB9O1xuaGFyZGVuKHNldHVwSXNzdWVyS2l0KTtcblxuLyoqIFRoZSBrZXkgYXQgd2hpY2ggdGhlIGlzc3VlciByZWNvcmQgaXMgc3RvcmVkLiAqL1xuY29uc3QgSU5TVEFOQ0VfS0VZPSdpc3N1ZXInO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGlzc3VlckJhZ2dhZ2VcbiAqIEBwYXJhbSB7U2h1dGRvd25XaXRoRmFpbHVyZX0gW29wdFNodXRkb3duV2l0aEZhaWx1cmVdIElmIHRoaXMgaXNzdWVyIGZhaWxzXG4gKiBpbiB0aGUgbWlkZGxlIG9mIGFuIGF0b21pYyBhY3Rpb24gKHdoaWNoIGJ0dyBzaG91bGQgbmV2ZXIgaGFwcGVuKSwgaXRcbiAqIHBvdGVudGlhbGx5IGxlYXZlcyBpdHMgbGVkZ2VyIGluIGEgY29ycnVwdGVkIHN0YXRlLiBJZiB0aGlzIGZ1bmN0aW9uIHdhc1xuICogcHJvdmlkZWQsIHRoZW4gdGhlIGZhaWxlZCBhdG9taWMgYWN0aW9uIHdpbGwgY2FsbCBpdCwgc28gdGhhdCBzb21lXG4gKiBsYXJnZXIgdW5pdCBvZiBjb21wdXRhdGlvbiwgbGlrZSB0aGUgZW5jbG9zaW5nIHZhdCwgY2FuIGJlIHNodXRkb3duXG4gKiBiZWZvcmUgYW55dGhpbmcgZWxzZSBpcyBjb3JydXB0ZWQgYnkgdGhhdCBjb3JydXB0ZWQgc3RhdGUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNDM0XG4gKiBAcmV0dXJucyB7SXNzdWVyS2l0PEs+fVxuICovXG5jb25zdCAgICAgICAgcHJlcGFyZUlzc3VlcktpdD0oXG5pc3N1ZXJCYWdnYWdlLFxub3B0U2h1dGRvd25XaXRoRmFpbHVyZT11bmRlZmluZWQpPT5cbntcbmNvbnN0IGlzc3VlclJlY29yZD1pc3N1ZXJCYWdnYWdlLmdldChJTlNUQU5DRV9LRVkpO1xucmV0dXJuIHNldHVwSXNzdWVyS2l0KGlzc3VlclJlY29yZCxpc3N1ZXJCYWdnYWdlLG9wdFNodXRkb3duV2l0aEZhaWx1cmUpO1xuIH07JGjigI1fb25jZS5wcmVwYXJlSXNzdWVyS2l0KHByZXBhcmVJc3N1ZXJLaXQpO1xuaGFyZGVuKHByZXBhcmVJc3N1ZXJLaXQpO1xuXG4vKipcbiAqIERvZXMgYmFnZ2FnZSBhbHJlYWR5IGhhdmUgYW4gaXNzdWVyIGZyb20gcHJlcGFyZUlzc3VlcktpdCgpP1xuICogVGhhdCBpczogZG9lcyBpdCBoYXZlIHRoZSByZWxldmFudCBrZXlzIGRlZmluZWQ/XG4gKlxuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKi9cbmNvbnN0ICAgICAgICBoYXNJc3N1ZXI9KGJhZ2dhZ2UpPT5iYWdnYWdlLmhhcyhJTlNUQU5DRV9LRVkpO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtQYXJ0aWFsPHtlbGVtZW50U2hhcGU6IFBhdHRlcm59Pn0gSXNzdWVyT3B0aW9uc1JlY29yZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIFRoZSBuYW1lIGJlY29tZXMgcGFydCBvZiB0aGUgYnJhbmQgaW4gYXNzZXQgZGVzY3JpcHRpb25zLlxuICogVGhlIG5hbWUgaXMgdXNlZnVsIGZvciBkZWJ1Z2dpbmcgYW5kIGRvdWJsZS1jaGVja2luZ1xuICogYXNzdW1wdGlvbnMsIGJ1dCBzaG91bGQgbm90IGJlIHRydXN0ZWQgd3J0IGFueSBleHRlcm5hbCBuYW1lc3BhY2UuXG4gKiBGb3IgZXhhbXBsZSwgYW55b25lIGNvdWxkIGNyZWF0ZSBhIG5ldyBpc3N1ZXIga2l0IHdpdGggbmFtZSAnQlRDJywgYnV0XG4gKiBpdCBpcyBub3QgYml0Y29pbiBvciBldmVuIHJlbGF0ZWQuIEl0IGlzIG9ubHkgdGhlIG5hbWUgYWNjb3JkaW5nXG4gKiB0byB0aGF0IGlzc3VlciBhbmQgYnJhbmQuXG4gKlxuICogVGhlIGFzc2V0S2luZCB3aWxsIGJlIHVzZWQgdG8gaW1wb3J0IGEgc3BlY2lmaWMgbWF0aEhlbHBlcnNcbiAqIGZyb20gdGhlIG1hdGhIZWxwZXJzIGxpYnJhcnkuIEZvciBleGFtcGxlLCBuYXRNYXRoSGVscGVycywgdGhlXG4gKiBkZWZhdWx0LCBpcyB1c2VkIGZvciBiYXNpYyBmdW5naWJsZSB0b2tlbnMuXG4gKlxuICogIGBkaXNwbGF5SW5mb2AgZ2l2ZXMgaW5mb3JtYXRpb24gdG8gdGhlIFVJIG9uIGhvdyB0byBkaXNwbGF5IHRoZSBhbW91bnQuXG4gKlxuICogQHBhcmFtIHtCYWdnYWdlfSBpc3N1ZXJCYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtLfSBbYXNzZXRLaW5kPUFzc2V0S2luZC5OQVRdXG4gKiBAcGFyYW0ge0FkZGl0aW9uYWxEaXNwbGF5SW5mb30gW2Rpc3BsYXlJbmZvPXt9XVxuICogQHBhcmFtIHtTaHV0ZG93bldpdGhGYWlsdXJlfSBbb3B0U2h1dGRvd25XaXRoRmFpbHVyZV0gSWYgdGhpcyBpc3N1ZXIgZmFpbHNcbiAqIGluIHRoZSBtaWRkbGUgb2YgYW4gYXRvbWljIGFjdGlvbiAod2hpY2ggYnR3IHNob3VsZCBuZXZlciBoYXBwZW4pLCBpdFxuICogcG90ZW50aWFsbHkgbGVhdmVzIGl0cyBsZWRnZXIgaW4gYSBjb3JydXB0ZWQgc3RhdGUuIElmIHRoaXMgZnVuY3Rpb24gd2FzXG4gKiBwcm92aWRlZCwgdGhlbiB0aGUgZmFpbGVkIGF0b21pYyBhY3Rpb24gd2lsbCBjYWxsIGl0LCBzbyB0aGF0IHNvbWVcbiAqIGxhcmdlciB1bml0IG9mIGNvbXB1dGF0aW9uLCBsaWtlIHRoZSBlbmNsb3NpbmcgdmF0LCBjYW4gYmUgc2h1dGRvd25cbiAqIGJlZm9yZSBhbnl0aGluZyBlbHNlIGlzIGNvcnJ1cHRlZCBieSB0aGF0IGNvcnJ1cHRlZCBzdGF0ZS5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzM0MzRcbiAqIEBwYXJhbSB7SXNzdWVyT3B0aW9uc1JlY29yZH0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7SXNzdWVyS2l0PEs+fVxuICovJGjigI1fb25jZS5oYXNJc3N1ZXIoaGFzSXNzdWVyKTtcbmNvbnN0ICAgICAgICBtYWtlRHVyYWJsZUlzc3VlcktpdD0oXG5pc3N1ZXJCYWdnYWdlLFxubmFtZSxcbi8qIEB0cy1leHBlY3QtZXJyb3IgSyBjb3VsZCBiZSBpbnN0YW50aWF0ZWQgd2l0aCBhIGRpZmZlcmVudCBzdWJ0eXBlIG9mIEFzc2V0S2luZCovXG5hc3NldEtpbmQ9QXNzZXRLaW5kLk5BVCxcbmRpc3BsYXlJbmZvPWhhcmRlbih7fSksXG5vcHRTaHV0ZG93bldpdGhGYWlsdXJlPXVuZGVmaW5lZCxcbntlbGVtZW50U2hhcGU9dW5kZWZpbmVkfT17fSk9Plxue1xuY29uc3QgaXNzdWVyRGF0YT1oYXJkZW4oe25hbWUsYXNzZXRLaW5kLGRpc3BsYXlJbmZvLGVsZW1lbnRTaGFwZX0pO1xuaXNzdWVyQmFnZ2FnZS5pbml0KElOU1RBTkNFX0tFWSxpc3N1ZXJEYXRhKTtcbnJldHVybiBzZXR1cElzc3VlcktpdChpc3N1ZXJEYXRhLGlzc3VlckJhZ2dhZ2Usb3B0U2h1dGRvd25XaXRoRmFpbHVyZSk7XG4gfTskaOKAjV9vbmNlLm1ha2VEdXJhYmxlSXNzdWVyS2l0KG1ha2VEdXJhYmxlSXNzdWVyS2l0KTtcbmhhcmRlbihtYWtlRHVyYWJsZUlzc3VlcktpdCk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IFtLPSduYXQnXVxuICogVGhlIG5hbWUgYmVjb21lcyBwYXJ0IG9mIHRoZSBicmFuZCBpbiBhc3NldCBkZXNjcmlwdGlvbnMuXG4gKiBUaGUgbmFtZSBpcyB1c2VmdWwgZm9yIGRlYnVnZ2luZyBhbmQgZG91YmxlLWNoZWNraW5nXG4gKiBhc3N1bXB0aW9ucywgYnV0IHNob3VsZCBub3QgYmUgdHJ1c3RlZCB3cnQgYW55IGV4dGVybmFsIG5hbWVzcGFjZS5cbiAqIEZvciBleGFtcGxlLCBhbnlvbmUgY291bGQgY3JlYXRlIGEgbmV3IGlzc3VlciBraXQgd2l0aCBuYW1lICdCVEMnLCBidXRcbiAqIGl0IGlzIG5vdCBiaXRjb2luIG9yIGV2ZW4gcmVsYXRlZC4gSXQgaXMgb25seSB0aGUgbmFtZSBhY2NvcmRpbmdcbiAqIHRvIHRoYXQgaXNzdWVyIGFuZCBicmFuZC5cbiAqXG4gKiBUaGUgYXNzZXRLaW5kIHdpbGwgYmUgdXNlZCB0byBpbXBvcnQgYSBzcGVjaWZpYyBtYXRoSGVscGVyc1xuICogZnJvbSB0aGUgbWF0aEhlbHBlcnMgbGlicmFyeS4gRm9yIGV4YW1wbGUsIG5hdE1hdGhIZWxwZXJzLCB0aGVcbiAqIGRlZmF1bHQsIGlzIHVzZWQgZm9yIGJhc2ljIGZ1bmdpYmxlIHRva2Vucy5cbiAqXG4gKiAgYGRpc3BsYXlJbmZvYCBnaXZlcyBpbmZvcm1hdGlvbiB0byB0aGUgVUkgb24gaG93IHRvIGRpc3BsYXkgdGhlIGFtb3VudC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtLfSBbYXNzZXRLaW5kPSduYXQnXVxuICogQHBhcmFtIHtBZGRpdGlvbmFsRGlzcGxheUluZm99IFtkaXNwbGF5SW5mbz17fV1cbiAqIEBwYXJhbSB7U2h1dGRvd25XaXRoRmFpbHVyZX0gW29wdFNodXRkb3duV2l0aEZhaWx1cmVdIElmIHRoaXMgaXNzdWVyIGZhaWxzXG4gKiBpbiB0aGUgbWlkZGxlIG9mIGFuIGF0b21pYyBhY3Rpb24gKHdoaWNoIGJ0dyBzaG91bGQgbmV2ZXIgaGFwcGVuKSwgaXRcbiAqIHBvdGVudGlhbGx5IGxlYXZlcyBpdHMgbGVkZ2VyIGluIGEgY29ycnVwdGVkIHN0YXRlLiBJZiB0aGlzIGZ1bmN0aW9uIHdhc1xuICogcHJvdmlkZWQsIHRoZW4gdGhlIGZhaWxlZCBhdG9taWMgYWN0aW9uIHdpbGwgY2FsbCBpdCwgc28gdGhhdCBzb21lXG4gKiBsYXJnZXIgdW5pdCBvZiBjb21wdXRhdGlvbiwgbGlrZSB0aGUgZW5jbG9zaW5nIHZhdCwgY2FuIGJlIHNodXRkb3duXG4gKiBiZWZvcmUgYW55dGhpbmcgZWxzZSBpcyBjb3JydXB0ZWQgYnkgdGhhdCBjb3JydXB0ZWQgc3RhdGUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNDM0XG4gKiBAcGFyYW0ge0lzc3Vlck9wdGlvbnNSZWNvcmR9IFtvcHRpb25zXVxuICogQHJldHVybnMge0lzc3VlcktpdDxLPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VJc3N1ZXJLaXQ9KFxubmFtZSxcbi8qIEB0cy1leHBlY3QtZXJyb3IgSyBjb3VsZCBiZSBpbnN0YW50aWF0ZWQgd2l0aCBhIGRpZmZlcmVudCBzdWJ0eXBlIG9mIEFzc2V0S2luZCovXG5hc3NldEtpbmQ9QXNzZXRLaW5kLk5BVCxcbmRpc3BsYXlJbmZvPWhhcmRlbih7fSksXG5vcHRTaHV0ZG93bldpdGhGYWlsdXJlPXVuZGVmaW5lZCxcbntlbGVtZW50U2hhcGU9dW5kZWZpbmVkfT17fSk9PlxuXG5tYWtlRHVyYWJsZUlzc3VlcktpdChcbm1ha2VTY2FsYXJCaWdNYXBTdG9yZSgnZHJvcHBlZCBpc3N1ZXIga2l0Jyx7ZHVyYWJsZTp0cnVlfSksXG5uYW1lLFxuYXNzZXRLaW5kLFxuZGlzcGxheUluZm8sXG5vcHRTaHV0ZG93bldpdGhGYWlsdXJlLFxue2VsZW1lbnRTaGFwZX0pOyRo4oCNX29uY2UubWFrZUlzc3VlcktpdChtYWtlSXNzdWVyS2l0KTtcblxuaGFyZGVuKG1ha2VJc3N1ZXJLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVJc3N1ZXJLaXQiOlsicHJlcGFyZUlzc3VlcktpdCJdLCJoYXNJc3N1ZXIiOlsiaGFzSXNzdWVyIl0sIm1ha2VEdXJhYmxlSXNzdWVyS2l0IjpbIm1ha2VEdXJhYmxlSXNzdWVyS2l0Il0sIm1ha2VJc3N1ZXJLaXQiOlsibWFrZUlzc3VlcktpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACAyG7uswUAALMFAABAAAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL2NvcHlCYWdNYXRoSGVscGVycy5qc3siaW1wb3J0cyI6WyIuLi90eXBlcy1hbWJpZW50LmpzIiwiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbImNvcHlCYWdNYXRoSGVscGVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBrZXlFUSxtYWtlQ29weUJhZyxtdXN0TWF0Y2gsTSxnZXRDb3B5QmFnRW50cmllcyxiYWdJc1N1cGVyYmFnLGJhZ1VuaW9uLGJhZ0Rpc2pvaW50U3VidHJhY3Q7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wia2V5RVFcIiwgWyRo4oCNX2EgPT4gKGtleUVRID0gJGjigI1fYSldXSxbXCJtYWtlQ29weUJhZ1wiLCBbJGjigI1fYSA9PiAobWFrZUNvcHlCYWcgPSAkaOKAjV9hKV1dLFtcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJnZXRDb3B5QmFnRW50cmllc1wiLCBbJGjigI1fYSA9PiAoZ2V0Q29weUJhZ0VudHJpZXMgPSAkaOKAjV9hKV1dLFtcImJhZ0lzU3VwZXJiYWdcIiwgWyRo4oCNX2EgPT4gKGJhZ0lzU3VwZXJiYWcgPSAkaOKAjV9hKV1dLFtcImJhZ1VuaW9uXCIsIFskaOKAjV9hID0+IChiYWdVbmlvbiA9ICRo4oCNX2EpXV0sW1wiYmFnRGlzam9pbnRTdWJ0cmFjdFwiLCBbJGjigI1fYSA9PiAoYmFnRGlzam9pbnRTdWJ0cmFjdCA9ICRo4oCNX2EpXV1dXSxbXCIuLi90eXBlcy1hbWJpZW50LmpzXCIsIFtdXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGUge0NvcHlCYWd9ICovXG5jb25zdCBlbXB0eT1tYWtlQ29weUJhZyhbXSk7XG5cbi8qKlxuICogQHR5cGUge01hdGhIZWxwZXJzPENvcHlCYWc+fVxuICovXG5jb25zdCAgICAgICAgY29weUJhZ01hdGhIZWxwZXJzPWhhcmRlbih7XG5kb0NvZXJjZTooYmFnKT0+e1xubXVzdE1hdGNoKGJhZyxNLmJhZygpLCdiYWcgb2YgYW1vdW50Jyk7XG5yZXR1cm4gYmFnO1xuIH0sXG5kb01ha2VFbXB0eTooKT0+ZW1wdHksXG5kb0lzRW1wdHk6KGJhZyk9PmdldENvcHlCYWdFbnRyaWVzKGJhZykubGVuZ3RoPT09MCxcbmRvSXNHVEU6YmFnSXNTdXBlcmJhZyxcbmRvSXNFcXVhbDprZXlFUSxcbmRvQWRkOmJhZ1VuaW9uLFxuZG9TdWJ0cmFjdDpiYWdEaXNqb2ludFN1YnRyYWN0fSk7JGjigI1fb25jZS5jb3B5QmFnTWF0aEhlbHBlcnMoY29weUJhZ01hdGhIZWxwZXJzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJjb3B5QmFnTWF0aEhlbHBlcnMiOlsiY29weUJhZ01hdGhIZWxwZXJzIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAHHnYj3HBQAAxwUAAEAAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvbWF0aEhlbHBlcnMvY29weVNldE1hdGhIZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiY29weVNldE1hdGhIZWxwZXJzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGtleUVRLG1ha2VDb3B5U2V0LG11c3RNYXRjaCxNLGdldENvcHlTZXRLZXlzLHNldElzU3VwZXJzZXQsc2V0RGlzam9pbnRVbmlvbixzZXREaXNqb2ludFN1YnRyYWN0OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV0sW1wibWFrZUNvcHlTZXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VDb3B5U2V0ID0gJGjigI1fYSldXSxbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV0sW1wiZ2V0Q29weVNldEtleXNcIiwgWyRo4oCNX2EgPT4gKGdldENvcHlTZXRLZXlzID0gJGjigI1fYSldXSxbXCJzZXRJc1N1cGVyc2V0XCIsIFskaOKAjV9hID0+IChzZXRJc1N1cGVyc2V0ID0gJGjigI1fYSldXSxbXCJzZXREaXNqb2ludFVuaW9uXCIsIFskaOKAjV9hID0+IChzZXREaXNqb2ludFVuaW9uID0gJGjigI1fYSldXSxbXCJzZXREaXNqb2ludFN1YnRyYWN0XCIsIFskaOKAjV9hID0+IChzZXREaXNqb2ludFN1YnRyYWN0ID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZSB7Q29weVNldH0gKi9cbmNvbnN0IGVtcHR5PW1ha2VDb3B5U2V0KFtdKTtcblxuLyoqXG4gKiBAdHlwZSB7TWF0aEhlbHBlcnM8Q29weVNldD59XG4gKi9cbmNvbnN0ICAgICAgICBjb3B5U2V0TWF0aEhlbHBlcnM9aGFyZGVuKHtcbmRvQ29lcmNlOihzZXQpPT57XG5tdXN0TWF0Y2goc2V0LE0uc2V0KCksJ3NldCBvZiBhbW91bnQnKTtcbnJldHVybiBzZXQ7XG4gfSxcbmRvTWFrZUVtcHR5OigpPT5lbXB0eSxcbmRvSXNFbXB0eTooc2V0KT0+Z2V0Q29weVNldEtleXMoc2V0KS5sZW5ndGg9PT0wLFxuZG9Jc0dURTpzZXRJc1N1cGVyc2V0LFxuZG9Jc0VxdWFsOmtleUVRLFxuZG9BZGQ6c2V0RGlzam9pbnRVbmlvbixcbmRvU3VidHJhY3Q6c2V0RGlzam9pbnRTdWJ0cmFjdH0pOyRo4oCNX29uY2UuY29weVNldE1hdGhIZWxwZXJzKGNvcHlTZXRNYXRoSGVscGVycyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiY29weVNldE1hdGhIZWxwZXJzIjpbImNvcHlTZXRNYXRoSGVscGVycyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAD/3LD7KgYAACoGAAA8AAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL25hdE1hdGhIZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLWFtYmllbnQuanMiLCJAZW5kby9uYXQiXSwiZXhwb3J0cyI6WyJuYXRNYXRoSGVscGVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBOYXQsaXNOYXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRo4oCNX2EgPT4gKE5hdCA9ICRo4oCNX2EpXV0sW1wiaXNOYXRcIiwgWyRo4oCNX2EgPT4gKGlzTmF0ID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuY29uc3QgZW1wdHk9MG47XG5cbi8qKlxuICogRnVuZ2libGUgZGlnaXRhbCBhc3NldHMgdXNlIHRoZSBuYXRNYXRoSGVscGVycyB0byBtYW5hZ2UgYmFsYW5jZXMgLVxuICogdGhlIG9wZXJhdGlvbnMgYXJlIG1lcmVseSBhcml0aG1ldGljIG9uIG5hdHVyYWwsIG5vbi1uZWdhdGl2ZVxuICogbnVtYmVycy5cbiAqXG4gKiBOYXR1cmFsIG51bWJlcnMgYXJlIHVzZWQgZm9yIGZ1bmdpYmxlIGVyaWdodHMgc3VjaCBhcyBtb25leSBiZWNhdXNlXG4gKiByb3VuZGluZyBpc3N1ZXMgbWFrZSBmbG9hdHMgcHJvYmxlbWF0aWMuIEFsbCBvcGVyYXRpb25zIHNob3VsZCBiZVxuICogZG9uZSB3aXRoIHRoZSBzbWFsbGVzdCB3aG9sZSB1bml0IHN1Y2ggdGhhdCB0aGUgYG5hdE1hdGhIZWxwZXJzYCBuZXZlclxuICogZGVhbHMgd2l0aCBmcmFjdGlvbmFsIHBhcnRzLlxuICpcbiAqIEB0eXBlIHtNYXRoSGVscGVyczxOYXRWYWx1ZT59XG4gKi9cbmNvbnN0ICAgICAgICBuYXRNYXRoSGVscGVycz1oYXJkZW4oe1xuZG9Db2VyY2U6KG5hdCk9Pntcbi8qIFRPRE86IHRpZ2h0ZW4gdGhlIGRlZmluaXRpb24gb2YgTmF0IGluIEBhZ29yaWMvbmF0IHRvIHRocm93IG9uIGBudW1iZXJgKi9cbmFzc2VydC50eXBlb2YobmF0LCdiaWdpbnQnKTtcbmlzTmF0KG5hdCl8fEZhaWwgYHZhbHVlICR7bmF0fSBtdXN0IGJlIGEgbmF0dXJhbCBudW1iZXJgO1xucmV0dXJuIE5hdChuYXQpO1xuIH0sXG5kb01ha2VFbXB0eTooKT0+ZW1wdHksXG5kb0lzRW1wdHk6KG5hdCk9Pm5hdD09PWVtcHR5LFxuZG9Jc0dURToobGVmdCxyaWdodCk9PmxlZnQ+PXJpZ2h0LFxuZG9Jc0VxdWFsOihsZWZ0LHJpZ2h0KT0+bGVmdD09PXJpZ2h0LFxuLyogQmlnSW50cyBkb24ndCBvYnNlcnZhYmx5IG92ZXJmbG93Ki9cbmRvQWRkOihsZWZ0LHJpZ2h0KT0+bGVmdCtyaWdodCxcbmRvU3VidHJhY3Q6KGxlZnQscmlnaHQpPT5OYXQobGVmdC1yaWdodCl9KTskaOKAjV9vbmNlLm5hdE1hdGhIZWxwZXJzKG5hdE1hdGhIZWxwZXJzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJuYXRNYXRoSGVscGVycyI6WyJuYXRNYXRoSGVscGVycyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAmmZgvnwcAAJ8HAAA8AAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL3NldE1hdGhIZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL3N0b3JlIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbInNldE1hdGhIZWxwZXJzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHBhc3NTdHlsZU9mLGFzc2VydEtleSxlbGVtZW50c0lzU3VwZXJzZXQsZWxlbWVudHNEaXNqb2ludFVuaW9uLGVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCxjb2VyY2VUb0VsZW1lbnRzLGVsZW1lbnRzQ29tcGFyZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiYXNzZXJ0S2V5XCIsIFskaOKAjV9hID0+IChhc3NlcnRLZXkgPSAkaOKAjV9hKV1dLFtcImVsZW1lbnRzSXNTdXBlcnNldFwiLCBbJGjigI1fYSA9PiAoZWxlbWVudHNJc1N1cGVyc2V0ID0gJGjigI1fYSldXSxbXCJlbGVtZW50c0Rpc2pvaW50VW5pb25cIiwgWyRo4oCNX2EgPT4gKGVsZW1lbnRzRGlzam9pbnRVbmlvbiA9ICRo4oCNX2EpXV0sW1wiZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0XCIsIFskaOKAjV9hID0+IChlbGVtZW50c0Rpc2pvaW50U3VidHJhY3QgPSAkaOKAjV9hKV1dLFtcImNvZXJjZVRvRWxlbWVudHNcIiwgWyRo4oCNX2EgPT4gKGNvZXJjZVRvRWxlbWVudHMgPSAkaOKAjV9hKV1dLFtcImVsZW1lbnRzQ29tcGFyZVwiLCBbJGjigI1fYSA9PiAoZWxlbWVudHNDb21wYXJlID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiBPcGVyYXRpb25zIGZvciBhcnJheXMgd2l0aCB1bmlxdWUgb2JqZWN0cyBpZGVudGlmeWluZyBhbmQgcHJvdmlkaW5nKi9cbi8qIGluZm9ybWF0aW9uIGFib3V0IGRpZ2l0YWwgYXNzZXRzLiBVc2VkIGZvciBab2UgaW52aXRlcy4qL1xuLyoqIEB0eXBlIHtTZXRWYWx1ZX0gKi9cbmNvbnN0IGVtcHR5PWhhcmRlbihbXSk7XG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgUmVwbGFjZSBhcnJheS1iYXNlZCBTZXRNYXRoIHdpdGggQ29weVNldC1iYXNlZCBDb3B5U2V0TWF0aFxuICogQHR5cGUge01hdGhIZWxwZXJzPFNldFZhbHVlPn1cbiAqL1xuY29uc3QgICAgICAgIHNldE1hdGhIZWxwZXJzPWhhcmRlbih7XG5kb0NvZXJjZToobGlzdCk9Pntcbmxpc3Q9Y29lcmNlVG9FbGVtZW50cyhsaXN0KTtcbi8qIEFzc2VydCB0aGF0IGxpc3QgY29udGFpbnMgb25seSovXG4vKiAqIHBhc3MtYnktY29weSBwcmltaXRpdmVzLCovXG4vKiAqIHBhc3MtYnktY29weSBjb250YWluZXJzIGNvbnRhaW5pbmcga2V5cywqL1xuLyogKiByZW1vdGFibGVzLiovXG5hc3NlcnRLZXkobGlzdCk7XG5yZXR1cm4gbGlzdDtcbiB9LFxuZG9NYWtlRW1wdHk6KCk9PmVtcHR5LFxuZG9Jc0VtcHR5OihsaXN0KT0+cGFzc1N0eWxlT2YobGlzdCk9PT0nY29weUFycmF5JyYmbGlzdC5sZW5ndGg9PT0wLFxuZG9Jc0dURTplbGVtZW50c0lzU3VwZXJzZXQsXG5kb0lzRXF1YWw6KHgseSk9PmVsZW1lbnRzQ29tcGFyZSh4LHkpPT09MCxcbmRvQWRkOmVsZW1lbnRzRGlzam9pbnRVbmlvbixcbmRvU3VidHJhY3Q6ZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0fSk7JGjigI1fb25jZS5zZXRNYXRoSGVscGVycyhzZXRNYXRoSGVscGVycyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsic2V0TWF0aEhlbHBlcnMiOlsic2V0TWF0aEhlbHBlcnMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAsDioH6UEAAClBAAAKQAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9wYXltZW50LmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsicHJlcGFyZVBheW1lbnRLaW5kIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGluaXRFbXB0eSxwcmVwYXJlRXhvQ2xhc3M7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiaW5pdEVtcHR5XCIsIFskaOKAjV9hID0+IChpbml0RW1wdHkgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wicHJlcGFyZUV4b0NsYXNzXCIsIFskaOKAjV9hID0+IChwcmVwYXJlRXhvQ2xhc3MgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gQmFnZ2FnZSAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGlzc3VlckJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBuYW1lXG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBicmFuZFxuICogQHBhcmFtIHtJbnRlcmZhY2VHdWFyZH0gUGF5bWVudElcbiAqIEByZXR1cm5zIHsoKSA9PiBQYXltZW50PEs+fVxuICovXG5jb25zdCAgICAgICAgcHJlcGFyZVBheW1lbnRLaW5kPShpc3N1ZXJCYWdnYWdlLG5hbWUsYnJhbmQsUGF5bWVudEkpPT57XG5jb25zdCBtYWtlUGF5bWVudD1wcmVwYXJlRXhvQ2xhc3MoXG5pc3N1ZXJCYWdnYWdlLFxuIGAke25hbWV9IHBheW1lbnRgLFxuUGF5bWVudEksXG5pbml0RW1wdHksXG57XG5nZXRBbGxlZ2VkQnJhbmQoKXtcbnJldHVybiBicmFuZDtcbiB9fSk7XG5cblxucmV0dXJuIG1ha2VQYXltZW50O1xuIH07JGjigI1fb25jZS5wcmVwYXJlUGF5bWVudEtpbmQocHJlcGFyZVBheW1lbnRLaW5kKTtcbmhhcmRlbihwcmVwYXJlUGF5bWVudEtpbmQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVQYXltZW50S2luZCI6WyJwcmVwYXJlUGF5bWVudEtpbmQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAD9fo7usxAADrMQAALwAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9wYXltZW50TGVkZ2VyLmpzeyJpbXBvcnRzIjpbIi4vYW1vdW50TWF0aC5qcyIsIi4vcGF5bWVudC5qcyIsIi4vcHVyc2UuanMiLCIuL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL3N0b3JlIiwiQGFnb3JpYy9zdG9yZS9leHBvcnRlZC5qcyIsIkBhZ29yaWMvdmF0LWRhdGEiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbInByZXBhcmVQYXltZW50TGVkZ2VyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzUHJvbWlzZSxtdXN0TWF0Y2gsTSxrZXlFUSxwcm92aWRlRHVyYWJsZVdlYWtNYXBTdG9yZSxwcmVwYXJlRXhvLHByb3ZpZGUsQW1vdW50TWF0aCxwcmVwYXJlUGF5bWVudEtpbmQscHJlcGFyZVB1cnNlS2luZCxCcmFuZEksbWFrZUlzc3VlckludGVyZmFjZXM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJrZXlFUVwiLCBbJGjigI1fYSA9PiAoa2V5RVEgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmVcIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlID0gJGjigI1fYSldXSxbXCJwcmVwYXJlRXhvXCIsIFskaOKAjV9hID0+IChwcmVwYXJlRXhvID0gJGjigI1fYSldXSxbXCJwcm92aWRlXCIsIFskaOKAjV9hID0+IChwcm92aWRlID0gJGjigI1fYSldXV1dLFtcIi4vYW1vdW50TWF0aC5qc1wiLCBbW1wiQW1vdW50TWF0aFwiLCBbJGjigI1fYSA9PiAoQW1vdW50TWF0aCA9ICRo4oCNX2EpXV1dXSxbXCIuL3BheW1lbnQuanNcIiwgW1tcInByZXBhcmVQYXltZW50S2luZFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZVBheW1lbnRLaW5kID0gJGjigI1fYSldXV1dLFtcIi4vcHVyc2UuanNcIiwgW1tcInByZXBhcmVQdXJzZUtpbmRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVQdXJzZUtpbmQgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZS9leHBvcnRlZC5qc1wiLCBbXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJCcmFuZElcIiwgWyRo4oCNX2EgPT4gKEJyYW5kSSA9ICRo4oCNX2EpXV0sW1wibWFrZUlzc3VlckludGVyZmFjZXNcIiwgWyRo4oCNX2EgPT4gKG1ha2VJc3N1ZXJJbnRlcmZhY2VzID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YScpLkJhZ2dhZ2V9IEJhZ2dhZ2UgKi9cblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG4vKipcbiAqIEBwYXJhbSB7QnJhbmR9IGJyYW5kXG4gKiBAcGFyYW0ge0Fzc2V0S2luZH0gYXNzZXRLaW5kXG4gKiBAcGFyYW0ge1BhdHRlcm59IGVsZW1lbnRTaGFwZVxuICovXG5jb25zdCBhbW91bnRTaGFwZUZyb21FbGVtZW50U2hhcGU9KGJyYW5kLGFzc2V0S2luZCxlbGVtZW50U2hhcGUpPT57XG5sZXQgdmFsdWVTaGFwZTtcbnN3aXRjaChhc3NldEtpbmQpe1xuY2FzZSduYXQnOntcbnZhbHVlU2hhcGU9TS5uYXQoKTtcbmVsZW1lbnRTaGFwZT09PXVuZGVmaW5lZHx8XG5GYWlsIGBGdW5naWJsZSBhc3NldHMgY2Fubm90IGhhdmUgYW4gZWxlbWVudFNoYXBlOiAke3EoZWxlbWVudFNoYXBlKX1gO1xuYnJlYWs7XG4gfVxuY2FzZSdzZXQnOntcbmlmKGVsZW1lbnRTaGFwZT09PXVuZGVmaW5lZCl7XG52YWx1ZVNoYXBlPU0uYXJyYXlPZihNLmtleSgpKTtcbiB9ZWxzZXtcbnZhbHVlU2hhcGU9TS5hcnJheU9mKE0uYW5kKE0ua2V5KCksZWxlbWVudFNoYXBlKSk7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSdjb3B5U2V0Jzp7XG5pZihlbGVtZW50U2hhcGU9PT11bmRlZmluZWQpe1xudmFsdWVTaGFwZT1NLnNldCgpO1xuIH1lbHNle1xudmFsdWVTaGFwZT1NLnNldE9mKGVsZW1lbnRTaGFwZSk7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSdjb3B5QmFnJzp7XG5pZihlbGVtZW50U2hhcGU9PT11bmRlZmluZWQpe1xudmFsdWVTaGFwZT1NLmJhZygpO1xuIH1lbHNle1xudmFsdWVTaGFwZT1NLmJhZ09mKGVsZW1lbnRTaGFwZSk7XG4gfVxuYnJlYWs7XG4gfVxuZGVmYXVsdDp7XG5GYWlsIGB1bmV4cGVjdGVkIGFzc2V0IGtpbmQgJHtxKGFzc2V0S2luZCl9YDtcbiB9fVxuXG5cbmNvbnN0IGFtb3VudFNoYXBlPWhhcmRlbih7XG5icmFuZCwvKiBtYXRjaGVzIG9ubHkgdGhpcyBleGFjdCBicmFuZCovXG52YWx1ZTp2YWx1ZVNoYXBlfSk7XG5cbnJldHVybiBhbW91bnRTaGFwZTtcbiB9O1xuXG4vKipcbiAqIE1ha2UgdGhlIHBheW1lbnRMZWRnZXIsIHRoZSBzb3VyY2Ugb2YgdHJ1dGggZm9yIHRoZSBiYWxhbmNlcyBvZlxuICogcGF5bWVudHMuIEFsbCBtaW50aW5nIGFuZCB0cmFuc2ZlciBhdXRob3JpdHkgb3JpZ2luYXRlcyBoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGlzc3VlckJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBuYW1lXG4gKiBAcGFyYW0ge0t9IGFzc2V0S2luZFxuICogQHBhcmFtIHtEaXNwbGF5SW5mbzxLPn0gZGlzcGxheUluZm9cbiAqIEBwYXJhbSB7UGF0dGVybn0gZWxlbWVudFNoYXBlXG4gKiBAcGFyYW0ge1NodXRkb3duV2l0aEZhaWx1cmV9IFtvcHRTaHV0ZG93bldpdGhGYWlsdXJlXVxuICogQHJldHVybnMge1BheW1lbnRMZWRnZXI8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlUGF5bWVudExlZGdlcj0oXG5pc3N1ZXJCYWdnYWdlLFxubmFtZSxcbmFzc2V0S2luZCxcbmRpc3BsYXlJbmZvLFxuZWxlbWVudFNoYXBlLFxub3B0U2h1dGRvd25XaXRoRmFpbHVyZT11bmRlZmluZWQpPT5cbntcbi8qKiBAdHlwZSB7QnJhbmQ8Sz59ICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIFhYWCBjYWxsV2hlbiovXG5jb25zdCBicmFuZD1wcmVwYXJlRXhvKGlzc3VlckJhZ2dhZ2UsIGAke25hbWV9IGJyYW5kYCxCcmFuZEkse1xuaXNNeUlzc3VlcihhbGxlZ2VkSXNzdWVyKXtcbi8qIEJyYW5kSSBkZWxheXMgY2FsbGluZyB0aGlzIG1ldGhvZCB1bnRpbCBgYWxsZWdlZElzc3VlcmAgaXMgYSBSZW1vdGFibGUqL1xucmV0dXJuIGFsbGVnZWRJc3N1ZXI9PT1pc3N1ZXI7XG4gfSxcbmdldEFsbGVnZWROYW1lKCl7XG5yZXR1cm4gbmFtZTtcbiB9LFxuLyogR2l2ZSBpbmZvcm1hdGlvbiB0byBVSSBvbiBob3cgdG8gZGlzcGxheSB0aGUgYW1vdW50LiovXG5nZXREaXNwbGF5SW5mbygpe1xucmV0dXJuIGRpc3BsYXlJbmZvO1xuIH0sXG5nZXRBbW91bnRTaGFwZSgpe1xucmV0dXJuIGFtb3VudFNoYXBlO1xuIH19KTtcblxuXG5jb25zdCBhbW91bnRTaGFwZT1hbW91bnRTaGFwZUZyb21FbGVtZW50U2hhcGUoXG5icmFuZCxcbmFzc2V0S2luZCxcbmVsZW1lbnRTaGFwZSk7XG5cblxuY29uc3R7SXNzdWVySSxNaW50SSxQYXltZW50SSxQdXJzZUlLaXR9PW1ha2VJc3N1ZXJJbnRlcmZhY2VzKFxuYnJhbmQsXG5hc3NldEtpbmQsXG5hbW91bnRTaGFwZSk7XG5cblxuY29uc3QgbWFrZVBheW1lbnQ9cHJlcGFyZVBheW1lbnRLaW5kKGlzc3VlckJhZ2dhZ2UsbmFtZSxicmFuZCxQYXltZW50SSk7XG5cbi8qKiBAdHlwZSB7U2h1dGRvd25XaXRoRmFpbHVyZX0gKi9cbmNvbnN0IHNodXRkb3duTGVkZ2VyV2l0aEZhaWx1cmU9KHJlYXNvbik9Pntcbi8qIFRPRE8gVGhpcyBzaG91bGQgYWxzbyBkZXN0cm95IGxlZGdlciBzdGF0ZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvMzQzNCovXG5pZihvcHRTaHV0ZG93bldpdGhGYWlsdXJlIT09dW5kZWZpbmVkKXtcbnRyeXtcbm9wdFNodXRkb3duV2l0aEZhaWx1cmUocmVhc29uKTtcbiB9Y2F0Y2goZXJySW5TaHV0ZG93bil7XG5hc3NlcnQubm90ZShlcnJJblNodXRkb3duLFggYENhdXNlZCBieTogJHtyZWFzb259YCk7XG50aHJvdyBlcnJJblNodXRkb3duO1xuIH1cbiB9XG50aHJvdyByZWFzb247XG4gfTtcblxuLyoqIEB0eXBlIHtXZWFrTWFwU3RvcmU8UGF5bWVudCwgQW1vdW50Pn0gKi9cbmNvbnN0IHBheW1lbnRMZWRnZXI9cHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUoXG5pc3N1ZXJCYWdnYWdlLFxuJ3BheW1lbnRMZWRnZXInLFxue3ZhbHVlU2hhcGU6YW1vdW50U2hhcGV9KTtcblxuXG4vKipcbiAqIEEgd2l0aGRyYXduIGxpdmUgcGF5bWVudCBpcyBhc3NvY2lhdGVkIHdpdGggdGhlIHJlY292ZXJ5IHNldCBvZlxuICogdGhlIHB1cnNlIGl0IHdhcyB3aXRoZHJhd24gZnJvbS4gTGV0J3MgY2FsbCB0aGVzZSBcInJlY292ZXJhYmxlXCJcbiAqIHBheW1lbnRzLiBBbGwgcmVjb3ZlcmFibGUgcGF5bWVudHMgYXJlIGxpdmUsIGJ1dCBub3QgYWxsIGxpdmVcbiAqIHBheW1lbnRzIGFyZSByZWNvdmVyYWJsZS4gV2UgZG8gdGhlIGJvb2trZWVwaW5nIGZvciBwYXltZW50IHJlY292ZXJ5XG4gKiB3aXRoIHRoaXMgd2Vha21hcCBmcm9tIHJlY292ZXJhYmxlIHBheW1lbnRzIHRvIHRoZSByZWNvdmVyeSBzZXQgdGhleSBhcmVcbiAqIGluLlxuICogQSBidW5jaCBvZiBpbnRlcmVzdGluZyBpbnZhcmlhbnRzIGhlcmU6XG4gKiAgICAqIEV2ZXJ5IHBheW1lbnQgdGhhdCBpcyBhIGtleSBpbiB0aGUgb3V0ZXIgYHBheW1lbnRSZWNvdmVyeVNldHNgXG4gKiAgICAgIHdlYWtNYXAgaXMgYWxzbyBpbiB0aGUgcmVjb3Zlcnkgc2V0IGluZGV4ZWQgYnkgdGhhdCBwYXltZW50LlxuICogICAgKiBJbXBsaWVkIGJ5IHRoZSBhYm92ZSBidXQgd29ydGggc3RhdGluZzogdGhlIHBheW1lbnQgaXMgb25seVxuICogICAgICBpbiBhdCBtb3N0IG9uZSByZWNvdmVyeSBzZXQuXG4gKiAgICAqIEEgcmVjb3Zlcnkgc2V0IG9ubHkgY29udGFpbnMgc3VjaCBwYXltZW50cy5cbiAqICAgICogRXZlcnkgcHVyc2UgaXMgYXNzb2NpYXRlZCB3aXRoIGV4YWN0bHkgb25lIHJlY292ZXJ5IHNldCB1bmlxdWUgdG9cbiAqICAgICAgaXQuXG4gKiAgICAqIEEgcHVyc2UncyByZWNvdmVyeSBzZXQgb25seSBjb250YWlucyBwYXltZW50cyB3aXRoZHJhd24gZnJvbVxuICogICAgICB0aGF0IHB1cnNlIGFuZCBub3QgeWV0IGNvbnN1bWVkLlxuICpcbiAqIEB0eXBlIHtXZWFrTWFwU3RvcmU8UGF5bWVudCwgU2V0U3RvcmU8UGF5bWVudD4+fVxuICovXG5jb25zdCBwYXltZW50UmVjb3ZlcnlTZXRzPXByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlKFxuaXNzdWVyQmFnZ2FnZSxcbidwYXltZW50UmVjb3ZlcnlTZXRzJyk7XG5cblxuLyoqXG4gKiBUbyBtYWludGFpbiB0aGUgaW52YXJpYW50cyBsaXN0ZWQgaW4gdGhlIGBwYXltZW50UmVjb3ZlcnlTZXRzYCBjb21tZW50LFxuICogYGluaXRQYXltZW50YCBzaG91bGQgY29udGFpbiB0aGUgb25seVxuICogY2FsbCB0byBgcGF5bWVudExlZGdlci5pbml0YC5cbiAqXG4gKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnRcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnRcbiAqIEBwYXJhbSB7U2V0U3RvcmU8UGF5bWVudD59IFtvcHRSZWNvdmVyeVNldF1cbiAqL1xuY29uc3QgaW5pdFBheW1lbnQ9KHBheW1lbnQsYW1vdW50LG9wdFJlY292ZXJ5U2V0PXVuZGVmaW5lZCk9PntcbmlmKG9wdFJlY292ZXJ5U2V0IT09dW5kZWZpbmVkKXtcbm9wdFJlY292ZXJ5U2V0LmFkZChwYXltZW50KTtcbnBheW1lbnRSZWNvdmVyeVNldHMuaW5pdChwYXltZW50LG9wdFJlY292ZXJ5U2V0KTtcbiB9XG5wYXltZW50TGVkZ2VyLmluaXQocGF5bWVudCxhbW91bnQpO1xuIH07XG5cbi8qKlxuICogVG8gbWFpbnRhaW4gdGhlIGludmFyaWFudHMgbGlzdGVkIGluIHRoZSBgcGF5bWVudFJlY292ZXJ5U2V0c2AgY29tbWVudCxcbiAqIGBkZWxldGVQYXltZW50YCBzaG91bGQgY29udGFpbiB0aGUgb25seVxuICogY2FsbCB0byBgcGF5bWVudExlZGdlci5kZWxldGVgLlxuICpcbiAqIEBwYXJhbSB7UGF5bWVudH0gcGF5bWVudFxuICovXG5jb25zdCBkZWxldGVQYXltZW50PShwYXltZW50KT0+e1xucGF5bWVudExlZGdlci5kZWxldGUocGF5bWVudCk7XG5pZihwYXltZW50UmVjb3ZlcnlTZXRzLmhhcyhwYXltZW50KSl7XG5jb25zdCByZWNvdmVyeVNldD1wYXltZW50UmVjb3ZlcnlTZXRzLmdldChwYXltZW50KTtcbnBheW1lbnRSZWNvdmVyeVNldHMuZGVsZXRlKHBheW1lbnQpO1xucmVjb3ZlcnlTZXQuZGVsZXRlKHBheW1lbnQpO1xuIH1cbiB9O1xuXG4vKiogQHR5cGUgeyhsZWZ0OiBBbW91bnQsIHJpZ2h0OiBBbW91bnQpID0+IEFtb3VudCB9ICovXG5jb25zdCBhZGQ9KGxlZnQscmlnaHQpPT5BbW91bnRNYXRoLmFkZChsZWZ0LHJpZ2h0LGJyYW5kKTtcbi8qKiBAdHlwZSB7KGxlZnQ6IEFtb3VudCwgcmlnaHQ6IEFtb3VudCkgPT4gQW1vdW50IH0gKi9cbmNvbnN0IHN1YnRyYWN0PShsZWZ0LHJpZ2h0KT0+QW1vdW50TWF0aC5zdWJ0cmFjdChsZWZ0LHJpZ2h0LGJyYW5kKTtcbi8qKiBAdHlwZSB7KGFsbGVnZWRBbW91bnQ6IEFtb3VudCkgPT4gQW1vdW50fSAqL1xuY29uc3QgY29lcmNlPShhbGxlZ2VkQW1vdW50KT0+QW1vdW50TWF0aC5jb2VyY2UoYnJhbmQsYWxsZWdlZEFtb3VudCk7XG4vKiogQHR5cGUgeyhsZWZ0OiBBbW91bnQsIHJpZ2h0OiBBbW91bnQpID0+IGJvb2xlYW4gfSAqL1xuXG4vKipcbiAqIE1ldGhvZHMgbGlrZSBkZXBvc2l0KCkgaGF2ZSBhbiBvcHRpb25hbCBzZWNvbmQgcGFyYW1ldGVyXG4gKiBgb3B0QW1vdW50U2hhcGVgXG4gKiB3aGljaCwgaWYgcHJlc2VudCwgaXMgc3VwcG9zZWQgdG8gbWF0Y2ggdGhlIGJhbGFuY2Ugb2YgdGhlXG4gKiBwYXltZW50LiBUaGlzIGhlbHBlciBmdW5jdGlvbiBkb2VzIHRoYXQgY2hlY2suXG4gKlxuICogTm90ZTogYG9wdEFtb3VudFNoYXBlYCBpcyB1c2VyLXN1cHBsaWVkIHdpdGggbm8gcHJldmlvdXMgdmFsaWRhdGlvbi5cbiAqXG4gKiBAcGFyYW0ge0Ftb3VudH0gcGF5bWVudEJhbGFuY2VcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge3ZvaWR9XG4gKi9cbmNvbnN0IGFzc2VydEFtb3VudENvbnNpc3RlbnQ9KHBheW1lbnRCYWxhbmNlLG9wdEFtb3VudFNoYXBlKT0+e1xuaWYob3B0QW1vdW50U2hhcGUhPT11bmRlZmluZWQpe1xubXVzdE1hdGNoKHBheW1lbnRCYWxhbmNlLG9wdEFtb3VudFNoYXBlLCdhbW91bnQnKTtcbiB9XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnRcbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5jb25zdCBhc3NlcnRMaXZlUGF5bWVudD0ocGF5bWVudCk9PntcbnBheW1lbnRMZWRnZXIuaGFzKHBheW1lbnQpfHxcbkZhaWwgYCR7cGF5bWVudH0gd2FzIG5vdCBhIGxpdmUgcGF5bWVudCBmb3IgYnJhbmQgJHtxKFxuYnJhbmQpXG4gfS4gSXQgY291bGQgYmUgYSB1c2VkLXVwIHBheW1lbnQsIGEgcGF5bWVudCBmb3IgYW5vdGhlciBicmFuZCwgb3IgaXQgbWlnaHQgbm90IGJlIGEgcGF5bWVudCBhdCBhbGwuYDtcbiB9O1xuXG4vKipcbiAqIFVzZWQgYnkgdGhlIHB1cnNlIGNvZGUgdG8gaW1wbGVtZW50IHB1cnNlLmRlcG9zaXRcbiAqXG4gKiBAcGFyYW0ge0Ftb3VudH0gY3VycmVudEJhbGFuY2UgLSB0aGUgY3VycmVudCBiYWxhbmNlIG9mIHRoZSBwdXJzZVxuICogYmVmb3JlIGEgZGVwb3NpdFxuICogQHBhcmFtIHsobmV3UHVyc2VCYWxhbmNlOiBBbW91bnQpID0+IHZvaWR9IHVwZGF0ZVB1cnNlQmFsYW5jZSAtXG4gKiBjb21taXQgdGhlIHB1cnNlIGJhbGFuY2VcbiAqIEBwYXJhbSB7UGF5bWVudH0gc3JjUGF5bWVudFxuICogQHBhcmFtIHtQYXR0ZXJufSBbb3B0QW1vdW50U2hhcGVdXG4gKiBAcmV0dXJucyB7QW1vdW50fVxuICovXG5jb25zdCBkZXBvc2l0SW50ZXJuYWw9KFxuY3VycmVudEJhbGFuY2UsXG51cGRhdGVQdXJzZUJhbGFuY2UsXG5zcmNQYXltZW50LFxub3B0QW1vdW50U2hhcGU9dW5kZWZpbmVkKT0+XG57XG4haXNQcm9taXNlKHNyY1BheW1lbnQpfHxcbmFzc2VydC5mYWlsKFxuIGBkZXBvc2l0IGRvZXMgbm90IGFjY2VwdCBwcm9taXNlcyBhcyBmaXJzdCBhcmd1bWVudC4gSW5zdGVhZCBvZiBwYXNzaW5nIHRoZSBwcm9taXNlIChkZXBvc2l0KHBheW1lbnRQcm9taXNlKSksIGNvbnNpZGVyIHVud3JhcHBpbmcgdGhlIHByb21pc2UgZmlyc3Q6IEUud2hlbihwYXltZW50UHJvbWlzZSwgKGFjdHVhbFBheW1lbnQgPT4gZGVwb3NpdChhY3R1YWxQYXltZW50KSlgLFxuVHlwZUVycm9yKTtcblxuYXNzZXJ0TGl2ZVBheW1lbnQoc3JjUGF5bWVudCk7XG5jb25zdCBzcmNQYXltZW50QmFsYW5jZT1wYXltZW50TGVkZ2VyLmdldChzcmNQYXltZW50KTtcbmFzc2VydEFtb3VudENvbnNpc3RlbnQoc3JjUGF5bWVudEJhbGFuY2Usb3B0QW1vdW50U2hhcGUpO1xuY29uc3QgbmV3UHVyc2VCYWxhbmNlPWFkZChzcmNQYXltZW50QmFsYW5jZSxjdXJyZW50QmFsYW5jZSk7XG50cnl7XG4vKiBDT01NSVQgUE9JTlQqL1xuLyogTW92ZSB0aGUgYXNzZXRzIGluIGBzcmNQYXltZW50YCBpbnRvIHRoaXMgcHVyc2UsIHVzaW5nIHVwIHRoZSovXG4vKiBzb3VyY2UgcGF5bWVudCwgc3VjaCB0aGF0IHRvdGFsIGFzc2V0cyBhcmUgY29uc2VydmVkLiovXG5kZWxldGVQYXltZW50KHNyY1BheW1lbnQpO1xudXBkYXRlUHVyc2VCYWxhbmNlKG5ld1B1cnNlQmFsYW5jZSk7XG4gfWNhdGNoKGVycil7XG5zaHV0ZG93bkxlZGdlcldpdGhGYWlsdXJlKGVycik7XG50aHJvdyBlcnI7XG4gfVxucmV0dXJuIHNyY1BheW1lbnRCYWxhbmNlO1xuIH07XG5cbi8qKlxuICogVXNlZCBieSB0aGUgcHVyc2UgY29kZSB0byBpbXBsZW1lbnQgcHVyc2Uud2l0aGRyYXdcbiAqXG4gKiBAcGFyYW0ge0Ftb3VudH0gY3VycmVudEJhbGFuY2UgLSB0aGUgY3VycmVudCBiYWxhbmNlIG9mIHRoZSBwdXJzZVxuICogYmVmb3JlIGEgd2l0aGRyYXdhbFxuICogQHBhcmFtIHsobmV3UHVyc2VCYWxhbmNlOiBBbW91bnQpID0+IHZvaWR9IHVwZGF0ZVB1cnNlQmFsYW5jZSAtXG4gKiBjb21taXQgdGhlIHB1cnNlIGJhbGFuY2VcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnQgLSB0aGUgYW1vdW50IHRvIGJlIHdpdGhkcmF3blxuICogQHBhcmFtIHtTZXRTdG9yZTxQYXltZW50Pn0gcmVjb3ZlcnlTZXRcbiAqIEByZXR1cm5zIHtQYXltZW50fVxuICovXG5jb25zdCB3aXRoZHJhd0ludGVybmFsPShcbmN1cnJlbnRCYWxhbmNlLFxudXBkYXRlUHVyc2VCYWxhbmNlLFxuYW1vdW50LFxucmVjb3ZlcnlTZXQpPT5cbntcbmFtb3VudD1jb2VyY2UoYW1vdW50KTtcbkFtb3VudE1hdGguaXNHVEUoY3VycmVudEJhbGFuY2UsYW1vdW50KXx8XG5GYWlsIGBXaXRoZHJhd2FsIG9mICR7YW1vdW50fSBmYWlsZWQgYmVjYXVzZSB0aGUgcHVyc2Ugb25seSBjb250YWluZWQgJHtjdXJyZW50QmFsYW5jZX1gO1xuY29uc3QgbmV3UHVyc2VCYWxhbmNlPXN1YnRyYWN0KGN1cnJlbnRCYWxhbmNlLGFtb3VudCk7XG5cbmNvbnN0IHBheW1lbnQ9bWFrZVBheW1lbnQoKTtcbnRyeXtcbi8qIENPTU1JVCBQT0lOVCBNb3ZlIHRoZSB3aXRoZHJhd24gYXNzZXRzIGZyb20gdGhpcyBwdXJzZSBpbnRvKi9cbi8qIHBheW1lbnQuIFRvdGFsIGFzc2V0cyBtdXN0IHJlbWFpbiBjb25zZXJ2ZWQuKi9cbnVwZGF0ZVB1cnNlQmFsYW5jZShuZXdQdXJzZUJhbGFuY2UpO1xuaW5pdFBheW1lbnQocGF5bWVudCxhbW91bnQscmVjb3ZlcnlTZXQpO1xuIH1jYXRjaChlcnIpe1xuc2h1dGRvd25MZWRnZXJXaXRoRmFpbHVyZShlcnIpO1xudGhyb3cgZXJyO1xuIH1cbnJldHVybiBwYXltZW50O1xuIH07XG5cbmNvbnN0IG1ha2VFbXB0eVB1cnNlPXByZXBhcmVQdXJzZUtpbmQoXG5pc3N1ZXJCYWdnYWdlLFxubmFtZSxcbmFzc2V0S2luZCxcbmJyYW5kLFxuUHVyc2VJS2l0LFxuaGFyZGVuKHtcbmRlcG9zaXRJbnRlcm5hbCxcbndpdGhkcmF3SW50ZXJuYWx9KSk7XG5cblxuXG4vKiogQHR5cGUge0lzc3VlcjxLPn0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCBkdWUgdG8gY2FsbFdoZW4gZGlzY3JlcGFuY3kqL1xuY29uc3QgaXNzdWVyPXByZXBhcmVFeG8oaXNzdWVyQmFnZ2FnZSwgYCR7bmFtZX0gaXNzdWVyYCxJc3N1ZXJJLHtcbmdldEJyYW5kKCl7XG5yZXR1cm4gYnJhbmQ7XG4gfSxcbmdldEFsbGVnZWROYW1lKCl7XG5yZXR1cm4gbmFtZTtcbiB9LFxuZ2V0QXNzZXRLaW5kKCl7XG5yZXR1cm4gYXNzZXRLaW5kO1xuIH0sXG5nZXREaXNwbGF5SW5mbygpe1xucmV0dXJuIGRpc3BsYXlJbmZvO1xuIH0sXG5tYWtlRW1wdHlQdXJzZSgpe1xucmV0dXJuIG1ha2VFbXB0eVB1cnNlKCk7XG4gfSxcbi8qKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnQgYXdhaXRlZCBieSBjYWxsV2hlbiAqL1xuaXNMaXZlKHBheW1lbnQpe1xuLyogSXNzdWVySSBkZWxheXMgY2FsbGluZyB0aGlzIG1ldGhvZCB1bnRpbCBgcGF5bWVudGAgaXMgYSBSZW1vdGFibGUqL1xucmV0dXJuIHBheW1lbnRMZWRnZXIuaGFzKHBheW1lbnQpO1xuIH0sXG4vKiogQHBhcmFtIHtQYXltZW50fSBwYXltZW50IGF3YWl0ZWQgYnkgY2FsbFdoZW4gKi9cbmdldEFtb3VudE9mKHBheW1lbnQpe1xuLyogSXNzdWVySSBkZWxheXMgY2FsbGluZyB0aGlzIG1ldGhvZCB1bnRpbCBgcGF5bWVudGAgaXMgYSBSZW1vdGFibGUqL1xuYXNzZXJ0TGl2ZVBheW1lbnQocGF5bWVudCk7XG5yZXR1cm4gcGF5bWVudExlZGdlci5nZXQocGF5bWVudCk7XG4gfSxcbi8qKlxuICogQHBhcmFtIHtQYXltZW50fSBwYXltZW50IGF3YWl0ZWQgYnkgY2FsbFdoZW5cbiAqIEBwYXJhbSB7UGF0dGVybn0gb3B0QW1vdW50U2hhcGVcbiAqL1xuYnVybihwYXltZW50LG9wdEFtb3VudFNoYXBlPXVuZGVmaW5lZCl7XG4vKiBJc3N1ZXJJIGRlbGF5cyBjYWxsaW5nIHRoaXMgbWV0aG9kIHVudGlsIGBwYXltZW50YCBpcyBhIFJlbW90YWJsZSovXG5hc3NlcnRMaXZlUGF5bWVudChwYXltZW50KTtcbmNvbnN0IHBheW1lbnRCYWxhbmNlPXBheW1lbnRMZWRnZXIuZ2V0KHBheW1lbnQpO1xuYXNzZXJ0QW1vdW50Q29uc2lzdGVudChwYXltZW50QmFsYW5jZSxvcHRBbW91bnRTaGFwZSk7XG50cnl7XG4vKiBDT01NSVQgUE9JTlQuKi9cbmRlbGV0ZVBheW1lbnQocGF5bWVudCk7XG4gfWNhdGNoKGVycil7XG5zaHV0ZG93bkxlZGdlcldpdGhGYWlsdXJlKGVycik7XG50aHJvdyBlcnI7XG4gfVxucmV0dXJuIHBheW1lbnRCYWxhbmNlO1xuIH19KTtcblxuXG4vKipcbiAqIFByb3ZpZGVzIGZvciB0aGUgcmVjb3Zlcnkgb2YgbmV3bHkgbWludGVkIGJ1dCBub3QteWV0LWRlcG9zaXRlZCBwYXltZW50cy5cbiAqXG4gKiBCZWNhdXNlIHRoZSBgbWludFJlY292ZXJ5UHVyc2VgIGlzIHBsYWNlZCBpbiBiYWdnYWdlLCBldmVuIGlmIHRoZVxuICogY2FsbGVyIG9mIGBtYWtlSXNzdWVyS2l0YCBkcm9wcyBpdCBvbiB0aGUgZmxvb3IsIGl0IGNhbiBzdGlsbCBiZVxuICogcmVjb3ZlcmVkIGluIGFuIGVtZXJnZW5jeSB1cGdyYWRlLlxuICpcbiAqIEB0eXBlIHtQdXJzZTxLPn1cbiAqL1xuY29uc3QgbWludFJlY292ZXJ5UHVyc2U9cHJvdmlkZShpc3N1ZXJCYWdnYWdlLCdtaW50UmVjb3ZlcnlQdXJzZScsKCk9PlxubWFrZUVtcHR5UHVyc2UoKSk7XG5cblxuLyoqIEB0eXBlIHtNaW50PEs+fSAqL1xuY29uc3QgbWludD1wcmVwYXJlRXhvKGlzc3VlckJhZ2dhZ2UsIGAke25hbWV9IG1pbnRgLE1pbnRJLHtcbmdldElzc3Vlcigpe1xucmV0dXJuIGlzc3VlcjtcbiB9LFxubWludFBheW1lbnQobmV3QW1vdW50KXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2hlY2tlZCBjYXN0Ki9cbm5ld0Ftb3VudD1jb2VyY2UobmV3QW1vdW50KTtcbm11c3RNYXRjaChuZXdBbW91bnQsYW1vdW50U2hhcGUsJ21pbnRlZCBhbW91bnQnKTtcbi8qIGByYXdQYXltZW50YCBpcyBub3QgYXNzb2NpYXRlZCB3aXRoIGFueSByZWNvdmVyeSBzZXQsIGFuZCovXG4vKiBzbyBtdXN0IG5vdCBlc2NhcGUuKi9cbmNvbnN0IHJhd1BheW1lbnQ9bWFrZVBheW1lbnQoKTtcbmluaXRQYXltZW50KHJhd1BheW1lbnQsbmV3QW1vdW50LHVuZGVmaW5lZCk7XG5cbmNvbnN0IG1pbnRSZWNvdmVyeVB1cnNlQmVmb3JlPW1pbnRSZWNvdmVyeVB1cnNlLmdldEN1cnJlbnRBbW91bnQoKTtcbm1pbnRSZWNvdmVyeVB1cnNlLmRlcG9zaXQocmF3UGF5bWVudCxuZXdBbW91bnQpO1xuY29uc3QgcGF5bWVudD1taW50UmVjb3ZlcnlQdXJzZS53aXRoZHJhdyhuZXdBbW91bnQpO1xuY29uc3QgbWludFJlY292ZXJ5UHVyc2VBZnRlcj1taW50UmVjb3ZlcnlQdXJzZS5nZXRDdXJyZW50QW1vdW50KCk7XG5hc3NlcnQoa2V5RVEobWludFJlY292ZXJ5UHVyc2VCZWZvcmUsbWludFJlY292ZXJ5UHVyc2VBZnRlcikpO1xucmV0dXJuIHBheW1lbnQ7XG4gfX0pO1xuXG5cbmNvbnN0IGlzc3VlcktpdD1oYXJkZW4oe2lzc3VlcixtaW50LGJyYW5kLG1pbnRSZWNvdmVyeVB1cnNlfSk7XG5yZXR1cm4gaXNzdWVyS2l0O1xuIH07JGjigI1fb25jZS5wcmVwYXJlUGF5bWVudExlZGdlcihwcmVwYXJlUGF5bWVudExlZGdlcik7XG5oYXJkZW4ocHJlcGFyZVBheW1lbnRMZWRnZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVQYXltZW50TGVkZ2VyIjpbInByZXBhcmVQYXltZW50TGVkZ2VyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAKJFRULADwAAwA8AACcAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvcHVyc2UuanN7ImltcG9ydHMiOlsiLi9hbW91bnRNYXRoLmpzIiwiLi90cmFuc2llbnROb3RpZmllci5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsicHJlcGFyZVB1cnNlS2luZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLHByZXBhcmVFeG9DbGFzc0tpdCxtYWtlU2NhbGFyQmlnU2V0U3RvcmUsQW1vdW50TWF0aCxtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQ7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJwcmVwYXJlRXhvQ2xhc3NLaXRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzc0tpdCA9ICRo4oCNX2EpXV0sW1wibWFrZVNjYWxhckJpZ1NldFN0b3JlXCIsIFskaOKAjV9hID0+IChtYWtlU2NhbGFyQmlnU2V0U3RvcmUgPSAkaOKAjV9hKV1dXV0sW1wiLi9hbW91bnRNYXRoLmpzXCIsIFtbXCJBbW91bnRNYXRoXCIsIFskaOKAjV9hID0+IChBbW91bnRNYXRoID0gJGjigI1fYSldXV1dLFtcIi4vdHJhbnNpZW50Tm90aWZpZXIuanNcIiwgW1tcIm1ha2VUcmFuc2llbnROb3RpZmllcktpdFwiLCBbJGjigI1fYSA9PiAobWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuY29uc3QgICAgICAgIHByZXBhcmVQdXJzZUtpbmQ9KFxuaXNzdWVyQmFnZ2FnZSxcbm5hbWUsXG5hc3NldEtpbmQsXG5icmFuZCxcblB1cnNlSUtpdCxcbnB1cnNlTWV0aG9kcyk9Plxue1xuY29uc3QgYW1vdW50U2hhcGU9YnJhbmQuZ2V0QW1vdW50U2hhcGUoKTtcblxuLyogTm90ZTogVmlydHVhbCBmb3IgaGlnaCBjYXJkaW5hbGl0eSwgYnV0ICpub3QqIGR1cmFibGUsIGFuZCBzbyovXG4vKiBicm9rZW4gYWNyb3NzIGFuIHVwZ3JhZGUuKi9cbmNvbnN0e3Byb3ZpZGVOb3RpZmllcix1cGRhdGU6dXBkYXRlQmFsYW5jZX09bWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0KCk7XG5cbmNvbnN0IHVwZGF0ZVB1cnNlQmFsYW5jZT0oc3RhdGUsbmV3UHVyc2VCYWxhbmNlLHB1cnNlKT0+e1xuc3RhdGUuY3VycmVudEJhbGFuY2U9bmV3UHVyc2VCYWxhbmNlO1xudXBkYXRlQmFsYW5jZShwdXJzZSxwdXJzZS5nZXRDdXJyZW50QW1vdW50KCkpO1xuIH07XG5cbi8qIC0gVGhpcyBraW5kIGlzIGEgcGFpciBvZiBwdXJzZSBhbmQgZGVwb3NpdEZhY2V0IHRoYXQgaGF2ZSBhIDE6MSovXG4vKiBjb3JyZXNwb25kZW5jZS4qL1xuLyogLSBUaGV5IGFyZSB2aXJ0dWFsaXplZCB0b2dldGhlciB0byBzaGFyZSBhIHNpbmdsZSBzdGF0ZSByZWNvcmQuKi9cbi8qIC0gQW4gYWx0ZXJuYXRpdmUgZGVzaWduIGNvbnNpZGVyZWQgd2FzIHRvIGhhdmUgdGhpcyByZXR1cm4gYSBQdXJzZSBhbG9uZSovXG4vKiB0aGF0IGNyZWF0ZWQgZGVwb3NpdEZhY2V0IGFzIG5lZWRlZC4gQnV0IHRoaXMgYXBwcm9hY2ggZW5zdXJlcyBhIGNvbnN0YW50Ki9cbi8qIGlkZW50aXR5IGZvciB0aGUgZmFjZXQgYW5kIGV4ZXJjaXNlcyB0aGUgbXVsdGktZmFjZXRlZCBvYmplY3Qgc3R5bGUuKi9cbmNvbnN0e2RlcG9zaXRJbnRlcm5hbCx3aXRoZHJhd0ludGVybmFsfT1wdXJzZU1ldGhvZHM7XG5jb25zdCBtYWtlUHVyc2VLaXQ9cHJlcGFyZUV4b0NsYXNzS2l0KFxuaXNzdWVyQmFnZ2FnZSxcbiBgJHtuYW1lfSBQdXJzZWAsXG5QdXJzZUlLaXQsXG4oKT0+e1xuY29uc3QgY3VycmVudEJhbGFuY2U9QW1vdW50TWF0aC5tYWtlRW1wdHkoYnJhbmQsYXNzZXRLaW5kKTtcblxuLyoqIEB0eXBlIHtTZXRTdG9yZTxQYXltZW50Pn0gKi9cbmNvbnN0IHJlY292ZXJ5U2V0PW1ha2VTY2FsYXJCaWdTZXRTdG9yZSgncmVjb3Zlcnkgc2V0Jyx7XG5kdXJhYmxlOnRydWV9KTtcblxuXG5yZXR1cm57XG5jdXJyZW50QmFsYW5jZSxcbnJlY292ZXJ5U2V0fTtcblxuIH0sXG57XG5wdXJzZTp7XG5kZXBvc2l0KHNyY1BheW1lbnQsb3B0QW1vdW50U2hhcGU9dW5kZWZpbmVkKXtcbi8qIFB1cnNlSSBkb2VzICpub3QqIGRlbGF5IGBkZXBvc2l0YCB1bnRpbCBgc3JjUGF5bWVudGAgaXMgZnVsZnVsbGVkLiovXG4vKiBTZWUgdGhlIGNvbW1lbnRzIG9uIFB1cnNlSS5kZXBvc2l0IGluIHR5cGVHdWFyZHMuanMqL1xuY29uc3R7c3RhdGV9PXRoaXM7XG4vKiBOb3RlIENPTU1JVCBQT0lOVCB3aXRoaW4gZGVwb3NpdC4qL1xucmV0dXJuIGRlcG9zaXRJbnRlcm5hbChcbnN0YXRlLmN1cnJlbnRCYWxhbmNlLFxuKG5ld1B1cnNlQmFsYW5jZSk9PlxudXBkYXRlUHVyc2VCYWxhbmNlKHN0YXRlLG5ld1B1cnNlQmFsYW5jZSx0aGlzLmZhY2V0cy5wdXJzZSksXG5zcmNQYXltZW50LFxub3B0QW1vdW50U2hhcGUpO1xuXG4gfSxcbndpdGhkcmF3KGFtb3VudCl7XG5jb25zdHtzdGF0ZX09dGhpcztcbi8qIE5vdGUgQ09NTUlUIFBPSU5UIHdpdGhpbiB3aXRoZHJhdy4qL1xucmV0dXJuIHdpdGhkcmF3SW50ZXJuYWwoXG5zdGF0ZS5jdXJyZW50QmFsYW5jZSxcbihuZXdQdXJzZUJhbGFuY2UpPT5cbnVwZGF0ZVB1cnNlQmFsYW5jZShzdGF0ZSxuZXdQdXJzZUJhbGFuY2UsdGhpcy5mYWNldHMucHVyc2UpLFxuYW1vdW50LFxuc3RhdGUucmVjb3ZlcnlTZXQpO1xuXG4gfSxcbmdldEN1cnJlbnRBbW91bnQoKXtcbnJldHVybiB0aGlzLnN0YXRlLmN1cnJlbnRCYWxhbmNlO1xuIH0sXG5nZXRDdXJyZW50QW1vdW50Tm90aWZpZXIoKXtcbnJldHVybiBwcm92aWRlTm90aWZpZXIodGhpcy5mYWNldHMucHVyc2UpO1xuIH0sXG5nZXRBbGxlZ2VkQnJhbmQoKXtcbnJldHVybiBicmFuZDtcbiB9LFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbmdldERlcG9zaXRGYWNldCgpe1xucmV0dXJuIHRoaXMuZmFjZXRzLmRlcG9zaXRGYWNldDtcbiB9LFxuXG5nZXRSZWNvdmVyeVNldCgpe1xucmV0dXJuIHRoaXMuc3RhdGUucmVjb3ZlcnlTZXQuc25hcHNob3QoKTtcbiB9LFxucmVjb3ZlckFsbCgpe1xuY29uc3R7c3RhdGUsZmFjZXRzfT10aGlzO1xubGV0IGFtb3VudD1BbW91bnRNYXRoLm1ha2VFbXB0eShicmFuZCxhc3NldEtpbmQpO1xuZm9yKGNvbnN0IHBheW1lbnQgb2Ygc3RhdGUucmVjb3ZlcnlTZXQua2V5cygpKXtcbi8qIFRoaXMgZG9lcyBjYXVzZSBkZWxldGlvbnMgZnJvbSB0aGUgc2V0IHdoaWxlIGl0ZXJhdGluZywqL1xuLyogYnV0IHRoaXMgc3BlY2lhbCBjYXNlIGlzIGFsbG93ZWQuKi9cbmNvbnN0IGRlbHRhPWZhY2V0cy5wdXJzZS5kZXBvc2l0KHBheW1lbnQpO1xuYW1vdW50PUFtb3VudE1hdGguYWRkKGFtb3VudCxkZWx0YSxicmFuZCk7XG4gfVxuc3RhdGUucmVjb3ZlcnlTZXQuZ2V0U2l6ZSgpPT09MHx8XG5GYWlsIGBpbnRlcm5hbDogUmVtYWluaW5nIHVucmVjb3ZlcmVkIHBheW1lbnRzOiAke2ZhY2V0cy5wdXJzZS5nZXRSZWNvdmVyeVNldCgpfWA7XG5yZXR1cm4gYW1vdW50O1xuIH19LFxuXG5kZXBvc2l0RmFjZXQ6e1xucmVjZWl2ZSguLi5hcmdzKXtcbnJldHVybiB0aGlzLmZhY2V0cy5wdXJzZS5kZXBvc2l0KC4uLmFyZ3MpO1xuIH19fSxcblxuXG57XG5zdGF0ZVNoYXBlOntcbmN1cnJlbnRCYWxhbmNlOmFtb3VudFNoYXBlLFxucmVjb3ZlcnlTZXQ6TS5yZW1vdGFibGUoJ3JlY292ZXJ5U2V0Jyl9fSk7XG5cblxuXG5yZXR1cm4oKT0+bWFrZVB1cnNlS2l0KCkucHVyc2U7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVQdXJzZUtpbmQocHJlcGFyZVB1cnNlS2luZCk7XG5oYXJkZW4ocHJlcGFyZVB1cnNlS2luZCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicHJlcGFyZVB1cnNlS2luZCI6WyJwcmVwYXJlUHVyc2VLaW5kIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAC5JY6kUBgAAFAYAADMAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvdHJhbnNpZW50Tm90aWZpZXIuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9ub3RpZmllciIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsibWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUscHJvdmlkZUxhenksbWFrZU5vdGlmaWVyS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmVcIiwgWyRo4oCNX2EgPT4gKG1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wicHJvdmlkZUxhenlcIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVMYXp5ID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvbm90aWZpZXJcIiwgW1tcIm1ha2VOb3RpZmllcktpdFwiLCBbJGjigI1fYSA9PiAobWFrZU5vdGlmaWVyS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyogTm90ZTogVmlydHVhbCBmb3IgaGlnaCBjYXJkaW5hbGl0eSwgYnV0ICpub3QqIGR1cmFibGUsIGFuZCBzbyovXG4vKiBicm9rZW4gYWNyb3NzIGFuIHVwZ3JhZGUuKi9cbmNvbnN0ICAgICAgICBtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQ9KCk9Pntcbi8qKiBAdHlwZSB7V2Vha01hcFN0b3JlPFB1cnNlLCBOb3RpZmllclJlY29yZDxhbnk+Pn0gKi9cbmNvbnN0IHRyYW5zaWVudE5vdGlmZXJLaXRzPW1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUoXG4ndHJhbnNpZW50Tm90aWZlcktpdHMnKTtcblxuXG5jb25zdCBwcm92aWRlTm90aWZpZXJLaXQ9KGtleSk9PlxucHJvdmlkZUxhenkodHJhbnNpZW50Tm90aWZlcktpdHMsa2V5LCgpPT5cbm1ha2VOb3RpZmllcktpdChrZXkuZ2V0Q3VycmVudEFtb3VudCgpKSk7XG5cblxuY29uc3QgcHJvdmlkZU5vdGlmaWVyPShrZXkpPT5wcm92aWRlTm90aWZpZXJLaXQoa2V5KS5ub3RpZmllcjtcbmNvbnN0IHVwZGF0ZT0oa2V5LG5ld1ZhbHVlKT0+e1xuaWYodHJhbnNpZW50Tm90aWZlcktpdHMuaGFzKGtleSkpe1xuY29uc3R7dXBkYXRlcn09dHJhbnNpZW50Tm90aWZlcktpdHMuZ2V0KGtleSk7XG51cGRhdGVyLnVwZGF0ZVN0YXRlKG5ld1ZhbHVlKTtcbiB9XG4gfTtcblxucmV0dXJue3Byb3ZpZGVOb3RpZmllcix1cGRhdGV9O1xuIH07JGjigI1fb25jZS5tYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQobWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0KTtcbmhhcmRlbihtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VUcmFuc2llbnROb3RpZmllcktpdCI6WyJtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAKO6ePhInAAASJwAALAAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy90eXBlR3VhcmRzLmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvc3RvcmUiXSwiZXhwb3J0cyI6WyJBbW91bnRTaGFwZSIsIkFzc2V0S2luZFNoYXBlIiwiQnJhbmRJIiwiQnJhbmRTaGFwZSIsIkRlcG9zaXRGYWNldFNoYXBlIiwiRGlzcGxheUluZm9TaGFwZSIsIklzc3VlcktpdFNoYXBlIiwiSXNzdWVyU2hhcGUiLCJNQVhfQUJTT0xVVEVfREVDSU1BTF9QTEFDRVMiLCJNaW50U2hhcGUiLCJOb3RpZmllclNoYXBlIiwiUGF5bWVudFNoYXBlIiwiUHVyc2VTaGFwZSIsIlJhdGlvU2hhcGUiLCJpc0NvcHlCYWdWYWx1ZSIsImlzQ29weVNldFZhbHVlIiwiaXNOYXRWYWx1ZSIsImlzU2V0VmFsdWUiLCJtYWtlSXNzdWVySW50ZXJmYWNlcyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLG1hdGNoZXM7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV0sW1wibWF0Y2hlc1wiLCBbJGjigI1fYSA9PiAobWF0Y2hlcyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3QgICAgICAgIEJyYW5kU2hhcGU9TS5yZW1vdGFibGUoJ0JyYW5kJyk7JGjigI1fb25jZS5CcmFuZFNoYXBlKEJyYW5kU2hhcGUpO1xuY29uc3QgICAgICAgIElzc3VlclNoYXBlPU0ucmVtb3RhYmxlKCdJc3N1ZXInKTskaOKAjV9vbmNlLklzc3VlclNoYXBlKElzc3VlclNoYXBlKTtcbmNvbnN0ICAgICAgICBQYXltZW50U2hhcGU9TS5yZW1vdGFibGUoJ1BheW1lbnQnKTskaOKAjV9vbmNlLlBheW1lbnRTaGFwZShQYXltZW50U2hhcGUpO1xuY29uc3QgICAgICAgIFB1cnNlU2hhcGU9TS5yZW1vdGFibGUoJ1B1cnNlJyk7JGjigI1fb25jZS5QdXJzZVNoYXBlKFB1cnNlU2hhcGUpO1xuY29uc3QgICAgICAgIERlcG9zaXRGYWNldFNoYXBlPU0ucmVtb3RhYmxlKCdEZXBvc2l0RmFjZXQnKTskaOKAjV9vbmNlLkRlcG9zaXRGYWNldFNoYXBlKERlcG9zaXRGYWNldFNoYXBlKTtcbmNvbnN0ICAgICAgICBOb3RpZmllclNoYXBlPU0ucmVtb3RhYmxlKCdOb3RpZmllcicpOyRo4oCNX29uY2UuTm90aWZpZXJTaGFwZShOb3RpZmllclNoYXBlKTtcbmNvbnN0ICAgICAgICBNaW50U2hhcGU9TS5yZW1vdGFibGUoJ01pbnQnKTtcblxuLyoqXG4gKiBXaGVuIHRoZSBBbW91bnRWYWx1ZSBvZiBhbiBBbW91bnQgZml0cyB0aGUgTmF0VmFsdWVTaGFwZSwgaS5lLiwgd2hlbiBpdCBpc1xuICogYSBub24tbmVnYXRpdmUgYmlnaW50LCB0aGVuIGl0IHJlcHJlc2VudHMgdGhhdCBtYW55IHVuaXRzIG9mIHRoZVxuICogZnVuZ2libGUgYXNzZXQgcmVwcmVzZW50ZWQgYnkgdGhhdCBhbW91bnQuIFRoZSBicmFuZCBvZiB0aGF0IGFtb3VudFxuICogc2hvdWxkIGluZGVlZCByZXByZXNlbnQgYSBraW5kIG9mIGFzc2V0IGNvbnNpc3Rpbmcgb2YgYSBjb3VudGFibGVcbiAqIHNldCBvZiBmdW5naWJsZSB1bml0cy5cbiAqLyRo4oCNX29uY2UuTWludFNoYXBlKE1pbnRTaGFwZSk7XG5jb25zdCBOYXRWYWx1ZVNoYXBlPU0ubmF0KCk7XG5cbi8qKlxuICogV2hlbiB0aGUgQW1vdW50VmFsdWUgb2YgYW4gQW1vdW50IGZpdHMgdGhlIENvcHlTZXRWYWx1ZVNoYXBlLCBpLmUuLCB3aGVuIGl0XG4gKiBpcyBhIENvcHlTZXQsIHRoZW4gaXQgcmVwcmVzZW50cyB0aGUgc2V0IG9mIHRob3NlXG4gKiBrZXlzLCB3aGVyZSBlYWNoIGtleSByZXByZXNlbnRzIHNvbWUgaW5kaXZpZHVhbCBub24tZnVuZ2libGVcbiAqIGl0ZW0sIGxpa2UgYSBjb25jZXJ0IHRpY2tldCwgZnJvbSB0aGUgbm9uLWZ1bmdpYmxlIGFzc2V0IGNsYXNzXG4gKiByZXByZXNlbnRlZCBieSB0aGF0IGFtb3VudCdzIGJyYW5kLiBUaGUgYW1vdW50IGl0c2VsZiByZXByZXNlbnRzXG4gKiB0aGUgc2V0IG9mIHRoZXNlIGl0ZW1zLCBhcyBvcHBvc2VkIHRvIGFueSBvZiB0aGUgb3RoZXIgaXRlbXNcbiAqIGZyb20gdGhlIHNhbWUgYXNzZXQgY2xhc3MuXG4gKlxuICogSWYgYSBnaXZlbiB2YWx1ZSBjbGFzcyByZXByZXNlbnRzIGNvbmNlcnQgdGlja2V0cywgaXQgc2VlbXMgYml6YXJyZVxuICogdGhhdCB3ZSBjYW4gZm9ybSBhbW91bnRzIG9mIGFueSBrZXkuIFRoZSBoYXJkIGNvbnN0cmFpbnQgaXMgdGhhdFxuICogdGhlIGNvZGUgdGhhdCBob2xkcyB0aGUgbWludCBmb3IgdGhhdCBhc3NldCBjbGFzcy0tLXRoZSBvbmUgYXNzb2NpYXRlZFxuICogd2l0aCB0aGF0IGJyYW5kLCBvbmx5IG1pbnRzIHRoZSBpdGVtcyByZXByZXNlbnRpbmcgdGhlIHJlYWwgdW5pdHNcbiAqIG9mIHRoYXQgYXNzZXQgY2xhc3MgYXMgZGVmaW5lZCBieSBpdC4gQW55b25lIGVsc2UgY2FuIHB1dCB0b2dldGhlclxuICogYW4gYW1vdW50IGV4cHJlc3NpbmcsIGZvciBleGFtcGxlLCB0aGF0IHRoZXkgXCJ3YW50XCIgc29tZSBpdGVtcyB0aGF0XG4gKiB3aWxsIG5ldmVyIGJlIG1pbnRlZC4gVGhhdCB3YW50IHdpbGwgbmV2ZXIgYmUgc2F0aXNmaWVkLlxuICogXCJZb3UgY2FuJ3QgYWx3YXlzIGdldC4uLlwiXG4gKi9cbmNvbnN0IENvcHlTZXRWYWx1ZVNoYXBlPU0uc2V0KCk7XG5cbi8qKlxuICogV2hlbiB0aGUgQW1vdW50VmFsdWUgb2YgYW4gQW1vdW50IGZpdHMgdGhlIFNldFZhbHVlU2hhcGUsIGkuZS4sIHdoZW4gaXRcbiAqIGlzIGEgQ29weUFycmF5IG9mIHBhc3NhYmxlIEtleXMuIFRoaXMgcmVwcmVzZW50YXRpb24gaXMgZGVwcmVjYXRlZC5cbiAqXG4gKiBAZGVwcmVjYXRlZCBQbGVhc2UgY2hhbmdlIGZyb20gdXNpbmcgYXJyYXktYmFzZWQgU2V0VmFsdWVzIHRvIENvcHlTZXQtYmFzZWRcbiAqIENvcHlTZXRWYWx1ZXMuXG4gKi9cbmNvbnN0IFNldFZhbHVlU2hhcGU9TS5hcnJheU9mKE0ua2V5KCkpO1xuXG4vKipcbiAqIFdoZW4gdGhlIEFtb3VudFZhbHVlIG9mIGFuIEFtb3VudCBmaXRzIHRoZSBDb3B5QmFnVmFsdWVTaGFwZSwgaS5lLiwgd2hlbiBpdFxuICogaXMgYSBDb3B5QmFnLCB0aGVuIGl0IHJlcHJlc2VudHMgdGhlIGJhZyAobXVsdGlzZXQpIG9mIHRob3NlXG4gKiBrZXlzLCB3aGVyZSBlYWNoIGtleSByZXByZXNlbnRzIHNvbWUgaW5kaXZpZHVhbCBzZW1pLWZ1bmdpYmxlXG4gKiBpdGVtLCBsaWtlIGEgY29uY2VydCB0aWNrZXQsIGZyb20gdGhlIHNlbWktZnVuZ2libGUgYXNzZXQgY2xhc3NcbiAqIHJlcHJlc2VudGVkIGJ5IHRoYXQgYW1vdW50J3MgYnJhbmQuIFRoZSBudW1iZXIgb2YgdGltZXMgdGhhdCBrZXlcbiAqIGFwcGVhcnMgaW4gdGhlIGJhZyBpcyB0aGUgbnVtYmVyIG9mIGZ1bmdpYmxlIHVuaXRzIG9mIHRoYXQga2V5LlxuICogVGhlIGFtb3VudCBpdHNlbGYgcmVwcmVzZW50c1xuICogdGhlIGJhZyBvZiB0aGVzZSBpdGVtcywgYXMgb3Bwb3NlZCB0byBhbnkgb2YgdGhlIG90aGVyIGl0ZW1zXG4gKiBmcm9tIHRoZSBzYW1lIGFzc2V0IGNsYXNzLlxuICpcbiAqIElmIGEgZ2l2ZW4gdmFsdWUgY2xhc3MgcmVwcmVzZW50cyBjb25jZXJ0IHRpY2tldHMsIGl0IHNlZW1zIGJpemFycmVcbiAqIHRoYXQgd2UgY2FuIGZvcm0gYW1vdW50cyBvZiBhbnkga2V5LiBUaGUgaGFyZCBjb25zdHJhaW50IGlzIHRoYXRcbiAqIHRoZSBjb2RlIHRoYXQgaG9sZHMgdGhlIG1pbnQgZm9yIHRoYXQgYXNzZXQgY2xhc3MtLS10aGUgb25lIGFzc29jaWF0ZWRcbiAqIHdpdGggdGhhdCBicmFuZCwgb25seSBtaW50cyB0aGUgaXRlbXMgcmVwcmVzZW50aW5nIHRoZSByZWFsIHVuaXRzXG4gKiBvZiB0aGF0IGFzc2V0IGNsYXNzIGFzIGRlZmluZWQgYnkgaXQuIEFueW9uZSBlbHNlIGNhbiBwdXQgdG9nZXRoZXJcbiAqIGFuIGFtb3VudCBleHByZXNzaW5nLCBmb3IgZXhhbXBsZSwgdGhhdCB0aGV5IFwid2FudFwiIHNvbWUgaXRlbXMgdGhhdFxuICogd2lsbCBuZXZlciBiZSBtaW50ZWQuIFRoYXQgd2FudCB3aWxsIG5ldmVyIGJlIHNhdGlzZmllZC5cbiAqIFwiWW91IGNhbid0IGFsd2F5cyBnZXQuLi5cIlxuICovXG5jb25zdCBDb3B5QmFnVmFsdWVTaGFwZT1NLmJhZygpO1xuXG5jb25zdCBBbW91bnRWYWx1ZVNoYXBlPU0ub3IoXG5OYXRWYWx1ZVNoYXBlLFxuQ29weVNldFZhbHVlU2hhcGUsXG5TZXRWYWx1ZVNoYXBlLFxuQ29weUJhZ1ZhbHVlU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBBbW91bnRTaGFwZT1oYXJkZW4oe1xuYnJhbmQ6QnJhbmRTaGFwZSxcbnZhbHVlOkFtb3VudFZhbHVlU2hhcGV9KTskaOKAjV9vbmNlLkFtb3VudFNoYXBlKEFtb3VudFNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgUmF0aW9TaGFwZT1oYXJkZW4oe1xubnVtZXJhdG9yOkFtb3VudFNoYXBlLFxuZGVub21pbmF0b3I6QW1vdW50U2hhcGV9KTtcblxuXG4vKipcbiAqIFJldHVybnMgdHJ1ZSBpZiB2YWx1ZSBpcyBhIE5hdCBiaWdpbnQuXG4gKlxuICogQHBhcmFtIHtBbW91bnRWYWx1ZX0gdmFsdWVcbiAqIEByZXR1cm5zIHt2YWx1ZSBpcyBYaW1wb3J0KCcuL3R5cGVzLmpzJykuTmF0VmFsdWV9XG4gKi8kaOKAjV9vbmNlLlJhdGlvU2hhcGUoUmF0aW9TaGFwZSk7XG5jb25zdCAgICAgICAgaXNOYXRWYWx1ZT0odmFsdWUpPT5tYXRjaGVzKHZhbHVlLE5hdFZhbHVlU2hhcGUpOyRo4oCNX29uY2UuaXNOYXRWYWx1ZShpc05hdFZhbHVlKTtcbmhhcmRlbihpc05hdFZhbHVlKTtcblxuLyoqXG4gKiBSZXR1cm5zIHRydWUgaWYgdmFsdWUgaXMgYSBDb3B5U2V0XG4gKlxuICogQHBhcmFtIHtBbW91bnRWYWx1ZX0gdmFsdWVcbiAqIEByZXR1cm5zIHt2YWx1ZSBpcyBDb3B5U2V0fVxuICovXG5jb25zdCAgICAgICAgaXNDb3B5U2V0VmFsdWU9KHZhbHVlKT0+bWF0Y2hlcyh2YWx1ZSxDb3B5U2V0VmFsdWVTaGFwZSk7JGjigI1fb25jZS5pc0NvcHlTZXRWYWx1ZShpc0NvcHlTZXRWYWx1ZSk7XG5oYXJkZW4oaXNDb3B5U2V0VmFsdWUpO1xuXG4vKipcbiAqIFJldHVybnMgdHJ1ZSBpZiB2YWx1ZSBpcyBhIHBhc3MgYnkgY29weSBhcnJheSBzdHJ1Y3R1cmUuIERvZXMgbm90XG4gKiBjaGVjayBmb3IgZHVwbGljYXRlcy4gVG8gY2hlY2sgZm9yIGR1cGxpY2F0ZXMsIHVzZSBzZXRNYXRoSGVscGVycy5jb2VyY2UuXG4gKlxuICogQGRlcHJlY2F0ZWQgUGxlYXNlIGNoYW5nZSBmcm9tIHVzaW5nIGFycmF5LWJhc2VkIFNldFZhbHVlcyB0byBDb3B5U2V0LWJhc2VkXG4gKiBDb3B5U2V0VmFsdWVzLlxuICogQHBhcmFtIHtBbW91bnRWYWx1ZX0gdmFsdWVcbiAqIEByZXR1cm5zIHt2YWx1ZSBpcyBTZXRWYWx1ZX1cbiAqL1xuY29uc3QgICAgICAgIGlzU2V0VmFsdWU9KHZhbHVlKT0+bWF0Y2hlcyh2YWx1ZSxTZXRWYWx1ZVNoYXBlKTskaOKAjV9vbmNlLmlzU2V0VmFsdWUoaXNTZXRWYWx1ZSk7XG5oYXJkZW4oaXNTZXRWYWx1ZSk7XG5cbi8qKlxuICogUmV0dXJucyB0cnVlIGlmIHZhbHVlIGlzIGEgQ29weUJhZ1xuICpcbiAqIEBwYXJhbSB7QW1vdW50VmFsdWV9IHZhbHVlXG4gKiBAcmV0dXJucyB7dmFsdWUgaXMgQ29weUJhZ31cbiAqL1xuY29uc3QgICAgICAgIGlzQ29weUJhZ1ZhbHVlPSh2YWx1ZSk9Pm1hdGNoZXModmFsdWUsQ29weUJhZ1ZhbHVlU2hhcGUpOyRo4oCNX29uY2UuaXNDb3B5QmFnVmFsdWUoaXNDb3B5QmFnVmFsdWUpO1xuaGFyZGVuKGlzQ29weUJhZ1ZhbHVlKTtcblxuLyogT25lIEdPT0dPTHRoIHNob3VsZCBiZSBlbm91Z2ggZGVjaW1hbCBwbGFjZXMgZm9yIGFueWJvZHkuKi9cbmNvbnN0ICAgICAgICBNQVhfQUJTT0xVVEVfREVDSU1BTF9QTEFDRVM9MTAwOyRo4oCNX29uY2UuTUFYX0FCU09MVVRFX0RFQ0lNQUxfUExBQ0VTKE1BWF9BQlNPTFVURV9ERUNJTUFMX1BMQUNFUyk7XG5cbmNvbnN0ICAgICAgICBBc3NldEtpbmRTaGFwZT1NLm9yKCduYXQnLCdzZXQnLCdjb3B5U2V0JywnY29weUJhZycpOyRo4oCNX29uY2UuQXNzZXRLaW5kU2hhcGUoQXNzZXRLaW5kU2hhcGUpO1xuXG5jb25zdCAgICAgICAgRGlzcGxheUluZm9TaGFwZT1NLnNwbGl0UmVjb3JkKFxue30sXG57XG5kZWNpbWFsUGxhY2VzOk0uYW5kKFxuTS5ndGUoLU1BWF9BQlNPTFVURV9ERUNJTUFMX1BMQUNFUyksXG5NLmx0ZShNQVhfQUJTT0xVVEVfREVDSU1BTF9QTEFDRVMpKSxcblxuYXNzZXRLaW5kOkFzc2V0S2luZFNoYXBlfSxcblxue1xuLyogSW5jbHVkaW5nIHRoaXMgZW1wdHkgYHJlc3RgIGVuc3VyZXMgdGhhdCB0aGVyZSBhcmUgbm8gb3RoZXIqL1xuLyogcHJvcGVydGllcyBiZXlvbmQgdGhvc2UgaW4gdGhlIGBiYXNlYCByZWNvcmQuKi99KTskaOKAjV9vbmNlLkRpc3BsYXlJbmZvU2hhcGUoRGlzcGxheUluZm9TaGFwZSk7XG5cblxuXG5jb25zdCAgICAgICAgSXNzdWVyS2l0U2hhcGU9aGFyZGVuKHtcbmJyYW5kOkJyYW5kU2hhcGUsXG5taW50Ok1pbnRTaGFwZSxcbm1pbnRSZWNvdmVyeVB1cnNlOlB1cnNlU2hhcGUsXG5pc3N1ZXI6SXNzdWVyU2hhcGUsXG5kaXNwbGF5SW5mbzpEaXNwbGF5SW5mb1NoYXBlfSk7XG5cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIEludGVyZmFjZXMgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qLyRo4oCNX29uY2UuSXNzdWVyS2l0U2hhcGUoSXNzdWVyS2l0U2hhcGUpO1xuXG5jb25zdCAgICAgICAgQnJhbmRJPU0uaW50ZXJmYWNlKCdCcmFuZCcse1xuaXNNeUlzc3VlcjpNLmNhbGxXaGVuKE0uYXdhaXQoSXNzdWVyU2hhcGUpKS5yZXR1cm5zKE0uYm9vbGVhbigpKSxcbmdldEFsbGVnZWROYW1lOk0uY2FsbCgpLnJldHVybnMoTS5zdHJpbmcoKSksXG5nZXREaXNwbGF5SW5mbzpNLmNhbGwoKS5yZXR1cm5zKERpc3BsYXlJbmZvU2hhcGUpLFxuZ2V0QW1vdW50U2hhcGU6TS5jYWxsKCkucmV0dXJucyhNLnBhdHRlcm4oKSl9KTtcblxuXG4vKipcbiAqIEBwYXJhbSB7UGF0dGVybn0gW2JyYW5kU2hhcGVdXG4gKiBAcGFyYW0ge1BhdHRlcm59IFthc3NldEtpbmRTaGFwZV1cbiAqIEBwYXJhbSB7UGF0dGVybn0gW2Ftb3VudFNoYXBlXVxuICovJGjigI1fb25jZS5CcmFuZEkoQnJhbmRJKTtcbmNvbnN0ICAgICAgICBtYWtlSXNzdWVySW50ZXJmYWNlcz0oXG5icmFuZFNoYXBlPUJyYW5kU2hhcGUsXG5hc3NldEtpbmRTaGFwZT1Bc3NldEtpbmRTaGFwZSxcbmFtb3VudFNoYXBlPUFtb3VudFNoYXBlKT0+XG57XG5jb25zdCBJc3N1ZXJJPU0uaW50ZXJmYWNlKCdJc3N1ZXInLHtcbmdldEJyYW5kOk0uY2FsbCgpLnJldHVybnMoYnJhbmRTaGFwZSksXG5nZXRBbGxlZ2VkTmFtZTpNLmNhbGwoKS5yZXR1cm5zKE0uc3RyaW5nKCkpLFxuZ2V0QXNzZXRLaW5kOk0uY2FsbCgpLnJldHVybnMoYXNzZXRLaW5kU2hhcGUpLFxuZ2V0RGlzcGxheUluZm86TS5jYWxsKCkucmV0dXJucyhEaXNwbGF5SW5mb1NoYXBlKSxcbm1ha2VFbXB0eVB1cnNlOk0uY2FsbCgpLnJldHVybnMoUHVyc2VTaGFwZSksXG5cbmlzTGl2ZTpNLmNhbGxXaGVuKE0uYXdhaXQoUGF5bWVudFNoYXBlKSkucmV0dXJucyhNLmJvb2xlYW4oKSksXG5nZXRBbW91bnRPZjpNLmNhbGxXaGVuKE0uYXdhaXQoUGF5bWVudFNoYXBlKSkucmV0dXJucyhhbW91bnRTaGFwZSksXG5idXJuOk0uY2FsbFdoZW4oTS5hd2FpdChQYXltZW50U2hhcGUpKS5cbm9wdGlvbmFsKE0ucGF0dGVybigpKS5cbnJldHVybnMoYW1vdW50U2hhcGUpfSk7XG5cblxuY29uc3QgTWludEk9TS5pbnRlcmZhY2UoJ01pbnQnLHtcbmdldElzc3VlcjpNLmNhbGwoKS5yZXR1cm5zKElzc3VlclNoYXBlKSxcbm1pbnRQYXltZW50Ok0uY2FsbChhbW91bnRTaGFwZSkucmV0dXJucyhQYXltZW50U2hhcGUpfSk7XG5cblxuY29uc3QgUGF5bWVudEk9TS5pbnRlcmZhY2UoJ1BheW1lbnQnLHtcbmdldEFsbGVnZWRCcmFuZDpNLmNhbGwoKS5yZXR1cm5zKGJyYW5kU2hhcGUpfSk7XG5cblxuY29uc3QgUHVyc2VJPU0uaW50ZXJmYWNlKCdQdXJzZScse1xuZ2V0QWxsZWdlZEJyYW5kOk0uY2FsbCgpLnJldHVybnMoYnJhbmRTaGFwZSksXG5nZXRDdXJyZW50QW1vdW50Ok0uY2FsbCgpLnJldHVybnMoYW1vdW50U2hhcGUpLFxuZ2V0Q3VycmVudEFtb3VudE5vdGlmaWVyOk0uY2FsbCgpLnJldHVybnMoTm90aWZpZXJTaGFwZSksXG4vKiBQdXJzZUkgZG9lcyAqbm90KiBkZWxheSBgZGVwb3NpdGAgdW50aWwgYHNyY1BheW1lbnRgIGlzIGZ1bGZ1bGxlZC4qL1xuLyogUmF0aGVyLCB0aGUgc2VtYW50aWNzIG9mIGBkZXBvc2l0YCByZXF1aXJlIGl0IHRvIHByb3ZpZGUgaXRzKi9cbi8qIGNhbGxlcnMgd2l0aCBhIHN0cm9uZyBndWFyYW50ZWUgdGhhdCBgZGVwb3NpdGAgbWVzc2FnZXMgYXJlKi9cbi8qIHByb2Nlc3NlZCB3aXRob3V0IGZ1cnRoZXIgZGVsYXkgaW4gdGhlIG9yZGVyIHRoZXkgYXJyaXZlLiovXG4vKiBQdXJzZUkgdGhlcmVmb3JlIHJlcXVpcmVzIHRoYXQgdGhlIGBzcmNQYXltZW50YCBhcmd1bWVudCBhbHJlYWR5Ki9cbi8qIGJlIGEgcmVtb3RhYmxlLCBub3QgYSBwcm9taXNlLiovXG4vKiBQdXJzZUkgb25seSBjYWxscyB0aGlzIHJhdyBtZXRob2QgYWZ0ZXIgdmFsaWRhdGluZyB0aGF0Ki9cbi8qIGBzcmNQYXltZW50YCBpcyBhIHJlbW90YWJsZSwgbGVhdmluZyBpdCovXG4vKiB0byB0aGlzIHJhdyBtZXRob2QgdG8gdmFsaWRhdGUgdGhhdCB0aGlzIHJlbW90YWJsZSBpcyBhY3R1YWxseSovXG4vKiBhIGxpdmUgcGF5bWVudCBvZiB0aGUgY29ycmVjdCBicmFuZCB3aXRoIHN1ZmZpY2llbnQgZnVuZHMuKi9cbmRlcG9zaXQ6TS5jYWxsKFBheW1lbnRTaGFwZSkub3B0aW9uYWwoTS5wYXR0ZXJuKCkpLnJldHVybnMoYW1vdW50U2hhcGUpLFxuZ2V0RGVwb3NpdEZhY2V0Ok0uY2FsbCgpLnJldHVybnMoRGVwb3NpdEZhY2V0U2hhcGUpLFxud2l0aGRyYXc6TS5jYWxsKGFtb3VudFNoYXBlKS5yZXR1cm5zKFBheW1lbnRTaGFwZSksXG5nZXRSZWNvdmVyeVNldDpNLmNhbGwoKS5yZXR1cm5zKE0uc2V0T2YoUGF5bWVudFNoYXBlKSksXG5yZWNvdmVyQWxsOk0uY2FsbCgpLnJldHVybnMoYW1vdW50U2hhcGUpfSk7XG5cblxuY29uc3QgRGVwb3NpdEZhY2V0ST1NLmludGVyZmFjZSgnRGVwb3NpdEZhY2V0Jyx7XG5yZWNlaXZlOlB1cnNlSS5tZXRob2RHdWFyZHMuZGVwb3NpdH0pO1xuXG5cbmNvbnN0IFB1cnNlSUtpdD1oYXJkZW4oe1xucHVyc2U6UHVyc2VJLFxuZGVwb3NpdEZhY2V0OkRlcG9zaXRGYWNldEl9KTtcblxuXG5yZXR1cm4gaGFyZGVuKHtcbklzc3VlckksXG5NaW50SSxcblBheW1lbnRJLFxuUHVyc2VJS2l0fSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZUlzc3VlckludGVyZmFjZXMobWFrZUlzc3VlckludGVyZmFjZXMpO1xuaGFyZGVuKG1ha2VJc3N1ZXJJbnRlcmZhY2VzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJCcmFuZFNoYXBlIjpbIkJyYW5kU2hhcGUiXSwiSXNzdWVyU2hhcGUiOlsiSXNzdWVyU2hhcGUiXSwiUGF5bWVudFNoYXBlIjpbIlBheW1lbnRTaGFwZSJdLCJQdXJzZVNoYXBlIjpbIlB1cnNlU2hhcGUiXSwiRGVwb3NpdEZhY2V0U2hhcGUiOlsiRGVwb3NpdEZhY2V0U2hhcGUiXSwiTm90aWZpZXJTaGFwZSI6WyJOb3RpZmllclNoYXBlIl0sIk1pbnRTaGFwZSI6WyJNaW50U2hhcGUiXSwiQW1vdW50U2hhcGUiOlsiQW1vdW50U2hhcGUiXSwiUmF0aW9TaGFwZSI6WyJSYXRpb1NoYXBlIl0sImlzTmF0VmFsdWUiOlsiaXNOYXRWYWx1ZSJdLCJpc0NvcHlTZXRWYWx1ZSI6WyJpc0NvcHlTZXRWYWx1ZSJdLCJpc1NldFZhbHVlIjpbImlzU2V0VmFsdWUiXSwiaXNDb3B5QmFnVmFsdWUiOlsiaXNDb3B5QmFnVmFsdWUiXSwiTUFYX0FCU09MVVRFX0RFQ0lNQUxfUExBQ0VTIjpbIk1BWF9BQlNPTFVURV9ERUNJTUFMX1BMQUNFUyJdLCJBc3NldEtpbmRTaGFwZSI6WyJBc3NldEtpbmRTaGFwZSJdLCJEaXNwbGF5SW5mb1NoYXBlIjpbIkRpc3BsYXlJbmZvU2hhcGUiXSwiSXNzdWVyS2l0U2hhcGUiOlsiSXNzdWVyS2l0U2hhcGUiXSwiQnJhbmRJIjpbIkJyYW5kSSJdLCJtYWtlSXNzdWVySW50ZXJmYWNlcyI6WyJtYWtlSXNzdWVySW50ZXJmYWNlcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAsz6lRcD8AAHA/AAAvAAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL3R5cGVzLWFtYmllbnQuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAamVzc2llLWNoZWNrKi9cblxuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gW0s9QXNzZXRLaW5kXVxuICogQHR5cGVkZWYge29iamVjdH0gQW1vdW50XG4gKiBBbW91bnRzIGFyZSBkZXNjcmlwdGlvbnMgb2YgZGlnaXRhbCBhc3NldHMsIGFuc3dlcmluZyB0aGUgcXVlc3Rpb25zXG4gKiBcImhvdyBtdWNoXCIgYW5kIFwib2Ygd2hhdCBraW5kXCIuIEFtb3VudHMgYXJlIHZhbHVlcyBsYWJlbGVkIHdpdGggYSBicmFuZC5cbiAqIEFtb3VudE1hdGggZXhlY3V0ZXMgdGhlIGxvZ2ljIG9mIGhvdyBhbW91bnRzIGFyZSBjaGFuZ2VkIHdoZW4gZGlnaXRhbFxuICogYXNzZXRzIGFyZSBtZXJnZWQsIHNlcGFyYXRlZCwgb3Igb3RoZXJ3aXNlIG1hbmlwdWxhdGVkLiBGb3JcbiAqIGV4YW1wbGUsIGEgZGVwb3NpdCBvZiAyIGJ1Y2tzIGludG8gYSBwdXJzZSB0aGF0IGFscmVhZHkgaGFzIDMgYnVja3NcbiAqIGdpdmVzIGEgbmV3IHB1cnNlIGJhbGFuY2Ugb2YgNSBidWNrcy4gQW4gZW1wdHkgcHVyc2UgaGFzIDAgYnVja3MuIEFtb3VudE1hdGhcbiAqIHJlbGllcyBoZWF2aWx5IG9uIHBvbHltb3JwaGljIE1hdGhIZWxwZXJzLCB3aGljaCBtYW5pcHVsYXRlIHRoZSB1bmJyYW5kZWRcbiAqIHBvcnRpb24uXG4gKlxuICogQHByb3BlcnR5IHtCcmFuZDxLPn0gYnJhbmRcbiAqIEBwcm9wZXJ0eSB7QXNzZXRWYWx1ZUZvcktpbmQ8Sz59IHZhbHVlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7TmF0VmFsdWUgfCBTZXRWYWx1ZSB8IENvcHlTZXQgfCBDb3B5QmFnfSBBbW91bnRWYWx1ZVxuICogQW4gYEFtb3VudFZhbHVlYCBkZXNjcmliZXMgYSBzZXQgb3IgcXVhbnRpdHkgb2YgYXNzZXRzIHRoYXQgY2FuIGJlIG93bmVkIG9yXG4gKiBzaGFyZWQuXG4gKlxuICogQSBmdW5naWJsZSBgQW1vdW50VmFsdWVgIHVzZXMgYSBub24tbmVnYXRpdmUgYmlnaW50IHRvIHJlcHJlc2VudCBhIHF1YW50aXR5XG4gKiBvZiB0aGF0IG1hbnkgYXNzZXRzLlxuICpcbiAqIEEgbm9uLWZ1bmdpYmxlIGBBbW91bnRWYWx1ZWAgdXNlcyBhbiBhcnJheSBvciBDb3B5U2V0IG9mIGBLZXlgcyB0byByZXByZXNlbnRcbiAqIGEgc2V0IG9mIHdoYXRldmVyIGFzc2V0IGVhY2gga2V5IHJlcHJlc2VudHMuIEEgYEtleWAgaXMgYSBwYXNzYWJsZSB2YWx1ZVxuICogdGhhdCBjYW4gYmUgdXNlZCBhcyBhbiBlbGVtZW50IGluIGEgc2V0IChTZXRTdG9yZSBvciBDb3B5U2V0KSBvciBhcyB0aGVcbiAqIGtleSBpbiBhIG1hcCAoTWFwU3RvcmUgb3IgQ29weU1hcCkuXG4gKlxuICogYFNldFZhbHVlYCBpcyBmb3IgdGhlIGRlcHJlY2F0ZWQgc2V0IHJlcHJlc2VudGF0aW9uLCB1c2luZyBhbiBhcnJheSBkaXJlY3RseVxuICogdG8gcmVwcmVzZW50IHRoZSBhcnJheSBvZiBpdHMgZWxlbWVudHMuIGBDb3B5U2V0YCBpcyB0aGUgcHJvcGVyXG4gKiByZXByZXNlbnRhdGlvbiB1c2luZyBhIENvcHlTZXQuXG4gKlxuICogQSBzZW1pLWZ1bmdpYmxlIGBDb3B5QmFnYCBpcyByZXByZXNlbnRlZCBhcyBhXG4gKiBgQ29weUJhZ2Agb2YgYEtleWAgb2JqZWN0cy4gXCJCYWdcIiBpcyBzeW5vbnltb3VzIHdpdGggTXVsdGlTZXQsIHdoZXJlIGFuXG4gKiBlbGVtZW50IG9mIGEgYmFnIGNhbiBiZSBwcmVzZW50IG9uY2Ugb3IgbW9yZSB0aW1lcywgaS5lLiwgc29tZSBwb3NpdGl2ZVxuICogYmlnaW50IG51bWJlciBvZiB0aW1lcywgcmVwcmVzZW50aW5nIHRoYXQgcXVhbnRpdHkgb2YgdGhlIGFzc2V0IHJlcHJlc2VudGVkXG4gKiBieSB0aGF0IGtleS5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsnbmF0JyB8ICdzZXQnIHwgJ2NvcHlTZXQnIHwgJ2NvcHlCYWcnIH0gQXNzZXRLaW5kXG4gKlxuICogU2VlIGRvYy1jb21tZW50IGZvciBgQW1vdW50VmFsdWVgLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEB0eXBlZGVmIHtLIGV4dGVuZHMgJ25hdCcgPyBOYXRWYWx1ZSA6XG4gKiBLIGV4dGVuZHMgJ3NldCcgPyBTZXRWYWx1ZSA6XG4gKiBLIGV4dGVuZHMgJ2NvcHlTZXQnID8gQ29weVNldDpcbiAqIEsgZXh0ZW5kcyAnY29weUJhZycgPyBDb3B5QmFnIDpcbiAqIG5ldmVyXG4gKiB9IEFzc2V0VmFsdWVGb3JLaW5kXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Ftb3VudFZhbHVlfSBWXG4gKiBAdHlwZWRlZiB7ViBleHRlbmRzIE5hdFZhbHVlID8gJ25hdCcgOlxuICogIFYgZXh0ZW5kcyBTZXRWYWx1ZSA/ICdzZXQnIDpcbiAqICBWIGV4dGVuZHMgQ29weVNldCA/ICdjb3B5U2V0JyA6XG4gKiAgViBleHRlbmRzIENvcHlCYWcgPyAnY29weUJhZycgOlxuICogIG5ldmVyfSBBc3NldEtpbmRGb3JWYWx1ZVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IFtLPUFzc2V0S2luZF1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IERpc3BsYXlJbmZvXG4gKiBAcHJvcGVydHkge251bWJlcn0gW2RlY2ltYWxQbGFjZXNdIFRlbGxzIHRoZSBkaXNwbGF5IHNvZnR3YXJlIGhvd1xuICogICBtYW55IGRlY2ltYWwgcGxhY2VzIHRvIG1vdmUgdGhlIGRlY2ltYWwgb3ZlciB0byB0aGUgbGVmdCwgb3IgaW5cbiAqICAgb3RoZXIgd29yZHMsIHdoaWNoIHBvc2l0aW9uIGNvcnJlc3BvbmRzIHRvIHdob2xlIG51bWJlcnMuIFdlXG4gKiAgIHJlcXVpcmUgZnVuZ2libGUgZGlnaXRhbCBhc3NldHMgdG8gYmUgcmVwcmVzZW50ZWQgaW4gaW50ZWdlcnMsIGluXG4gKiAgIHRoZSBzbWFsbGVzdCB1bml0IChpLmUuIFVTRCBtaWdodCBiZSByZXByZXNlbnRlZCBpbiBtaWxsLCBhXG4gKiAgIHRob3VzYW5kdGggb2YgYSBkb2xsYXIuIEluIHRoYXQgY2FzZSwgYGRlY2ltYWxQbGFjZXNgIHdvdWxkIGJlXG4gKiAgIDMuKSBUaGlzIHByb3BlcnR5IGlzIG9wdGlvbmFsLCBhbmQgZm9yIG5vbi1mdW5naWJsZSBkaWdpdGFsXG4gKiAgIGFzc2V0cywgc2hvdWxkIG5vdCBiZSBzcGVjaWZpZWQuIFRoZSBkZWNpbWFsUGxhY2VzIHByb3BlcnR5XG4gKiAgIHNob3VsZCBiZSB1c2VkIGZvciAqZGlzcGxheSBwdXJwb3NlcyBvbmx5Ki4gQW55IG90aGVyIHVzZSBpcyBhblxuICogICBhbnRpLXBhdHRlcm4uXG4gKiBAcHJvcGVydHkge0t9IGFzc2V0S2luZCAtIHRoZSBraW5kIG9mIGFzc2V0LCBlaXRoZXJcbiAqICAgQXNzZXRLaW5kLk5BVCAoZnVuZ2libGUpIG9yXG4gKiAgIEFzc2V0S2luZC5TRVQgb3IgQXNzZXRLaW5kLkNPUFlfU0VUIChub24tZnVuZ2libGUpXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gW0s9QXNzZXRLaW5kXVxuICogQHR5cGVkZWYge29iamVjdH0gQnJhbmRcbiAqIFRoZSBicmFuZCBpZGVudGlmaWVzIHRoZSBraW5kIG9mIGlzc3VlciwgYW5kIGhhcyBhIGZ1bmN0aW9uIHRvIGdldCB0aGVcbiAqIGFsbGVnZWQgbmFtZSBmb3IgdGhlIGtpbmQgb2YgYXNzZXQgZGVzY3JpYmVkLiBUaGUgYWxsZWdlZCBuYW1lIChzdWNoXG4gKiBhcyAnQlRDJyBvciAnbW9vbGEnKSBpcyBwcm92aWRlZCBieSB0aGUgbWFrZXIgb2YgdGhlIGlzc3VlciBhbmQgc2hvdWxkXG4gKiBub3QgYmUgdHJ1c3RlZCBhcyBhY2N1cmF0ZS5cbiAqXG4gKiBFdmVyeSBhbW91bnQgY3JlYXRlZCBieSBhIHBhcnRpY3VsYXIgQW1vdW50TWF0aCB3aWxsIHNoYXJlIHRoZSBzYW1lIGJyYW5kLFxuICogYnV0IHJlY2lwaWVudHMgY2Fubm90IHJlbHkgb24gdGhlIGJyYW5kIHRvIHZlcmlmeSB0aGF0IGEgcHVycG9ydGVkIGFtb3VudFxuICogcmVwcmVzZW50cyB0aGUgaXNzdWVyIHRoZXkgaW50ZW5kZWQsIHNpbmNlIHRoZSBzYW1lIGJyYW5kIGNhbiBiZSByZXVzZWQgYnlcbiAqIGEgbWlzYmVoYXZpbmcgaXNzdWVyLlxuICpcbiAqIEBwcm9wZXJ0eSB7KGFsbGVnZWRJc3N1ZXI6IEVSZWY8SXNzdWVyPikgPT4gUHJvbWlzZTxib29sZWFuPn0gaXNNeUlzc3VlclxuICogU2hvdWxkIGJlIHVzZWQgd2l0aCBgaXNzdWVyLmdldEJyYW5kYCB0byBlbnN1cmUgYW4gaXNzdWVyIGFuZCBicmFuZCBtYXRjaC5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gc3RyaW5nfSBnZXRBbGxlZ2VkTmFtZVxuICogQHByb3BlcnR5IHsoKSA9PiBEaXNwbGF5SW5mbzxLPn0gZ2V0RGlzcGxheUluZm9cbiAqIEdpdmUgaW5mb3JtYXRpb24gdG8gVUkgb24gaG93IHRvIGRpc3BsYXkgdGhlIGFtb3VudC5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUGF0dGVybn0gZ2V0QW1vdW50U2hhcGVcbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gSXNzdWVyIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQGNhbGxiYWNrIElzc3VlcklzTGl2ZVxuICpcbiAqIFJldHVybiB0cnVlIGlmIHRoZSBwYXltZW50IGNvbnRpbnVlcyB0byBleGlzdC5cbiAqXG4gKiBJZiB0aGUgcGF5bWVudCBpcyBhIHByb21pc2UsIHRoZSBvcGVyYXRpb24gd2lsbCBwcm9jZWVkIHVwb25cbiAqIHJlc29sdXRpb24uXG4gKlxuICogQHBhcmFtIHtFUmVmPFBheW1lbnQ+fSBwYXltZW50XG4gKiBAcmV0dXJucyB7UHJvbWlzZTxib29sZWFuPn1cbiAqL1xuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gS1xuICogQGNhbGxiYWNrIElzc3VlckdldEFtb3VudE9mXG4gKlxuICogR2V0IHRoZSBhbW91bnQgb2YgZGlnaXRhbCBhc3NldHMgaW4gdGhlIHBheW1lbnQuIEJlY2F1c2UgdGhlXG4gKiBwYXltZW50IGlzIG5vdCB0cnVzdGVkLCB3ZSBjYW5ub3QgY2FsbCBhIG1ldGhvZCBvbiBpdCBkaXJlY3RseSwgYW5kXG4gKiBtdXN0IHVzZSB0aGUgaXNzdWVyIGluc3RlYWQuXG4gKlxuICogSWYgdGhlIHBheW1lbnQgaXMgYSBwcm9taXNlLCB0aGUgb3BlcmF0aW9uIHdpbGwgcHJvY2VlZCB1cG9uXG4gKiByZXNvbHV0aW9uLlxuICpcbiAqIEBwYXJhbSB7RVJlZjxQYXltZW50Pn0gcGF5bWVudFxuICogQHJldHVybnMge1Byb21pc2U8QW1vdW50PEs+Pn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBJc3N1ZXJCdXJuXG4gKlxuICogQnVybiBhbGwgb2YgdGhlIGRpZ2l0YWwgYXNzZXRzIGluIHRoZVxuICogcGF5bWVudC4gYG9wdEFtb3VudGAgaXMgb3B0aW9uYWwuIElmIGBvcHRBbW91bnRgIGlzIHByZXNlbnQsIHRoZVxuICogY29kZSB3aWxsIGluc2lzdCB0aGF0IHRoZSBhbW91bnQgb2YgdGhlIGRpZ2l0YWwgYXNzZXRzIGluIHRoZVxuICogcGF5bWVudCBpcyBlcXVhbCB0byBgb3B0QW1vdW50YCwgdG8gcHJldmVudCBzZW5kaW5nIHRoZSB3cm9uZ1xuICogcGF5bWVudCBhbmQgb3RoZXIgY29uZnVzaW9uLlxuICpcbiAqIElmIHRoZSBwYXltZW50IGlzIGEgcHJvbWlzZSwgdGhlIG9wZXJhdGlvbiB3aWxsIHByb2NlZWQgdXBvblxuICogcmVzb2x1dGlvbi5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8UGF5bWVudD59IHBheW1lbnRcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge1Byb21pc2U8QW1vdW50Pn1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAY2FsbGJhY2sgSXNzdWVyQ2xhaW1cbiAqXG4gKiBUcmFuc2ZlciBhbGwgZGlnaXRhbCBhc3NldHMgZnJvbSB0aGUgcGF5bWVudCB0byBhIG5ldyBwYXltZW50IGFuZFxuICogZGVsZXRlIHRoZSBvcmlnaW5hbC4gYG9wdEFtb3VudGAgaXMgb3B0aW9uYWwuIElmIGBvcHRBbW91bnRgIGlzXG4gKiBwcmVzZW50LCB0aGUgY29kZSB3aWxsIGluc2lzdCB0aGF0IHRoZSBhbW91bnQgb2YgZGlnaXRhbCBhc3NldHMgaW5cbiAqIHRoZSBwYXltZW50IGlzIGVxdWFsIHRvIGBvcHRBbW91bnRgLCB0byBwcmV2ZW50IHNlbmRpbmcgdGhlIHdyb25nXG4gKiBwYXltZW50IGFuZCBvdGhlciBjb25mdXNpb24uXG4gKlxuICogSWYgdGhlIHBheW1lbnQgaXMgYSBwcm9taXNlLCB0aGUgb3BlcmF0aW9uIHdpbGwgcHJvY2VlZCB1cG9uXG4gKiByZXNvbHV0aW9uLlxuICpcbiAqIEBwYXJhbSB7RVJlZjxQYXltZW50PEs+Pn0gcGF5bWVudFxuICogQHBhcmFtIHtQYXR0ZXJufSBbb3B0QW1vdW50U2hhcGVdXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxQYXltZW50PEs+Pn1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAY2FsbGJhY2sgSXNzdWVyQ29tYmluZVxuICpcbiAqIENvbWJpbmUgbXVsdGlwbGUgcGF5bWVudHMgaW50byBvbmUgcGF5bWVudC5cbiAqXG4gKiBJZiBhbnkgb2YgdGhlIHBheW1lbnRzIGlzIGEgcHJvbWlzZSwgdGhlIG9wZXJhdGlvbiB3aWxsIHByb2NlZWRcbiAqIHVwb24gcmVzb2x1dGlvbi5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8UGF5bWVudDxLPj5bXX0gcGF5bWVudHNBcnJheVxuICogQHBhcmFtIHtBbW91bnQ8Sz59IFtvcHRUb3RhbEFtb3VudF1cbiAqIEByZXR1cm5zIHtQcm9taXNlPFBheW1lbnQ8Sz4+fVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBjYWxsYmFjayBJc3N1ZXJTcGxpdFxuICpcbiAqIFNwbGl0IGEgc2luZ2xlIHBheW1lbnQgaW50byB0d28gcGF5bWVudHMsXG4gKiBBIGFuZCBCLCBhY2NvcmRpbmcgdG8gdGhlIHBheW1lbnRBbW91bnRBIHBhc3NlZCBpbi5cbiAqXG4gKiBJZiB0aGUgcGF5bWVudCBpcyBhIHByb21pc2UsIHRoZSBvcGVyYXRpb24gd2lsbCBwcm9jZWVkIHVwb25cbiAqIHJlc29sdXRpb24uXG4gKlxuICogQHBhcmFtIHtFUmVmPFBheW1lbnQ8Sz4+fSBwYXltZW50XG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gcGF5bWVudEFtb3VudEFcbiAqIEByZXR1cm5zIHtQcm9taXNlPFBheW1lbnQ8Sz5bXT59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgSXNzdWVyU3BsaXRNYW55XG4gKlxuICogU3BsaXQgYSBzaW5nbGUgcGF5bWVudCBpbnRvIG1hbnkgcGF5bWVudHMsIGFjY29yZGluZyB0byB0aGUgYW1vdW50c1xuICogcGFzc2VkIGluLlxuICpcbiAqIElmIHRoZSBwYXltZW50IGlzIGEgcHJvbWlzZSwgdGhlIG9wZXJhdGlvbiB3aWxsIHByb2NlZWQgdXBvblxuICogcmVzb2x1dGlvbi5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8UGF5bWVudD59IHBheW1lbnRcbiAqIEBwYXJhbSB7QW1vdW50W119IGFtb3VudHNcbiAqIEByZXR1cm5zIHtQcm9taXNlPFBheW1lbnRbXT59XG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gW0s9QXNzZXRLaW5kXVxuICogQHR5cGVkZWYge29iamVjdH0gSXNzdWVyXG4gKlxuICogVGhlIGlzc3VlciBjYW5ub3QgbWludCBhIG5ldyBhbW91bnQsIGJ1dCBpdCBjYW4gY3JlYXRlIGVtcHR5IHB1cnNlc1xuICogYW5kIHBheW1lbnRzLiBUaGUgaXNzdWVyIGNhbiBhbHNvIHRyYW5zZm9ybSBwYXltZW50cyAoc3BsaXR0aW5nXG4gKiBwYXltZW50cywgY29tYmluaW5nIHBheW1lbnRzLCBidXJuaW5nIHBheW1lbnRzLCBhbmQgY2xhaW1pbmdcbiAqIHBheW1lbnRzIGV4Y2x1c2l2ZWx5KS4gVGhlIGlzc3VlciBzaG91bGQgYmUgZ290dGVuIGZyb20gYSB0cnVzdGVkXG4gKiBzb3VyY2UgYW5kIHRoZW4gcmVsaWVkIHVwb24gYXMgdGhlIGRlY2lkZXIgb2Ygd2hldGhlciBhbiB1bnRydXN0ZWRcbiAqIHBheW1lbnQgaXMgdmFsaWQuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBCcmFuZDxLPn0gZ2V0QnJhbmQgR2V0IHRoZSBCcmFuZCBmb3IgdGhpcyBJc3N1ZXIuIFRoZVxuICogQnJhbmQgaW5kaWNhdGVzIHRoZSB0eXBlIG9mIGRpZ2l0YWwgYXNzZXQgYW5kIGlzIHNoYXJlZCBieSB0aGVcbiAqIG1pbnQsIHRoZSBpc3N1ZXIsIGFuZCBhbnkgcHVyc2VzIGFuZCBwYXltZW50cyBvZiB0aGlzIHBhcnRpY3VsYXJcbiAqIGtpbmQuIFRoZSBicmFuZCBpcyBub3QgY2xvc2VseSBoZWxkLCBzbyB0aGlzIGZ1bmN0aW9uIHNob3VsZCBub3QgYmVcbiAqIHRydXN0ZWQgdG8gaWRlbnRpZnkgYW4gaXNzdWVyIGFsb25lLiBGYWtlIGRpZ2l0YWwgYXNzZXRzIGFuZCBhbW91bnRcbiAqIGNhbiB1c2UgYW5vdGhlciBpc3N1ZXIncyBicmFuZC5cbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IHN0cmluZ30gZ2V0QWxsZWdlZE5hbWUgR2V0IHRoZSBhbGxlZ2VkTmFtZSBmb3JcbiAqIHRoaXMgbWludC9pc3N1ZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gQXNzZXRLaW5kfSBnZXRBc3NldEtpbmQgR2V0IHRoZSBraW5kIG9mXG4gKiBNYXRoSGVscGVycyB1c2VkIGJ5IHRoaXMgSXNzdWVyLlxuICogQHByb3BlcnR5IHsoKSA9PiBEaXNwbGF5SW5mbzxLPn0gZ2V0RGlzcGxheUluZm8gR2l2ZSBpbmZvcm1hdGlvbiB0byBVSVxuICogIG9uIGhvdyB0byBkaXNwbGF5IGFtb3VudHMgZm9yIHRoaXMgaXNzdWVyLlxuICogQHByb3BlcnR5IHsoKSA9PiBQdXJzZTxLPn0gbWFrZUVtcHR5UHVyc2UgTWFrZSBhbiBlbXB0eSBwdXJzZSBvZiB0aGlzXG4gKiBicmFuZC5cbiAqIEBwcm9wZXJ0eSB7SXNzdWVySXNMaXZlfSBpc0xpdmVcbiAqIEBwcm9wZXJ0eSB7SXNzdWVyR2V0QW1vdW50T2Y8Sz59IGdldEFtb3VudE9mXG4gKiBAcHJvcGVydHkge0lzc3VlckJ1cm59IGJ1cm5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXltZW50TGVkZ2VyXG4gKiBAcHJvcGVydHkge01pbnQ8Sz59IG1pbnRcbiAqIEBwcm9wZXJ0eSB7UHVyc2U8Sz59IG1pbnRSZWNvdmVyeVB1cnNlXG4gKiBAcHJvcGVydHkge0lzc3VlcjxLPn0gaXNzdWVyXG4gKiBAcHJvcGVydHkge0JyYW5kPEs+fSBicmFuZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IFtLPUFzc2V0S2luZF1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IElzc3VlcktpdFxuICogQHByb3BlcnR5IHtNaW50PEs+fSBtaW50XG4gKiBAcHJvcGVydHkge1B1cnNlPEs+fSBtaW50UmVjb3ZlcnlQdXJzZVxuICogQHByb3BlcnR5IHtJc3N1ZXI8Sz59IGlzc3VlclxuICogQHByb3BlcnR5IHtCcmFuZDxLPn0gYnJhbmRcbiAqIEBwcm9wZXJ0eSB7RGlzcGxheUluZm99IGRpc3BsYXlJbmZvXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBBZGRpdGlvbmFsRGlzcGxheUluZm9cbiAqXG4gKiBAcHJvcGVydHkge251bWJlcn0gW2RlY2ltYWxQbGFjZXNdIFRlbGxzIHRoZSBkaXNwbGF5IHNvZnR3YXJlIGhvd1xuICogICBtYW55IGRlY2ltYWwgcGxhY2VzIHRvIG1vdmUgdGhlIGRlY2ltYWwgb3ZlciB0byB0aGUgbGVmdCwgb3IgaW5cbiAqICAgb3RoZXIgd29yZHMsIHdoaWNoIHBvc2l0aW9uIGNvcnJlc3BvbmRzIHRvIHdob2xlIG51bWJlcnMuIFdlXG4gKiAgIHJlcXVpcmUgZnVuZ2libGUgZGlnaXRhbCBhc3NldHMgdG8gYmUgcmVwcmVzZW50ZWQgaW4gaW50ZWdlcnMsIGluXG4gKiAgIHRoZSBzbWFsbGVzdCB1bml0IChpLmUuIFVTRCBtaWdodCBiZSByZXByZXNlbnRlZCBpbiBtaWxsLCBhXG4gKiAgIHRob3VzYW5kdGggb2YgYSBkb2xsYXIuIEluIHRoYXQgY2FzZSwgYGRlY2ltYWxQbGFjZXNgIHdvdWxkIGJlXG4gKiAgIDMuKSBUaGlzIHByb3BlcnR5IGlzIG9wdGlvbmFsLCBhbmQgZm9yIG5vbi1mdW5naWJsZSBkaWdpdGFsXG4gKiAgIGFzc2V0cywgc2hvdWxkIG5vdCBiZSBzcGVjaWZpZWQuIFRoZSBkZWNpbWFsUGxhY2VzIHByb3BlcnR5XG4gKiAgIHNob3VsZCBiZSB1c2VkIGZvciAqZGlzcGxheSBwdXJwb3NlcyBvbmx5Ki4gQW55IG90aGVyIHVzZSBpcyBhblxuICogICBhbnRpLXBhdHRlcm4uXG4gKiBAcHJvcGVydHkge0Fzc2V0S2luZH0gW2Fzc2V0S2luZF1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3N3aW5nc2V0LXZhdCcpLlNodXRkb3duV2l0aEZhaWx1cmV9IFNodXRkb3duV2l0aEZhaWx1cmVcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBNaW50XG4gKiBIb2xkaW5nIGEgTWludCBjYXJyaWVzIHRoZSByaWdodCB0byBpc3N1ZSBuZXcgZGlnaXRhbCBhc3NldHMuIFRoZXNlXG4gKiBhc3NldHMgYWxsIGhhdmUgdGhlIHNhbWUga2luZCwgd2hpY2ggaXMgY2FsbGVkIGEgQnJhbmQuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBJc3N1ZXI8Sz59IGdldElzc3VlciBHZXRzIHRoZSBJc3N1ZXIgZm9yIHRoaXMgbWludC5cbiAqIEBwcm9wZXJ0eSB7KG5ld0Ftb3VudDogQW1vdW50PEs+KSA9PiBQYXltZW50PEs+fSBtaW50UGF5bWVudFxuICogQ3JlYXRlcyBhIG5ldyBQYXltZW50IGNvbnRhaW5pbmcgbmV3bHkgbWludGVkIGFtb3VudC5cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBEZXBvc2l0RmFjZXRSZWNlaXZlXG4gKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnRcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge0Ftb3VudH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IERlcG9zaXRGYWNldFxuICogQHByb3BlcnR5IHtEZXBvc2l0RmFjZXRSZWNlaXZlfSByZWNlaXZlXG4gKiBEZXBvc2l0IGFsbCB0aGUgY29udGVudHMgb2YgcGF5bWVudCBpbnRvIHRoZSBwdXJzZSB0aGF0IG1hZGUgdGhpcyBmYWNldCxcbiAqIHJldHVybmluZyB0aGUgYW1vdW50LiBJZiB0aGUgb3B0aW9uYWwgYXJndW1lbnQgYG9wdEFtb3VudGAgZG9lcyBub3QgZXF1YWwgdGhlXG4gKiBhbW91bnQgb2YgZGlnaXRhbCBhc3NldHMgaW4gdGhlIHBheW1lbnQsIHRocm93IGFuIGVycm9yLlxuICpcbiAqIElmIHBheW1lbnQgaXMgYSBwcm9taXNlLCB0aHJvdyBhbiBlcnJvci5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAY2FsbGJhY2sgUHVyc2VEZXBvc2l0XG4gKiBAcGFyYW0ge1BheW1lbnQ8Sz59IHBheW1lbnRcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge0Ftb3VudDxLPn1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQdXJzZVxuICogUHVyc2VzIGhvbGQgYW1vdW50IG9mIGRpZ2l0YWwgYXNzZXRzIG9mIHRoZSBzYW1lIGJyYW5kLCBidXQgdW5saWtlIFBheW1lbnRzLFxuICogdGhleSBhcmUgbm90IG1lYW50IHRvIGJlIHNlbnQgdG8gb3RoZXJzLiBUbyB0cmFuc2ZlciBkaWdpdGFsIGFzc2V0cywgYVxuICogUGF5bWVudCBzaG91bGQgYmUgd2l0aGRyYXduIGZyb20gYSBQdXJzZS4gVGhlIGFtb3VudCBvZiBkaWdpdGFsXG4gKiBhc3NldHMgaW4gYSBwdXJzZSBjYW4gY2hhbmdlIHRocm91Z2ggdGhlIGFjdGlvbiBvZiBkZXBvc2l0KCkgYW5kIHdpdGhkcmF3KCkuXG4gKlxuICogVGhlIHByaW1hcnkgdXNlIGZvciBQdXJzZXMgYW5kIFBheW1lbnRzIGlzIGZvciBjdXJyZW5jeS1saWtlIGFuZCBnb29kcy1saWtlXG4gKiBkaWdpdGFsIGFzc2V0cywgYnV0IHRoZXkgY2FuIGFsc28gYmUgdXNlZCB0byByZXByZXNlbnQgb3RoZXIga2luZHMgb2YgcmlnaHRzLFxuICogc3VjaCBhcyB0aGUgcmlnaHQgdG8gcGFydGljaXBhdGUgaW4gYSBwYXJ0aWN1bGFyIGNvbnRyYWN0LlxuICpcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gQnJhbmQ8Sz59IGdldEFsbGVnZWRCcmFuZCBHZXQgdGhlIGFsbGVnZWQgQnJhbmQgZm9yIHRoaXMgUHVyc2VcbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IEFtb3VudDxLPn0gZ2V0Q3VycmVudEFtb3VudFxuICogR2V0IHRoZSBhbW91bnQgY29udGFpbmVkIGluIHRoaXMgcHVyc2UuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBMYXRlc3RUb3BpYzxBbW91bnQ8Sz4+fSBnZXRDdXJyZW50QW1vdW50Tm90aWZpZXJcbiAqIEdldCBhIGxvc3N5IG5vdGlmaWVyIGZvciBjaGFuZ2VzIHRvIHRoaXMgcHVyc2UncyBiYWxhbmNlLlxuICpcbiAqIEBwcm9wZXJ0eSB7UHVyc2VEZXBvc2l0PEs+fSBkZXBvc2l0XG4gKiBEZXBvc2l0IGFsbCB0aGUgY29udGVudHMgb2YgcGF5bWVudCBpbnRvIHRoaXMgcHVyc2UsIHJldHVybmluZyB0aGVcbiAqIGFtb3VudC4gSWYgdGhlIG9wdGlvbmFsIGFyZ3VtZW50IGBvcHRBbW91bnRgIGRvZXMgbm90IGVxdWFsIHRoZVxuICogYW1vdW50IG9mIGRpZ2l0YWwgYXNzZXRzIGluIHRoZSBwYXltZW50LCB0aHJvdyBhbiBlcnJvci5cbiAqXG4gKiBJZiBwYXltZW50IGlzIGEgcHJvbWlzZSwgdGhyb3cgYW4gZXJyb3IuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBEZXBvc2l0RmFjZXR9IGdldERlcG9zaXRGYWNldFxuICogUmV0dXJuIGFuIG9iamVjdCB3aG9zZSBgcmVjZWl2ZWAgbWV0aG9kIGRlcG9zaXRzIHRvIHRoZSBjdXJyZW50IFB1cnNlLlxuICpcbiAqIEBwcm9wZXJ0eSB7KGFtb3VudDogQW1vdW50PEs+KSA9PiBQYXltZW50PEs+fSB3aXRoZHJhd1xuICogV2l0aGRyYXcgYW1vdW50IGZyb20gdGhpcyBwdXJzZSBpbnRvIGEgbmV3IFBheW1lbnQuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBDb3B5U2V0PFBheW1lbnQ8Sz4+fSBnZXRSZWNvdmVyeVNldFxuICogVGhlIHNldCBvZiBwYXltZW50cyB3aXRoZHJhd24gZnJvbSB0aGlzIHB1cnNlIHRoYXQgYXJlIHN0aWxsIGxpdmUuIFRoZXNlXG4gKiBhcmUgdGhlIHBheW1lbnRzIHRoYXQgY2FuIHN0aWxsIGJlIHJlY292ZXJlZCBpbiBlbWVyZ2VuY2llcyBieSwgZm9yIGV4YW1wbGUsXG4gKiBkZXBvc2l0aW5nIGludG8gdGhpcyBwdXJzZS4gU3VjaCBhIGRlcG9zaXQgYWN0aW9uIGlzIGxpa2UgY2FuY2VsaW5nIGFuXG4gKiBvdXRzdGFuZGluZyBjaGVjayBiZWNhdXNlIHlvdSdyZSB0aXJlZCBvZiB3YWl0aW5nIGZvciBpdC4gT25jZSB5b3VyXG4gKiBjYW5jZWxsYXRpb24gaXMgYWNrbm93bGVkZ2VkLCB5b3UgY2FuIHNwZW5kIHRoZSBhc3NldHMgYXQgc3Rha2Ugb24gb3RoZXJcbiAqIHRoaW5ncy4gQWZ0ZXJ3YXJkcywgaWYgdGhlIHJlY2lwaWVudCBvZiB0aGUgb3JpZ2luYWwgY2hlY2sgZmluYWxseSBnZXRzXG4gKiBhcm91bmQgdG8gZGVwb3NpdGluZyBpdCwgdGhlaXIgZGVwb3NpdCBmYWlscy5cbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IEFtb3VudDxLPn0gcmVjb3ZlckFsbFxuICogRm9yIHVzZSBpbiBlbWVyZ2VuY2llcywgc3VjaCBhcyBjb21pbmcgYmFjayBmcm9tIGEgdHJhdW1hdGljIGNyYXNoIGFuZFxuICogdXBncmFkZS4gVGhpcyBkZXBvc2l0cyBhbGwgdGhlIHBheW1lbnRzIGluIHRoaXMgcHVyc2UncyByZWNvdmVyeSBzZXRcbiAqIGludG8gdGhlIHB1cnNlIGl0c2VsZiwgcmV0dXJuaW5nIHRoZSB0b3RhbCBhbW91bnQgb2YgYXNzZXRzIHJlY292ZXJlZC5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXltZW50XG4gKiBQYXltZW50cyBob2xkIGFtb3VudCBvZiBkaWdpdGFsIGFzc2V0cyBvZiB0aGUgc2FtZSBicmFuZCBpbiB0cmFuc2l0LiBQYXltZW50c1xuICogY2FuIGJlIGRlcG9zaXRlZCBpbiBwdXJzZXMsIHNwbGl0IGludG8gbXVsdGlwbGUgcGF5bWVudHMsIGNvbWJpbmVkLCBhbmRcbiAqIGNsYWltZWQgKGdldHRpbmcgYW4gZXhjbHVzaXZlIHBheW1lbnQpLiBQYXltZW50cyBhcmUgbGluZWFyLCBtZWFuaW5nXG4gKiB0aGF0IGVpdGhlciBhIHBheW1lbnQgaGFzIHRoZSBzYW1lIGFtb3VudCBvZiBkaWdpdGFsIGFzc2V0cyBpdFxuICogc3RhcnRlZCB3aXRoLCBvciBpdCBpcyB1c2VkIHVwIGVudGlyZWx5LiBJdCBpcyBpbXBvc3NpYmxlIHRvIHBhcnRpYWxseSB1c2UgYVxuICogcGF5bWVudC5cbiAqXG4gKiBQYXltZW50cyBhcmUgb2Z0ZW4gcmVjZWl2ZWQgZnJvbSBvdGhlciBhY3RvcnMgYW5kIHRoZXJlZm9yZSBzaG91bGRcbiAqIG5vdCBiZSB0cnVzdGVkIHRoZW1zZWx2ZXMuIFRvIGdldCB0aGUgYW1vdW50IG9mIGRpZ2l0YWwgYXNzZXRzIGluIGEgcGF5bWVudCxcbiAqIHVzZSB0aGUgdHJ1c3RlZCBpc3N1ZXI6IGlzc3Vlci5nZXRBbW91bnRPZihwYXltZW50KSxcbiAqXG4gKiBQYXltZW50cyBjYW4gYmUgY29udmVydGVkIHRvIFB1cnNlcyBieSBnZXR0aW5nIGEgdHJ1c3RlZCBpc3N1ZXIgYW5kXG4gKiBjYWxsaW5nIGBpc3N1ZXIubWFrZUVtcHR5UHVyc2UoKWAgdG8gY3JlYXRlIGEgcHVyc2UsIHRoZW5cbiAqIGBwdXJzZS5kZXBvc2l0KHBheW1lbnQpYC5cbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IEJyYW5kPEs+fSBnZXRBbGxlZ2VkQnJhbmRcbiAqIEdldCB0aGUgYWxsZWdlZEJyYW5kLCBpbmRpY2F0aW5nIHRoZSB0eXBlIG9mIGRpZ2l0YWwgYXNzZXQgdGhpc1xuICogcGF5bWVudCBwdXJwb3J0cyB0byBiZSwgYW5kIHdoaWNoIGlzc3VlciB0byB1c2UuIEJlY2F1c2UgcGF5bWVudHNcbiAqIGFyZSBub3QgdHJ1c3RlZCwgYW55IG1ldGhvZCBjYWxscyBvbiBwYXltZW50cyBzaG91bGQgYmUgdHJlYXRlZFxuICogd2l0aCBzdXNwaWNpb24gYW5kIHZlcmlmaWVkIGVsc2V3aGVyZS5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QW1vdW50VmFsdWV9IFZcbiAqIEB0eXBlZGVmIHtvYmplY3R9IE1hdGhIZWxwZXJzXG4gKiBBbGwgb2YgdGhlIGRpZmZlcmVuY2UgaW4gaG93IGRpZ2l0YWwgYXNzZXQgYW1vdW50IGFyZSBtYW5pcHVsYXRlZCBjYW4gYmVcbiAqIHJlZHVjZWQgdG8gdGhlIGJlaGF2aW9yIG9mIHRoZSBtYXRoIG9uIHZhbHVlcy4gV2UgZXh0cmFjdCB0aGlzXG4gKiBjdXN0b20gbG9naWMgaW50byBtYXRoSGVscGVycy4gTWF0aEhlbHBlcnMgYXJlIGFib3V0IHZhbHVlXG4gKiBhcml0aG1ldGljLCB3aGVyZWFzIEFtb3VudE1hdGggaXMgYWJvdXQgYW1vdW50cywgd2hpY2ggYXJlIHRoZVxuICogdmFsdWVzIGxhYmVsZWQgd2l0aCBhIGJyYW5kLiBBbW91bnRNYXRoIHVzZSBtYXRoSGVscGVycyB0byBkbyB0aGVpciB2YWx1ZVxuICogYXJpdGhtZXRpYywgYW5kIHRoZW4gYnJhbmQgdGhlIHJlc3VsdHMsIG1ha2luZyBhIG5ldyBhbW91bnQuXG4gKlxuICogVGhlIE1hdGhIZWxwZXJzIGFyZSBkZXNpZ25lZCB0byBiZSBjYWxsZWQgb25seSBmcm9tIEFtb3VudE1hdGgsIGFuZCBzb1xuICogYWxsIG1ldGhvZHMgYnV0IGNvZXJjZSBjYW4gYXNzdW1lIHRoZWlyIGlucHV0cyBhcmUgdmFsaWQuIFRoZXkgb25seVxuICogbmVlZCB0byBkbyBvdXRwdXQgdmFsaWRhdGlvbiwgYW5kIG9ubHkgd2hlbiB0aGVyZSBpcyBhIHBvc3NpYmlsaXR5IG9mXG4gKiBpbnZhbGlkIG91dHB1dC5cbiAqXG4gKiBAcHJvcGVydHkgeyhhbGxlZ2VkVmFsdWU6IFYpID0+IFZ9IGRvQ29lcmNlXG4gKiBDaGVjayB0aGUga2luZCBvZiB0aGlzIHZhbHVlIGFuZCB0aHJvdyBpZiBpdCBpcyBub3QgdGhlXG4gKiBleHBlY3RlZCBraW5kLlxuICpcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gVn0gZG9NYWtlRW1wdHlcbiAqIEdldCB0aGUgcmVwcmVzZW50YXRpb24gZm9yIHRoZSBpZGVudGl0eSBlbGVtZW50IChvZnRlbiAwIG9yIGFuXG4gKiBlbXB0eSBhcnJheSlcbiAqXG4gKiBAcHJvcGVydHkgeyh2YWx1ZTogVikgPT4gYm9vbGVhbn0gZG9Jc0VtcHR5XG4gKiBJcyB0aGUgdmFsdWUgdGhlIGlkZW50aXR5IGVsZW1lbnQ/XG4gKlxuICogQHByb3BlcnR5IHsobGVmdDogViwgcmlnaHQ6IFYpID0+IGJvb2xlYW59IGRvSXNHVEVcbiAqIElzIHRoZSBsZWZ0IGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byB0aGUgcmlnaHQ/XG4gKlxuICogQHByb3BlcnR5IHsobGVmdDogViwgcmlnaHQ6IFYpID0+IGJvb2xlYW59IGRvSXNFcXVhbFxuICogRG9lcyBsZWZ0IGVxdWFsIHJpZ2h0P1xuICpcbiAqIEBwcm9wZXJ0eSB7KGxlZnQ6IFYsIHJpZ2h0OiBWKSA9PiBWfSBkb0FkZFxuICogUmV0dXJuIHRoZSBsZWZ0IGNvbWJpbmVkIHdpdGggdGhlIHJpZ2h0LlxuICpcbiAqIEBwcm9wZXJ0eSB7KGxlZnQ6IFYsIHJpZ2h0OiBWKSA9PiBWfSBkb1N1YnRyYWN0XG4gKiBSZXR1cm4gd2hhdCByZW1haW5zIGFmdGVyIHJlbW92aW5nIHRoZSByaWdodCBmcm9tIHRoZSBsZWZ0LiBJZlxuICogc29tZXRoaW5nIGluIHRoZSByaWdodCB3YXMgbm90IGluIHRoZSBsZWZ0LCB3ZSB0aHJvdyBhbiBlcnJvci5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtiaWdpbnR9IE5hdFZhbHVlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7QXJyYXk8S2V5Pn0gU2V0VmFsdWVcbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACiI0DydREAAHURAABEAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5BcGkuanN7ImltcG9ydHMiOlsiLi4vcXVlc3Rpb24uanMiLCJAYWdvcmljL3N0b3JlIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJtYWtlQXBpSW52b2NhdGlvblBvc2l0aW9ucyIsInNldHVwQXBpR292ZXJuYW5jZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixrZXlFUSxDaG9pY2VNZXRob2QsUXVvcnVtUnVsZSxFbGVjdGlvblR5cGUsY29lcmNlUXVlc3Rpb25TcGVjOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wia2V5RVFcIiwgWyRo4oCNX2EgPT4gKGtleUVRID0gJGjigI1fYSldXV1dLFtcIi4uL3F1ZXN0aW9uLmpzXCIsIFtbXCJDaG9pY2VNZXRob2RcIiwgWyRo4oCNX2EgPT4gKENob2ljZU1ldGhvZCA9ICRo4oCNX2EpXV0sW1wiUXVvcnVtUnVsZVwiLCBbJGjigI1fYSA9PiAoUXVvcnVtUnVsZSA9ICRo4oCNX2EpXV0sW1wiRWxlY3Rpb25UeXBlXCIsIFskaOKAjV9hID0+IChFbGVjdGlvblR5cGUgPSAkaOKAjV9hKV1dLFtcImNvZXJjZVF1ZXN0aW9uU3BlY1wiLCBbJGjigI1fYSA9PiAoY29lcmNlUXVlc3Rpb25TcGVjID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e0ZhaWwscXVvdGU6cX09YXNzZXJ0O1xuXG4vKipcbiAqIE1ha2UgYSBwYWlyIG9mIHBvc2l0aW9ucyBmb3IgYSBxdWVzdGlvbiBhYm91dCB3aGV0aGVyIHRvIGludm9rZSBhbiBBUEkuIElmXG4gKiB0aGUgdm90ZSBwYXNzZXMsIHRoZSBtZXRob2Qgd2lsbCBiZSBjYWxsZWQgb24gdGhlIGdvdmVybmVkQXBpcyBmYWNldCB3aXRoIHRoZVxuICogYXJndW1lbnRzIHRoYXQgd2VyZSBwcm92aWRlZC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gYXBpTWV0aG9kTmFtZVxuICogQHBhcmFtIHt1bmtub3duW119IG1ldGhvZEFyZ3NcbiAqL1xuY29uc3QgbWFrZUFwaUludm9jYXRpb25Qb3NpdGlvbnM9KGFwaU1ldGhvZE5hbWUsbWV0aG9kQXJncyk9PntcbmNvbnN0IHBvc2l0aXZlPWhhcmRlbih7YXBpTWV0aG9kTmFtZSxtZXRob2RBcmdzfSk7XG5jb25zdCBuZWdhdGl2ZT1oYXJkZW4oe2RvbnRJbnZva2U6YXBpTWV0aG9kTmFtZX0pO1xucmV0dXJuIGhhcmRlbih7cG9zaXRpdmUsbmVnYXRpdmV9KTtcbiB9O1xuXG4vKipcbiAqIG1hbmFnZSBjb250cmFjdHMgdGhhdCBhbGxvdyBnb3Zlcm5hbmNlIHRvIGludm9rZSBmdW5jdGlvbnMuXG4gKlxuICogQHBhcmFtIHtFUmVmPHsgW21ldGhvZE5hbWU6IHN0cmluZ106ICguLi5hcmdzOiBhbnkpID0+IHVua25vd24gfT59IGdvdmVybmVkQXBpc1xuICogQHBhcmFtIHtBcnJheTxzdHJpbmcgfCBzeW1ib2w+fSBnb3Zlcm5lZE5hbWVzIG5hbWVzIG9mIHRoZSBnb3Zlcm5lZCBBUEkgbWV0aG9kc1xuICogQHBhcmFtIHtFUmVmPFhpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lclNlcnZpY2U+fSB0aW1lclxuICogQHBhcmFtIHsoKSA9PiBQcm9taXNlPFBvc2VyRmFjZXQ+fSBnZXRVcGRhdGVkUG9zZXJGYWNldFxuICogQHJldHVybnMge0FwaUdvdmVybm9yfVxuICovJGjigI1fb25jZS5tYWtlQXBpSW52b2NhdGlvblBvc2l0aW9ucyhtYWtlQXBpSW52b2NhdGlvblBvc2l0aW9ucyk7XG5jb25zdCBzZXR1cEFwaUdvdmVybmFuY2U9KFxuZ292ZXJuZWRBcGlzLFxuZ292ZXJuZWROYW1lcyxcbnRpbWVyLFxuZ2V0VXBkYXRlZFBvc2VyRmFjZXQpPT5cbntcbi8qKiBAdHlwZSB7V2Vha1NldDxJbnN0YW5jZT59ICovXG5jb25zdCB2b3RlQ291bnRlcnM9bmV3IFdlYWtTZXQoKTtcblxuLyoqIEB0eXBlIHtWb3RlT25BcGlJbnZvY2F0aW9ufSAqL1xuY29uc3Qgdm90ZU9uQXBpSW52b2NhdGlvbj1hc3luYyhcbmFwaU1ldGhvZE5hbWUsXG5tZXRob2RBcmdzLFxudm90ZUNvdW50ZXJJbnN0YWxsYXRpb24sXG5kZWFkbGluZSk9Plxue1xuZ292ZXJuZWROYW1lcy5pbmNsdWRlcyhhcGlNZXRob2ROYW1lKXx8XG5GYWlsIGAke2FwaU1ldGhvZE5hbWV9IGlzIG5vdCBhIGdvdmVybmVkIEFQSS5gO1xuXG5jb25zdHtwb3NpdGl2ZSxuZWdhdGl2ZX09bWFrZUFwaUludm9jYXRpb25Qb3NpdGlvbnMoXG5hcGlNZXRob2ROYW1lLFxubWV0aG9kQXJncyk7XG5cblxuLyoqIEB0eXBlIHtBcGlJbnZvY2F0aW9uSXNzdWV9ICovXG5jb25zdCBpc3N1ZT1oYXJkZW4oe2FwaU1ldGhvZE5hbWUsbWV0aG9kQXJnc30pO1xuY29uc3QgcXVlc3Rpb25TcGVjPWNvZXJjZVF1ZXN0aW9uU3BlYyh7XG5tZXRob2Q6Q2hvaWNlTWV0aG9kLlVOUkFOS0VELFxuaXNzdWUsXG5wb3NpdGlvbnM6W3Bvc2l0aXZlLG5lZ2F0aXZlXSxcbmVsZWN0aW9uVHlwZTpFbGVjdGlvblR5cGUuQVBJX0lOVk9DQVRJT04sXG5tYXhDaG9pY2VzOjEsXG5tYXhXaW5uZXJzOjEsXG5jbG9zaW5nUnVsZTp7dGltZXIsZGVhZGxpbmV9LFxucXVvcnVtUnVsZTpRdW9ydW1SdWxlLk1BSk9SSVRZLFxudGllT3V0Y29tZTpuZWdhdGl2ZX0pO1xuXG5cbmNvbnN0e3B1YmxpY0ZhY2V0OmNvdW50ZXJQdWJsaWNGYWNldCxpbnN0YW5jZTp2b3RlQ291bnRlcn09YXdhaXQgRShcbmdldFVwZGF0ZWRQb3NlckZhY2V0KCkpLlxuYWRkUXVlc3Rpb24odm90ZUNvdW50ZXJJbnN0YWxsYXRpb24scXVlc3Rpb25TcGVjKTtcblxudm90ZUNvdW50ZXJzLmFkZCh2b3RlQ291bnRlcik7XG5cbi8qIENSVUNJQUw6IEhlcmUgd2Ugd2FpdCBmb3IgdGhlIHZvdGVDb3VudGVyIHRvIGRlY2xhcmUgYW4gb3V0Y29tZSwgYW5kIHRoZW4qL1xuLyogYXR0ZW1wdCB0byBpbnZva2UgdGhlIEFQSSBpZiB0aGF0J3Mgd2hhdCB0aGUgdm90ZSBjYWxsZWQgZm9yLiBXZSBuZWVkIHRvKi9cbi8qIG1ha2Ugc3VyZSB0aGF0IG91dGNvbWVPZlVwZGF0ZVAgaXMgdXBkYXRlZCB3aGF0ZXZlciBoYXBwZW5zLiovXG4vKiovXG4vKiAqIElmIHRoZSB2b3RlIHBhc3NlZCwgaW52b2tlIHRoZSBBUEksIGFuZCByZXR1cm4gdGhlIHBvc2l0aXZlIHBvc2l0aW9uKi9cbi8qICogSWYgdGhlIHZvdGUgd2FzIG5lZ2F0aXZlLCByZXR1cm4gdGhlIG5lZ2F0aXZlIHBvc2l0aW9uKi9cbi8qICogSWYgd2UgY2FuJ3QgZG8gZWl0aGVyLCAodGhlIHZvdGUgZmFpbGVkIG9yIHRoZSBBUEkgaW52b2NhdGlvbiBmYWlsZWQpKi9cbi8qIHJldHVybiBhIGJyb2tlbiBwcm9taXNlLiovXG5jb25zdCBvdXRjb21lT2ZVcGRhdGU9RShjb3VudGVyUHVibGljRmFjZXQpLlxuZ2V0T3V0Y29tZSgpLlxudGhlbihcbi8qKiBAdHlwZSB7KG91dGNvbWU6IFBvc2l0aW9uKSA9PiBFUmVmPFBvc2l0aW9uPn0gKi9cbihvdXRjb21lKT0+e1xuaWYoa2V5RVEocG9zaXRpdmUsb3V0Y29tZSkpe1xua2V5RVEob3V0Y29tZSxoYXJkZW4oe2FwaU1ldGhvZE5hbWUsbWV0aG9kQXJnc30pKXx8XG5GYWlsIGBUaGUgcXVlc3Rpb24ncyBtZXRob2QgbmFtZSAoJHtxKFxuYXBpTWV0aG9kTmFtZSlcbiB9KSBhbmQgYXJncyAoJHttZXRob2RBcmdzfSkgZGlkbid0IG1hdGNoIHRoZSBvdXRjb21lICR7b3V0Y29tZX1gO1xuXG4vKiBFKHJlbW90ZSlbbmFtZV0oYXJncykgaW52b2tlcyB0aGUgbWV0aG9kIG5hbWVkICduYW1lJyBvbiByZW1vdGUuKi9cbnJldHVybiBFKGdvdmVybmVkQXBpcylbXG5hcGlNZXRob2ROYW1lXSguLi5tZXRob2RBcmdzKS5cbnRoZW4oKCk9PntcbnJldHVybiBwb3NpdGl2ZTtcbiB9KTtcbiB9ZWxzZXtcbnJldHVybiBuZWdhdGl2ZTtcbiB9XG4gfSk7XG5cblxucmV0dXJuIGhhcmRlbih7XG5vdXRjb21lT2ZVcGRhdGUsXG5pbnN0YW5jZTp2b3RlQ291bnRlcixcbmRldGFpbHM6RShjb3VudGVyUHVibGljRmFjZXQpLmdldERldGFpbHMoKX0pO1xuXG4gfTtcblxucmV0dXJuIEZhcigncGFyYW1Hb3Zlcm5vcicse1xudm90ZU9uQXBpSW52b2NhdGlvbixcbmNyZWF0ZWRRdWVzdGlvbjooYik9PnZvdGVDb3VudGVycy5oYXMoYil9KTtcblxuIH07JGjigI1fb25jZS5zZXR1cEFwaUdvdmVybmFuY2Uoc2V0dXBBcGlHb3Zlcm5hbmNlKTtcblxuaGFyZGVuKHNldHVwQXBpR292ZXJuYW5jZSk7XG5oYXJkZW4obWFrZUFwaUludm9jYXRpb25Qb3NpdGlvbnMpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VBcGlJbnZvY2F0aW9uUG9zaXRpb25zIjpbIm1ha2VBcGlJbnZvY2F0aW9uUG9zaXRpb25zIl0sInNldHVwQXBpR292ZXJuYW5jZSI6WyJzZXR1cEFwaUdvdmVybmFuY2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAG+1eyqsPAACrDwAARwAAAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuRmlsdGVyLmpzeyJpbXBvcnRzIjpbIi4uL3F1ZXN0aW9uLmpzIiwiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvdmF0LWRhdGEiLCJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbIm1ha2VPZmZlckZpbHRlclBvc2l0aW9ucyIsInNldHVwRmlsdGVyR292ZXJuYW5jZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixtdXN0TWF0Y2gsa2V5RVEsTSxDaG9pY2VNZXRob2QsUXVvcnVtUnVsZSxFbGVjdGlvblR5cGUsY29lcmNlUXVlc3Rpb25TcGVjOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dLFtcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXV1dLFtcIi4uL3F1ZXN0aW9uLmpzXCIsIFtbXCJDaG9pY2VNZXRob2RcIiwgWyRo4oCNX2EgPT4gKENob2ljZU1ldGhvZCA9ICRo4oCNX2EpXV0sW1wiUXVvcnVtUnVsZVwiLCBbJGjigI1fYSA9PiAoUXVvcnVtUnVsZSA9ICRo4oCNX2EpXV0sW1wiRWxlY3Rpb25UeXBlXCIsIFskaOKAjV9hID0+IChFbGVjdGlvblR5cGUgPSAkaOKAjV9hKV1dLFtcImNvZXJjZVF1ZXN0aW9uU3BlY1wiLCBbJGjigI1fYSA9PiAoY29lcmNlUXVlc3Rpb25TcGVjID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBNYWtlIGEgcGFpciBvZiBwb3NpdGlvbnMgZm9yIGEgcXVlc3Rpb24gYWJvdXQgd2hldGhlciB0byB1cGRhdGUgdGhlIG9mZmVyXG4gKiBmaWx0ZXIuIElmIHRoZSB2b3RlIHBhc3NlcywgdGhlIGxpc3Qgb2YgYmxvY2tlZCBpbnZpdGF0aW9uIHN0cmluZ3Mgd2lsbCBiZVxuICogdXBkYXRlZC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ1tdfSBzdHJpbmdzXG4gKi9cbmNvbnN0IG1ha2VPZmZlckZpbHRlclBvc2l0aW9ucz0oc3RyaW5ncyk9PntcbmNvbnN0IHBvc2l0aXZlPWhhcmRlbih7c3RyaW5nc30pO1xuY29uc3QgbmVnYXRpdmU9aGFyZGVuKHtkb250VXBkYXRlOnN0cmluZ3N9KTtcbnJldHVybntwb3NpdGl2ZSxuZWdhdGl2ZX07XG4gfTtcblxuLyoqXG4gKiBTZXR1cCB0byBhbGxvdyBnb3Zlcm5hbmNlIHRvIGJsb2NrIHNvbWUgaW52aXRhdGlvbnMuXG4gKlxuICogQHBhcmFtIHtFUmVmPFhpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lclNlcnZpY2U+fSB0aW1lclxuICogQHBhcmFtIHsoKSA9PiBQcm9taXNlPFBvc2VyRmFjZXQ+fSBnZXRVcGRhdGVkUG9zZXJGYWNldFxuICogQHBhcmFtIHtHb3Zlcm5lZENyZWF0b3JGYWNldDx7fT59IGdvdmVybmVkQ0ZcbiAqIEByZXR1cm5zIHtGaWx0ZXJHb3Zlcm5vcn1cbiAqLyRo4oCNX29uY2UubWFrZU9mZmVyRmlsdGVyUG9zaXRpb25zKG1ha2VPZmZlckZpbHRlclBvc2l0aW9ucyk7XG5jb25zdCBzZXR1cEZpbHRlckdvdmVybmFuY2U9KHRpbWVyLGdldFVwZGF0ZWRQb3NlckZhY2V0LGdvdmVybmVkQ0YpPT57XG4vKiogQHR5cGUge1dlYWtTZXQ8SW5zdGFuY2U+fSAqL1xuY29uc3Qgdm90ZUNvdW50ZXJzPW5ldyBXZWFrU2V0KCk7XG5cbi8qKiBAdHlwZSB7Vm90ZU9uT2ZmZXJGaWx0ZXJ9ICovXG5jb25zdCB2b3RlT25GaWx0ZXI9YXN5bmModm90ZUNvdW50ZXJJbnN0YWxsYXRpb24sZGVhZGxpbmUsc3RyaW5ncyk9Pntcbm11c3RNYXRjaChzdHJpbmdzLE0uYXJyYXlPZihNLnN0cmluZygpKSk7XG5jb25zdHtwb3NpdGl2ZSxuZWdhdGl2ZX09bWFrZU9mZmVyRmlsdGVyUG9zaXRpb25zKHN0cmluZ3MpO1xuXG4vKiogQHR5cGUge09mZmVyRmlsdGVySXNzdWV9ICovXG5jb25zdCBpc3N1ZT1oYXJkZW4oe3N0cmluZ3N9KTtcbmNvbnN0IHF1ZXN0aW9uU3BlYz1jb2VyY2VRdWVzdGlvblNwZWMoe1xubWV0aG9kOkNob2ljZU1ldGhvZC5VTlJBTktFRCxcbmlzc3VlLFxucG9zaXRpb25zOltwb3NpdGl2ZSxuZWdhdGl2ZV0sXG5lbGVjdGlvblR5cGU6RWxlY3Rpb25UeXBlLk9GRkVSX0ZJTFRFUixcbm1heENob2ljZXM6MSxcbm1heFdpbm5lcnM6MSxcbmNsb3NpbmdSdWxlOnt0aW1lcixkZWFkbGluZX0sXG5xdW9ydW1SdWxlOlF1b3J1bVJ1bGUuTUFKT1JJVFksXG50aWVPdXRjb21lOm5lZ2F0aXZlfSk7XG5cblxuY29uc3R7cHVibGljRmFjZXQ6Y291bnRlclB1YmxpY0ZhY2V0LGluc3RhbmNlOnZvdGVDb3VudGVyfT1hd2FpdCBFKFxuZ2V0VXBkYXRlZFBvc2VyRmFjZXQoKSkuXG5hZGRRdWVzdGlvbih2b3RlQ291bnRlckluc3RhbGxhdGlvbixxdWVzdGlvblNwZWMpO1xuXG52b3RlQ291bnRlcnMuYWRkKHZvdGVDb3VudGVyKTtcblxuLyogQ1JVQ0lBTDogSGVyZSB3ZSB3YWl0IGZvciB0aGUgdm90ZUNvdW50ZXIgdG8gZGVjbGFyZSBhbiBvdXRjb21lLCBhbmQgdGhlbiovXG4vKiBhdHRlbXB0IHRvIGludm9rZSB0aGUgQVBJIGlmIHRoYXQncyB3aGF0IHRoZSB2b3RlIGNhbGxlZCBmb3IuIFdlIG5lZWQgdG8qL1xuLyogbWFrZSBzdXJlIHRoYXQgb3V0Y29tZU9mVXBkYXRlUCBpcyB1cGRhdGVkIHdoYXRldmVyIGhhcHBlbnMuKi9cbi8qKi9cbi8qICogSWYgdGhlIHZvdGUgcGFzc2VkLCBpbnZva2UgdGhlIEFQSSwgYW5kIHJldHVybiB0aGUgcG9zaXRpdmUgcG9zaXRpb24qL1xuLyogKiBJZiB0aGUgdm90ZSB3YXMgbmVnYXRpdmUsIHJldHVybiB0aGUgbmVnYXRpdmUgcG9zaXRpb24qL1xuLyogKiBJZiB3ZSBjYW4ndCBkbyBlaXRoZXIsICh0aGUgdm90ZSBmYWlsZWQgb3IgdGhlIEFQSSBpbnZvY2F0aW9uIGZhaWxlZCkqL1xuLyogcmV0dXJuIGEgYnJva2VuIHByb21pc2UuKi9cbmNvbnN0IG91dGNvbWVPZlVwZGF0ZT1FKGNvdW50ZXJQdWJsaWNGYWNldCkuXG5nZXRPdXRjb21lKCkuXG50aGVuKFxuLyoqIEB0eXBlIHsob3V0Y29tZTogUG9zaXRpb24pID0+IEVSZWY8UG9zaXRpb24+fSAqL1xuKG91dGNvbWUpPT57XG5pZihrZXlFUShvdXRjb21lLHBvc2l0aXZlKSl7XG5yZXR1cm4gRShnb3Zlcm5lZENGKS5cbnNldE9mZmVyRmlsdGVyKHN0cmluZ3MpLlxudGhlbigoKT0+e1xucmV0dXJuIHBvc2l0aXZlO1xuIH0pO1xuIH1lbHNlIGlmKGtleUVRKG91dGNvbWUsbmVnYXRpdmUpKXtcbnJldHVybiBuZWdhdGl2ZTtcbiB9ZWxzZXtcbmFzc2VydC5mYWlsKCd1bnJlY29nbml6ZWQgb3V0Y29tZScpO1xuIH1cbiB9KTtcblxuXG5yZXR1cm4gaGFyZGVuKHtcbm91dGNvbWVPZlVwZGF0ZSxcbmluc3RhbmNlOnZvdGVDb3VudGVyLFxuZGV0YWlsczpFKGNvdW50ZXJQdWJsaWNGYWNldCkuZ2V0RGV0YWlscygpfSk7XG5cbiB9O1xuXG5yZXR1cm4gRmFyKCdmaWx0ZXJHb3Zlcm5vcicse1xudm90ZU9uRmlsdGVyLFxuY3JlYXRlZFF1ZXN0aW9uOihiKT0+dm90ZUNvdW50ZXJzLmhhcyhiKX0pO1xuXG4gfTskaOKAjV9vbmNlLnNldHVwRmlsdGVyR292ZXJuYW5jZShzZXR1cEZpbHRlckdvdmVybmFuY2UpO1xuXG5oYXJkZW4oc2V0dXBGaWx0ZXJHb3Zlcm5hbmNlKTtcbmhhcmRlbihtYWtlT2ZmZXJGaWx0ZXJQb3NpdGlvbnMpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VPZmZlckZpbHRlclBvc2l0aW9ucyI6WyJtYWtlT2ZmZXJGaWx0ZXJQb3NpdGlvbnMiXSwic2V0dXBGaWx0ZXJHb3Zlcm5hbmNlIjpbInNldHVwRmlsdGVyR292ZXJuYW5jZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABGD4o1SBYAAEgWAABGAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qc3siaW1wb3J0cyI6WyIuLi9xdWVzdGlvbi5qcyIsIi4uL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL3N0b3JlIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJDT05UUkFDVF9FTEVDVE9SQVRFIiwiYXNzZXJ0QmFsbG90Q29uY2VybnNQYXJhbSIsIm1ha2VQYXJhbUNoYW5nZVBvc2l0aW9ucyIsInNldHVwUGFyYW1Hb3Zlcm5hbmNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsZGVlcGx5RnVsZmlsbGVkLEZhcixtdXN0TWF0Y2gsa2V5RVEsQ2hvaWNlTWV0aG9kLGNvZXJjZVF1ZXN0aW9uU3BlYyxFbGVjdGlvblR5cGUsUXVvcnVtUnVsZSxQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcImRlZXBseUZ1bGZpbGxlZFwiLCBbJGjigI1fYSA9PiAoZGVlcGx5RnVsZmlsbGVkID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wia2V5RVFcIiwgWyRo4oCNX2EgPT4gKGtleUVRID0gJGjigI1fYSldXV1dLFtcIi4uL3F1ZXN0aW9uLmpzXCIsIFtbXCJDaG9pY2VNZXRob2RcIiwgWyRo4oCNX2EgPT4gKENob2ljZU1ldGhvZCA9ICRo4oCNX2EpXV0sW1wiY29lcmNlUXVlc3Rpb25TcGVjXCIsIFskaOKAjV9hID0+IChjb2VyY2VRdWVzdGlvblNwZWMgPSAkaOKAjV9hKV1dLFtcIkVsZWN0aW9uVHlwZVwiLCBbJGjigI1fYSA9PiAoRWxlY3Rpb25UeXBlID0gJGjigI1fYSldXSxbXCJRdW9ydW1SdWxlXCIsIFskaOKAjV9hID0+IChRdW9ydW1SdWxlID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVHdWFyZHMuanNcIiwgW1tcIlBhcmFtQ2hhbmdlc1F1ZXN0aW9uRGV0YWlsc1NoYXBlXCIsIFskaOKAjV9hID0+IChQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuLyoqXG4gKiBUaGUgZWxlY3RvcmF0ZSB0aGF0IGdvdmVybnMgY2hhbmdlcyB0byB0aGUgY29udHJhY3QncyBwYXJhbWV0ZXJzLiBJdCBtdXN0IGJlXG4gKiBkZWNsYXJlZCBpbiB0aGUgZ292ZXJuZWQgY29udHJhY3QuXG4gKi9cbmNvbnN0IENPTlRSQUNUX0VMRUNUT1JBVEU9J0VsZWN0b3JhdGUnO1xuXG4vKipcbiAqIFJldHVybiBhIHJlY29yZCBjb250YWluaW5nIHRoZSBwb3NpdGl2ZSBhbmQgbmVnYXRpdmUgcG9zaXRpb25zIGZvciBhXG4gKiBxdWVzdGlvbiBvbiBjaGFuZ2luZyB0aGUgcGFyYW0gdG8gdGhlIHByb3Bvc2VkVmFsdWUuXG4gKlxuICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCBQYXJhbVZhbHVlPn0gY2hhbmdlc1xuICogQHJldHVybnMge1BhcmFtQ2hhbmdlUG9zaXRpb25zfVxuICovJGjigI1fb25jZS5DT05UUkFDVF9FTEVDVE9SQVRFKENPTlRSQUNUX0VMRUNUT1JBVEUpO1xuY29uc3QgbWFrZVBhcmFtQ2hhbmdlUG9zaXRpb25zPShjaGFuZ2VzKT0+e1xuLyoqIEB0eXBlIHtDaGFuZ2VQYXJhbXNQb3NpdGlvbn0gKi9cbmNvbnN0IHBvc2l0aXZlPXtjaGFuZ2VzfTtcbmNvbnN0IG5hbWVzT25seT1PYmplY3Qua2V5cyhjaGFuZ2VzKTtcbmNvbnN0IG5lZ2F0aXZlPXtub0NoYW5nZTpuYW1lc09ubHl9O1xucmV0dXJuIGhhcmRlbih7cG9zaXRpdmUsbmVnYXRpdmV9KTtcbiB9O1xuXG4vKipcbiAqIGFzc2VydCB0aGF0IHRoZSBwYXJhbWV0ZXIgZGVzY3JpYmVkIGJ5IHBhcmFtU3BlYyBpcyBwcm9wb3NlZCB0byBiZSBjaGFuZ2VkIGluXG4gKiB0aGUgcXVlc3Rpb24gZGVzY3JpYmVkIGJ5IHF1ZXN0aW9uU3BlYy5cbiAqXG4gKiBAcGFyYW0ge3sgcGFyYW1ldGVyTmFtZTogc3RyaW5nLCBwYXJhbVBhdGg6IHVua25vd259fSBwYXJhbVNwZWNcbiAqIEBwYXJhbSB7UXVlc3Rpb25TcGVjPFBhcmFtQ2hhbmdlSXNzdWU8dW5rbm93bj4+fSBxdWVzdGlvblNwZWNcbiAqLyRo4oCNX29uY2UubWFrZVBhcmFtQ2hhbmdlUG9zaXRpb25zKG1ha2VQYXJhbUNoYW5nZVBvc2l0aW9ucyk7XG5jb25zdCBhc3NlcnRCYWxsb3RDb25jZXJuc1BhcmFtPShwYXJhbVNwZWMscXVlc3Rpb25TcGVjKT0+e1xubXVzdE1hdGNoKHF1ZXN0aW9uU3BlYyxQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZSk7XG5cbmNvbnN0e3BhcmFtZXRlck5hbWUscGFyYW1QYXRofT1wYXJhbVNwZWM7XG5jb25zdHtpc3N1ZX09cXVlc3Rpb25TcGVjO1xuaXNzdWUuc3BlYy5jaGFuZ2VzW3BhcmFtZXRlck5hbWVdfHxcbkZhaWwgYFF1ZXN0aW9uICgke2lzc3VlLnNwZWMuY2hhbmdlc30pIGRvZXMgbm90IGNvbmNlcm4gJHtwYXJhbWV0ZXJOYW1lfWA7XG5rZXlFUShpc3N1ZS5zcGVjLnBhcmFtUGF0aCxwYXJhbVBhdGgpfHxcbkZhaWwgYFF1ZXN0aW9uIHBhdGggKCR7aXNzdWUuc3BlYy5wYXJhbVBhdGh9KSBkb2Vzbid0IG1hdGNoIHJlcXVlc3QgKCR7cGFyYW1QYXRofSlgO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtFUmVmPFBhcmFtTWFuYWdlclJldHJpZXZlcj59IHBhcmFtTWFuYWdlclJldHJpZXZlclxuICogQHBhcmFtIHtJbnN0YW5jZX0gY29udHJhY3RJbnN0YW5jZVxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXJTZXJ2aWNlfSB0aW1lclxuICogQHBhcmFtIHsoKSA9PiBQcm9taXNlPFBvc2VyRmFjZXQ+fSBnZXRVcGRhdGVkUG9zZXJGYWNldFxuICogQHJldHVybnMge1BhcmFtR292ZXJub3J9XG4gKi8kaOKAjV9vbmNlLmFzc2VydEJhbGxvdENvbmNlcm5zUGFyYW0oYXNzZXJ0QmFsbG90Q29uY2VybnNQYXJhbSk7XG5jb25zdCBzZXR1cFBhcmFtR292ZXJuYW5jZT0oXG5wYXJhbU1hbmFnZXJSZXRyaWV2ZXIsXG5jb250cmFjdEluc3RhbmNlLFxudGltZXIsXG5nZXRVcGRhdGVkUG9zZXJGYWNldCk9Plxue1xuLyoqIEB0eXBlIHtXZWFrU2V0PEluc3RhbmNlPn0gKi9cbmNvbnN0IHZvdGVDb3VudGVycz1uZXcgV2Vha1NldCgpO1xuXG4vKiogQHR5cGUge1ZvdGVPblBhcmFtQ2hhbmdlc30gKi9cbmNvbnN0IHZvdGVPblBhcmFtQ2hhbmdlcz1hc3luYyhcbnZvdGVDb3VudGVySW5zdGFsbGF0aW9uLFxuZGVhZGxpbmUsXG5wYXJhbVNwZWMpPT5cbntcbmNvbnN0IHBhcmFtTWdyPWF3YWl0IEUocGFyYW1NYW5hZ2VyUmV0cmlldmVyKS5nZXQocGFyYW1TcGVjLnBhcmFtUGF0aCk7XG5jb25zdCBjaGFuZ2VQcz17fTtcbmZvcihjb25zdCBuYW1lIG9mIE9iamVjdC5rZXlzKHBhcmFtU3BlYy5jaGFuZ2VzKSl7XG5jb25zdCBwcm9wb3NlZFZhbHVlPUUocGFyYW1NZ3IpLmdldFZpc2libGVWYWx1ZShcbm5hbWUsXG5wYXJhbVNwZWMuY2hhbmdlc1tuYW1lXSk7XG5cbmNoYW5nZVBzW25hbWVdPXByb3Bvc2VkVmFsdWU7XG4gfVxuY29uc3QgY2hhbmdlcz1hd2FpdCBkZWVwbHlGdWxmaWxsZWQoaGFyZGVuKGNoYW5nZVBzKSk7XG5cbmNvbnN0e3Bvc2l0aXZlLG5lZ2F0aXZlfT1tYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMoY2hhbmdlcyk7XG5cbi8qKiBAdHlwZSB7UGFyYW1DaGFuZ2VJc3N1ZTx1bmtub3duPn0gKi9cbmNvbnN0IGlzc3VlPWhhcmRlbih7XG5zcGVjOntcbnBhcmFtUGF0aDpwYXJhbVNwZWMucGFyYW1QYXRoLFxuY2hhbmdlc30sXG5cbmNvbnRyYWN0OmNvbnRyYWN0SW5zdGFuY2V9KTtcblxuXG5jb25zdCBxdWVzdGlvblNwZWM9Y29lcmNlUXVlc3Rpb25TcGVjKHtcbm1ldGhvZDpDaG9pY2VNZXRob2QuVU5SQU5LRUQsXG5pc3N1ZSxcbnBvc2l0aW9uczpbcG9zaXRpdmUsbmVnYXRpdmVdLFxuZWxlY3Rpb25UeXBlOkVsZWN0aW9uVHlwZS5QQVJBTV9DSEFOR0UsXG5tYXhDaG9pY2VzOjEsXG5tYXhXaW5uZXJzOjEsXG5jbG9zaW5nUnVsZTp7dGltZXIsZGVhZGxpbmV9LFxucXVvcnVtUnVsZTpRdW9ydW1SdWxlLk1BSk9SSVRZLFxudGllT3V0Y29tZTpuZWdhdGl2ZX0pO1xuXG5cbmNvbnN0e3B1YmxpY0ZhY2V0OmNvdW50ZXJQdWJsaWNGYWNldCxpbnN0YW5jZTp2b3RlQ291bnRlcn09YXdhaXQgRShcbmdldFVwZGF0ZWRQb3NlckZhY2V0KCkpLlxuYWRkUXVlc3Rpb24odm90ZUNvdW50ZXJJbnN0YWxsYXRpb24scXVlc3Rpb25TcGVjKTtcblxudm90ZUNvdW50ZXJzLmFkZCh2b3RlQ291bnRlcik7XG5cbi8qIENSVUNJQUw6IEhlcmUgd2Ugd2FpdCBmb3IgdGhlIHZvdGVDb3VudGVyIHRvIGRlY2xhcmUgYW4gb3V0Y29tZSwgYW5kIHRoZW4qL1xuLyogYXR0ZW1wdCB0byB1cGRhdGUgdGhlIHZhbHVlIG9mIHRoZSBwYXJhbWV0ZXIgaWYgdGhhdCdzIHdoYXQgdGhlIHZvdGUqL1xuLyogZGVjaWRlZC4gV2UgbmVlZCB0byBtYWtlIHN1cmUgdGhhdCBvdXRjb21lT2ZVcGRhdGVQIGlzIHVwZGF0ZWQgd2hhdGV2ZXIqL1xuLyogaGFwcGVucy4qL1xuLyogKiBJZiB0aGUgdm90ZSB3YXMgbmVnYXRpdmUsIHJlc29sdmUgdG8gdGhlIG91dGNvbWUqL1xuLyogKiBJZiB3ZSB1cGRhdGUgdGhlIHZhbHVlLCBzYXkgc28qL1xuLyogKiBJZiB0aGUgdXBkYXRlIGZhaWxzLCByZWplY3QgdGhlIHByb21pc2UqL1xuLyogKiBpZiB0aGUgdm90ZSBvdXRjb21lIGZhaWxlZCwgcmVqZWN0IHRoZSBwcm9taXNlLiovXG5jb25zdCBvdXRjb21lT2ZVcGRhdGU9RShjb3VudGVyUHVibGljRmFjZXQpLlxuZ2V0T3V0Y29tZSgpLlxudGhlbihhc3luYyhvdXRjb21lKT0+e1xuaWYoa2V5RVEocG9zaXRpdmUsb3V0Y29tZSkpe1xucmV0dXJuIEUud2hlbihcbkUocGFyYW1NZ3IpLnVwZGF0ZVBhcmFtcyhwYXJhbVNwZWMuY2hhbmdlcyksXG4oKT0+cG9zaXRpdmUpO1xuXG4gfVxucmV0dXJuIG5lZ2F0aXZlO1xuIH0pO1xuXG5yZXR1cm57XG5vdXRjb21lT2ZVcGRhdGUsXG5pbnN0YW5jZTp2b3RlQ291bnRlcixcbmRldGFpbHM6RShjb3VudGVyUHVibGljRmFjZXQpLmdldERldGFpbHMoKX07XG5cbiB9O1xuXG5yZXR1cm4gRmFyKCdwYXJhbUdvdmVybm9yJyx7XG52b3RlT25QYXJhbUNoYW5nZXMsXG5jcmVhdGVkUXVlc3Rpb246KGIpPT52b3RlQ291bnRlcnMuaGFzKGIpfSk7XG5cbiB9OyRo4oCNX29uY2Uuc2V0dXBQYXJhbUdvdmVybmFuY2Uoc2V0dXBQYXJhbUdvdmVybmFuY2UpO1xuXG5oYXJkZW4oc2V0dXBQYXJhbUdvdmVybmFuY2UpO1xuaGFyZGVuKG1ha2VQYXJhbUNoYW5nZVBvc2l0aW9ucyk7XG5oYXJkZW4oYXNzZXJ0QmFsbG90Q29uY2VybnNQYXJhbSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ09OVFJBQ1RfRUxFQ1RPUkFURSI6WyJDT05UUkFDVF9FTEVDVE9SQVRFIl0sIm1ha2VQYXJhbUNoYW5nZVBvc2l0aW9ucyI6WyJtYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMiXSwiYXNzZXJ0QmFsbG90Q29uY2VybnNQYXJhbSI6WyJhc3NlcnRCYWxsb3RDb25jZXJuc1BhcmFtIl0sInNldHVwUGFyYW1Hb3Zlcm5hbmNlIjpbInNldHVwUGFyYW1Hb3Zlcm5hbmNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGtgSq57HQAAex0AADsAAABAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29udHJhY3RHb3Zlcm5vcktpdC5qc3siaW1wb3J0cyI6WyIuL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5BcGkuanMiLCIuL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5GaWx0ZXIuanMiLCIuL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qcyIsIkBhZ29yaWMvYXNzZXJ0IiwiQGFnb3JpYy9pbnRlcm5hbCIsIkBhZ29yaWMvdmF0LWRhdGEiLCJAZW5kby9ldmVudHVhbC1zZW5kIl0sImV4cG9ydHMiOlsicHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRmFpbCxtYWtlVHJhY2VyLHByZXBhcmVFeG9DbGFzc0tpdCxFLHNldHVwQXBpR292ZXJuYW5jZSxzZXR1cEZpbHRlckdvdmVybmFuY2UsQ09OVFJBQ1RfRUxFQ1RPUkFURSxzZXR1cFBhcmFtR292ZXJuYW5jZTskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2Fzc2VydFwiLCBbW1wiRmFpbFwiLCBbJGjigI1fYSA9PiAoRmFpbCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL2ludGVybmFsXCIsIFtbXCJtYWtlVHJhY2VyXCIsIFskaOKAjV9hID0+IChtYWtlVHJhY2VyID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcInByZXBhcmVFeG9DbGFzc0tpdFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4b0NsYXNzS2l0ID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiLi9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuQXBpLmpzXCIsIFtbXCJzZXR1cEFwaUdvdmVybmFuY2VcIiwgWyRo4oCNX2EgPT4gKHNldHVwQXBpR292ZXJuYW5jZSA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5GaWx0ZXIuanNcIiwgW1tcInNldHVwRmlsdGVyR292ZXJuYW5jZVwiLCBbJGjigI1fYSA9PiAoc2V0dXBGaWx0ZXJHb3Zlcm5hbmNlID0gJGjigI1fYSldXV1dLFtcIi4vY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVyblBhcmFtLmpzXCIsIFtbXCJDT05UUkFDVF9FTEVDVE9SQVRFXCIsIFskaOKAjV9hID0+IChDT05UUkFDVF9FTEVDVE9SQVRFID0gJGjigI1fYSldXSxbXCJzZXR1cFBhcmFtR292ZXJuYW5jZVwiLCBbJGjigI1fYSA9PiAoc2V0dXBQYXJhbUdvdmVybmFuY2UgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuY29uc3QgdHJhY2U9bWFrZVRyYWNlcignQ0dLJyxmYWxzZSk7XG5cbi8qKlxuICpcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YScpLkJhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7e1xuICogICB0aW1lcjogWGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVyU2VydmljZSxcbiAqICAgem9lOiBFUmVmPFpvZVNlcnZpY2U+LFxuICogfX0gcG93ZXJzXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlQ29udHJhY3RHb3Zlcm5vcktpdD0oYmFnZ2FnZSxwb3dlcnMpPT57XG4vKiBUaGVzZSBhcmUgcHJvZHVjZWQganVzdC1pbi10aW1lIGJlY2F1c2UgQVBJIGdvdmVybmFuY2UgbWFrZXMgcmVtb3RlIGNhbGxzLCB3aGljaCBwcmV2ZW50IHZhdCByZXN0YXJ0LiovXG4vKiBUaGUgb3RoZXIgdHdvIGNvdWxkIGhhcHBlbiBkdXJpbmcgcmVzdGFydCBidXQgdGhleSdkIG5lZWQgdG8gaGF2ZSBhIHNlcGFyYXRlIGhvb2ssIHNvIGZvciBjb25zaXN0ZW5jeSovXG4vKiB0aGV5J3JlIGFsbCBsYXp5LiovXG4vKiogQHR5cGUge1JldHVyblR5cGU8dHlwZW9mIHNldHVwRmlsdGVyR292ZXJuYW5jZT59ICovXG5sZXQgZmlsdGVyR292ZXJuYW5jZTtcbi8qKiBAdHlwZSB7UmV0dXJuVHlwZTx0eXBlb2Ygc2V0dXBQYXJhbUdvdmVybmFuY2U+fSAqL1xubGV0IHBhcmFtR292ZXJuYW5jZTtcbi8qKiBAdHlwZSB7QXdhaXRlZDxSZXR1cm5UeXBlPHR5cGVvZiBzZXR1cEFwaUdvdmVybmFuY2U+Pn0gKi9cbmxldCBhcGlHb3Zlcm5hbmNlO1xuXG4vKiogQHR5cGUge2FueX0gKi9cbmxldCBwb3NlckZhY2V0O1xuXG5jb25zdCBtYWtlQ29udHJhY3RHb3Zlcm5vcktpdD1wcmVwYXJlRXhvQ2xhc3NLaXQoXG5iYWdnYWdlLFxuJ0NvbnRyYWN0R292ZXJub3JLaXQnLFxudW5kZWZpbmVkLFxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9lL3NyYy96b2VTZXJ2aWNlL3V0aWxzLmpzJykuU3RhcnRlZEluc3RhbmNlS2l0PEdvdmVybmFibGVTdGFydEZuPn0gc3RhcnRlZEluc3RhbmNlS2l0XG4gKiBAcGFyYW0ge0xpbWl0ZWRDRjx1bmtub3duPn0gbGltaXRlZENyZWF0b3JGYWNldFxuICovXG4oc3RhcnRlZEluc3RhbmNlS2l0LGxpbWl0ZWRDcmVhdG9yRmFjZXQpPT57XG5yZXR1cm57XG4uLi5zdGFydGVkSW5zdGFuY2VLaXQsXG5saW1pdGVkQ3JlYXRvckZhY2V0LFxuY3VycmVudEludml0YXRpb246LyoqIEB0eXBlIHtJbnZpdGF0aW9uPHVua25vd24sIG5ldmVyPj99ICovbnVsbH07XG5cbiB9LFxue1xuaGVscGVyOntcbi8qKiBAdHlwZSB7KCkgPT4gUHJvbWlzZTxJbnN0YW5jZT59ICovXG4gICAgICBhc3luYyBnZXRFbGVjdG9yYXRlSW5zdGFuY2UoKXtcbmNvbnN0e3B1YmxpY0ZhY2V0fT10aGlzLnN0YXRlO1xuY29uc3QgaW52aXRhdGlvbkFtb3VudD1hd2FpdCBFKHB1YmxpY0ZhY2V0KS5nZXRJbnZpdGF0aW9uQW1vdW50KFxuQ09OVFJBQ1RfRUxFQ1RPUkFURSk7XG5cbnJldHVybiBpbnZpdGF0aW9uQW1vdW50LnZhbHVlWzBdLmluc3RhbmNlO1xuIH0sXG4vKiogQHR5cGUgeygpID0+IFByb21pc2U8UG9zZXJGYWNldD59ICovXG4gICAgICBhc3luYyBnZXRVcGRhdGVkUG9zZXJGYWNldCgpe1xuY29uc3R7Y3JlYXRvckZhY2V0fT10aGlzLnN0YXRlO1xuY29uc3QgbmV3SW52aXRhdGlvbj1hd2FpdCBFKFxuRShFKGNyZWF0b3JGYWNldCkuZ2V0UGFyYW1NZ3JSZXRyaWV2ZXIoKSkuZ2V0KHtcbmtleTonZ292ZXJuZWRQYXJhbXMnfSkpLlxuXG5nZXRJbnRlcm5hbFBhcmFtVmFsdWUoQ09OVFJBQ1RfRUxFQ1RPUkFURSk7XG5cbmlmKG5ld0ludml0YXRpb24hPT10aGlzLnN0YXRlLmN1cnJlbnRJbnZpdGF0aW9uKXtcbnBvc2VyRmFjZXQ9RShFKHBvd2Vycy56b2UpLm9mZmVyKG5ld0ludml0YXRpb24pKS5nZXRPZmZlclJlc3VsdCgpO1xudGhpcy5zdGF0ZS5jdXJyZW50SW52aXRhdGlvbj1uZXdJbnZpdGF0aW9uO1xuIH1cbnJldHVybiBwb3NlckZhY2V0O1xuIH0sXG4gICAgICBhc3luYyBwcm92aWRlQXBpR292ZXJuYW5jZSgpe1xuY29uc3R7dGltZXJ9PXBvd2VycztcbmNvbnN0e2NyZWF0b3JGYWNldH09dGhpcy5zdGF0ZTtcbmlmKCFhcGlHb3Zlcm5hbmNlKXtcbnRyYWNlKCdhd2FpdGluZyBnb3Zlcm5lZCBBUEkgZGVwZW5kZW5jaWVzJyk7XG5jb25zdFtnb3Zlcm5lZEFwaXMsZ292ZXJuZWROYW1lc109YXdhaXQgUHJvbWlzZS5hbGwoW1xuRShjcmVhdG9yRmFjZXQpLmdldEdvdmVybmVkQXBpcygpLFxuRShjcmVhdG9yRmFjZXQpLmdldEdvdmVybmVkQXBpTmFtZXMoKV0pO1xuXG50cmFjZSgnc2V0dXBBcGlHb3Zlcm5hbmNlJyk7XG5hcGlHb3Zlcm5hbmNlPWdvdmVybmVkTmFtZXMubGVuZ3RoP1xuc2V0dXBBcGlHb3Zlcm5hbmNlKGdvdmVybmVkQXBpcyxnb3Zlcm5lZE5hbWVzLHRpbWVyLCgpPT5cbnRoaXMuZmFjZXRzLmhlbHBlci5nZXRVcGRhdGVkUG9zZXJGYWNldCgpKTpcblxue1xuLyogaWYgd2UgYXJlbid0IGdvdmVybmluZyBBUElzLCB2b3RlT25BcGlJbnZvY2F0aW9uIHNob3VsZG4ndCBiZSBjYWxsZWQqL1xudm90ZU9uQXBpSW52b2NhdGlvbjooKT0+e1xudGhyb3cgRXJyb3IoJ2FwaSBnb3Zlcm5hbmNlIG5vdCBjb25maWd1cmVkJyk7XG4gfSxcbmNyZWF0ZWRRdWVzdGlvbjooKT0+ZmFsc2V9O1xuXG4gfVxucmV0dXJuIGFwaUdvdmVybmFuY2U7XG4gfSxcbnByb3ZpZGVGaWx0ZXJHb3Zlcm5hbmNlKCl7XG5pZighZmlsdGVyR292ZXJuYW5jZSl7XG5jb25zdHt0aW1lcn09cG93ZXJzO1xuY29uc3R7Y3JlYXRvckZhY2V0fT10aGlzLnN0YXRlO1xuZmlsdGVyR292ZXJuYW5jZT1zZXR1cEZpbHRlckdvdmVybmFuY2UoXG50aW1lcixcbigpPT50aGlzLmZhY2V0cy5oZWxwZXIuZ2V0VXBkYXRlZFBvc2VyRmFjZXQoKSxcbmNyZWF0b3JGYWNldCk7XG5cbiB9XG5yZXR1cm4gZmlsdGVyR292ZXJuYW5jZTtcbiB9LFxucHJvdmlkZVBhcmFtR292ZXJuYW5jZSgpe1xuaWYoIXBhcmFtR292ZXJuYW5jZSl7XG5jb25zdHt0aW1lcn09cG93ZXJzO1xuY29uc3R7Y3JlYXRvckZhY2V0LGluc3RhbmNlfT10aGlzLnN0YXRlO1xucGFyYW1Hb3Zlcm5hbmNlPXNldHVwUGFyYW1Hb3Zlcm5hbmNlKFxuRShjcmVhdG9yRmFjZXQpLmdldFBhcmFtTWdyUmV0cmlldmVyKCksXG5pbnN0YW5jZSxcbnRpbWVyLFxuKCk9PnRoaXMuZmFjZXRzLmhlbHBlci5nZXRVcGRhdGVkUG9zZXJGYWNldCgpKTtcblxuIH1cbnJldHVybiBwYXJhbUdvdmVybmFuY2U7XG4gfX0sXG5cbmNyZWF0b3I6e1xuLyoqXG4gKiBAcGFyYW0ge0ludml0YXRpb259IHBvc2VySW52aXRhdGlvblxuICogQHJldHVybnMge1Byb21pc2U8dm9pZD59XG4gKi9cbnJlcGxhY2VFbGVjdG9yYXRlKHBvc2VySW52aXRhdGlvbil7XG5jb25zdHtjcmVhdG9yRmFjZXR9PXRoaXMuc3RhdGU7XG4vKiogQHR5cGUge1Byb21pc2U8WGltcG9ydCgnLi9jb250cmFjdEdvdmVybmFuY2UvdHlwZWRQYXJhbU1hbmFnZXIuanMnKS5UeXBlZFBhcmFtTWFuYWdlcjx7J0VsZWN0b3JhdGUnOiAnaW52aXRhdGlvbid9Pj59ICovXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L3ByZWZlci10cy1leHBlY3QtZXJyb3IgLS0gdGhlIGJ1aWxkIGNvbmZpZyBkb2Vzbid0IGV4cGVjdCBhbiBlcnJvciBoZXJlKi9cbi8qIEB0cy1pZ25vcmUgY2FzdCovXG5jb25zdCBwYXJhbU1ncj1FKEUoY3JlYXRvckZhY2V0KS5nZXRQYXJhbU1nclJldHJpZXZlcigpKS5nZXQoe1xua2V5Oidnb3Zlcm5lZFBhcmFtcyd9KTtcblxuXG4vKiBUT0RPIHVzZSB1cGRhdGVFbGVjdG9yYXRlKi9cbnJldHVybiBFKHBhcmFtTWdyKS51cGRhdGVQYXJhbXMoe1xuRWxlY3RvcmF0ZTpwb3Nlckludml0YXRpb259KTtcblxuIH0sXG4vKiogQHR5cGUge1ZvdGVPblBhcmFtQ2hhbmdlc30gKi9cbnZvdGVPblBhcmFtQ2hhbmdlcyh2b3RlQ291bnRlckluc3RhbGxhdGlvbixkZWFkbGluZSxwYXJhbVNwZWMpe1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcbnJldHVybiBoZWxwZXIuXG5wcm92aWRlUGFyYW1Hb3Zlcm5hbmNlKCkuXG52b3RlT25QYXJhbUNoYW5nZXModm90ZUNvdW50ZXJJbnN0YWxsYXRpb24sZGVhZGxpbmUscGFyYW1TcGVjKTtcbiB9LFxuLyoqIEB0eXBlIHtWb3RlT25BcGlJbnZvY2F0aW9ufSAqL1xudm90ZU9uQXBpSW52b2NhdGlvbihcbmFwaU1ldGhvZE5hbWUsXG5tZXRob2RBcmdzLFxudm90ZUNvdW50ZXJJbnN0YWxsYXRpb24sXG5kZWFkbGluZSlcbntcbmNvbnN0e2hlbHBlcn09dGhpcy5mYWNldHM7XG5yZXR1cm4gRShoZWxwZXIucHJvdmlkZUFwaUdvdmVybmFuY2UoKSkudm90ZU9uQXBpSW52b2NhdGlvbihcbmFwaU1ldGhvZE5hbWUsXG5tZXRob2RBcmdzLFxudm90ZUNvdW50ZXJJbnN0YWxsYXRpb24sXG5kZWFkbGluZSk7XG5cbiB9LFxuLyoqIEB0eXBlIHtWb3RlT25PZmZlckZpbHRlcn0gKi9cbnZvdGVPbk9mZmVyRmlsdGVyKHZvdGVDb3VudGVySW5zdGFsbGF0aW9uLGRlYWRsaW5lLHN0cmluZ3Mpe1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcbnJldHVybiBoZWxwZXIuXG5wcm92aWRlRmlsdGVyR292ZXJuYW5jZSgpLlxudm90ZU9uRmlsdGVyKHZvdGVDb3VudGVySW5zdGFsbGF0aW9uLGRlYWRsaW5lLHN0cmluZ3MpO1xuIH0sXG5nZXRDcmVhdG9yRmFjZXQoKXtcbnJldHVybiB0aGlzLnN0YXRlLmxpbWl0ZWRDcmVhdG9yRmFjZXQ7XG4gfSxcbmdldEFkbWluRmFjZXQoKXtcbnJldHVybiB0aGlzLnN0YXRlLmFkbWluRmFjZXQ7XG4gfSxcbmdldEluc3RhbmNlKCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5pbnN0YW5jZTtcbiB9LFxuZ2V0UHVibGljRmFjZXQoKXtcbnJldHVybiB0aGlzLnN0YXRlLnB1YmxpY0ZhY2V0O1xuIH19LFxuXG5wdWJsaWM6e1xuZ2V0RWxlY3RvcmF0ZSgpe1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcbnJldHVybiBoZWxwZXIuZ2V0RWxlY3RvcmF0ZUluc3RhbmNlKCk7XG4gfSxcbmdldEdvdmVybmVkQ29udHJhY3QoKXtcbnJldHVybiB0aGlzLnN0YXRlLmluc3RhbmNlO1xuIH0sXG4vKiogQHBhcmFtIHtJbnN0YW5jZX0gY291bnRlciAqL1xuICAgICAgYXN5bmMgdmFsaWRhdGVWb3RlQ291bnRlcihjb3VudGVyKXtcbmNvbnN0e2hlbHBlcn09dGhpcy5mYWNldHM7XG5jb25zdCB2YWxpZGF0b3JzPVtcbkUuZ2V0KGhlbHBlci5wcm92aWRlQXBpR292ZXJuYW5jZSgpKSxcbmhlbHBlci5wcm92aWRlRmlsdGVyR292ZXJuYW5jZSgpLFxuaGVscGVyLnByb3ZpZGVQYXJhbUdvdmVybmFuY2UoKV07XG5cbmNvbnN0IGNoZWNrcz1hd2FpdCBQcm9taXNlLmFsbChcbnZhbGlkYXRvcnMubWFwKCh2YWxpZGF0ZSk9PkUodmFsaWRhdGUuY3JlYXRlZFF1ZXN0aW9uKShjb3VudGVyKSkpO1xuXG5cbmNoZWNrcy5zb21lKEJvb2xlYW4pfHxcbkZhaWwgYFZvdGVDb3VudGVyIHdhcyBub3QgY3JlYXRlZCBieSB0aGlzIGNvbnRyYWN0R292ZXJub3JgO1xuIH0sXG4vKiogQHBhcmFtIHtJbnN0YW5jZX0gcmVnUCAqL1xudmFsaWRhdGVFbGVjdG9yYXRlKHJlZ1Ape1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcbnJldHVybiBFLndoZW4ocmVnUCxhc3luYyhyZWcpPT57XG5jb25zdCBlbGVjdG9yYXRlSW5zdGFuY2U9YXdhaXQgaGVscGVyLmdldEVsZWN0b3JhdGVJbnN0YW5jZSgpO1xuYXNzZXJ0KFxucmVnPT09ZWxlY3RvcmF0ZUluc3RhbmNlLFxuXCJFbGVjdG9yYXRlIGRvZXNuJ3QgbWF0Y2ggbXkgRWxlY3RvcmF0ZVwiKTtcblxuIH0pO1xuIH0sXG4vKiogQHBhcmFtIHtDbG9zaW5nUnVsZX0gY2xvc2luZ1J1bGUgKi9cbnZhbGlkYXRlVGltZXIoY2xvc2luZ1J1bGUpe1xuYXNzZXJ0KFxuY2xvc2luZ1J1bGUudGltZXI9PT1wb3dlcnMudGltZXIsXG4nY2xvc2luZyBydWxlIG11c3QgdXNlIG15IHRpbWVyJyk7XG5cbiB9fX0pO1xuXG5cblxuXG5yZXR1cm4gbWFrZUNvbnRyYWN0R292ZXJub3JLaXQ7XG4gfTtcblxuLyoqIEB0eXBlZGVmIHtSZXR1cm5UeXBlPFJldHVyblR5cGU8dHlwZW9mIHByZXBhcmVDb250cmFjdEdvdmVybm9yS2l0Pj59IENvbnRyYWN0R292ZXJub3JLaXQgKi8kaOKAjV9vbmNlLnByZXBhcmVDb250cmFjdEdvdmVybm9yS2l0KHByZXBhcmVDb250cmFjdEdvdmVybm9yS2l0KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJwcmVwYXJlQ29udHJhY3RHb3Zlcm5vcktpdCI6WyJwcmVwYXJlQ29udHJhY3RHb3Zlcm5vcktpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABZt2/Ypw8AAKcPAAAwAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL3F1ZXN0aW9uLmpzeyJpbXBvcnRzIjpbIi4vdHlwZUd1YXJkcy5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3pvZS9zcmMvbWFrZUhhbmRsZS5qcyJdLCJleHBvcnRzIjpbIkNob2ljZU1ldGhvZCIsIkVsZWN0aW9uVHlwZSIsIlF1b3J1bVJ1bGUiLCJidWlsZFF1ZXN0aW9uIiwiY29lcmNlUXVlc3Rpb25TcGVjIiwicG9zaXRpb25JbmNsdWRlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlRXhvLG11c3RNYXRjaCxrZXlFUSxNLG1ha2VIYW5kbGUsUXVlc3Rpb25JLFF1ZXN0aW9uU3BlY1NoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm1ha2VFeG9cIiwgWyRo4oCNX2EgPT4gKG1ha2VFeG8gPSAkaOKAjV9hKV1dLFtcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJrZXlFUVwiLCBbJGjigI1fYSA9PiAoa2V5RVEgPSAkaOKAjV9hKV1dLFtcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy96b2Uvc3JjL21ha2VIYW5kbGUuanNcIiwgW1tcIm1ha2VIYW5kbGVcIiwgWyRo4oCNX2EgPT4gKG1ha2VIYW5kbGUgPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJRdWVzdGlvbklcIiwgWyRo4oCNX2EgPT4gKFF1ZXN0aW9uSSA9ICRo4oCNX2EpXV0sW1wiUXVlc3Rpb25TcGVjU2hhcGVcIiwgWyRo4oCNX2EgPT4gKFF1ZXN0aW9uU3BlY1NoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cbi8qIFRvcGljcyBiZWluZyB2b3RlZCBvbiBhcmUgJ1F1ZXN0aW9ucycuIEJlZm9yZSBhIFF1ZXN0aW9uIGlzIGtub3duIHRvIGEqL1xuLyogZWxlY3RvcmF0ZSwgdGhlIHBhcmFtZXRlcnMgY2FuIGJlIGRlc2NyaWJlZCB3aXRoIGEgUXVlc3Rpb25TcGVjLiBPbmNlIHRoZSovXG4vKiBxdWVzdGlvbiBoYXMgYmVlbiBwcmVzZW50ZWQgdG8gYW4gRWxlY3RvcmF0ZSwgdGhlcmUgaXMgYSBRdWVzdGlvbkRldGFpbHMqL1xuLyogcmVjb3JkIHRoYXQgYWxzbyBpbmNsdWRlcyB0aGUgVm90ZUNvdW50ZXIgd2hpY2ggd2lsbCBkZXRlcm1pbmUgdGhlIG91dGNvbWUqL1xuLyogYW5kIHRoZSBxdWVzdGlvbkhhbmRsZSB0aGF0IHVuaXF1ZWx5IGlkZW50aWZpZXMgaXQuKi9cblxuLyoqXG4gKiBcInVucmFua2VkXCIgaXMgbW9yZSBmb3JtYWxseSBrbm93biBhcyBcImFwcHJvdmFsXCIgdm90aW5nLCBidXQgdGhpcyBpcyBoYXJkIGZvclxuICogcGVvcGxlIHRvIGludHVpdCB3aGVuIHRoZXJlIGFyZSBvbmx5IHR3byBhbHRlcm5hdGl2ZXMuXG4gKi9cbmNvbnN0IENob2ljZU1ldGhvZD0vKiogQHR5cGUge2NvbnN0fSAqL3tcblVOUkFOS0VEOid1bnJhbmtlZCcsXG5PUkRFUjonb3JkZXInLFxuUExVUkFMSVRZOidwbHVyYWxpdHknfTskaOKAjV9vbmNlLkNob2ljZU1ldGhvZChDaG9pY2VNZXRob2QpO1xuXG5cbmNvbnN0IEVsZWN0aW9uVHlwZT0vKiogQHR5cGUge2NvbnN0fSAqL3tcbi8qIEEgcGFyYW1ldGVyIGlzIG5hbWVkLCBhbmQgYSBuZXcgdmFsdWUgcHJvcG9zZWQqL1xuUEFSQU1fQ0hBTkdFOidwYXJhbV9jaGFuZ2UnLFxuLyogY2hvb3NlIG9uZSBvciBtdWx0aXBsZSB3aW5uZXJzLCBkZXBlbmRpbmcgb24gQ2hvaWNlTWV0aG9kKi9cbkVMRUNUSU9OOidlbGVjdGlvbicsXG5TVVJWRVk6J3N1cnZleScsXG4vKiB3aGV0aGVyIG9yIG5vdCB0byBpbnZva2UgYW4gQVBJIG1ldGhvZCovXG5BUElfSU5WT0NBVElPTjonYXBpX2ludm9jYXRpb24nLFxuT0ZGRVJfRklMVEVSOidvZmZlcl9maWx0ZXInfTskaOKAjV9vbmNlLkVsZWN0aW9uVHlwZShFbGVjdGlvblR5cGUpO1xuXG5cbmNvbnN0IFF1b3J1bVJ1bGU9LyoqIEB0eXBlIHtjb25zdH0gKi97XG5NQUpPUklUWTonbWFqb3JpdHknLFxuTk9fUVVPUlVNOidub19xdW9ydW0nLFxuLyogVGhlIGVsZWN0aW9uIGlzbid0IHZhbGlkIHVubGVzcyBhbGwgdm90ZXJzIHZvdGUqL1xuQUxMOidhbGwnfTtcblxuXG4vKiogQHR5cGUge1Bvc2l0aW9uSW5jbHVkZWR9ICovJGjigI1fb25jZS5RdW9ydW1SdWxlKFF1b3J1bVJ1bGUpO1xuY29uc3QgcG9zaXRpb25JbmNsdWRlZD0ocG9zaXRpb25zLHApPT5wb3NpdGlvbnMuc29tZSgoZSk9PmtleUVRKGUscCkpO1xuXG4vKipcbiAqIEBwYXJhbSB7UXVlc3Rpb25TcGVjfSBhbGxlZ2VkUXVlc3Rpb25TcGVjXG4gKiBAcmV0dXJucyB7UXVlc3Rpb25TcGVjfVxuICovJGjigI1fb25jZS5wb3NpdGlvbkluY2x1ZGVkKHBvc2l0aW9uSW5jbHVkZWQpO1xuY29uc3QgY29lcmNlUXVlc3Rpb25TcGVjPSh7XG5tZXRob2QsXG5pc3N1ZSxcbnBvc2l0aW9ucyxcbmVsZWN0aW9uVHlwZSxcbm1heENob2ljZXMsXG5tYXhXaW5uZXJzLFxuY2xvc2luZ1J1bGUsXG5xdW9ydW1SdWxlLFxudGllT3V0Y29tZX0pPT5cbntcbmNvbnN0IHF1ZXN0aW9uPWhhcmRlbih7XG5tZXRob2QsXG5pc3N1ZSxcbnBvc2l0aW9ucyxcbm1heENob2ljZXM6TnVtYmVyKG1heENob2ljZXMpLFxubWF4V2lubmVyczpOdW1iZXIobWF4V2lubmVycyksXG5lbGVjdGlvblR5cGUsXG5jbG9zaW5nUnVsZSxcbnF1b3J1bVJ1bGUsXG50aWVPdXRjb21lfSk7XG5cblxubXVzdE1hdGNoKHF1ZXN0aW9uLFF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuLyogWFhYIEl0IHdvdWxkIGJlIG5pY2UgdG8gZW5mb3JjZSB0aGlzIHVzaW5nIHBhcmFtZXRlcml6ZWQgdHlwZXMsIGJ1dCB0aGF0Ki9cbi8qIHNlZW1zIHRvIG9ubHkgZW5mb3JjZSB0eXBlIGNvbnN0cmFpbnRzLCAoaS5lLiB0aGUgdGllT3V0Y29tZSB3aWxsIGJlIHRoZSovXG4vKiBzYW1lIHR5cGUgYXMgYW55IG9mIHRoZSBwb3NpdGlvbnMpIHVubGVzcyB5b3UgY2FuIHByb3ZpZGUgdGhlIGNvbmNyZXRlKi9cbi8qIHZhbHVlIGF0IHBhdHRlcm4gY3JlYXRpb24gdGltZS4qL1xubXVzdE1hdGNoKHF1ZXN0aW9uLnRpZU91dGNvbWUsTS5vciguLi5xdWVzdGlvbi5wb3NpdGlvbnMpKTtcblxucmV0dXJuIHF1ZXN0aW9uO1xuIH07XG5cbi8qKiBAdHlwZSB7QnVpbGRRdWVzdGlvbn0gKi8kaOKAjV9vbmNlLmNvZXJjZVF1ZXN0aW9uU3BlYyhjb2VyY2VRdWVzdGlvblNwZWMpO1xuY29uc3QgYnVpbGRRdWVzdGlvbj0ocXVlc3Rpb25TcGVjLGNvdW50ZXJJbnN0YW5jZSk9PntcbmNvbnN0IHF1ZXN0aW9uSGFuZGxlPW1ha2VIYW5kbGUoJ1F1ZXN0aW9uJyk7XG5cbi8qKiBAdHlwZSB7UXVlc3Rpb259ICovXG5yZXR1cm4gbWFrZUV4bygncXVlc3Rpb24gZGV0YWlscycsUXVlc3Rpb25JLHtcbmdldFZvdGVDb3VudGVyKCl7XG5yZXR1cm4gY291bnRlckluc3RhbmNlO1xuIH0sXG5nZXREZXRhaWxzKCl7XG5yZXR1cm4gaGFyZGVuKHtcbi4uLnF1ZXN0aW9uU3BlYyxcbnF1ZXN0aW9uSGFuZGxlLFxuY291bnRlckluc3RhbmNlfSk7XG5cbiB9fSk7XG5cbiB9OyRo4oCNX29uY2UuYnVpbGRRdWVzdGlvbihidWlsZFF1ZXN0aW9uKTtcblxuaGFyZGVuKGJ1aWxkUXVlc3Rpb24pO1xuaGFyZGVuKENob2ljZU1ldGhvZCk7XG5oYXJkZW4oRWxlY3Rpb25UeXBlKTtcbmhhcmRlbihjb2VyY2VRdWVzdGlvblNwZWMpO1xuaGFyZGVuKHBvc2l0aW9uSW5jbHVkZWQpO1xuaGFyZGVuKFF1b3J1bVJ1bGUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNob2ljZU1ldGhvZCI6WyJDaG9pY2VNZXRob2QiXSwiRWxlY3Rpb25UeXBlIjpbIkVsZWN0aW9uVHlwZSJdLCJRdW9ydW1SdWxlIjpbIlF1b3J1bVJ1bGUiXSwicG9zaXRpb25JbmNsdWRlZCI6WyJwb3NpdGlvbkluY2x1ZGVkIl0sImNvZXJjZVF1ZXN0aW9uU3BlYyI6WyJjb2VyY2VRdWVzdGlvblNwZWMiXSwiYnVpbGRRdWVzdGlvbiI6WyJidWlsZFF1ZXN0aW9uIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJ7Q0hMoOwAAKDsAADIAAABAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvdHlwZUd1YXJkcy5qc3siaW1wb3J0cyI6WyJAYWdvcmljL25vdGlmaWVyIiwiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvdGltZSIsIkBhZ29yaWMvem9lL3NyYy90eXBlR3VhcmRzLmpzIl0sImV4cG9ydHMiOlsiQXBpSW52b2NhdGlvblBvc2l0aW9uc1NoYXBlIiwiQXBpSW52b2NhdGlvblF1ZXN0aW9uRGV0YWlsc1NoYXBlIiwiQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlIiwiQmluYXJ5Vm90ZUNvdW50ZXJBZG1pbkkiLCJCaW5hcnlWb3RlQ291bnRlckNsb3NlSSIsIkJpbmFyeVZvdGVDb3VudGVyUHVibGljSSIsIkNob2ljZU1ldGhvZFNoYXBlIiwiQ2xvc2luZ1J1bGVTaGFwZSIsIkVsZWN0aW9uVHlwZVNoYXBlIiwiRWxlY3RvcmF0ZUNyZWF0b3JJIiwiRWxlY3RvcmF0ZVB1YmxpY0kiLCJHb3Zlcm5vckZhY2V0U2hhcGUiLCJJbnZpdGF0aW9uU2hhcGUiLCJOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlIiwiTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGUiLCJOb1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUiLCJOb1NpbXBsZVBvc2l0aW9uU2hhcGUiLCJPZmZlckZpbHRlcklzc3VlU2hhcGUiLCJPZmZlckZpbHRlclBvc2l0aW9uc1NoYXBlIiwiT2ZmZXJGaWx0ZXJRdWVzdGlvbkRldGFpbHNTaGFwZSIsIk9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGUiLCJQYXJhbUNoYW5nZXNJc3N1ZVNoYXBlIiwiUGFyYW1DaGFuZ2VzUG9zaXRpb25zU2hhcGUiLCJQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZSIsIlBhcmFtQ2hhbmdlc1F1ZXN0aW9uU3BlY1NoYXBlIiwiUGFyYW1DaGFuZ2VzU3BlY1NoYXBlIiwiUGFyYW1QYXRoU2hhcGUiLCJQb3NpdGlvblNoYXBlIiwiUXVlc3Rpb25EZXRhaWxzU2hhcGUiLCJRdWVzdGlvbkhhbmRsZVNoYXBlIiwiUXVlc3Rpb25JIiwiUXVlc3Rpb25TcGVjU2hhcGUiLCJRdWVzdGlvblN0YXRzU2hhcGUiLCJRdW9ydW1SdWxlU2hhcGUiLCJTaW1wbGVJc3N1ZVNoYXBlIiwiU2ltcGxlUG9zaXRpb25zU2hhcGUiLCJTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSIsIlNpbXBsZVF1ZXN0aW9uU3BlY1NoYXBlIiwiVm90ZUNvdW50ZXJBZG1pbkkiLCJWb3RlQ291bnRlckNsb3NlSSIsIlZvdGVDb3VudGVyUHVibGljSSIsIlZvdGVySGFuZGxlIiwiWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUiLCJZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGUiLCJZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlIiwiWWVzU2ltcGxlUG9zaXRpb25TaGFwZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLFRpbWVzdGFtcFNoYXBlLEluc3RhbmNlSGFuZGxlU2hhcGUsVGltZXJTaGFwZSxtYWtlSGFuZGxlU2hhcGUsU3Vic2NyaWJlclNoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy90aW1lXCIsIFtbXCJUaW1lc3RhbXBTaGFwZVwiLCBbJGjigI1fYSA9PiAoVGltZXN0YW1wU2hhcGUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy96b2Uvc3JjL3R5cGVHdWFyZHMuanNcIiwgW1tcIkluc3RhbmNlSGFuZGxlU2hhcGVcIiwgWyRo4oCNX2EgPT4gKEluc3RhbmNlSGFuZGxlU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlRpbWVyU2hhcGVcIiwgWyRo4oCNX2EgPT4gKFRpbWVyU2hhcGUgPSAkaOKAjV9hKV1dLFtcIm1ha2VIYW5kbGVTaGFwZVwiLCBbJGjigI1fYSA9PiAobWFrZUhhbmRsZVNoYXBlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvbm90aWZpZXJcIiwgW1tcIlN1YnNjcmliZXJTaGFwZVwiLCBbJGjigI1fYSA9PiAoU3Vic2NyaWJlclNoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuY29uc3QgICAgICAgIENob2ljZU1ldGhvZFNoYXBlPU0ub3IoJ3VucmFua2VkJywnb3JkZXInLCdwbHVyYWxpdHknKTskaOKAjV9vbmNlLkNob2ljZU1ldGhvZFNoYXBlKENob2ljZU1ldGhvZFNoYXBlKTtcbmNvbnN0ICAgICAgICBRdW9ydW1SdWxlU2hhcGU9TS5vcignbWFqb3JpdHknLCdub19xdW9ydW0nLCdhbGwnKTskaOKAjV9vbmNlLlF1b3J1bVJ1bGVTaGFwZShRdW9ydW1SdWxlU2hhcGUpO1xuY29uc3QgICAgICAgIEVsZWN0aW9uVHlwZVNoYXBlPU0ub3IoXG4ncGFyYW1fY2hhbmdlJyxcbidlbGVjdGlvbicsXG4nc3VydmV5JyxcbidhcGlfaW52b2NhdGlvbicsXG4nb2ZmZXJfZmlsdGVyJyk7JGjigI1fb25jZS5FbGVjdGlvblR5cGVTaGFwZShFbGVjdGlvblR5cGVTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIENsb3NpbmdSdWxlU2hhcGU9aGFyZGVuKHtcbnRpbWVyOk0uZXJlZihUaW1lclNoYXBlKSxcbmRlYWRsaW5lOlRpbWVzdGFtcFNoYXBlfSk7XG5cblxuLyogYWxsIHRoZSBzdHJpbmdzIHRoYXQgd2lsbCBiZSBpbiB0aGUgZmlsdGVyIGFmdGVyIHBhc3NpbmcqLyRo4oCNX29uY2UuQ2xvc2luZ1J1bGVTaGFwZShDbG9zaW5nUnVsZVNoYXBlKTtcbmNvbnN0ICAgICAgICBZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGU9aGFyZGVuKHtcbnN0cmluZ3M6TS5hcnJheU9mKE0uc3RyaW5nKCkpfSk7JGjigI1fb25jZS5ZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGUoWWVzT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlKTtcblxuY29uc3QgICAgICAgIE5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlPWhhcmRlbih7XG5kb250VXBkYXRlOk0uYXJyYXlPZihNLnN0cmluZygpKX0pOyRo4oCNX29uY2UuTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGUoTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGUpO1xuXG5jb25zdCAgICAgICAgT2ZmZXJGaWx0ZXJQb3NpdGlvbnNTaGFwZT1oYXJkZW4oW1xuWWVzT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlLFxuTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGVdKTskaOKAjV9vbmNlLk9mZmVyRmlsdGVyUG9zaXRpb25zU2hhcGUoT2ZmZXJGaWx0ZXJQb3NpdGlvbnNTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBPZmZlckZpbHRlcklzc3VlU2hhcGU9aGFyZGVuKHtcbnN0cmluZ3M6TS5hcnJheU9mKE0uc3RyaW5nKCkpfSk7JGjigI1fb25jZS5PZmZlckZpbHRlcklzc3VlU2hhcGUoT2ZmZXJGaWx0ZXJJc3N1ZVNoYXBlKTtcblxuY29uc3QgICAgICAgIE9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGU9aGFyZGVuKHtcbm1ldGhvZDpDaG9pY2VNZXRob2RTaGFwZSxcbmlzc3VlOk9mZmVyRmlsdGVySXNzdWVTaGFwZSxcbnBvc2l0aW9uczpPZmZlckZpbHRlclBvc2l0aW9uc1NoYXBlLFxuZWxlY3Rpb25UeXBlOidvZmZlcl9maWx0ZXInLFxubWF4Q2hvaWNlczoxLFxubWF4V2lubmVyczoxLFxuY2xvc2luZ1J1bGU6Q2xvc2luZ1J1bGVTaGFwZSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZVNoYXBlLFxudGllT3V0Y29tZTpOb09mZmVyRmlsdGVyUG9zaXRpb25TaGFwZX0pOyRo4oCNX29uY2UuT2ZmZXJGaWx0ZXJRdWVzdGlvblNwZWNTaGFwZShPZmZlckZpbHRlclF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuY29uc3QgICAgICAgIE9mZmVyRmlsdGVyUXVlc3Rpb25EZXRhaWxzU2hhcGU9aGFyZGVuKHtcbi4uLk9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGUsXG5xdWVzdGlvbkhhbmRsZTptYWtlSGFuZGxlU2hhcGUoJ1F1ZXN0aW9uJyksXG5jb3VudGVySW5zdGFuY2U6SW5zdGFuY2VIYW5kbGVTaGFwZX0pO1xuXG5cbi8qIGtleXMgYXJlIHBhcmFtZXRlciBuYW1lcywgdmFsdWVzIGFyZSBwcm9wb3NlZCB2YWx1ZXMqLyRo4oCNX29uY2UuT2ZmZXJGaWx0ZXJRdWVzdGlvbkRldGFpbHNTaGFwZShPZmZlckZpbHRlclF1ZXN0aW9uRGV0YWlsc1NoYXBlKTtcbmNvbnN0ICAgICAgICBQYXJhbUNoYW5nZXNTcGVjU2hhcGU9TS5yZWNvcmRPZihNLnN0cmluZygpLE0uYW55KCkpOyRo4oCNX29uY2UuUGFyYW1DaGFuZ2VzU3BlY1NoYXBlKFBhcmFtQ2hhbmdlc1NwZWNTaGFwZSk7XG5jb25zdCAgICAgICAgWWVzUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZT1QYXJhbUNoYW5nZXNTcGVjU2hhcGU7JGjigI1fb25jZS5ZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlKFllc1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUpO1xuY29uc3QgICAgICAgIE5vUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZT1oYXJkZW4oe1xubm9DaGFuZ2U6TS5hcnJheU9mKE0uc3RyaW5nKCkpfSk7JGjigI1fb25jZS5Ob1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUoTm9QYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlKTtcblxuY29uc3QgICAgICAgIFBhcmFtQ2hhbmdlc1Bvc2l0aW9uc1NoYXBlPWhhcmRlbihbXG5ZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlLFxuTm9QYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlXSk7JGjigI1fb25jZS5QYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZShQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBQYXJhbVBhdGhTaGFwZT1oYXJkZW4oe1xua2V5Ok0uYW55KCl9KTskaOKAjV9vbmNlLlBhcmFtUGF0aFNoYXBlKFBhcmFtUGF0aFNoYXBlKTtcblxuY29uc3QgICAgICAgIFBhcmFtQ2hhbmdlc0lzc3VlU2hhcGU9aGFyZGVuKHtcbnNwZWM6e1xucGFyYW1QYXRoOlBhcmFtUGF0aFNoYXBlLFxuY2hhbmdlczpQYXJhbUNoYW5nZXNTcGVjU2hhcGV9LFxuXG5jb250cmFjdDpJbnN0YW5jZUhhbmRsZVNoYXBlfSk7JGjigI1fb25jZS5QYXJhbUNoYW5nZXNJc3N1ZVNoYXBlKFBhcmFtQ2hhbmdlc0lzc3VlU2hhcGUpO1xuXG5jb25zdCAgICAgICAgUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGU9aGFyZGVuKHtcbm1ldGhvZDondW5yYW5rZWQnLFxuaXNzdWU6UGFyYW1DaGFuZ2VzSXNzdWVTaGFwZSxcbnBvc2l0aW9uczpQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSxcbmVsZWN0aW9uVHlwZToncGFyYW1fY2hhbmdlJyxcbm1heENob2ljZXM6MSxcbm1heFdpbm5lcnM6MSxcbmNsb3NpbmdSdWxlOkNsb3NpbmdSdWxlU2hhcGUsXG5xdW9ydW1SdWxlOidtYWpvcml0eScsXG50aWVPdXRjb21lOk5vUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZX0pOyRo4oCNX29uY2UuUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUoUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZT1oYXJkZW4oe1xuLi4uUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUsXG5xdWVzdGlvbkhhbmRsZTptYWtlSGFuZGxlU2hhcGUoJ1F1ZXN0aW9uJyksXG5jb3VudGVySW5zdGFuY2U6SW5zdGFuY2VIYW5kbGVTaGFwZX0pOyRo4oCNX29uY2UuUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUoUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUpO1xuXG5cbmNvbnN0IEFwaUludm9jYXRpb25TcGVjU2hhcGU9aGFyZGVuKHtcbmFwaU1ldGhvZE5hbWU6TS5zdHJpbmcoKSxcbm1ldGhvZEFyZ3M6TS5hcnJheU9mKE0uYW55KCkpfSk7XG5cbmNvbnN0ICAgICAgICBZZXNBcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZT1BcGlJbnZvY2F0aW9uU3BlY1NoYXBlOyRo4oCNX29uY2UuWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUoWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUpO1xuY29uc3QgICAgICAgIE5vQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGU9aGFyZGVuKHtcbmRvbnRJbnZva2U6TS5zdHJpbmcoKX0pOyRo4oCNX29uY2UuTm9BcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZShOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlKTtcblxuY29uc3QgICAgICAgIEFwaUludm9jYXRpb25Qb3NpdGlvbnNTaGFwZT1oYXJkZW4oW1xuWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUsXG5Ob0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlXSk7JGjigI1fb25jZS5BcGlJbnZvY2F0aW9uUG9zaXRpb25zU2hhcGUoQXBpSW52b2NhdGlvblBvc2l0aW9uc1NoYXBlKTtcblxuY29uc3QgICAgICAgIEFwaUludm9jYXRpb25RdWVzdGlvblNwZWNTaGFwZT1oYXJkZW4oe1xubWV0aG9kOid1bnJhbmtlZCcsXG5pc3N1ZTpBcGlJbnZvY2F0aW9uU3BlY1NoYXBlLFxucG9zaXRpb25zOkFwaUludm9jYXRpb25Qb3NpdGlvbnNTaGFwZSxcbmVsZWN0aW9uVHlwZTonYXBpX2ludm9jYXRpb24nLFxubWF4Q2hvaWNlczoxLFxubWF4V2lubmVyczoxLFxuY2xvc2luZ1J1bGU6Q2xvc2luZ1J1bGVTaGFwZSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZVNoYXBlLFxudGllT3V0Y29tZTpOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlfSk7JGjigI1fb25jZS5BcGlJbnZvY2F0aW9uUXVlc3Rpb25TcGVjU2hhcGUoQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuY29uc3QgICAgICAgIEFwaUludm9jYXRpb25RdWVzdGlvbkRldGFpbHNTaGFwZT1oYXJkZW4oe1xuLi4uQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlLFxucXVlc3Rpb25IYW5kbGU6bWFrZUhhbmRsZVNoYXBlKCdRdWVzdGlvbicpLFxuY291bnRlckluc3RhbmNlOkluc3RhbmNlSGFuZGxlU2hhcGV9KTskaOKAjV9vbmNlLkFwaUludm9jYXRpb25RdWVzdGlvbkRldGFpbHNTaGFwZShBcGlJbnZvY2F0aW9uUXVlc3Rpb25EZXRhaWxzU2hhcGUpO1xuXG5cbmNvbnN0IFNpbXBsZVNwZWNTaGFwZT1oYXJkZW4oe1xudGV4dDpNLnN0cmluZygpfSk7XG5cbmNvbnN0ICAgICAgICBZZXNTaW1wbGVQb3NpdGlvblNoYXBlPWhhcmRlbih7dGV4dDpNLnN0cmluZygpfSk7JGjigI1fb25jZS5ZZXNTaW1wbGVQb3NpdGlvblNoYXBlKFllc1NpbXBsZVBvc2l0aW9uU2hhcGUpO1xuY29uc3QgICAgICAgIE5vU2ltcGxlUG9zaXRpb25TaGFwZT1oYXJkZW4oe3RleHQ6TS5zdHJpbmcoKX0pOyRo4oCNX29uY2UuTm9TaW1wbGVQb3NpdGlvblNoYXBlKE5vU2ltcGxlUG9zaXRpb25TaGFwZSk7XG5jb25zdCAgICAgICAgU2ltcGxlUG9zaXRpb25zU2hhcGU9aGFyZGVuKFtcblllc1NpbXBsZVBvc2l0aW9uU2hhcGUsXG5Ob1NpbXBsZVBvc2l0aW9uU2hhcGVdKTskaOKAjV9vbmNlLlNpbXBsZVBvc2l0aW9uc1NoYXBlKFNpbXBsZVBvc2l0aW9uc1NoYXBlKTtcblxuY29uc3QgICAgICAgIFNpbXBsZUlzc3VlU2hhcGU9U2ltcGxlU3BlY1NoYXBlOyRo4oCNX29uY2UuU2ltcGxlSXNzdWVTaGFwZShTaW1wbGVJc3N1ZVNoYXBlKTtcbmNvbnN0ICAgICAgICBTaW1wbGVRdWVzdGlvblNwZWNTaGFwZT1oYXJkZW4oe1xubWV0aG9kOkNob2ljZU1ldGhvZFNoYXBlLFxuaXNzdWU6U2ltcGxlSXNzdWVTaGFwZSxcbnBvc2l0aW9uczpNLmFycmF5T2YoaGFyZGVuKHt0ZXh0Ok0uc3RyaW5nKCl9KSksXG5lbGVjdGlvblR5cGU6TS5vcignZWxlY3Rpb24nLCdzdXJ2ZXknKSxcbm1heENob2ljZXM6TS5ndGUoMSksXG5tYXhXaW5uZXJzOk0uZ3RlKDEpLFxuY2xvc2luZ1J1bGU6Q2xvc2luZ1J1bGVTaGFwZSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZVNoYXBlLFxudGllT3V0Y29tZTpOb1NpbXBsZVBvc2l0aW9uU2hhcGV9KTskaOKAjV9vbmNlLlNpbXBsZVF1ZXN0aW9uU3BlY1NoYXBlKFNpbXBsZVF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuY29uc3QgICAgICAgIFNpbXBsZVF1ZXN0aW9uRGV0YWlsc1NoYXBlPWhhcmRlbih7XG4uLi5TaW1wbGVRdWVzdGlvblNwZWNTaGFwZSxcbnF1ZXN0aW9uSGFuZGxlOm1ha2VIYW5kbGVTaGFwZSgnUXVlc3Rpb24nKSxcbmNvdW50ZXJJbnN0YW5jZTpJbnN0YW5jZUhhbmRsZVNoYXBlfSk7JGjigI1fb25jZS5TaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZShTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIFF1ZXN0aW9uU3BlY1NoYXBlPU0ub3IoXG5BcGlJbnZvY2F0aW9uUXVlc3Rpb25TcGVjU2hhcGUsXG5PZmZlckZpbHRlclF1ZXN0aW9uU3BlY1NoYXBlLFxuUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUsXG5TaW1wbGVRdWVzdGlvblNwZWNTaGFwZSk7JGjigI1fb25jZS5RdWVzdGlvblNwZWNTaGFwZShRdWVzdGlvblNwZWNTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIFBvc2l0aW9uU2hhcGU9TS5vcihcblllc0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlLFxuTm9BcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZSxcblllc09mZmVyRmlsdGVyUG9zaXRpb25TaGFwZSxcbk5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlLFxuWWVzU2ltcGxlUG9zaXRpb25TaGFwZSxcbk5vU2ltcGxlUG9zaXRpb25TaGFwZSxcblllc1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUsXG5Ob1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUpOyRo4oCNX29uY2UuUG9zaXRpb25TaGFwZShQb3NpdGlvblNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgUXVlc3Rpb25IYW5kbGVTaGFwZT1tYWtlSGFuZGxlU2hhcGUoJ3F1ZXN0aW9uJyk7XG5cbi8qIFRPRE8oaGliYmVydCk6IGFkZCBkZXRhaWxzOyBtb3ZlIHRvIGEgbW9yZSBhcHByb3ByaWF0ZSBsb2NhdGlvbiovJGjigI1fb25jZS5RdWVzdGlvbkhhbmRsZVNoYXBlKFF1ZXN0aW9uSGFuZGxlU2hhcGUpO1xuY29uc3QgICAgICAgIEludml0YXRpb25TaGFwZT1NLnJlbW90YWJsZSgnSW52aXRhdGlvbicpO1xuXG4vKiBYWFggSSB3YW50IHRvIGFkZCBxdWVzdGlvbkhhbmRsZSBhbmQgY291bnRlckluc3RhbmNlIHRvKi9cbi8qIFBhcmFtQ2hhbmdlc1F1ZXN0aW9uU3BlY1NoYXBlLiBJIGRvbid0IHNlZSBhbnkgYWx0ZXJuYXRpdmUgdG8gYWRkaW5nIHRoZSovXG4vKiBtZXRob2RzIHRvIGVhY2ggbWVtYmVyIHNlcGFyYXRlbHkqLyRo4oCNX29uY2UuSW52aXRhdGlvblNoYXBlKEludml0YXRpb25TaGFwZSk7XG5jb25zdCAgICAgICAgUXVlc3Rpb25EZXRhaWxzU2hhcGU9TS5vcihcblBhcmFtQ2hhbmdlc1F1ZXN0aW9uRGV0YWlsc1NoYXBlLFxuQXBpSW52b2NhdGlvblF1ZXN0aW9uRGV0YWlsc1NoYXBlLFxuT2ZmZXJGaWx0ZXJRdWVzdGlvbkRldGFpbHNTaGFwZSxcblNpbXBsZVF1ZXN0aW9uRGV0YWlsc1NoYXBlKTskaOKAjV9vbmNlLlF1ZXN0aW9uRGV0YWlsc1NoYXBlKFF1ZXN0aW9uRGV0YWlsc1NoYXBlKTtcblxuXG5jb25zdCAgICAgICAgRWxlY3RvcmF0ZVB1YmxpY0k9TS5pbnRlcmZhY2UoJ0NvbW1pdHRlZSBQdWJsaWNGYWNldCcse1xuZ2V0UXVlc3Rpb25TdWJzY3JpYmVyOk0uY2FsbCgpLnJldHVybnMoU3Vic2NyaWJlclNoYXBlKSxcbmdldE9wZW5RdWVzdGlvbnM6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXROYW1lOk0uY2FsbCgpLnJldHVybnMoTS5zdHJpbmcoKSksXG5nZXRJbnN0YW5jZTpNLmNhbGwoKS5yZXR1cm5zKEluc3RhbmNlSGFuZGxlU2hhcGUpLFxuZ2V0UXVlc3Rpb246TS5jYWxsKFF1ZXN0aW9uSGFuZGxlU2hhcGUpLnJldHVybnMoTS5wcm9taXNlKCkpfSk7JGjigI1fb25jZS5FbGVjdG9yYXRlUHVibGljSShFbGVjdG9yYXRlUHVibGljSSk7XG5cbmNvbnN0IEVsZWN0b3JhdGVQdWJsaWNTaGFwZT1NLnJlbW90YWJsZSgnRWxlY3RvcmF0ZVB1YmxpYycpO1xuXG5jb25zdCAgICAgICAgRWxlY3RvcmF0ZUNyZWF0b3JJPU0uaW50ZXJmYWNlKCdDb21taXR0ZWUgQWRtaW5GYWNldCcse1xuZ2V0UG9zZXJJbnZpdGF0aW9uOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuYWRkUXVlc3Rpb246TS5jYWxsKEluc3RhbmNlSGFuZGxlU2hhcGUsUXVlc3Rpb25TcGVjU2hhcGUpLnJldHVybnMoXG5NLnByb21pc2UoKSksXG5cbmdldFZvdGVySW52aXRhdGlvbnM6TS5jYWxsKCkucmV0dXJucyhNLmFycmF5T2YoTS5wcm9taXNlKCkpKSxcbmdldFF1ZXN0aW9uU3Vic2NyaWJlcjpNLmNhbGwoKS5yZXR1cm5zKFN1YnNjcmliZXJTaGFwZSksXG5nZXRQdWJsaWNGYWNldDpNLmNhbGwoKS5yZXR1cm5zKEVsZWN0b3JhdGVQdWJsaWNTaGFwZSl9KTskaOKAjV9vbmNlLkVsZWN0b3JhdGVDcmVhdG9ySShFbGVjdG9yYXRlQ3JlYXRvckkpO1xuXG5cbmNvbnN0ICAgICAgICBRdWVzdGlvblN0YXRzU2hhcGU9aGFyZGVuKHtcbnNwb2lsZWQ6TS5uYXQoKSxcbnZvdGVzOk0ubmF0KCksXG5yZXN1bHRzOk0uYXJyYXlPZih7cG9zaXRpb246UG9zaXRpb25TaGFwZSx0b3RhbDpNLm5hdCgpfSl9KTskaOKAjV9vbmNlLlF1ZXN0aW9uU3RhdHNTaGFwZShRdWVzdGlvblN0YXRzU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBRdWVzdGlvbkk9TS5pbnRlcmZhY2UoJ1F1ZXN0aW9uJyx7XG5nZXRWb3RlQ291bnRlcjpNLmNhbGwoKS5yZXR1cm5zKEluc3RhbmNlSGFuZGxlU2hhcGUpLFxuZ2V0RGV0YWlsczpNLmNhbGwoKS5yZXR1cm5zKFF1ZXN0aW9uRGV0YWlsc1NoYXBlKX0pOyRo4oCNX29uY2UuUXVlc3Rpb25JKFF1ZXN0aW9uSSk7XG5cbmNvbnN0IFF1ZXN0aW9uU2hhcGU9TS5yZW1vdGFibGUoJ1F1ZXN0aW9uJyk7XG5cbmNvbnN0ICAgICAgICBCaW5hcnlWb3RlQ291bnRlclB1YmxpY0k9TS5pbnRlcmZhY2UoXG4nQmluYXJ5Vm90ZUNvdW50ZXIgUHVibGljRmFjZXQnLFxue1xuZ2V0UXVlc3Rpb246TS5jYWxsKCkucmV0dXJucyhRdWVzdGlvblNoYXBlKSxcbmlzT3BlbjpNLmNhbGwoKS5yZXR1cm5zKE0uYm9vbGVhbigpKSxcbmdldE91dGNvbWU6TS5jYWxsKCkucmV0dXJucyhNLmVyZWYoTS5wcm9taXNlKCkpKSxcbmdldFN0YXRzOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0RGV0YWlsczpNLmNhbGwoKS5yZXR1cm5zKFF1ZXN0aW9uRGV0YWlsc1NoYXBlKSxcbmdldEluc3RhbmNlOk0uY2FsbCgpLnJldHVybnMoSW5zdGFuY2VIYW5kbGVTaGFwZSl9KTskaOKAjV9vbmNlLkJpbmFyeVZvdGVDb3VudGVyUHVibGljSShCaW5hcnlWb3RlQ291bnRlclB1YmxpY0kpO1xuXG5cblxuY29uc3QgICAgICAgIFZvdGVySGFuZGxlPU0ucmVtb3RhYmxlKCk7JGjigI1fb25jZS5Wb3RlckhhbmRsZShWb3RlckhhbmRsZSk7XG5jb25zdCAgICAgICAgQmluYXJ5Vm90ZUNvdW50ZXJBZG1pbkk9TS5pbnRlcmZhY2UoXG4nQmluYXJ5Vm90ZUNvdW50ZXIgQWRtaW5GYWNldCcsXG57XG5zdWJtaXRWb3RlOk0uY2FsbChWb3RlckhhbmRsZSxNLmFycmF5T2YoUG9zaXRpb25TaGFwZSkpLlxub3B0aW9uYWwoTS5uYXQoKSkuXG5yZXR1cm5zKHtjaG9zZW46UG9zaXRpb25TaGFwZSxzaGFyZXM6TS5uYXQoKX0pfSk7JGjigI1fb25jZS5CaW5hcnlWb3RlQ291bnRlckFkbWluSShCaW5hcnlWb3RlQ291bnRlckFkbWluSSk7XG5cblxuXG5jb25zdCAgICAgICAgQmluYXJ5Vm90ZUNvdW50ZXJDbG9zZUk9TS5pbnRlcmZhY2UoXG4nQmluYXJ5Vm90ZUNvdW50ZXIgQ2xvc2VGYWNldCcsXG57XG5jbG9zZVZvdGluZzpNLmNhbGwoKS5yZXR1cm5zKCl9KTskaOKAjV9vbmNlLkJpbmFyeVZvdGVDb3VudGVyQ2xvc2VJKEJpbmFyeVZvdGVDb3VudGVyQ2xvc2VJKTtcblxuXG5cbmNvbnN0ICAgICAgICBWb3RlQ291bnRlclB1YmxpY0k9TS5pbnRlcmZhY2UoJ1ZvdGVDb3VudGVyIFB1YmxpY0ZhY2V0Jyx7XG5nZXRRdWVzdGlvbjpNLmNhbGwoKS5yZXR1cm5zKFF1ZXN0aW9uU2hhcGUpLFxuaXNPcGVuOk0uY2FsbCgpLnJldHVybnMoTS5ib29sZWFuKCkpLFxuZ2V0T3V0Y29tZTpNLmNhbGwoKS5yZXR1cm5zKE0uZXJlZihNLnByb21pc2UoKSkpLFxuZ2V0U3RhdHM6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXREZXRhaWxzOk0uY2FsbCgpLnJldHVybnMoUXVlc3Rpb25EZXRhaWxzU2hhcGUpLFxuZ2V0SW5zdGFuY2U6TS5jYWxsKCkucmV0dXJucyhJbnN0YW5jZUhhbmRsZVNoYXBlKX0pOyRo4oCNX29uY2UuVm90ZUNvdW50ZXJQdWJsaWNJKFZvdGVDb3VudGVyUHVibGljSSk7XG5cblxuY29uc3QgICAgICAgIFZvdGVDb3VudGVyQWRtaW5JPU0uaW50ZXJmYWNlKCdWb3RlQ291bnRlciBBZG1pbkZhY2V0Jyx7XG5zdWJtaXRWb3RlOk0uY2FsbChWb3RlckhhbmRsZSxNLmFycmF5T2YoUG9zaXRpb25TaGFwZSkpLlxub3B0aW9uYWwoTS5uYXQoKSkuXG5yZXR1cm5zKHtjaG9zZW46TS5hcnJheU9mKFBvc2l0aW9uU2hhcGUpLHNoYXJlczpNLm5hdCgpfSl9KTskaOKAjV9vbmNlLlZvdGVDb3VudGVyQWRtaW5JKFZvdGVDb3VudGVyQWRtaW5JKTtcblxuXG5jb25zdCAgICAgICAgVm90ZUNvdW50ZXJDbG9zZUk9TS5pbnRlcmZhY2UoJ1ZvdGVDb3VudGVyIENsb3NlRmFjZXQnLHtcbmNsb3NlVm90aW5nOk0uY2FsbCgpLnJldHVybnMoKX0pOyRo4oCNX29uY2UuVm90ZUNvdW50ZXJDbG9zZUkoVm90ZUNvdW50ZXJDbG9zZUkpO1xuXG5cbmNvbnN0ICAgICAgICBHb3Zlcm5vckZhY2V0U2hhcGU9e1xuZ2V0UGFyYW1NZ3JSZXRyaWV2ZXI6TS5jYWxsKCkucmV0dXJucyhNLnJlbW90YWJsZSgncGFyYW1SZXRyaWV2ZXInKSksXG5nZXRJbnZpdGF0aW9uOk0uY2FsbCgpLnJldHVybnMoSW52aXRhdGlvblNoYXBlKSxcbmdldExpbWl0ZWRDcmVhdG9yRmFjZXQ6TS5jYWxsKCkucmV0dXJucyhNLnJlbW90YWJsZSgpKSxcbmdldEdvdmVybmVkQXBpczpNLmNhbGwoKS5yZXR1cm5zKE0ucmVtb3RhYmxlKCdnb3Zlcm5lZEFQSXMnKSksXG5nZXRHb3Zlcm5lZEFwaU5hbWVzOk0uY2FsbCgpLnJldHVybnMoTS5hcnJheU9mKE0uc3RyaW5nKCkpKSxcbnNldE9mZmVyRmlsdGVyOk0uY2FsbChNLmFycmF5T2YoTS5zdHJpbmcoKSkpLnJldHVybnMoTS5wcm9taXNlKCkpfTskaOKAjV9vbmNlLkdvdmVybm9yRmFjZXRTaGFwZShHb3Zlcm5vckZhY2V0U2hhcGUpO1xuXG5oYXJkZW4oR292ZXJub3JGYWNldFNoYXBlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJDaG9pY2VNZXRob2RTaGFwZSI6WyJDaG9pY2VNZXRob2RTaGFwZSJdLCJRdW9ydW1SdWxlU2hhcGUiOlsiUXVvcnVtUnVsZVNoYXBlIl0sIkVsZWN0aW9uVHlwZVNoYXBlIjpbIkVsZWN0aW9uVHlwZVNoYXBlIl0sIkNsb3NpbmdSdWxlU2hhcGUiOlsiQ2xvc2luZ1J1bGVTaGFwZSJdLCJZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGUiOlsiWWVzT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlIl0sIk5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlIjpbIk5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlIl0sIk9mZmVyRmlsdGVyUG9zaXRpb25zU2hhcGUiOlsiT2ZmZXJGaWx0ZXJQb3NpdGlvbnNTaGFwZSJdLCJPZmZlckZpbHRlcklzc3VlU2hhcGUiOlsiT2ZmZXJGaWx0ZXJJc3N1ZVNoYXBlIl0sIk9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGUiOlsiT2ZmZXJGaWx0ZXJRdWVzdGlvblNwZWNTaGFwZSJdLCJPZmZlckZpbHRlclF1ZXN0aW9uRGV0YWlsc1NoYXBlIjpbIk9mZmVyRmlsdGVyUXVlc3Rpb25EZXRhaWxzU2hhcGUiXSwiUGFyYW1DaGFuZ2VzU3BlY1NoYXBlIjpbIlBhcmFtQ2hhbmdlc1NwZWNTaGFwZSJdLCJZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlIjpbIlllc1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUiXSwiTm9QYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlIjpbIk5vUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZSJdLCJQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSI6WyJQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSJdLCJQYXJhbVBhdGhTaGFwZSI6WyJQYXJhbVBhdGhTaGFwZSJdLCJQYXJhbUNoYW5nZXNJc3N1ZVNoYXBlIjpbIlBhcmFtQ2hhbmdlc0lzc3VlU2hhcGUiXSwiUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUiOlsiUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUiXSwiUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUiOlsiUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUiXSwiWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUiOlsiWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUiXSwiTm9BcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZSI6WyJOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlIl0sIkFwaUludm9jYXRpb25Qb3NpdGlvbnNTaGFwZSI6WyJBcGlJbnZvY2F0aW9uUG9zaXRpb25zU2hhcGUiXSwiQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlIjpbIkFwaUludm9jYXRpb25RdWVzdGlvblNwZWNTaGFwZSJdLCJBcGlJbnZvY2F0aW9uUXVlc3Rpb25EZXRhaWxzU2hhcGUiOlsiQXBpSW52b2NhdGlvblF1ZXN0aW9uRGV0YWlsc1NoYXBlIl0sIlllc1NpbXBsZVBvc2l0aW9uU2hhcGUiOlsiWWVzU2ltcGxlUG9zaXRpb25TaGFwZSJdLCJOb1NpbXBsZVBvc2l0aW9uU2hhcGUiOlsiTm9TaW1wbGVQb3NpdGlvblNoYXBlIl0sIlNpbXBsZVBvc2l0aW9uc1NoYXBlIjpbIlNpbXBsZVBvc2l0aW9uc1NoYXBlIl0sIlNpbXBsZUlzc3VlU2hhcGUiOlsiU2ltcGxlSXNzdWVTaGFwZSJdLCJTaW1wbGVRdWVzdGlvblNwZWNTaGFwZSI6WyJTaW1wbGVRdWVzdGlvblNwZWNTaGFwZSJdLCJTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSI6WyJTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSJdLCJRdWVzdGlvblNwZWNTaGFwZSI6WyJRdWVzdGlvblNwZWNTaGFwZSJdLCJQb3NpdGlvblNoYXBlIjpbIlBvc2l0aW9uU2hhcGUiXSwiUXVlc3Rpb25IYW5kbGVTaGFwZSI6WyJRdWVzdGlvbkhhbmRsZVNoYXBlIl0sIkludml0YXRpb25TaGFwZSI6WyJJbnZpdGF0aW9uU2hhcGUiXSwiUXVlc3Rpb25EZXRhaWxzU2hhcGUiOlsiUXVlc3Rpb25EZXRhaWxzU2hhcGUiXSwiRWxlY3RvcmF0ZVB1YmxpY0kiOlsiRWxlY3RvcmF0ZVB1YmxpY0kiXSwiRWxlY3RvcmF0ZUNyZWF0b3JJIjpbIkVsZWN0b3JhdGVDcmVhdG9ySSJdLCJRdWVzdGlvblN0YXRzU2hhcGUiOlsiUXVlc3Rpb25TdGF0c1NoYXBlIl0sIlF1ZXN0aW9uSSI6WyJRdWVzdGlvbkkiXSwiQmluYXJ5Vm90ZUNvdW50ZXJQdWJsaWNJIjpbIkJpbmFyeVZvdGVDb3VudGVyUHVibGljSSJdLCJWb3RlckhhbmRsZSI6WyJWb3RlckhhbmRsZSJdLCJCaW5hcnlWb3RlQ291bnRlckFkbWluSSI6WyJCaW5hcnlWb3RlQ291bnRlckFkbWluSSJdLCJCaW5hcnlWb3RlQ291bnRlckNsb3NlSSI6WyJCaW5hcnlWb3RlQ291bnRlckNsb3NlSSJdLCJWb3RlQ291bnRlclB1YmxpY0kiOlsiVm90ZUNvdW50ZXJQdWJsaWNJIl0sIlZvdGVDb3VudGVyQWRtaW5JIjpbIlZvdGVDb3VudGVyQWRtaW5JIl0sIlZvdGVDb3VudGVyQ2xvc2VJIjpbIlZvdGVDb3VudGVyQ2xvc2VJIl0sIkdvdmVybm9yRmFjZXRTaGFwZSI6WyJHb3Zlcm5vckZhY2V0U2hhcGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAbdthCl4oAABeKAAALQAAAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy9jYWxsYmFjay5qc3siaW1wb3J0cyI6WyJAZW5kby9mYXIiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiY2FsbEUiLCJjYWxsU3luYyIsImlzQ2FsbGJhY2siLCJtYWtlRnVuY3Rpb25DYWxsYmFjayIsIm1ha2VNZXRob2RDYWxsYmFjayIsIm1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayIsIm1ha2VTeW5jTWV0aG9kQ2FsbGJhY2siLCJwcmVwYXJlQXR0ZW51YXRvciIsInByZXBhcmVHdWFyZGVkQXR0ZW51YXRvciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLGlzT2JqZWN0LGlzUGFzc2FibGVTeW1ib2w7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wiaXNQYXNzYWJsZVN5bWJvbFwiLCBbJGjigI1fYSA9PiAoaXNQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5cbmNvbnN0e2Zyb21FbnRyaWVzfT1PYmplY3Q7XG5cbmNvbnN0e293bktleXM6cmF3T3duS2V5c309UmVmbGVjdDtcbmNvbnN0IG93bktleXM9XG4vKiogQHR5cGUgezxUIGV4dGVuZHMgUHJvcGVydHlLZXk+KG9iajoge1tLIGluIFRdPzogdW5rbm93bn0pID0+IFRbXX0gKi9cbnJhd093bktleXM7XG5cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPFJldHVyblR5cGU8cHJlcGFyZUF0dGVudWF0b3I+PikgPT4gRmFyYWJsZTxUPn0gTWFrZUF0dGVudWF0b3JcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IHVua25vd25bXSkgPT4gYW55fSBJXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcycpLkNhbGxiYWNrPEk+fSBDYWxsYmFja1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzJykuU3luY0NhbGxiYWNrPEk+fSBTeW5jQ2FsbGJhY2tcbiAqL1xuXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDx7fSwgVD4gJiBUfSBGYXJhYmxlICovXG5cbi8qKlxuICogQHBhcmFtIHt1bmtub3dufSBrZXlcbiAqIEByZXR1cm5zIHtrZXkgaXMgUHJvcGVydHlLZXl9IEZJWE1FOiBzaG91bGQgYmUganVzdCBgUHJvcGVydHlLZXlgIGJ1dCBUU1xuICogY29tcGxhaW5zIGl0IGNhbid0IGJlIHVzZWQgYXMgYW4gaW5kZXggdHlwZS5cbiAqL1xuY29uc3QgaXNQcm9wZXJ0eUtleT0oa2V5KT0+e1xuc3dpdGNoKHR5cGVvZiBrZXkpe1xuY2FzZSdzdHJpbmcnOlxuY2FzZSdudW1iZXInOlxuY2FzZSdzeW1ib2wnOlxucmV0dXJuIHRydWU7XG5kZWZhdWx0OlxucmV0dXJuIGZhbHNlO31cblxuIH07XG5cbi8qKlxuICogU3luY2hyb25vdXNseSBjYWxsIGEgY2FsbGJhY2suXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEBwYXJhbSB7U3luY0NhbGxiYWNrPEk+fSBjYWxsYmFja1xuICogQHBhcmFtIHtQYXJhbWV0ZXJzPEk+fSBhcmdzXG4gKiBAcmV0dXJucyB7UmV0dXJuVHlwZTxJPn1cbiAqL1xuY29uc3QgICAgICAgIGNhbGxTeW5jPShjYWxsYmFjaywuLi5hcmdzKT0+e1xuY29uc3R7dGFyZ2V0LG1ldGhvZE5hbWUsYm91bmR9PWNhbGxiYWNrO1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gdGFyZ2V0KC4uLmJvdW5kLC4uLmFyZ3MpO1xuIH1cbnJldHVybiB0YXJnZXRbbWV0aG9kTmFtZV0oLi4uYm91bmQsLi4uYXJncyk7XG4gfTskaOKAjV9vbmNlLmNhbGxTeW5jKGNhbGxTeW5jKTtcbmhhcmRlbihjYWxsU3luYyk7XG5cbi8qKlxuICogRXZlbnR1YWwgc2VuZCB0byBhIGNhbGxiYWNrLlxuICpcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IHVua25vd25bXSkgPT4gYW55fSBJXG4gKiBAcGFyYW0ge0NhbGxiYWNrPEk+fSBjYWxsYmFja1xuICogQHBhcmFtIHtQYXJhbWV0ZXJzPEk+fSBhcmdzXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFJldHVyblR5cGU8ST4+Pn1cbiAqL1xuY29uc3QgICAgICAgIGNhbGxFPShjYWxsYmFjaywuLi5hcmdzKT0+e1xuY29uc3R7dGFyZ2V0LG1ldGhvZE5hbWUsYm91bmR9PWNhbGxiYWNrO1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gRSh0YXJnZXQpKC4uLmJvdW5kLC4uLmFyZ3MpO1xuIH1cbnJldHVybiBFKHRhcmdldClbbWV0aG9kTmFtZV0oLi4uYm91bmQsLi4uYXJncyk7XG4gfTskaOKAjV9vbmNlLmNhbGxFKGNhbGxFKTtcbmhhcmRlbihjYWxsRSk7XG5cbi8qKlxuICogQ3JlYXRlIGEgY2FsbGJhY2sgZnJvbSBhIG5lYXIgZnVuY3Rpb24uXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IFsuLi5CLCAuLi5QYXJhbWV0ZXJzPEk+XSkgPT4gUmV0dXJuVHlwZTxJPn0gW1Q9SV1cbiAqIEB0ZW1wbGF0ZSB7dW5rbm93bltdfSBbQj1bXV1cbiAqIEBwYXJhbSB7VH0gdGFyZ2V0XG4gKiBAcGFyYW0ge0J9IGJvdW5kXG4gKiBAcmV0dXJucyB7U3luY0NhbGxiYWNrPEk+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVN5bmNGdW5jdGlvbkNhbGxiYWNrPSh0YXJnZXQsLi4uYm91bmQpPT57XG50eXBlb2YgdGFyZ2V0PT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBzeW5jIGZ1bmN0aW9uIGNhbGxiYWNrIHRhcmdldCBtdXN0IGJlIGEgZnVuY3Rpb246ICR7dGFyZ2V0fWA7XG4vKiogQHR5cGUge3Vua25vd259ICovXG5jb25zdCBjYj1oYXJkZW4oe3RhcmdldCxib3VuZCxpc1N5bmM6dHJ1ZX0pO1xucmV0dXJuICgvKiogQHR5cGUge1N5bmNDYWxsYmFjazxJPn0gKi9jYik7XG4gfTskaOKAjV9vbmNlLm1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayhtYWtlU3luY0Z1bmN0aW9uQ2FsbGJhY2spO1xuaGFyZGVuKG1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayk7XG5cbi8qKlxuICogQ3JlYXRlIGEgY2FsbGJhY2sgZnJvbSBhIHBvdGVudGlhbGx5IGZhciBmdW5jdGlvbi5cbiAqXG4gKiBAdGVtcGxhdGUgeyguLi5hcmdzOiB1bmtub3duW10pID0+IGFueX0gSVxuICogQHRlbXBsYXRlIHtYaW1wb3J0KCdAZW5kby9mYXInKS5FUmVmPFxuICogICAoLi4uYXJnczogWy4uLkIsIC4uLlBhcmFtZXRlcnM8ST5dKSA9PiBSZXR1cm5UeXBlPEk+XG4gKiA+fSBbVD1YaW1wb3J0KCdAZW5kby9mYXInKS5FUmVmPEk+XVxuICogQHRlbXBsYXRlIHt1bmtub3duW119IFtCPVtdXVxuICogQHBhcmFtIHtUfSB0YXJnZXRcbiAqIEBwYXJhbSB7Qn0gYm91bmRcbiAqIEByZXR1cm5zIHtDYWxsYmFjazxJPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VGdW5jdGlvbkNhbGxiYWNrPSh0YXJnZXQsLi4uYm91bmQpPT57XG5pc09iamVjdCh0YXJnZXQpfHxcbkZhaWwgYGZ1bmN0aW9uIGNhbGxiYWNrIHRhcmdldCBtdXN0IGJlIGEgZnVuY3Rpb24gcHJlc2VuY2U6ICR7dGFyZ2V0fWA7XG4vKiogQHR5cGUge3Vua25vd259ICovXG5jb25zdCBjYj1oYXJkZW4oe3RhcmdldCxib3VuZH0pO1xucmV0dXJuICgvKiogQHR5cGUge0NhbGxiYWNrPEk+fSAqL2NiKTtcbiB9OyRo4oCNX29uY2UubWFrZUZ1bmN0aW9uQ2FsbGJhY2sobWFrZUZ1bmN0aW9uQ2FsbGJhY2spO1xuaGFyZGVuKG1ha2VGdW5jdGlvbkNhbGxiYWNrKTtcblxuLyoqXG4gKiBDcmVhdGUgYSBjYWxsYmFjayBmcm9tIGEgbmVhciBtZXRob2QuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0ZW1wbGF0ZSB7UHJvcGVydHlLZXl9IFBcbiAqIEB0ZW1wbGF0ZSB7e1xuICogICBbeCBpbiBQXTogKC4uLmFyZ3M6IFsuLi5CLCAuLi5QYXJhbWV0ZXJzPEk+XSkgPT4gUmV0dXJuVHlwZTxJPlxuICogfX0gW1Q9eyBbeCBpbiBQXTogSSB9XVxuICogQHRlbXBsYXRlIHt1bmtub3duW119IFtCPVtdXVxuICogQHBhcmFtIHtUfSB0YXJnZXRcbiAqIEBwYXJhbSB7UH0gbWV0aG9kTmFtZVxuICogQHBhcmFtIHtCfSBib3VuZFxuICogQHJldHVybnMge1N5bmNDYWxsYmFjazxJPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VTeW5jTWV0aG9kQ2FsbGJhY2s9KHRhcmdldCxtZXRob2ROYW1lLC4uLmJvdW5kKT0+e1xuaXNPYmplY3QodGFyZ2V0KXx8XG5GYWlsIGBzeW5jIG1ldGhvZCBjYWxsYmFjayB0YXJnZXQgbXVzdCBiZSBhbiBvYmplY3Q6ICR7dGFyZ2V0fWA7XG50eXBlb2YgbWV0aG9kTmFtZT09PSdzdHJpbmcnfHxcbmlzUGFzc2FibGVTeW1ib2wobWV0aG9kTmFtZSl8fFxuRmFpbCBgbWV0aG9kIG5hbWUgbXVzdCBiZSBhIHN0cmluZyBvciBwYXNzYWJsZSBzeW1ib2w6ICR7bWV0aG9kTmFtZX1gO1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL1xuY29uc3QgY2I9aGFyZGVuKHt0YXJnZXQsbWV0aG9kTmFtZSxib3VuZCxpc1N5bmM6dHJ1ZX0pO1xucmV0dXJuICgvKiogQHR5cGUge1N5bmNDYWxsYmFjazxJPn0gKi9jYik7XG4gfTskaOKAjV9vbmNlLm1ha2VTeW5jTWV0aG9kQ2FsbGJhY2sobWFrZVN5bmNNZXRob2RDYWxsYmFjayk7XG5oYXJkZW4obWFrZVN5bmNNZXRob2RDYWxsYmFjayk7XG5cbi8qKlxuICogQ3JlYXRlIGEgY2FsbGJhY2sgZnJvbSBhIHBvdGVudGlhbGx5IGZhciBtZXRob2QuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0ZW1wbGF0ZSB7UHJvcGVydHlLZXl9IFBcbiAqIEB0ZW1wbGF0ZSB7WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjx7XG4gKiAgIFt4IGluIFBdOiAoLi4uYXJnczogWy4uLkIsIC4uLlBhcmFtZXRlcnM8ST5dKSA9PiBSZXR1cm5UeXBlPEk+XG4gKiB9Pn0gW1Q9WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjx7IFt4IGluIFBdOiBJIH0+XVxuICogQHRlbXBsYXRlIHt1bmtub3duW119IFtCPVtdXVxuICogQHBhcmFtIHtUfSB0YXJnZXRcbiAqIEBwYXJhbSB7UH0gbWV0aG9kTmFtZVxuICogQHBhcmFtIHtCfSBib3VuZFxuICogQHJldHVybnMge0NhbGxiYWNrPEk+fVxuICovXG5jb25zdCAgICAgICAgbWFrZU1ldGhvZENhbGxiYWNrPSh0YXJnZXQsbWV0aG9kTmFtZSwuLi5ib3VuZCk9PntcbmlzT2JqZWN0KHRhcmdldCl8fEZhaWwgYG1ldGhvZCBjYWxsYmFjayB0YXJnZXQgbXVzdCBiZSBhbiBvYmplY3Q6ICR7dGFyZ2V0fWA7XG50eXBlb2YgbWV0aG9kTmFtZT09PSdzdHJpbmcnfHxcbmlzUGFzc2FibGVTeW1ib2wobWV0aG9kTmFtZSl8fFxuRmFpbCBgbWV0aG9kIG5hbWUgbXVzdCBiZSBhIHN0cmluZyBvciBwYXNzYWJsZSBzeW1ib2w6ICR7bWV0aG9kTmFtZX1gO1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL1xuY29uc3QgY2I9aGFyZGVuKHt0YXJnZXQsbWV0aG9kTmFtZSxib3VuZH0pO1xucmV0dXJuICgvKiogQHR5cGUge0NhbGxiYWNrPEk+fSAqL2NiKTtcbiB9OyRo4oCNX29uY2UubWFrZU1ldGhvZENhbGxiYWNrKG1ha2VNZXRob2RDYWxsYmFjayk7XG5oYXJkZW4obWFrZU1ldGhvZENhbGxiYWNrKTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gY2FsbGJhY2tcbiAqIEByZXR1cm5zIHtjYWxsYmFjayBpcyBDYWxsYmFjazxhbnk+fVxuICovXG5jb25zdCAgICAgICAgaXNDYWxsYmFjaz0oY2FsbGJhY2spPT57XG5pZighaXNPYmplY3QoY2FsbGJhY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdHt0YXJnZXQsbWV0aG9kTmFtZSxib3VuZH09Y2FsbGJhY2s7XG5yZXR1cm4oXG5pc09iamVjdCh0YXJnZXQpJiYoXG5tZXRob2ROYW1lPT09dW5kZWZpbmVkfHxcbnR5cGVvZiBtZXRob2ROYW1lPT09J3N0cmluZyd8fFxuaXNQYXNzYWJsZVN5bWJvbChtZXRob2ROYW1lKSkmJlxuQXJyYXkuaXNBcnJheShib3VuZCkpO1xuXG4gfTskaOKAjV9vbmNlLmlzQ2FsbGJhY2soaXNDYWxsYmFjayk7XG5oYXJkZW4oaXNDYWxsYmFjayk7XG5cbi8qKlxuICogUHJlcGFyZSBhbiBhdHRlbnVhdG9yIGNsYXNzIHdob3NlIG1ldGhvZHMgY2FuIGJlIHJlZGlyZWN0ZWQgdmlhIGNhbGxiYWNrcy5cbiAqXG4gKiBAdGVtcGxhdGUge1Byb3BlcnR5S2V5fSBNXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9uZScpLlpvbmV9IHpvbmUgVGhlIHpvbmUgaW4gd2hpY2ggdG8gYWxsb2NhdGUgYXR0ZW51YXRvcnMuXG4gKiBAcGFyYW0ge01bXX0gbWV0aG9kTmFtZXMgTWV0aG9kcyB0byBmb3J3YXJkLlxuICogQHBhcmFtIHtvYmplY3R9IG9wdHNcbiAqIEBwYXJhbSB7SW50ZXJmYWNlR3VhcmR9IFtvcHRzLmludGVyZmFjZUd1YXJkXSBBbiBpbnRlcmZhY2UgZ3VhcmQgZm9yIHRoZVxuICogbmV3IGF0dGVudWF0b3IuXG4gKiBAcGFyYW0ge3N0cmluZ30gW29wdHMudGFnXSBBIHRhZyBmb3IgdGhlIG5ldyBhdHRlbnVhdG9yIGV4b0NsYXNzLlxuICovXG5jb25zdCAgICAgICAgcHJlcGFyZUF0dGVudWF0b3I9KFxuem9uZSxcbm1ldGhvZE5hbWVzLFxue2ludGVyZmFjZUd1YXJkLHRhZz0nQXR0ZW51YXRvcid9PXt9KT0+XG57XG4vKipcbiAqIEB0eXBlZGVmIHsodGhpczogYW55LCAuLi5hcmdzOiB1bmtub3duW10pID0+IGFueX0gTWV0aG9kXG4gKiBAdHlwZWRlZiB7eyBbSyBpbiBNXT86IENhbGxiYWNrPGFueT4gfCBudWxsfX0gT3ZlcnJpZGVzXG4gKiBAdHlwZWRlZiB7eyBbSyBpbiBNXTogKHRoaXM6IGFueSwgLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnkgfX0gTWV0aG9kc1xuICovXG5jb25zdCBtZXRob2RzPS8qKiBAdHlwZSB7TWV0aG9kc30gKi9cbmZyb21FbnRyaWVzKFxubWV0aG9kTmFtZXMubWFwKChrZXkpPT57XG4vKiBPbmx5IGFsbG93IHRoZSBgUHJvcGVydHlLZXlgIHR5cGUgZm9yIHRoZSB0YXJnZXQgbWV0aG9kIGtleS4qL1xuaWYoIWlzUHJvcGVydHlLZXkoa2V5KSl7XG50aHJvdyBGYWlsIGBrZXkgJHtxKGtleSl9IGlzIG5vdCBhIFByb3BlcnR5S2V5YDtcbiB9XG5cbmNvbnN0IG09LyoqIEB0eXBlIHtNZXRob2RzfSAqL3tcbi8qIEV4cGxpY2l0bHkgdXNlIGNvbmNpc2UgbWV0aG9kIHN5bnRheCB0byBwcmVzZXJ2ZSBgdGhpc2AgYnV0IHByZXZlbnQqL1xuLyogY29uc3RydWN0b3IgYmVoYXZpb3IuKi9cbi8qKiBAdHlwZSB7TWV0aG9kfSAqL1xuW2tleV0oLi4uYXJncyl7XG4vKiBTdXBwb3J0IGJvdGggc3luY2hyb25vdXMgYW5kIGFzeW5jIGNhbGxiYWNrcy4qL1xuY29uc3QgY2I9dGhpcy5zdGF0ZS5jYnNba2V5XTtcbmlmKCFjYil7XG5jb25zdCBlcnI9YXNzZXJ0LmVycm9yKFxuIGB1bmltcGxlbWVudGVkICR7cSh0YWcpfSBtZXRob2QgJHtxKGtleSl9YCk7XG5cbmlmKHRoaXMuc3RhdGUuaXNTeW5jKXtcbnRocm93IGVycjtcbiB9XG5yZXR1cm4gUHJvbWlzZS5yZWplY3QoZXJyKTtcbiB9XG5pZihjYi5pc1N5bmMpe1xucmV0dXJuIGNhbGxTeW5jKGNiLC4uLmFyZ3MpO1xuIH1cbnJldHVybiBjYWxsRShjYiwuLi5hcmdzKTtcbiB9fVtcbmtleV07XG5yZXR1cm4gKC8qKiBAdHlwZSB7Y29uc3R9ICovW2tleSxtXSk7XG4gfSkpO1xuXG5cblxuLyoqXG4gKiBDcmVhdGUgYW4gZXhvIG9iamVjdCB3aG9zZSBiZWhhdmlvciBpcyBjb21wb3NlZCBmcm9tIGEgZGVmYXVsdCB0YXJnZXRcbiAqIGFuZC9vciBpbmRpdmlkdWFsIG1ldGhvZCBvdmVycmlkZSBjYWxsYmFja3MuXG4gKlxuICogQHBhcmFtIHtvYmplY3R9IG9wdHNcbiAqIEBwYXJhbSB7dW5rbm93bn0gW29wdHMudGFyZ2V0XSBUaGUgdGFyZ2V0IGZvciBhbnkgbWV0aG9kcyB0aGF0XG4gKiB3ZXJlbid0IHNwZWNpZmllZCBpbiBgb3B0cy5vdmVycmlkZXNgLlxuICogQHBhcmFtIHtib29sZWFufSBbb3B0cy5pc1N5bmM9ZmFsc2VdIFdoZXRoZXIgdGhlIHRhcmdldCBzaG91bGQgYmUgdHJlYXRlZFxuICogYXMgc3luY2hyb25vdXNseSBhdmFpbGFibGUuXG4gKiBAcGFyYW0ge092ZXJyaWRlc30gW29wdHMub3ZlcnJpZGVzXSBTZXQgaW5kaXZpZHVhbFxuICogY2FsbGJhY2tzIGZvciBtZXRob2RzICh3aG9zZSBuYW1lcyBtdXN0IGJlIGRlZmluZWQgaW4gdGhlXG4gKiBgcHJlcGFyZUF0dGVudWF0b3JgIG9yIGBwcmVwYXJlR3VhcmRlZEF0dGVudWF0b3JgIGNhbGwpLiAgTnVsbGlzaCBvdmVycmlkZXNcbiAqIG1lYW4gdG8gdGhyb3cuXG4gKi9cbmNvbnN0IG1ha2VBdHRlbnVhdG9yPXpvbmUuZXhvQ2xhc3MoXG50YWcsXG5pbnRlcmZhY2VHdWFyZCxcbi8qKlxuICogQHBhcmFtIHtvYmplY3R9IG9wdHNcbiAqIEBwYXJhbSB7YW55fSBbb3B0cy50YXJnZXRdXG4gKiBAcGFyYW0ge2Jvb2xlYW59IFtvcHRzLmlzU3luYz1mYWxzZV1cbiAqIEBwYXJhbSB7T3ZlcnJpZGVzfSBbb3B0cy5vdmVycmlkZXNdXG4gKi9cbih7XG50YXJnZXQ9bnVsbCxcbmlzU3luYz1mYWxzZSxcbm92ZXJyaWRlcz0vKiogQHR5cGUge092ZXJyaWRlc30gKi97fX0pPT5cbntcbmNvbnN0IGNicz0vKiogQHR5cGUge092ZXJyaWRlc30gKi97fTtcblxuY29uc3QgcmVtYWluaW5nPW5ldyBTZXQobWV0aG9kTmFtZXMpO1xuZm9yKGNvbnN0IGtleSBvZiBvd25LZXlzKG92ZXJyaWRlcykpe1xucmVtYWluaW5nLmhhcyhrZXkpfHxcbkZhaWwgYCR7cSh0YWcpfSBvdmVycmlkZXNbJHtxKGtleSl9XSBub3QgYWxsb3dlZCBieSBtZXRob2ROYW1lc2A7XG5cbnJlbWFpbmluZy5kZWxldGUoa2V5KTtcbmNvbnN0IGNiPW92ZXJyaWRlc1trZXldO1xuY2I9PW51bGx8fFxuaXNDYWxsYmFjayhjYil8fFxuRmFpbCBgJHtxKHRhZyl9IG92ZXJyaWRlc1ske3Eoa2V5KX1dIGlzIG5vdCBhIGNhbGxiYWNrOyBnb3QgJHtjYn1gO1xuY2JzW2tleV09Y2I7XG4gfVxuZm9yKGNvbnN0IGtleSBvZiByZW1haW5pbmcpe1xuaWYoaXNTeW5jKXtcbmNic1trZXldPW1ha2VTeW5jTWV0aG9kQ2FsbGJhY2sodGFyZ2V0LGtleSk7XG4gfWVsc2V7XG5jYnNba2V5XT1tYWtlTWV0aG9kQ2FsbGJhY2sodGFyZ2V0LGtleSk7XG4gfVxuIH1cbnJldHVybiBoYXJkZW4oe2Nicyxpc1N5bmN9KTtcbiB9LFxuLyoqIEB0eXBlIHtNZXRob2RzfSAqL21ldGhvZHMpO1xuXG5yZXR1cm4gbWFrZUF0dGVudWF0b3I7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVBdHRlbnVhdG9yKHByZXBhcmVBdHRlbnVhdG9yKTtcbmhhcmRlbihwcmVwYXJlQXR0ZW51YXRvcik7XG5cbi8qKlxuICogUHJlcGFyZSBhbiBhdHRlbnVhdG9yIHdob3NlIG1ldGhvZE5hbWVzIGFyZSBkZXJpdmVkIGZyb20gdGhlIGludGVyZmFjZUd1YXJkLlxuICpcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy96b25lJykuWm9uZX0gem9uZVxuICogQHBhcmFtIHtJbnRlcmZhY2VHdWFyZH0gaW50ZXJmYWNlR3VhcmRcbiAqIEBwYXJhbSB7b2JqZWN0fSBbb3B0c11cbiAqIEBwYXJhbSB7c3RyaW5nfSBbb3B0cy50YWddXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlR3VhcmRlZEF0dGVudWF0b3I9KHpvbmUsaW50ZXJmYWNlR3VhcmQsb3B0cz17fSk9PntcbmNvbnN0e21ldGhvZEd1YXJkc309aW50ZXJmYWNlR3VhcmQ7XG5jb25zdCBtZXRob2ROYW1lcz1vd25LZXlzKG1ldGhvZEd1YXJkcyk7XG5jb25zdCBtYWtlQXR0ZW51YXRvcj1wcmVwYXJlQXR0ZW51YXRvcih6b25lLG1ldGhvZE5hbWVzLHtcbi4uLm9wdHMsXG5pbnRlcmZhY2VHdWFyZH0pO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7TWFrZUF0dGVudWF0b3I8YW55Pn0gKi9tYWtlQXR0ZW51YXRvcik7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVHdWFyZGVkQXR0ZW51YXRvcihwcmVwYXJlR3VhcmRlZEF0dGVudWF0b3IpO1xuaGFyZGVuKHByZXBhcmVHdWFyZGVkQXR0ZW51YXRvcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiY2FsbFN5bmMiOlsiY2FsbFN5bmMiXSwiY2FsbEUiOlsiY2FsbEUiXSwibWFrZVN5bmNGdW5jdGlvbkNhbGxiYWNrIjpbIm1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayJdLCJtYWtlRnVuY3Rpb25DYWxsYmFjayI6WyJtYWtlRnVuY3Rpb25DYWxsYmFjayJdLCJtYWtlU3luY01ldGhvZENhbGxiYWNrIjpbIm1ha2VTeW5jTWV0aG9kQ2FsbGJhY2siXSwibWFrZU1ldGhvZENhbGxiYWNrIjpbIm1ha2VNZXRob2RDYWxsYmFjayJdLCJpc0NhbGxiYWNrIjpbImlzQ2FsbGJhY2siXSwicHJlcGFyZUF0dGVudWF0b3IiOlsicHJlcGFyZUF0dGVudWF0b3IiXSwicHJlcGFyZUd1YXJkZWRBdHRlbnVhdG9yIjpbInByZXBhcmVHdWFyZGVkQXR0ZW51YXRvciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACqj91GIgYAACIGAAArAAAAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL2NvbmZpZy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiQnJpZGdlSWQiLCJWQmFua0FjY291bnQiLCJXYWxsZXROYW1lIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQHRzLWNoZWNrKi9cbi8qIEBqZXNzaWUtY2hlY2sqL1xuXG4vKipcbiAqIEBmaWxlXG4gKlxuICogU29tZSBvZiB0aGlzIGNvbmZpZyBpbmZvIG1heSBtYWtlIG1vcmUgc2Vuc2UgaW4gYSBwYXJ0aWN1bGFyIHBhY2thZ2UuIEhvd2V2ZXJcbiAqIGR1ZSB0byBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQ2MjAgYW5kIG91ciBsYXggcGFja2FnZVxuICogZGVwZW5kZW5jeSBncmFwaCwgc29tZXRpbWVzIHJhdGlvbmFsIHBsYWNlbWVudHMgY2F1c2UgdHlwZSByZXNvbHV0aW9uIGVycm9ycy5cbiAqXG4gKiBTbyBhcyBhIHdvcmstYXJvdW5kIHNvbWUgY29uc3RhbnRzIHRoYXQgbmVlZCBhY2Nlc3MgZnJvbSBtb3JlIHRoYW4gb25lIHBhY2thZ2UgYXJlIHBsYWNlZCBoZXJlLlxuICovXG5cbi8qKlxuICogRXZlbnQgc291cmNlIGlkcyB1c2VkIGJ5IHRoZSBicmlkZ2UgZGV2aWNlLlxuICovXG5jb25zdCAgICAgICAgQnJpZGdlSWQ9e1xuQkFOSzonYmFuaycsXG5DT1JFOidjb3JlJyxcbkRJQkM6J2RpYmMnLFxuU1RPUkFHRTonc3RvcmFnZScsXG5QUk9WSVNJT046J3Byb3Zpc2lvbicsXG5QUk9WSVNJT05fU01BUlRfV0FMTEVUOidwcm92aXNpb25XYWxsZXQnLFxuV0FMTEVUOid3YWxsZXQnfTskaOKAjV9vbmNlLkJyaWRnZUlkKEJyaWRnZUlkKTtcblxuaGFyZGVuKEJyaWRnZUlkKTtcblxuY29uc3QgICAgICAgIFdhbGxldE5hbWU9e1xuZGVwb3NpdEZhY2V0OidkZXBvc2l0RmFjZXQnfTskaOKAjV9vbmNlLldhbGxldE5hbWUoV2FsbGV0TmFtZSk7XG5cbmhhcmRlbihXYWxsZXROYW1lKTtcblxuLyogZGVmaW5lZCBpbiBnb2xhbmcvY29zbW9zL3gvdmJhbmsqL1xuY29uc3QgICAgICAgIFZCYW5rQWNjb3VudD17XG5yZXNlcnZlOntcbm1vZHVsZTondmJhbmsvcmVzZXJ2ZScsXG5hZGRyZXNzOidhZ29yaWMxYWUwbG10emxncmNubGE5eGprcGFhcnE1ZDVkZmV6NjNoM251Y2wnfSxcblxucHJvdmlzaW9uOntcbm1vZHVsZTondmJhbmsvcHJvdmlzaW9uJyxcbmFkZHJlc3M6J2Fnb3JpYzFtZWd6eXRnNjVjeXJnenM2ZnZ6eGdyY3F2d3dsN3VncHQ2MjM0Nid9fTskaOKAjV9vbmNlLlZCYW5rQWNjb3VudChWQmFua0FjY291bnQpO1xuXG5cbmhhcmRlbihWQmFua0FjY291bnQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkJyaWRnZUlkIjpbIkJyaWRnZUlkIl0sIldhbGxldE5hbWUiOlsiV2FsbGV0TmFtZSJdLCJWQmFua0FjY291bnQiOlsiVkJhbmtBY2NvdW50Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABfJM4DIBAAAyAQAACoAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvZGVidWcuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbIm1ha2VUcmFjZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAamVzc2llLWNoZWNrKi9cblxubGV0IGRlYnVnSW5zdGFuY2U9MTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtib29sZWFuIHwgJ3ZlcmJvc2UnfSBlbmFibGVcbiAqL1xuY29uc3QgICAgICAgIG1ha2VUcmFjZXI9KG5hbWUsZW5hYmxlPXRydWUpPT57XG5kZWJ1Z0luc3RhbmNlKz0xO1xubGV0IGRlYnVnQ291bnQ9MTtcbmNvbnN0IGtleT0gYC0tLS0tICR7bmFtZX0uJHtkZWJ1Z0luc3RhbmNlfSBgO1xuLyogdGhlIGNhc2VzIGJlbG93IGRlZmluZSBhIG5hbWVkIHZhcmlhYmxlIHRvIHByb3ZpZGUgYmV0dGVyIGRlYnVnIGluZm8qL1xuc3dpdGNoKGVuYWJsZSl7XG5jYXNlIGZhbHNlOntcbmNvbnN0IGxvZ0Rpc2FibGVkPSguLi5fYXJncyk9PnsgfTtcbnJldHVybiBsb2dEaXNhYmxlZDtcbiB9XG5jYXNlJ3ZlcmJvc2UnOntcbmNvbnN0IGluZm9UaWNrPShvcHRMb2csLi4uYXJncyk9PntcbmlmKG9wdExvZy5sb2cpe1xuY29uc29sZS5pbmZvKGtleSxkZWJ1Z0NvdW50Kz0xLC4uLmFyZ3MpO1xuIH1lbHNle1xuY29uc29sZS5pbmZvKGtleSxkZWJ1Z0NvdW50Kz0xLG9wdExvZywuLi5hcmdzKTtcbiB9XG4gfTtcbnJldHVybiBpbmZvVGljaztcbiB9XG5kZWZhdWx0OntcbmNvbnN0IGRlYnVnVGljaz0ob3B0TG9nLC4uLmFyZ3MpPT57XG5pZihvcHRMb2cubG9nKXtcbm9wdExvZy5sb2coa2V5LGRlYnVnQ291bnQrPTEsLi4uYXJncyk7XG4gfWVsc2V7XG5jb25zb2xlLmluZm8oa2V5LGRlYnVnQ291bnQrPTEsb3B0TG9nLC4uLmFyZ3MpO1xuIH1cbiB9O1xucmV0dXJuIGRlYnVnVGljaztcbiB9fVxuXG4gfTskaOKAjV9vbmNlLm1ha2VUcmFjZXIobWFrZVRyYWNlcik7XG5oYXJkZW4obWFrZVRyYWNlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVRyYWNlciI6WyJtYWtlVHJhY2VyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG4VmJ9DAgAAQwIAACoAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiLi9jb25maWcuanMiLCIuL2RlYnVnLmpzIiwiLi9tZXRob2QtdG9vbHMuanMiLCIuL3R5cGVHdWFyZHMuanMiLCIuL3V0aWxzLmpzIl0sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOlsiLi9jb25maWcuanMiLCIuL2RlYnVnLmpzIiwiLi9tZXRob2QtdG9vbHMuanMiLCIuL3R5cGVHdWFyZHMuanMiLCIuL3V0aWxzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9jb25maWcuanNcIiwgW11dLFtcIi4vZGVidWcuanNcIiwgW11dLFtcIi4vdXRpbHMuanNcIiwgW11dLFtcIi4vbWV0aG9kLXRvb2xzLmpzXCIsIFtdXSxbXCIuL3R5cGVHdWFyZHMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG3KOOsJLgAACS4AADUAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvbGliLWNoYWluU3RvcmFnZS5qc3siaW1wb3J0cyI6WyIuL2NhbGxiYWNrLmpzIiwiQGFnb3JpYy96b25lIiwiQGVuZG8vZmFyIl0sImV4cG9ydHMiOlsiYXNzZXJ0Q2FwRGF0YSIsImFzc2VydFBhdGhTZWdtZW50IiwiaXNTdHJlYW1DZWxsIiwibWFrZUNoYWluU3RvcmFnZVJvb3QiLCJtYWtlU2VyaWFsaXplVG9TdG9yYWdlIiwibWFrZVN0b3JhZ2VOb2RlQ2hpbGQiLCJwcmVwYXJlQ2hhaW5TdG9yYWdlTm9kZSIsInVubWFyc2hhbEZyb21Wc3RvcmFnZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLE0saGVhcFpvbmUsY2I7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9uZVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV0sW1wiaGVhcFpvbmVcIiwgWyRo4oCNX2EgPT4gKGhlYXBab25lID0gJGjigI1fYSldXV1dLFtcIi4vY2FsbGJhY2suanNcIiwgW1tcIipcIiwgWyRo4oCNX2EgPT4gKGNiID0gJGjigI1fYSldXV1dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VDaGFpblN0b3JhZ2VSb290LCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlQ2hhaW5TdG9yYWdlUm9vdFwifSk7JGjigI1fb25jZS5tYWtlQ2hhaW5TdG9yYWdlUm9vdChtYWtlQ2hhaW5TdG9yYWdlUm9vdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VTdG9yYWdlTm9kZUNoaWxkLCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlU3RvcmFnZU5vZGVDaGlsZFwifSk7JGjigI1fb25jZS5tYWtlU3RvcmFnZU5vZGVDaGlsZChtYWtlU3RvcmFnZU5vZGVDaGlsZCk7ICAgXG5cblxuXG5cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGVkZWYge1JldHVyblR5cGU8dHlwZW9mIFhpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5tYWtlTWFyc2hhbD59IE1hcnNoYWxsZXIgKi9cbi8qKiBAdHlwZWRlZiB7UGljazxNYXJzaGFsbGVyLCAnZnJvbUNhcERhdGEnPn0gVW5zZXJpYWxpemVyICovXG5cbi8qKlxuICogRGVmaW5lZCBieSB2c3RvcmFnZVN0b3JlS2V5IGluIHZzdG9yYWdlLmdvXG4gKlxuICogQHR5cGVkZWYgVlN0b3JhZ2VLZXlcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBzdG9yZU5hbWVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBzdG9yZVN1YmtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IGRhdGFQcmVmaXhCeXRlc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IFtub0RhdGFWYWx1ZV1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBbVD11bmtub3duXVxuICogQHR5cGVkZWYgU3RyZWFtQ2VsbFxuICogQHByb3BlcnR5IHtzdHJpbmd9IGJsb2NrSGVpZ2h0IGRlY2ltYWwgcmVwcmVzZW50YXRpb24gb2YgYSBuYXR1cmFsIG51bWJlclxuICogQHByb3BlcnR5IHtUW119IHZhbHVlc1xuICovXG5cbi8qKlxuICogVGhpcyByZXByZXNlbnRzIGEgbm9kZSBpbiBhbiBJQVZMIHRyZWUuXG4gKlxuICogVGhlIGFjdGl2ZSBpbXBsZW1lbnRhdGlvbiBpcyB4L3ZzdG9yYWdlLCBhbiBBZ29yaWMgZXh0ZW5zaW9uIG9mIHRoZSBDb3Ntb3MgU0RLLlxuICpcbiAqIFZzdG9yYWdlIGlzIGEgaGllcmFyY2hpY2FsIGV4dGVybmFsbHktcmVhY2hhYmxlIHN0b3JhZ2Ugc3RydWN0dXJlIHRoYXRcbiAqIGlkZW50aWZpZXMgY2hpbGRyZW4gYnkgcmVzdHJpY3RlZCBBU0NJSSBuYW1lIGFuZCBpcyBhc3NvY2lhdGVkIHdpdGggYXJiaXRyYXJ5XG4gKiBzdHJpbmctdmFsdWVkIGRhdGEgZm9yIGVhY2ggbm9kZSwgZGVmYXVsdGluZyB0byB0aGUgZW1wdHkgc3RyaW5nLlxuICpcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN0b3JhZ2VOb2RlXG4gKiBAcHJvcGVydHkgeyhkYXRhOiBzdHJpbmcpID0+IFByb21pc2U8dm9pZD59IHNldFZhbHVlIHB1Ymxpc2hlcyBzb21lIGRhdGFcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gc3RyaW5nfSBnZXRQYXRoIHRoZSBjaGFpbiBzdG9yYWdlIHBhdGggYXQgd2hpY2ggdGhlIG5vZGUgd2FzIGNvbnN0cnVjdGVkXG4gKiBAcHJvcGVydHkgeygpID0+IFByb21pc2U8VlN0b3JhZ2VLZXk+fSBnZXRTdG9yZUtleSBERVBSRUNBVEVEIHVzZSBnZXRQYXRoXG4gKiBAcHJvcGVydHkgeyhzdWJQYXRoOiBzdHJpbmcsIG9wdGlvbnM/OiB7c2VxdWVuY2U/OiBib29sZWFufSkgPT4gU3RvcmFnZU5vZGV9IG1ha2VDaGlsZE5vZGVcbiAqL1xuXG5jb25zdCBDaGFpblN0b3JhZ2VOb2RlST1NLmludGVyZmFjZSgnU3RvcmFnZU5vZGUnLHtcbnNldFZhbHVlOk0uY2FsbFdoZW4oTS5zdHJpbmcoKSkucmV0dXJucygpLFxuZ2V0UGF0aDpNLmNhbGwoKS5yZXR1cm5zKE0uc3RyaW5nKCkpLFxuZ2V0U3RvcmVLZXk6TS5jYWxsV2hlbigpLnJldHVybnMoTS5yZWNvcmQoKSksXG5tYWtlQ2hpbGROb2RlOk0uY2FsbChNLnN0cmluZygpKS5cbm9wdGlvbmFsKE0uc3BsaXRSZWNvcmQoe30se3NlcXVlbmNlOk0uYm9vbGVhbigpfSx7fSkpLlxucmV0dXJucyhNLnJlbW90YWJsZSgnU3RvcmFnZU5vZGUnKSl9KTtcblxuXG4vKipcbiAqIFRoaXMgaXMgYW4gaW1wZXJmZWN0IGhldXJpc3RpYyB0byBuYXZpZ2F0ZSB0aGUgbWlncmF0aW9uIGZyb20gdmFsdWUgY2VsbHMgdG9cbiAqIHN0cmVhbSBjZWxscy5cbiAqIEF0IHRpbWUgb2Ygd3JpdGluZywgbm8gbGVnYWN5IGNlbGxzIGhhdmUgdGhlIHNhbWUgc2hhcGUgYXMgYSBzdHJlYW0gY2VsbCxcbiAqIGFuZCB3ZSBkbyBub3QgaW50ZW5kIHRvIGNyZWF0ZSBhbnkgbW9yZSBsZWdhY3kgdmFsdWUgY2VsbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IGNlbGxcbiAqIEByZXR1cm5zIHtjZWxsIGlzIFN0cmVhbUNlbGx9XG4gKi9cbmNvbnN0ICAgICAgICBpc1N0cmVhbUNlbGw9KGNlbGwpPT5cbmNlbGwmJlxudHlwZW9mIGNlbGw9PT0nb2JqZWN0JyYmXG5BcnJheS5pc0FycmF5KGNlbGwudmFsdWVzKSYmXG50eXBlb2YgY2VsbC5ibG9ja0hlaWdodD09PSdzdHJpbmcnJiZcbi9eMCR8XlsxLTldWzAtOV0qJC8udGVzdChjZWxsLmJsb2NrSGVpZ2h0KTskaOKAjV9vbmNlLmlzU3RyZWFtQ2VsbChpc1N0cmVhbUNlbGwpO1xuaGFyZGVuKGlzU3RyZWFtQ2VsbCk7XG5cbi8qIFRPRE86IENvbnNvbGlkYXRlIHdpdGggYGluc2lzdENhcERhdGFgIGZ1bmN0aW9ucyBmcm9tIHN3aW5nc2V0LWxpdmVzbG90cywqL1xuLyogc3dpbmdzZXQteHNuYXAtc3VwZXJ2aXNvciwgZXRjLiovXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gZGF0YVxuICogQHJldHVybnMge2Fzc2VydHMgZGF0YSBpcyBYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2FwRGF0YTxzdHJpbmc+fVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0Q2FwRGF0YT0oZGF0YSk9PntcbmFzc2VydC50eXBlb2YoZGF0YSwnb2JqZWN0Jyk7XG5hc3NlcnQoZGF0YSk7XG5hc3NlcnQudHlwZW9mKGRhdGEuYm9keSwnc3RyaW5nJyk7XG5hc3NlcnQoQXJyYXkuaXNBcnJheShkYXRhLnNsb3RzKSk7XG4vKiBYWFggY2hlY2sgdGhhdCB0aGUgLnNsb3RzIGFycmF5IGVsZW1lbnRzIGFyZSBhY3R1YWxseSBzdHJpbmdzKi9cbiB9OyRo4oCNX29uY2UuYXNzZXJ0Q2FwRGF0YShhc3NlcnRDYXBEYXRhKTtcbmhhcmRlbihhc3NlcnRDYXBEYXRhKTtcblxuLyoqXG4gKiBSZWFkIGFuZCB1bm1hcnNoYWwgYSB2YWx1ZSBmcm9tIGEgbWFwIHJlcHJlc2VudGF0aW9uIG9mIHZzdG9yYWdlIGRhdGFcbiAqXG4gKiBAcGFyYW0ge01hcDxzdHJpbmcsIHN0cmluZz59IGRhdGFcbiAqIEBwYXJhbSB7c3RyaW5nfSBrZXlcbiAqIEBwYXJhbSB7UmV0dXJuVHlwZTx0eXBlb2YgWGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLm1ha2VNYXJzaGFsPlsnZnJvbUNhcERhdGEnXX0gZnJvbUNhcERhdGFcbiAqIEBwYXJhbSB7bnVtYmVyfSBbaW5kZXg9LTFdIGluZGV4IG9mIHRoZSBkZXNpcmVkIHZhbHVlIGluIGEgZGVzZXJpYWxpemVkIHN0cmVhbSBjZWxsXG4gKi9cbmNvbnN0ICAgICAgICB1bm1hcnNoYWxGcm9tVnN0b3JhZ2U9KGRhdGEsa2V5LGZyb21DYXBEYXRhLGluZGV4PS0xKT0+e1xuY29uc3Qgc2VyaWFsaXplZD1kYXRhLmdldChrZXkpfHxGYWlsIGBubyBkYXRhIGZvciAke2tleX1gO1xuYXNzZXJ0LnR5cGVvZihzZXJpYWxpemVkLCdzdHJpbmcnKTtcblxuY29uc3Qgc3RyZWFtQ2VsbD1KU09OLnBhcnNlKHNlcmlhbGl6ZWQpO1xuaWYoIWlzU3RyZWFtQ2VsbChzdHJlYW1DZWxsKSl7XG50aHJvdyBGYWlsIGBub3QgYSBTdHJlYW1DZWxsOiAke3N0cmVhbUNlbGx9YDtcbiB9XG5cbmNvbnN0e3ZhbHVlc309c3RyZWFtQ2VsbDtcbnZhbHVlcy5sZW5ndGg+MHx8RmFpbCBgbm8gU3RyZWFtQ2VsbCB2YWx1ZXM6ICR7c3RyZWFtQ2VsbH1gO1xuXG5jb25zdCBtYXJzaGFsbGVkPXZhbHVlcy5hdChpbmRleCk7XG5hc3NlcnQudHlwZW9mKG1hcnNoYWxsZWQsJ3N0cmluZycpO1xuXG4vKiogQHR5cGUge1hpbXBvcnQoXCJAZW5kby9tYXJzaGFsXCIpLkNhcERhdGE8c3RyaW5nPn0gKi9cbmNvbnN0IGNhcERhdGE9aGFyZGVuKEpTT04ucGFyc2UobWFyc2hhbGxlZCkpO1xuYXNzZXJ0Q2FwRGF0YShjYXBEYXRhKTtcblxuY29uc3QgdW5tYXJzaGFsbGVkPWZyb21DYXBEYXRhKGNhcERhdGEpO1xucmV0dXJuIHVubWFyc2hhbGxlZDtcbiB9OyRo4oCNX29uY2UudW5tYXJzaGFsRnJvbVZzdG9yYWdlKHVubWFyc2hhbEZyb21Wc3RvcmFnZSk7XG5oYXJkZW4odW5tYXJzaGFsRnJvbVZzdG9yYWdlKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yZWRGYWNldFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPHN0cmluZz59IGdldFBhdGggdGhlIGNoYWluIHN0b3JhZ2UgcGF0aCBhdCB3aGljaCB0aGUgbm9kZSB3YXMgY29uc3RydWN0ZWRcbiAqIEBwcm9wZXJ0eSB7U3RvcmFnZU5vZGVbJ2dldFN0b3JlS2V5J119IGdldFN0b3JlS2V5IERFUFJFQ0FURUQgdXNlIGdldFBhdGhcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gVW5zZXJpYWxpemVyfSBnZXRVbnNlcmlhbGl6ZXIgZ2V0IHRoZSB1bnNlcmlhbGl6ZXIgZm9yIHRoZSBzdG9yZWQgZGF0YVxuICovXG5cbi8qIFRPRE86IEZvcm1hbGl6ZSBzZWdtZW50IGNvbnN0cmFpbnRzLiovXG4vKiBNdXN0IGJlIG5vbmVtcHR5IGFuZCBkaXNhbGxvdyAodW5lc2NhcGVkKSBgLmAsIGFuZCBmb3Igc2ltcGxpY2l0eSovXG4vKiAoYW5kIGZ1dHVyZSBwb3NzaWJpbGl0eSBvZiBlLmcuIGVzY2FwaW5nKSB3ZSBjdXJyZW50bHkgbGltaXQgdG8qL1xuLyogQVNDSUkgYWxwaGFudW1lcmljIHBsdXMgdW5kZXJzY29yZSBhbmQgZGFzaC4qL1xuY29uc3QgcGF0aFNlZ21lbnRQYXR0ZXJuPS9eW2EtekEtWjAtOV8tXXsxLDEwMH0kLztcblxuLyoqIEB0eXBlIHsobmFtZTogc3RyaW5nKSA9PiB2b2lkfSAqL1xuY29uc3QgICAgICAgIGFzc2VydFBhdGhTZWdtZW50PShuYW1lKT0+e1xucGF0aFNlZ21lbnRQYXR0ZXJuLnRlc3QobmFtZSl8fFxuRmFpbCBgUGF0aCBzZWdtZW50IG5hbWVzIG11c3QgY29uc2lzdCBvZiAxIHRvIDEwMCBjaGFyYWN0ZXJzIGxpbWl0ZWQgdG8gQVNDSUkgYWxwaGFudW1lcmljcywgdW5kZXJzY29yZXMsIGFuZC9vciBkYXNoZXM6ICR7bmFtZX1gO1xuIH07JGjigI1fb25jZS5hc3NlcnRQYXRoU2VnbWVudChhc3NlcnRQYXRoU2VnbWVudCk7XG5oYXJkZW4oYXNzZXJ0UGF0aFNlZ21lbnQpO1xuXG4vKipcbiAqIE11c3QgbWF0Y2ggdGhlIHN3aXRjaCBpbiB2c3RvcmFnZS5nbyB1c2luZyBgdnN0b3JhZ2VNZXNzYWdlYCB0eXBlXG4gKlxuICogQHR5cGVkZWYgeyAnZ2V0JyB8ICdnZXRTdG9yZUtleScgfCAnaGFzJyB8ICdjaGlsZHJlbicgfCAnZW50cmllcycgfCAndmFsdWVzJyB8J3NpemUnIH0gU3RvcmFnZUdldEJ5UGF0aE1lc3NhZ2VNZXRob2RcbiAqIEB0eXBlZGVmIHsgJ3NldCcgfCAnc2V0V2l0aG91dE5vdGlmeScgfCAnYXBwZW5kJyB9IFN0b3JhZ2VVcGRhdGVFbnRyaWVzTWVzc2FnZU1ldGhvZFxuICogQHR5cGVkZWYge1N0b3JhZ2VHZXRCeVBhdGhNZXNzYWdlTWV0aG9kIHwgU3RvcmFnZVVwZGF0ZUVudHJpZXNNZXNzYWdlTWV0aG9kIH0gU3RvcmFnZU1lc3NhZ2VNZXRob2RcbiAqIEB0eXBlZGVmIHsgW3BhdGg6IHN0cmluZ10gfSBTdG9yYWdlR2V0QnlQYXRoTWVzc2FnZUFyZ3NcbiAqIEB0eXBlZGVmIHsgW3BhdGg6IHN0cmluZywgdmFsdWU/OiBzdHJpbmcgfCBudWxsXSB9IFN0b3JhZ2VFbnRyeVxuICogQHR5cGVkZWYgeyBTdG9yYWdlRW50cnlbXSB9IFN0b3JhZ2VVcGRhdGVFbnRyaWVzTWVzc2FnZUFyZ3NcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIG1ldGhvZDogU3RvcmFnZUdldEJ5UGF0aE1lc3NhZ2VNZXRob2Q7XG4gKiAgIGFyZ3M6IFN0b3JhZ2VHZXRCeVBhdGhNZXNzYWdlQXJncztcbiAqICB9IHwge1xuICogICBtZXRob2Q6IFN0b3JhZ2VVcGRhdGVFbnRyaWVzTWVzc2FnZU1ldGhvZDtcbiAqICAgYXJnczogU3RvcmFnZVVwZGF0ZUVudHJpZXNNZXNzYWdlQXJncztcbiAqIH19IFN0b3JhZ2VNZXNzYWdlXG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9uZScpLlpvbmV9IHpvbmVcbiAqL1xuY29uc3QgICAgICAgIHByZXBhcmVDaGFpblN0b3JhZ2VOb2RlPSh6b25lKT0+e1xuLyoqXG4gKiBDcmVhdGUgYSBzdG9yYWdlIG5vZGUgZm9yIGEgZ2l2ZW4gYmFja2luZyBzdG9yYWdlIGludGVyZmFjZSBhbmQgcGF0aC5cbiAqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vY2FsbGJhY2snKS5DYWxsYmFjazwobWVzc2FnZTogU3RvcmFnZU1lc3NhZ2UpID0+IGFueT59IG1lc3NlbmdlciBhIGNhbGxiYWNrXG4gKiBmb3Igc2VuZGluZyBhIHN0b3JhZ2VNZXNzYWdlIG9iamVjdCB0byB0aGUgc3RvcmFnZSBpbXBsZW1lbnRhdGlvblxuICogKGNmLiBnb2xhbmcvY29zbW9zL3gvdnN0b3JhZ2UvdnN0b3JhZ2UuZ28pXG4gKiBAcGFyYW0ge3N0cmluZ30gcGF0aFxuICogQHBhcmFtIHtvYmplY3R9IFtvcHRpb25zXVxuICogQHBhcmFtIHtib29sZWFufSBbb3B0aW9ucy5zZXF1ZW5jZV0gc2V0IHZhbHVlcyB3aXRoIGBhcHBlbmRgIG1lc3NhZ2VzIHJhdGhlciB0aGFuIGBzZXRgIG1lc3NhZ2VzXG4gKiBzbyB0aGUgYmFja2luZyBpbXBsZW1lbnRhdGlvbiBlbXBsb3lzIGEgd3JhcHBpbmcgc3RydWN0dXJlIHRoYXRcbiAqIHByZXNlcnZlcyBlYWNoIHZhbHVlIHNldCB3aXRoaW4gYSBzaW5nbGUgYmxvY2suXG4gKiBDaGlsZCBub2RlcyBkZWZhdWx0IHRvIGluaGVyaXRpbmcgdGhpcyBvcHRpb24gZnJvbSB0aGVpciBwYXJlbnQuXG4gKiBAcmV0dXJucyB7U3RvcmFnZU5vZGV9XG4gKi9cbmNvbnN0IG1ha2VDaGFpblN0b3JhZ2VOb2RlPXpvbmUuZXhvQ2xhc3MoXG4nQ2hhaW5TdG9yYWdlTm9kZScsXG5DaGFpblN0b3JhZ2VOb2RlSSxcbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2NhbGxiYWNrJykuQ2FsbGJhY2s8KG1lc3NhZ2U6IFN0b3JhZ2VNZXNzYWdlKSA9PiBhbnk+fSBtZXNzZW5nZXJcbiAqIEBwYXJhbSB7c3RyaW5nfSBwYXRoXG4gKiBAcGFyYW0ge29iamVjdH0gW29wdGlvbnNdXG4gKiBAcGFyYW0ge2Jvb2xlYW59IFtvcHRpb25zLnNlcXVlbmNlXVxuICovXG4obWVzc2VuZ2VyLHBhdGgse3NlcXVlbmNlPWZhbHNlfT17fSk9PntcbmFzc2VydC50eXBlb2YocGF0aCwnc3RyaW5nJyk7XG5hc3NlcnQudHlwZW9mKHNlcXVlbmNlLCdib29sZWFuJyk7XG5yZXR1cm4gaGFyZGVuKHtwYXRoLG1lc3NlbmdlcixzZXF1ZW5jZX0pO1xuIH0sXG57XG5nZXRQYXRoKCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5wYXRoO1xuIH0sXG4vKipcbiAqIEBkZXByZWNhdGVkIHVzZSBnZXRQYXRoXG4gKiBAdHlwZSB7KCkgPT4gUHJvbWlzZTxWU3RvcmFnZUtleT59XG4gKi9cbiAgICAgIGFzeW5jIGdldFN0b3JlS2V5KCl7XG5jb25zdHtwYXRoLG1lc3Nlbmdlcn09dGhpcy5zdGF0ZTtcbnJldHVybiBjYi5jYWxsRShtZXNzZW5nZXIse1xubWV0aG9kOidnZXRTdG9yZUtleScsXG5hcmdzOltwYXRoXX0pO1xuXG4gfSxcbi8qKiBAdHlwZSB7KG5hbWU6IHN0cmluZywgY2hpbGROb2RlT3B0aW9ucz86IHtzZXF1ZW5jZT86IGJvb2xlYW59KSA9PiBTdG9yYWdlTm9kZX0gKi9cbm1ha2VDaGlsZE5vZGUobmFtZSxjaGlsZE5vZGVPcHRpb25zPXt9KXtcbmNvbnN0e3NlcXVlbmNlLHBhdGgsbWVzc2VuZ2VyfT10aGlzLnN0YXRlO1xuYXNzZXJ0UGF0aFNlZ21lbnQobmFtZSk7XG5jb25zdCBtZXJnZWRPcHRpb25zPXtzZXF1ZW5jZSwuLi5jaGlsZE5vZGVPcHRpb25zfTtcbnJldHVybiBtYWtlQ2hhaW5TdG9yYWdlTm9kZShcbm1lc3NlbmdlcixcbiBgJHtwYXRofS4ke25hbWV9YCxcbm1lcmdlZE9wdGlvbnMpO1xuXG4gfSxcbi8qKiBAdHlwZSB7KHZhbHVlOiBzdHJpbmcpID0+IFByb21pc2U8dm9pZD59ICovXG4gICAgICBhc3luYyBzZXRWYWx1ZSh2YWx1ZSl7XG5jb25zdHtzZXF1ZW5jZSxwYXRoLG1lc3Nlbmdlcn09dGhpcy5zdGF0ZTtcbmFzc2VydC50eXBlb2YodmFsdWUsJ3N0cmluZycpO1xuLyoqIEB0eXBlIHtTdG9yYWdlRW50cnl9ICovXG5sZXQgZW50cnk7XG5pZighc2VxdWVuY2UmJiF2YWx1ZSl7XG5lbnRyeT1bcGF0aF07XG4gfWVsc2V7XG5lbnRyeT1bcGF0aCx2YWx1ZV07XG4gfVxuYXdhaXQgY2IuY2FsbEUobWVzc2VuZ2VyLHtcbm1ldGhvZDpzZXF1ZW5jZT8nYXBwZW5kJzonc2V0JyxcbmFyZ3M6W2VudHJ5XX0pO1xuXG4gfVxuLyogUG9zc2libGUgZXh0ZW5zaW9uczoqL1xuLyogKiBnZXRWYWx1ZSgpKi9cbi8qICogZ2V0Q2hpbGROYW1lcygpIGFuZC9vciBtYWtlQ2hpbGROb2RlcygpKi9cbi8qICogZ2V0TmFtZSgpKi9cbi8qICogcmVjdXJzaXZlIGRlbGV0ZSovXG4vKiAqIGJhdGNoIG9wZXJhdGlvbnMqL1xuLyogKiBsb2NhbCBidWZmZXJpbmcgKHdpdGggZW5kLW9mLWJsb2NrIGNvbW1pdCkqL30pO1xuXG5cbnJldHVybiBtYWtlQ2hhaW5TdG9yYWdlTm9kZTtcbiB9OyRo4oCNX29uY2UucHJlcGFyZUNoYWluU3RvcmFnZU5vZGUocHJlcGFyZUNoYWluU3RvcmFnZU5vZGUpO1xuXG5jb25zdCBtYWtlSGVhcENoYWluU3RvcmFnZU5vZGU9cHJlcGFyZUNoYWluU3RvcmFnZU5vZGUoaGVhcFpvbmUpO1xuXG4vKipcbiAqIENyZWF0ZSBhIGhlYXAtYmFzZWQgcm9vdCBzdG9yYWdlIG5vZGUgZm9yIGEgZ2l2ZW4gYmFja2luZyBmdW5jdGlvbiBhbmQgcm9vdCBwYXRoLlxuICpcbiAqIEBwYXJhbSB7KG1lc3NhZ2U6IFN0b3JhZ2VNZXNzYWdlKSA9PiBhbnl9IGhhbmRsZVN0b3JhZ2VNZXNzYWdlIGEgZnVuY3Rpb24gZm9yXG4gKiBzZW5kaW5nIGEgc3RvcmFnZU1lc3NhZ2Ugb2JqZWN0IHRvIHRoZSBzdG9yYWdlIGltcGxlbWVudGF0aW9uXG4gKiAoY2YuIGdvbGFuZy9jb3Ntb3MveC92c3RvcmFnZS92c3RvcmFnZS5nbylcbiAqIEBwYXJhbSB7c3RyaW5nfSByb290UGF0aFxuICogQHBhcmFtIHtvYmplY3R9IFtyb290T3B0aW9uc11cbiAqIEBwYXJhbSB7Ym9vbGVhbn0gW3Jvb3RPcHRpb25zLnNlcXVlbmNlXSBlbXBsb3kgYSB3cmFwcGluZyBzdHJ1Y3R1cmUgdGhhdFxuICogcHJlc2VydmVzIGVhY2ggdmFsdWUgc2V0IHdpdGhpbiBhIHNpbmdsZSBibG9jaywgYW5kIGRlZmF1bHQgY2hpbGQgbm9kZXNcbiAqIHRvIGRvIHRoZSBzYW1lXG4gKi9cbmZ1bmN0aW9uICAgICAgICBtYWtlQ2hhaW5TdG9yYWdlUm9vdChcbmhhbmRsZVN0b3JhZ2VNZXNzYWdlLFxucm9vdFBhdGgsXG5yb290T3B0aW9ucz17fSlcbntcbmNvbnN0IG1lc3Nlbmdlcj1jYi5tYWtlRnVuY3Rpb25DYWxsYmFjayhoYW5kbGVTdG9yYWdlTWVzc2FnZSk7XG5cbi8qIFVzZSB0aGUgaGVhcFpvbmUgZGlyZWN0bHkuKi9cbmNvbnN0IHJvb3ROb2RlPW1ha2VIZWFwQ2hhaW5TdG9yYWdlTm9kZShtZXNzZW5nZXIscm9vdFBhdGgscm9vdE9wdGlvbnMpO1xucmV0dXJuIHJvb3ROb2RlO1xuIH1cblxuLyoqXG4gKiBAcmV0dXJucyB7U3RvcmFnZU5vZGV9IGFuIG9iamVjdCB0aGF0IGNvbmZpcm1zIHRvIFN0b3JhZ2VOb2RlIEFQSSBidXQgZG9lcyBub3Qgc3RvcmUgYW55d2hlcmUuXG4gKi9cbmNvbnN0IG1ha2VOdWxsU3RvcmFnZU5vZGU9KCk9Pntcbi8qIFhYWCByZS11c2UgXCJDaGFpblN0b3JhZ2VcIiBtZXRob2RzIGFib3ZlIHdoaWNoIGRvbid0IGFjdHVhbGx5IGRlcGVuZCBvbiBjaGFpbnMqL1xucmV0dXJuIG1ha2VDaGFpblN0b3JhZ2VSb290KCgpPT5udWxsLCdudWxsJyk7XG4gfTtcblxuLyoqXG4gKiBDb252ZW5pZW5jZSBmdW5jdGlvbiBmb3IgcmV0dXJuaW5nIGEgc3RvcmFnZSBub2RlIGF0IG9yIHVuZGVyIGl0cyBpbnB1dCxcbiAqIGZhbGxpbmcgYmFjayB0byBhbiBpbmVydCBvYmplY3Qgd2l0aCB0aGUgY29ycmVjdCBpbnRlcmZhY2UgKGJ1dCBpbmNvbXBsZXRlXG4gKiBiZWhhdmlvcikgd2hlbiB0aGF0IGlzIHVuYXZhaWxhYmxlLlxuICpcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjxTdG9yYWdlTm9kZT8+fSBzdG9yYWdlTm9kZVJlZlxuICogQHBhcmFtIHtzdHJpbmd9IGNoaWxkTmFtZVxuICogQHJldHVybnMge1Byb21pc2U8U3RvcmFnZU5vZGU+fVxuICovXG5hc3luYyBmdW5jdGlvbiAgICAgICAgbWFrZVN0b3JhZ2VOb2RlQ2hpbGQoc3RvcmFnZU5vZGVSZWYsY2hpbGROYW1lKXtcbmNvbnN0IGV4aXN0aW5nU3RvcmFnZU5vZGU9YXdhaXQgc3RvcmFnZU5vZGVSZWY7XG5jb25zdCBzdG9yYWdlTm9kZT1leGlzdGluZ1N0b3JhZ2VOb2RlfHxtYWtlTnVsbFN0b3JhZ2VOb2RlKCk7XG5yZXR1cm4gRShzdG9yYWdlTm9kZSkubWFrZUNoaWxkTm9kZShjaGlsZE5hbWUpO1xuIH1cbmhhcmRlbihtYWtlU3RvcmFnZU5vZGVDaGlsZCk7XG5cbi8qIFRPRE8gZmluZCBhIGJldHRlciBtb2R1bGUgZm9yIHRoaXMqL1xuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BlbmRvL2ZhcicpLkVSZWY8U3RvcmFnZU5vZGU+fSBzdG9yYWdlTm9kZVxuICogQHBhcmFtIHtYaW1wb3J0KCdAZW5kby9mYXInKS5FUmVmPE1hcnNoYWxsZXI+fSBtYXJzaGFsbGVyXG4gKiBAcmV0dXJucyB7KHZhbHVlOiB1bmtub3duKSA9PiBQcm9taXNlPHZvaWQ+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVNlcmlhbGl6ZVRvU3RvcmFnZT0oc3RvcmFnZU5vZGUsbWFyc2hhbGxlcik9PntcbnJldHVybiBhc3luYyh2YWx1ZSk9PntcbmNvbnN0IG1hcnNoYWxsZWQ9YXdhaXQgRShtYXJzaGFsbGVyKS50b0NhcERhdGEodmFsdWUpO1xuY29uc3Qgc2VyaWFsaXplZD1KU09OLnN0cmluZ2lmeShtYXJzaGFsbGVkKTtcbnJldHVybiBFKHN0b3JhZ2VOb2RlKS5zZXRWYWx1ZShzZXJpYWxpemVkKTtcbiB9O1xuIH07JGjigI1fb25jZS5tYWtlU2VyaWFsaXplVG9TdG9yYWdlKG1ha2VTZXJpYWxpemVUb1N0b3JhZ2UpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzU3RyZWFtQ2VsbCI6WyJpc1N0cmVhbUNlbGwiXSwiYXNzZXJ0Q2FwRGF0YSI6WyJhc3NlcnRDYXBEYXRhIl0sInVubWFyc2hhbEZyb21Wc3RvcmFnZSI6WyJ1bm1hcnNoYWxGcm9tVnN0b3JhZ2UiXSwiYXNzZXJ0UGF0aFNlZ21lbnQiOlsiYXNzZXJ0UGF0aFNlZ21lbnQiXSwicHJlcGFyZUNoYWluU3RvcmFnZU5vZGUiOlsicHJlcGFyZUNoYWluU3RvcmFnZU5vZGUiXSwibWFrZUNoYWluU3RvcmFnZVJvb3QiOlsibWFrZUNoYWluU3RvcmFnZVJvb3QiXSwibWFrZVN0b3JhZ2VOb2RlQ2hpbGQiOlsibWFrZVN0b3JhZ2VOb2RlQ2hpbGQiXSwibWFrZVNlcmlhbGl6ZVRvU3RvcmFnZSI6WyJtYWtlU2VyaWFsaXplVG9TdG9yYWdlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGnyxEAnDwAAJw8AADEAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvbWV0aG9kLXRvb2xzLmpzeyJpbXBvcnRzIjpbIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJiaW5kQWxsTWV0aG9kcyIsImdldE1ldGhvZE5hbWVzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzT2JqZWN0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL21hcnNoYWxcIiwgW1tcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cbi8qKlxuICogQGZpbGUgbWV0aG9kLXRvb2xzIHVzZSBkeW5hbWljIHByb3BlcnR5IGxvb2t1cCwgd2hpY2ggaXMgbm90IEplc3NpZS1jb21wYXRpYmxlXG4gKi9cblxuY29uc3R7Z2V0UHJvdG90eXBlT2YsY3JlYXRlLGZyb21FbnRyaWVzLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PVxuT2JqZWN0O1xuY29uc3R7b3duS2V5cyxhcHBseX09UmVmbGVjdDtcblxuLyoqXG4gKiBQcmlvcml0aXplIHN5bWJvbHMgYXMgZWFybGllciB0aGFuIHN0cmluZ3MuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd8c3ltYm9sfSBhXG4gKiBAcGFyYW0ge3N0cmluZ3xzeW1ib2x9IGJcbiAqIEByZXR1cm5zIHstMSB8IDAgfCAxfVxuICovXG5jb25zdCBjb21wYXJlU3RyaW5naWZpZWQ9KGEsYik9PntcbmlmKHR5cGVvZiBhPT09dHlwZW9mIGIpe1xuY29uc3QgbGVmdD1TdHJpbmcoYSk7XG5jb25zdCByaWdodD1TdHJpbmcoYik7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnkqL1xucmV0dXJuIGxlZnQ8cmlnaHQ/LTE6bGVmdD5yaWdodD8xOjA7XG4gfVxuaWYodHlwZW9mIGE9PT0nc3ltYm9sJyl7XG5hc3NlcnQodHlwZW9mIGI9PT0nc3RyaW5nJyk7XG5yZXR1cm4tMTtcbiB9XG5hc3NlcnQodHlwZW9mIGE9PT0nc3RyaW5nJyk7XG5hc3NlcnQodHlwZW9mIGI9PT0nc3ltYm9sJyk7XG5yZXR1cm4gMTtcbiB9O1xuXG4vKipcbiAqIFRPRE8gQ29uc29saWRhdGUgd2l0aCB0aGUgYGdldE1ldGhvZE5hbWVzYCBpbiBgQGVuZG8vZXZlbnR1YWwtc2VuZGBcbiAqXG4gKiBAdGVtcGxhdGUge1Byb3BlcnR5S2V5fSBLXG4gKiBAcGFyYW0ge1JlY29yZDxLLCBhbnk+fSB2YWxcbiAqIEByZXR1cm5zIHtLW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRNZXRob2ROYW1lcz0odmFsKT0+e1xubGV0IGxheWVyPXZhbDtcbmNvbnN0IG5hbWVzPW5ldyBTZXQoKTsvKiBTZXQgdG8gZGVkdXBsaWNhdGUqL1xud2hpbGUobGF5ZXIhPT1udWxsJiZsYXllciE9PU9iamVjdC5wcm90b3R5cGUpe1xuLyogYmUgdG9sZXJhbnQgb2Ygbm9uLW9iamVjdHMqL1xuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhsYXllcik7XG5jb25zdCBvd25OYW1lcz0vKiogQHR5cGUge0tbXX0gKi9vd25LZXlzKGRlc2NzKTtcbmZvcihjb25zdCBuYW1lIG9mIG93bk5hbWVzKXtcbi8qIEluIGNhc2UgYSBtZXRob2QgaXMgb3ZlcnJpZGRlbiBieSBhIG5vbi1tZXRob2QsKi9cbi8qIHRlc3QgYHZhbFtuYW1lXWAgcmF0aGVyIHRoYW4gYGxheWVyW25hbWVdYCovXG5pZih0eXBlb2YgdmFsW25hbWVdPT09J2Z1bmN0aW9uJyl7XG5uYW1lcy5hZGQobmFtZSk7XG4gfVxuIH1cbmlmKCFpc09iamVjdCh2YWwpKXtcbmJyZWFrO1xuIH1cbmxheWVyPWdldFByb3RvdHlwZU9mKGxheWVyKTtcbiB9XG5yZXR1cm4gaGFyZGVuKFsuLi5uYW1lc10uc29ydChjb21wYXJlU3RyaW5naWZpZWQpKTtcbiB9OyRo4oCNX29uY2UuZ2V0TWV0aG9kTmFtZXMoZ2V0TWV0aG9kTmFtZXMpO1xuaGFyZGVuKGdldE1ldGhvZE5hbWVzKTtcblxuLyoqXG4gKiBUT0RPIFRoaXMgZnVuY3Rpb24gZXhpc3RzIG9ubHkgdG8gZWFzZSB0aGVcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9wdWxsLzU5NzAgdHJhbnNpdGlvbiwgZnJvbSBhbGwgbWV0aG9kc1xuICogYmVpbmcgb3duIHByb3BlcnRpZXMgdG8gbWV0aG9kcyBiZWluZyBpbmhlcml0ZWQgZnJvbSBhIGNvbW1vbiBwcm90b3R5cGUuXG4gKiBUaGlzIHRyYW5zaXRpb24gYnJlYWtzIHR3byBwYXR0ZXJucyB1c2VkIGluIHByaW9yIGNvZGU6IGF1dG9iaW5kaW5nLFxuICogYW5kIGVudW1lcmF0aW5nIG1ldGhvZHMgYnkgZW51bWVyYXRpbmcgb3duIHByb3BlcnRpZXMuIEZvciBib3RoLCB0aGVcbiAqIHByZWZlcnJlZCByZXBhaXJzIGFyZVxuICogICAgKiBhdXRvYmluZGluZzogUmVwbGFjZSwgZm9yIGV4YW1wbGUsXG4gKiAgICAgIGBmb28ob2JqLm1ldGhvZClgIHdpdGggYGZvbyhhcmcgPT4gYG9iai5tZXRob2QoYXJnKSlgLiBJT1csIHN0b3AgcmVseWluZ1xuICogICAgICBvbiBleHByZXNzaW9ucyBsaWtlIGBvYmoubWV0aG9kYCB0byBleHRyYWN0IGEgbWV0aG9kIHN0aWxsIGJvdW5kIHRvIHRoZVxuICogICAgICBzdGF0ZSBvZiBgb2JqYCBiZWNhdXNlLCBmb3IgdmlydHVhbCBhbmQgZHVyYWJsZSBvYmplY3RzLFxuICogICAgICB0aGV5IG5vIGxvbmdlciB3aWxsIGFmdGVyICM1OTcwLlxuICogICAgKiBtZXRob2QgZW51bWVyYXRpb246IFJlcGxhY2UsIGZvciBleGFtcGxlXG4gKiAgICAgIGBSZWZsZWN0Lm93bktleXMob2JqKWAgd2l0aCBgZ2V0TWV0aG9kTmFtZXMob2JqKWAuXG4gKlxuICogT25jZSBhbGwgcHJvYmxlbWF0aWMgY2FzZXMgaGF2ZSBiZWVuIGNvbnZlcnRlZCBpbiB0aGlzIG1hbm5lciwgdGhpc1xuICogYGJpbmRBbGxNZXRob2RzYCBoYWNrIGNhbiBhbmQgVE9ETyBzaG91bGQgYmUgZGVsZXRlZC4gSG93ZXZlciwgd2UgY3VycmVudGx5XG4gKiBoYXZlIG5vIHJlbGlhYmxlIHN0YXRpYyB3YXkgdG8gdHJhY2sgZG93biBhbmQgZml4IGFsbCBhdXRvYmluZGluZyBzaXRlcy5cbiAqIEZvciB0aG9zZSBvYmplY3RzIHRoYXQgaGF2ZSBub3QgeWV0IGJlZW4gZnVsbHkgcmVwYWlyZWQgYnkgdGhlIGFib3ZlIHR3b1xuICogdGVjaG5pcXVlcywgYGJpbmRBbGxNZXRob2RzYCBjcmVhdGVzIGFuIG9iamVjdCB0aGF0IGFjdHMgbXVjaCBsaWtlIHRoZVxuICogcHJlLSM1OTcwIG9iamVjdHMsIHdpdGggYWxsIHRoZWlyIG1ldGhvZHMgYXMgaW5zdGFuY2UtYm91bmQgb3duIHByb3BlcnRpZXMuXG4gKiBJdCBkb2VzIHRoaXMgYnkgbWFraW5nIGEgbmV3IG9iamVjdCBpbmhlcml0aW5nIGZyb20gYG9iamAgd2hlcmUgdGhlIG5ld1xuICogb2JqZWN0IGhhcyBib3VuZCBvd24gbWV0aG9kcyBvdmVycmlkZGluZyBhbGwgdGhlIG1ldGhvZHMgaXQgd291bGQgaGF2ZVxuICogaW5oZXJpdGVkIGZyb20gYG9iamAuXG4gKlxuICogQHRlbXBsYXRlIHtSZWNvcmQ8UHJvcGVydHlLZXksIGFueT59IFRcbiAqIEBwYXJhbSB7VH0gb2JqXG4gKiBAcmV0dXJucyB7VH1cbiAqL1xuY29uc3QgICAgICAgIGJpbmRBbGxNZXRob2RzPShvYmopPT5cbmhhcmRlbihcbmNyZWF0ZShcbm9iaixcbmZyb21FbnRyaWVzKFxuZ2V0TWV0aG9kTmFtZXMob2JqKS5tYXAoKG5hbWUpPT5bXG5uYW1lLFxue1xudmFsdWU6KC8qKiBAdHlwZSB7dW5rbm93bltdfSAqLy4uLmFyZ3MpPT5cbmFwcGx5KG9ialtuYW1lXSxvYmosYXJncyksXG5lbnVtZXJhYmxlOnRydWV9XSkpKSk7JGjigI1fb25jZS5iaW5kQWxsTWV0aG9kcyhiaW5kQWxsTWV0aG9kcyk7XG5cblxuXG5cblxuaGFyZGVuKGJpbmRBbGxNZXRob2RzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRNZXRob2ROYW1lcyI6WyJnZXRNZXRob2ROYW1lcyJdLCJiaW5kQWxsTWV0aG9kcyI6WyJiaW5kQWxsTWV0aG9kcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABUOfoRLQIAAC0CAAAvAAAAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGVuZG8vcGF0dGVybnMiXSwiZXhwb3J0cyI6WyJTdG9yYWdlTm9kZVNoYXBlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IE07JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGF0dGVybnNcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cbmNvbnN0ICAgICAgICBTdG9yYWdlTm9kZVNoYXBlPU0ucmVtb3RhYmxlKCdTdG9yYWdlTm9kZScpOyRo4oCNX29uY2UuU3RvcmFnZU5vZGVTaGFwZShTdG9yYWdlTm9kZVNoYXBlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJTdG9yYWdlTm9kZVNoYXBlIjpbIlN0b3JhZ2VOb2RlU2hhcGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA3saijCsHAAArBwAAMAAAAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy91cGdyYWRlLWFwaS5qc3siaW1wb3J0cyI6WyJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiaXNVcGdyYWRlRGlzY29ubmVjdGlvbiIsIm1ha2VVcGdyYWRlRGlzY29ubmVjdGlvbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBpc09iamVjdDskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJpc09iamVjdFwiLCBbJGjigI1fYSA9PiAoaXNPYmplY3QgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cbi8qKlxuICogQHR5cGVkZWYge3sgbmFtZTogc3RyaW5nLCB1cGdyYWRlTWVzc2FnZTogc3RyaW5nLCBpbmNhcm5hdGlvbk51bWJlcjogbnVtYmVyIH19IERpc2Nvbm5lY3Rpb25PYmplY3RcbiAqL1xuXG4vKipcbiAqIE1ha2VzIGFuIEVycm9yLWxpa2Ugb2JqZWN0IGZvciB1c2UgYXMgdGhlIHJlamVjdGlvbiB2YWx1ZSBvZiBwcm9taXNlc1xuICogYWJhbmRvbmVkIGJ5IHVwZ3JhZGUuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IHVwZ3JhZGVNZXNzYWdlXG4gKiBAcGFyYW0ge251bWJlcn0gdG9JbmNhcm5hdGlvbk51bWJlclxuICogQHJldHVybnMge0Rpc2Nvbm5lY3Rpb25PYmplY3R9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlVXBncmFkZURpc2Nvbm5lY3Rpb249KHVwZ3JhZGVNZXNzYWdlLHRvSW5jYXJuYXRpb25OdW1iZXIpPT5cbmhhcmRlbih7XG5uYW1lOid2YXRVcGdyYWRlZCcsXG51cGdyYWRlTWVzc2FnZSxcbmluY2FybmF0aW9uTnVtYmVyOnRvSW5jYXJuYXRpb25OdW1iZXJ9KTskaOKAjV9vbmNlLm1ha2VVcGdyYWRlRGlzY29ubmVjdGlvbihtYWtlVXBncmFkZURpc2Nvbm5lY3Rpb24pO1xuXG5oYXJkZW4obWFrZVVwZ3JhZGVEaXNjb25uZWN0aW9uKTtcblxuLyogVE9ETzogU2ltcGxpZnkgb25jZSB3ZSBoYXZlIEBlbmRvL3BhdHRlcm5zIChvciBqdXN0IGV4cG9ydCB0aGUgc2hhcGUpLiovXG4vKiBjb25zdCB1cGdyYWRlRGlzY29ubmVjdGlvblNoYXBlID0gaGFyZGVuKHsqL1xuLyogbmFtZTogJ3ZhdFVwZ3JhZGVkJywqL1xuLyogdXBncmFkZU1lc3NhZ2U6IE0uc3RyaW5nKCksKi9cbi8qIGluY2FybmF0aW9uTnVtYmVyOiBNLm51bWJlcigpLCovXG4vKiB9KTsqL1xuLyogY29uc3QgaXNVcGdyYWRlRGlzY29ubmVjdGlvbiA9IGVyciA9PiBtYXRjaGVzKGVyciwgdXBncmFkZURpc2Nvbm5lY3Rpb25TaGFwZSk7Ki9cbi8qKlxuICogQHBhcmFtIHthbnl9IGVyclxuICogQHJldHVybnMge2VyciBpcyBEaXNjb25uZWN0aW9uT2JqZWN0fVxuICovXG5jb25zdCAgICAgICAgaXNVcGdyYWRlRGlzY29ubmVjdGlvbj0oZXJyKT0+XG5pc09iamVjdChlcnIpJiZcbmVyci5uYW1lPT09J3ZhdFVwZ3JhZGVkJyYmXG50eXBlb2YgZXJyLnVwZ3JhZGVNZXNzYWdlPT09J3N0cmluZycmJlxudHlwZW9mIGVyci5pbmNhcm5hdGlvbk51bWJlcj09PSdudW1iZXInOyRo4oCNX29uY2UuaXNVcGdyYWRlRGlzY29ubmVjdGlvbihpc1VwZ3JhZGVEaXNjb25uZWN0aW9uKTtcbmhhcmRlbihpc1VwZ3JhZGVEaXNjb25uZWN0aW9uKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlVXBncmFkZURpc2Nvbm5lY3Rpb24iOlsibWFrZVVwZ3JhZGVEaXNjb25uZWN0aW9uIl0sImlzVXBncmFkZURpc2Nvbm5lY3Rpb24iOlsiaXNVcGdyYWRlRGlzY29ubmVjdGlvbiJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACi6bGS4zwAAOM8AAAqAAAAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL3V0aWxzLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2ZhciIsIkBlbmRvL21hcnNoYWwiLCJAZW5kby9wcm9taXNlLWtpdCIsIkBlbmRvL3N0cmVhbSIsImplc3NpZS5qcyJdLCJleHBvcnRzIjpbIkJBU0lTX1BPSU5UUyIsIlByb21pc2VBbGxPckVycm9ycyIsImFnZ3JlZ2F0ZVRyeUZpbmFsbHkiLCJhbGxWYWx1ZXMiLCJhcHBseUxhYmVsaW5nRXJyb3IiLCJhc3NlcnRBbGxEZWZpbmVkIiwiZGVlcGx5RnVsZmlsbGVkT2JqZWN0IiwiZm9yZXZlciIsImZyb21VbmlxdWVFbnRyaWVzIiwibGlzdERpZmZlcmVuY2UiLCJtYWtlQWdncmVnYXRlRXJyb3IiLCJtYWtlTWVhc3VyZVNlY29uZHMiLCJvYmplY3RNYXAiLCJzeW5jaHJvbml6ZWRUZWUiLCJ0aHJvd0xhYmVsZWQiLCJ1bnRpbFRydWUiLCJ3aGlsZVRydWUiLCJ6aXAiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRSxkZWVwbHlGdWxmaWxsZWQsaXNPYmplY3QsaXNQcm9taXNlLG1ha2VQcm9taXNlS2l0LG1ha2VRdWV1ZSxhc3luY0dlbmVyYXRlLG1ha2VTZXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcImRlZXBseUZ1bGZpbGxlZFwiLCBbJGjigI1fYSA9PiAoZGVlcGx5RnVsZmlsbGVkID0gJGjigI1fYSldXSxbXCJpc09iamVjdFwiLCBbJGjigI1fYSA9PiAoaXNPYmplY3QgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXSxbXCJtYWtlUHJvbWlzZUtpdFwiLCBbJGjigI1fYSA9PiAobWFrZVByb21pc2VLaXQgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vc3RyZWFtXCIsIFtbXCJtYWtlUXVldWVcIiwgWyRo4oCNX2EgPT4gKG1ha2VRdWV1ZSA9ICRo4oCNX2EpXV1dXSxbXCJqZXNzaWUuanNcIiwgW1tcImFzeW5jR2VuZXJhdGVcIiwgWyRo4oCNX2EgPT4gKGFzeW5jR2VuZXJhdGUgPSAkaOKAjV9hKV1dLFtcIm1ha2VTZXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VTZXQgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5jb25zdHtlbnRyaWVzLGZyb21FbnRyaWVzLGtleXMsdmFsdWVzfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG5jb25zdHtkZXRhaWxzOlgscXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5cbmNvbnN0ICAgICAgICBCQVNJU19QT0lOVFM9MTBfMDAwbjtcblxuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9ldmVudHVhbC1zZW5kJykuRVJlZjxUPn0gRVJlZjxUPiAqL1xuXG4vKipcbiAqIFRocm93cyBpZiBtdWx0aXBsZSBlbnRyaWVzIHVzZSB0aGUgc2FtZSBwcm9wZXJ0eSBuYW1lLiBPdGhlcndpc2UgYWN0c1xuICogbGlrZSBgT2JqZWN0LmZyb21FbnRyaWVzYCBidXQgaGFyZGVucyB0aGUgcmVzdWx0LlxuICogVXNlIGl0IHRvIHByb3RlY3QgZnJvbSBwcm9wZXJ0eSBuYW1lcyBjb21wdXRlZCBmcm9tIHVzZXItcHJvdmlkZWQgZGF0YS5cbiAqXG4gKiBAdGVtcGxhdGUgSyxWXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtLLFZdPn0gYWxsRW50cmllc1xuICogQHJldHVybnMge3tbazogS106IFZ9fVxuICovJGjigI1fb25jZS5CQVNJU19QT0lOVFMoQkFTSVNfUE9JTlRTKTtcbmNvbnN0ICAgICAgICBmcm9tVW5pcXVlRW50cmllcz0oYWxsRW50cmllcyk9PntcbmNvbnN0IGVudHJpZXNBcnJheT1bLi4uYWxsRW50cmllc107XG5jb25zdCByZXN1bHQ9aGFyZGVuKGZyb21FbnRyaWVzKGVudHJpZXNBcnJheSkpO1xuaWYob3duS2V5cyhyZXN1bHQpLmxlbmd0aD09PWVudHJpZXNBcnJheS5sZW5ndGgpe1xucmV0dXJuIHJlc3VsdDtcbiB9XG5jb25zdCBuYW1lcz1tYWtlU2V0KCk7XG5mb3IoY29uc3RbbmFtZSxfXW9mIGVudHJpZXNBcnJheSl7XG5pZihuYW1lcy5oYXMobmFtZSkpe1xuRmFpbCBgY29sbGlzaW9uIG9uIHByb3BlcnR5IG5hbWUgJHtxKG5hbWUpfTogJHtlbnRyaWVzQXJyYXl9YDtcbiB9XG5uYW1lcy5hZGQobmFtZSk7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IGZhaWxlZCB0byBjcmVhdGUgb2JqZWN0IGZyb20gdW5pcXVlIGVudHJpZXNgO1xuIH07JGjigI1fb25jZS5mcm9tVW5pcXVlRW50cmllcyhmcm9tVW5pcXVlRW50cmllcyk7XG5oYXJkZW4oZnJvbVVuaXF1ZUVudHJpZXMpO1xuXG4vKipcbiAqIEJ5IGFuYWxvZ3kgd2l0aCBob3cgYEFycmF5LnByb3RvdHlwZS5tYXBgIHdpbGwgbWFwIHRoZSBlbGVtZW50cyBvZlxuICogYW4gYXJyYXkgdG8gdHJhbnNmb3JtZWQgZWxlbWVudHMgb2YgYW4gYXJyYXkgb2YgdGhlIHNhbWUgc2hhcGUsXG4gKiBgb2JqZWN0TWFwYCB3aWxsIGRvIGxpa2V3aXNlIGZvciB0aGUgc3RyaW5nLW5hbWVkIG93biBlbnVtZXJhYmxlXG4gKiBwcm9wZXJ0aWVzIG9mIGFuIG9iamVjdC5cbiAqXG4gKiBUeXBpY2FsIHVzYWdlIGFwcGxpZXMgYG9iamVjdE1hcGAgdG8gYSBDb3B5UmVjb3JkLCBpLmUuLFxuICogYW4gb2JqZWN0IGZvciB3aGljaCBgcGFzc1N0eWxlT2Yob3JpZ2luYWwpID09PSAnY29weVJlY29yZCdgLiBGb3IgdGhlc2UsXG4gKiBub25lIG9mIHRoZSBmb2xsb3dpbmcgZWRnZSBjYXNlcyBhcmlzZS4gVGhlIHJlc3VsdCB3aWxsIGJlIGEgQ29weVJlY29yZFxuICogd2l0aCBleGFjdGx5IHRoZSBzYW1lIHByb3BlcnR5IG5hbWVzLCB3aG9zZSB2YWx1ZXMgYXJlIHRoZSBtYXBwZWQgZm9ybSBvZlxuICogdGhlIG9yaWdpbmFsJ3MgdmFsdWVzLlxuICpcbiAqIFdoZW4gdGhlIG9yaWdpbmFsIGlzIG5vdCBhIENvcHlSZWNvcmQsIHNvbWUgZWRnZSBjYXNlcyB0byBiZSBhd2FyZSBvZlxuICogICAgKiBObyBtYXR0ZXIgaG93IG11dGFibGUgdGhlIG9yaWdpbmFsIG9iamVjdCwgdGhlIHJldHVybmVkIG9iamVjdCBpc1xuICogICAgICBoYXJkZW5lZC5cbiAqICAgICogT25seSB0aGUgc3RyaW5nLW5hbWVkIGVudW1lcmFibGUgb3duIHByb3BlcnRpZXMgb2YgdGhlIG9yaWdpbmFsXG4gKiAgICAgIGFyZSBtYXBwZWQuIEFsbCBvdGhlciBwcm9wZXJ0aWVzIGFyZSBpZ25vcmVkLlxuICogICAgKiBJZiBhbnkgb2YgdGhlIG9yaWdpbmFsIHByb3BlcnRpZXMgd2VyZSBhY2Nlc3NvcnMsIGBPYmplY3QuZW50cmllc2BcbiAqICAgICAgd2lsbCBjYXVzZSBpdHMgYGdldHRlcmAgdG8gYmUgY2FsbGVkIGFuZCB3aWxsIHVzZSB0aGUgcmVzdWx0aW5nXG4gKiAgICAgIHZhbHVlLlxuICogICAgKiBObyBtYXR0ZXIgd2hldGhlciB0aGUgb3JpZ2luYWwgcHJvcGVydHkgd2FzIGFuIGFjY2Vzc29yLCB3cml0YWJsZSxcbiAqICAgICAgb3IgY29uZmlndXJhYmxlLCBhbGwgdGhlIHByb3BlcnRpZXMgb2YgdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGJlXG4gKiAgICAgIG5vbi13cml0YWJsZSwgbm9uLWNvbmZpZ3VyYWJsZSwgZGF0YSBwcm9wZXJ0aWVzLlxuICogICAgKiBObyBtYXR0ZXIgd2hhdCB0aGUgb3JpZ2luYWwgb2JqZWN0IG1heSBoYXZlIGluaGVyaXRlZCBmcm9tLCBhbmRcbiAqICAgICAgbm8gbWF0dGVyIHdoZXRoZXIgaXQgd2FzIGEgc3BlY2lhbCBraW5kIG9mIG9iamVjdCBzdWNoIGFzIGFuIGFycmF5LFxuICogICAgICB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYWx3YXlzIGJlIGEgcGxhaW4gb2JqZWN0IGluaGVyaXRpbmcgZGlyZWN0bHlcbiAqICAgICAgZnJvbSBgT2JqZWN0LnByb3RvdHlwZWAgYW5kIHdob3NlIHN0YXRlIGlzIG9ubHkgdGhlc2UgbmV3IG1hcHBlZFxuICogICAgICBvd24gcHJvcGVydGllcy5cbiAqXG4gKiBXaXRoIHRoZXNlIGRpZmZlcmVuY2VzLCBldmVuIGlmIHRoZSBvcmlnaW5hbCBvYmplY3Qgd2FzIG5vdCBhIENvcHlSZWNvcmQsXG4gKiBpZiBhbGwgdGhlIG1hcHBlZCB2YWx1ZXMgYXJlIFBhc3NhYmxlLCB0aGVuIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBiZVxuICogYSBDb3B5UmVjb3JkLlxuICpcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgYW55Pn0gT1xuICogQHBhcmFtIHtPfSBvcmlnaW5hbFxuICogQHRlbXBsYXRlIFIgbWFwIHJlc3VsdFxuICogQHBhcmFtIHsodmFsdWU6IE9ba2V5b2YgT10sIGtleToga2V5b2YgTykgPT4gUn0gbWFwRm5cbiAqIEByZXR1cm5zIHt7IFtQIGluIGtleW9mIE9dOiBSfX1cbiAqL1xuY29uc3QgICAgICAgIG9iamVjdE1hcD0ob3JpZ2luYWwsbWFwRm4pPT57XG5jb25zdCBlbnRzPWVudHJpZXMob3JpZ2luYWwpO1xuY29uc3QgbWFwRW50cz1lbnRzLm1hcCgoW2ssdl0pPT5bayxtYXBGbih2LGspXSk7XG5yZXR1cm4gaGFyZGVuKGZyb21FbnRyaWVzKG1hcEVudHMpKTtcbiB9OyRo4oCNX29uY2Uub2JqZWN0TWFwKG9iamVjdE1hcCk7XG5oYXJkZW4ob2JqZWN0TWFwKTtcblxuLyoqXG4gKiBAcGFyYW0ge0FycmF5PHN0cmluZyB8IHN5bWJvbD59IGxlZnROYW1lc1xuICogQHBhcmFtIHtBcnJheTxzdHJpbmcgfCBzeW1ib2w+fSByaWdodE5hbWVzXG4gKi9cbmNvbnN0ICAgICAgICBsaXN0RGlmZmVyZW5jZT0obGVmdE5hbWVzLHJpZ2h0TmFtZXMpPT57XG5jb25zdCByaWdodFNldD1tYWtlU2V0KHJpZ2h0TmFtZXMpO1xucmV0dXJuIGxlZnROYW1lcy5maWx0ZXIoKG5hbWUpPT4hcmlnaHRTZXQuaGFzKG5hbWUpKTtcbiB9OyRo4oCNX29uY2UubGlzdERpZmZlcmVuY2UobGlzdERpZmZlcmVuY2UpO1xuaGFyZGVuKGxpc3REaWZmZXJlbmNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge0Vycm9yfSBpbm5lckVyclxuICogQHBhcmFtIHtzdHJpbmd8bnVtYmVyfSBsYWJlbFxuICogQHBhcmFtIHtFcnJvckNvbnN0cnVjdG9yfSBbRXJyb3JDb25zdHJ1Y3Rvcl1cbiAqIEByZXR1cm5zIHtuZXZlcn1cbiAqL1xuY29uc3QgICAgICAgIHRocm93TGFiZWxlZD0oaW5uZXJFcnIsbGFiZWwsRXJyb3JDb25zdHJ1Y3Rvcj11bmRlZmluZWQpPT57XG5pZih0eXBlb2YgbGFiZWw9PT0nbnVtYmVyJyl7XG5sYWJlbD0gYFske2xhYmVsfV1gO1xuIH1cbmNvbnN0IG91dGVyRXJyPWFzc2VydC5lcnJvcihcbiBgJHtsYWJlbH06ICR7aW5uZXJFcnIubWVzc2FnZX1gLFxuRXJyb3JDb25zdHJ1Y3Rvcik7XG5cbmFzc2VydC5ub3RlKG91dGVyRXJyLFggYENhdXNlZCBieSAke2lubmVyRXJyfWApO1xudGhyb3cgb3V0ZXJFcnI7XG4gfTskaOKAjV9vbmNlLnRocm93TGFiZWxlZCh0aHJvd0xhYmVsZWQpO1xuaGFyZGVuKHRocm93TGFiZWxlZCk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEEsUlxuICogQHBhcmFtIHsoLi4uYXJnczogQVtdKSA9PiBSfSBmdW5jXG4gKiBAcGFyYW0ge0FbXX0gYXJnc1xuICogQHBhcmFtIHtzdHJpbmd8bnVtYmVyfSBbbGFiZWxdXG4gKiBAcmV0dXJucyB7Un1cbiAqL1xuY29uc3QgICAgICAgIGFwcGx5TGFiZWxpbmdFcnJvcj0oZnVuYyxhcmdzLGxhYmVsPXVuZGVmaW5lZCk9PntcbmlmKGxhYmVsPT09dW5kZWZpbmVkKXtcbnJldHVybiBmdW5jKC4uLmFyZ3MpO1xuIH1cbmxldCByZXN1bHQ7XG50cnl7XG5yZXN1bHQ9ZnVuYyguLi5hcmdzKTtcbiB9Y2F0Y2goZXJyKXtcbnRocm93TGFiZWxlZChlcnIsbGFiZWwpO1xuIH1cbmlmKGlzUHJvbWlzZShyZXN1bHQpKXtcbi8qIElmIHJlc3VsdCBpcyBhIHJlamVjdGVkIHByb21pc2UsIHRoaXMgd2lsbCByZXR1cm4gYSBwcm9taXNlIHdpdGggYSovXG4vKiBkaWZmZXJlbnQgcmVqZWN0aW9uIHJlYXNvbi4gQnV0IHRoaXMgY29uZnVzZXMgVHlwZVNjcmlwdCBiZWNhdXNlIGl0IHR5cGVzKi9cbi8qIHRoYXQgY2FzZSBhcyBgUHJvbWlzZTxuZXZlcj5gIHdoaWNoIGlzIGNvb2wgZm9yIGEgcHJvbWlzZSB0aGF0IHdpbGwgbmV2ZXIqL1xuLyogZnVsZmlsbC4gIEJ1dCBUeXBlU2NyaXB0IGRvZXNuJ3QgdW5kZXJzdGFuZCB0aGF0IHRoaXMgd2lsbCBvbmx5IGhhcHBlbiovXG4vKiB3aGVuIGByZXN1bHRgIHdhcyBhIHJlamVjdGVkIHByb21pc2UuIEluIG9ubHkgdGhpcyBjYXNlIGBSYCBzaG91bGQqL1xuLyogYWxyZWFkeSBhbGxvdyBgUHJvbWlzZTxuZXZlcj5gIGFzIGEgc3VidHlwZS4qL1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL1xuY29uc3QgcmVsYWJlbGVkPUUud2hlbihyZXN1bHQsdW5kZWZpbmVkLChyZWFzb24pPT5cbnRocm93TGFiZWxlZChyZWFzb24sbGFiZWwpKTtcblxucmV0dXJuICgvKiogQHR5cGUge1J9ICovcmVsYWJlbGVkKTtcbiB9ZWxzZXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH07JGjigI1fb25jZS5hcHBseUxhYmVsaW5nRXJyb3IoYXBwbHlMYWJlbGluZ0Vycm9yKTtcbmhhcmRlbihhcHBseUxhYmVsaW5nRXJyb3IpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7e1tLZXlUeXBlIGluIGtleW9mIFRdOiBUW0tleVR5cGVdfSAmIHt9fSBTaW1wbGlmeVxuICogZmxhdHRlbiB0aGUgdHlwZSBvdXRwdXQgdG8gaW1wcm92ZSB0eXBlIGhpbnRzIHNob3duIGluIGVkaXRvcnNcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9zaW5kcmVzb3JodXMvdHlwZS1mZXN0L2Jsb2IvbWFpbi9zb3VyY2Uvc2ltcGxpZnkuZC50c1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYgeyguLi5hcmdzOiBhbnlbXSkgPT4gYW55fSBDYWxsYWJsZVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHt7fX0gVFxuICogQHR5cGVkZWYge3sgW0sgaW4ga2V5b2YgVF06IFRbS10gZXh0ZW5kcyBDYWxsYWJsZSA/IFRbS10gOiBEZWVwbHlBd2FpdGVkPFRbS10+IH19IERlZXBseUF3YWl0ZWRPYmplY3RcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7VCBleHRlbmRzIFByb21pc2VMaWtlPGFueT4gPyBBd2FpdGVkPFQ+IDogVCBleHRlbmRzIHt9ID8gU2ltcGxpZnk8RGVlcGx5QXdhaXRlZE9iamVjdDxUPj4gOiBBd2FpdGVkPFQ+fSBEZWVwbHlBd2FpdGVkXG4gKi9cblxuLyoqXG4gKiBBIG1vcmUgY29uc3RyYWluZWQgdmVyc2lvbiBvZiB7ZGVlcGx5RnVsZmlsbGVkfSBmb3IgdHlwZSBzYWZldHkgdW50aWxcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTI1N1xuICogVXNlZnVsIGluIHN0YXJ0aW5nIGNvbnRyYWN0cyB0aGF0IG5lZWQgYWxsIHRlcm1zIHRvIGJlIGZ1bGZpbGxlZFxuICogaW4gb3JkZXIgdG8gYmUgZHVyYWJsZS5cbiAqXG4gKiBAdHlwZSB7PFQgZXh0ZW5kcyB7fT4odW5mdWxmaWxsZWRUZXJtczogVCkgPT4gUHJvbWlzZTxEZWVwbHlBd2FpdGVkPFQ+Pn1cbiAqL1xuY29uc3QgICAgICAgIGRlZXBseUZ1bGZpbGxlZE9iamVjdD1hc3luYyhvYmopPT57XG5pc09iamVjdChvYmopfHxGYWlsIGBwYXJhbSBtdXN0IGJlIGFuIG9iamVjdGA7XG5yZXR1cm4gZGVlcGx5RnVsZmlsbGVkKG9iaik7XG4gfTtcblxuLyoqXG4gKiBSZXR1cm5zIGEgZnVuY3Rpb24gdGhhdCB1c2VzIGEgbWlsbGlzZWNvbmQtYmFzZWQgdGltZS1zaW5jZS1lcG9jaCBjYXBhYmlsaXR5XG4gKiAoc3VjaCBhcyBgcGVyZm9ybWFuY2Uubm93YCkgdG8gbWVhc3VyZSBleGVjdXRpb24gdGltZSBvZiBhbiBhc3luYyBmdW5jdGlvblxuICogYW5kIHJlcG9ydCB0aGUgcmVzdWx0IGluIHNlY29uZHMgdG8gbWF0Y2ggb3VyIHRlbGVtZXRyeSBzdGFuZGFyZC5cbiAqXG4gKiBAcGFyYW0ge3R5cGVvZiBYaW1wb3J0KCdwZXJmX2hvb2tzJykucGVyZm9ybWFuY2Uubm93fSBjdXJyZW50VGltZU1pbGxpc2VjXG4gKiBAcmV0dXJucyB7PFQ+KGZuOiAoKSA9PiBQcm9taXNlPFQ+KSA9PiBQcm9taXNlPHsgcmVzdWx0OiBULCBkdXJhdGlvbjogbnVtYmVyIH0+fVxuICovJGjigI1fb25jZS5kZWVwbHlGdWxmaWxsZWRPYmplY3QoZGVlcGx5RnVsZmlsbGVkT2JqZWN0KTtcbmNvbnN0ICAgICAgICBtYWtlTWVhc3VyZVNlY29uZHM9KGN1cnJlbnRUaW1lTWlsbGlzZWMpPT57XG4vKiogQHBhcmFtIHsoKSA9PiBhbnl9IGZuICovXG5jb25zdCBtZWFzdXJlU2Vjb25kcz1hc3luYyhmbik9PntcbmNvbnN0IHQwPWN1cnJlbnRUaW1lTWlsbGlzZWMoKTtcbmNvbnN0IHJlc3VsdD1hd2FpdCBmbigpO1xuY29uc3QgZHVyYXRpb25NaWxsaXNlYz1jdXJyZW50VGltZU1pbGxpc2VjKCktdDA7XG5yZXR1cm57cmVzdWx0LGR1cmF0aW9uOmR1cmF0aW9uTWlsbGlzZWMvMTAwMH07XG4gfTtcbnJldHVybiBtZWFzdXJlU2Vjb25kcztcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7RXJyb3JbXX0gZXJyb3JzXG4gKiBAcGFyYW0ge3N0cmluZ30gW21lc3NhZ2VdXG4gKi8kaOKAjV9vbmNlLm1ha2VNZWFzdXJlU2Vjb25kcyhtYWtlTWVhc3VyZVNlY29uZHMpO1xuY29uc3QgICAgICAgIG1ha2VBZ2dyZWdhdGVFcnJvcj0oZXJyb3JzLG1lc3NhZ2UpPT57XG5jb25zdCBlcnI9RXJyb3IobWVzc2FnZSk7XG5PYmplY3QuZGVmaW5lUHJvcGVydGllcyhlcnIse1xubmFtZTp7XG52YWx1ZTonQWdncmVnYXRlRXJyb3InfSxcblxuZXJyb3JzOntcbnZhbHVlOmVycm9yc319KTtcblxuXG5yZXR1cm4gZXJyO1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7cmVhZG9ubHkgKFQgfCBQcm9taXNlTGlrZTxUPilbXX0gaXRlbXNcbiAqIEByZXR1cm5zIHtQcm9taXNlPFRbXT59XG4gKi8kaOKAjV9vbmNlLm1ha2VBZ2dyZWdhdGVFcnJvcihtYWtlQWdncmVnYXRlRXJyb3IpO1xuY29uc3QgICAgICAgIFByb21pc2VBbGxPckVycm9ycz1hc3luYyhpdGVtcyk9PntcbnJldHVybiBQcm9taXNlLmFsbFNldHRsZWQoaXRlbXMpLnRoZW4oKHJlc3VsdHMpPT57XG5jb25zdCBlcnJvcnM9LyoqIEB0eXBlIHtQcm9taXNlUmVqZWN0ZWRSZXN1bHRbXX0gKi9cbnJlc3VsdHMuZmlsdGVyKCh7c3RhdHVzfSk9PnN0YXR1cz09PSdyZWplY3RlZCcpLlxubWFwKChyZXN1bHQpPT5yZXN1bHQucmVhc29uKTtcbmlmKCFlcnJvcnMubGVuZ3RoKXtcbnJldHVybiAoLyoqIEB0eXBlIHtQcm9taXNlRnVsZmlsbGVkUmVzdWx0PFQ+W119ICovcmVzdWx0cy5tYXAoXG4ocmVzdWx0KT0+cmVzdWx0LnZhbHVlKSk7XG5cbiB9ZWxzZSBpZihlcnJvcnMubGVuZ3RoPT09MSl7XG50aHJvdyBlcnJvcnNbMF07XG4gfWVsc2V7XG50aHJvdyBtYWtlQWdncmVnYXRlRXJyb3IoZXJyb3JzKTtcbiB9XG4gfSk7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7PFQ+KFxuICogICB0cmllcjogKCkgPT4gUHJvbWlzZTxUPixcbiAqICBmaW5hbGl6ZXI6IChlcnJvcj86IHVua25vd24pID0+IFByb21pc2U8dm9pZD4sXG4gKiApID0+IFByb21pc2U8VD59XG4gKi8kaOKAjV9vbmNlLlByb21pc2VBbGxPckVycm9ycyhQcm9taXNlQWxsT3JFcnJvcnMpO2NvbnN0IGFnZ3JlZ2F0ZVRyeUZpbmFsbHk9YXN5bmModHJpZXIsZmluYWxpemVyKT0+XG50cmllcigpLnRoZW4oXG5hc3luYyhyZXN1bHQpPT5maW5hbGl6ZXIoKS50aGVuKCgpPT5yZXN1bHQpLFxuYXN5bmModHJ5RXJyb3IpPT5cbmZpbmFsaXplcih0cnlFcnJvcikuXG50aGVuKFxuKCk9PnRyeUVycm9yLFxuKGZpbmFsaXplRXJyb3IpPT5tYWtlQWdncmVnYXRlRXJyb3IoW3RyeUVycm9yLGZpbmFsaXplRXJyb3JdKSkuXG5cbnRoZW4oKGVycm9yKT0+UHJvbWlzZS5yZWplY3QoZXJyb3IpKSk7XG5cblxuLyoqXG4gKiBAdGVtcGxhdGUge1JlY29yZDxzdHJpbmcsIHVua25vd24+fSBUXG4gKiBAdHlwZWRlZiB7e1tQIGluIGtleW9mIFRdOiBFeGNsdWRlPFRbUF0sIHVuZGVmaW5lZD47fX0gQWxsRGVmaW5lZFxuICovXG5cbi8qKlxuICogQ29uY2lzZSB3YXkgdG8gY2hlY2sgdmFsdWVzIGFyZSBhdmFpbGFibGUgZnJvbSBvYmplY3QgbGl0ZXJhbCBzaG9ydGhhbmQuXG4gKiBUaHJvd3MgZXJyb3IgbWVzc2FnZSB0byBzcGVjaWZ5IHRoZSBtaXNzaW5nIHZhbHVlcy5cbiAqXG4gKiBAdGVtcGxhdGUge1JlY29yZDxzdHJpbmcsIHVua25vd24+fSBUXG4gKiBAcGFyYW0ge1R9IG9ialxuICogQHRocm93cyBpZiBhbnkgdmFsdWUgaW4gdGhlIG9iamVjdCBlbnRyaWVzIGlzIG5vdCBkZWZpbmVkXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBvYmogaXMgQWxsRGVmaW5lZDxUPn1cbiAqLyRo4oCNX29uY2UuYWdncmVnYXRlVHJ5RmluYWxseShhZ2dyZWdhdGVUcnlGaW5hbGx5KTtcblxuY29uc3QgICAgICAgIGFzc2VydEFsbERlZmluZWQ9KG9iaik9PntcbmNvbnN0IG1pc3Npbmc9W107XG5mb3IoY29uc3Rba2V5LHZhbF1vZiBPYmplY3QuZW50cmllcyhvYmopKXtcbmlmKHZhbD09PXVuZGVmaW5lZCl7XG5taXNzaW5nLnB1c2goa2V5KTtcbiB9XG4gfVxuaWYobWlzc2luZy5sZW5ndGg+MCl7XG5GYWlsIGBtaXNzaW5nICR7cShtaXNzaW5nKX1gO1xuIH1cbiB9O1xuXG4vKiogQHR5cGUge0l0ZXJhdG9yUmVzdWx0PHVuZGVmaW5lZCwgbmV2ZXI+fSAqLyRo4oCNX29uY2UuYXNzZXJ0QWxsRGVmaW5lZChhc3NlcnRBbGxEZWZpbmVkKTtcbmNvbnN0IG5vdERvbmU9aGFyZGVuKHtkb25lOmZhbHNlLHZhbHVlOnVuZGVmaW5lZH0pO1xuXG4vKiogQHR5cGUge0l0ZXJhdG9yUmVzdWx0PG5ldmVyLCB2b2lkPn0gKi9cbmNvbnN0IGFsd2F5c0RvbmU9aGFyZGVuKHtkb25lOnRydWUsdmFsdWU6dW5kZWZpbmVkfSk7XG5cbmNvbnN0ICAgICAgICBmb3JldmVyPWFzeW5jR2VuZXJhdGUoKCk9Pm5vdERvbmUpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0geygpID0+IFR9IHByb2R1Y2VcbiAqIFRoZSB2YWx1ZSBvZiBgYXdhaXQgcHJvZHVjZSgpYCBpcyB1c2VkIGZvciBpdHMgdHJ1dGhpbmVzcyB2cyBmYWxzaW5lc3MuXG4gKiBJT1csIGl0IGlzIGNvZXJjZWQgdG8gYSBib29sZWFuIHNvIHRoZSBjYWxsZXIgbmVlZCBub3QgYm90aGVyIGRvaW5nIHRoaXNcbiAqIHRoZW1zZWx2ZXMuXG4gKiBAcmV0dXJucyB7QXN5bmNJdGVyYWJsZTxBd2FpdGVkPFQ+Pn1cbiAqLyRo4oCNX29uY2UuZm9yZXZlcihmb3JldmVyKTtcbmNvbnN0ICAgICAgICB3aGlsZVRydWU9KHByb2R1Y2UpPT5cbmFzeW5jR2VuZXJhdGUoYXN5bmMoKT0+e1xuY29uc3QgdmFsdWU9YXdhaXQgcHJvZHVjZSgpO1xuaWYoIXZhbHVlKXtcbnJldHVybiBhbHdheXNEb25lO1xuIH1cbnJldHVybiBoYXJkZW4oe1xuZG9uZTpmYWxzZSxcbnZhbHVlfSk7XG5cbiB9KTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHsoKSA9PiBUfSBwcm9kdWNlXG4gKiBUaGUgdmFsdWUgb2YgYGF3YWl0IHByb2R1Y2UoKWAgaXMgdXNlZCBmb3IgaXRzIHRydXRoaW5lc3MgdnMgZmFsc2luZXNzLlxuICogSU9XLCBpdCBpcyBjb2VyY2VkIHRvIGEgYm9vbGVhbiBzbyB0aGUgY2FsbGVyIG5lZWQgbm90IGJvdGhlciBkb2luZyB0aGlzXG4gKiB0aGVtc2VsdmVzLlxuICogQHJldHVybnMge0FzeW5jSXRlcmFibGU8QXdhaXRlZDxUPj59XG4gKi8kaOKAjV9vbmNlLndoaWxlVHJ1ZSh3aGlsZVRydWUpO1xuY29uc3QgICAgICAgIHVudGlsVHJ1ZT0ocHJvZHVjZSk9PlxuYXN5bmNHZW5lcmF0ZShhc3luYygpPT57XG5jb25zdCB2YWx1ZT1hd2FpdCBwcm9kdWNlKCk7XG5pZih2YWx1ZSl7XG5yZXR1cm4gaGFyZGVuKHtcbmRvbmU6dHJ1ZSxcbnZhbHVlfSk7XG5cbiB9XG5yZXR1cm4gaGFyZGVuKHtcbmRvbmU6ZmFsc2UsXG52YWx1ZX0pO1xuXG4gfSk7XG5cbi8qKiBAdHlwZSB7IDxYLCBZPih4czogWFtdLCB5czogWVtdKSA9PiBbWCwgWV1bXX0gKi8kaOKAjV9vbmNlLnVudGlsVHJ1ZSh1bnRpbFRydWUpO1xuY29uc3QgICAgICAgIHppcD0oeHMseXMpPT5oYXJkZW4oeHMubWFwKCh4LGkpPT5beCx5c1sraV1dKSk7XG5cbi8qKiBAdHlwZSB7IDxUIGV4dGVuZHMgUmVjb3JkPHN0cmluZywgRVJlZjxhbnk+Pj4ob2JqOiBUKSA9PiBQcm9taXNlPHsgW0sgaW4ga2V5b2YgVF06IEF3YWl0ZWQ8VFtLXT59PiB9ICovJGjigI1fb25jZS56aXAoemlwKTtcbmNvbnN0ICAgICAgICBhbGxWYWx1ZXM9YXN5bmMob2JqKT0+e1xuY29uc3QgcmVzb2x2ZWQ9YXdhaXQgUHJvbWlzZS5hbGwodmFsdWVzKG9iaikpO1xuLyogQHRzLWV4cGVjdC1lcnJvciBjYXN0Ki9cbnJldHVybiBoYXJkZW4oZnJvbUVudHJpZXMoemlwKGtleXMob2JqKSxyZXNvbHZlZCkpKTtcbiB9O1xuXG4vKipcbiAqIEEgdGVlIGltcGxlbWVudGF0aW9uIHdoZXJlIGFsbCByZWFkZXJzIGFyZSBzeW5jaHJvbml6ZWQgd2l0aCBlYWNoIG90aGVyLlxuICogVGhleSBhbGwgY29uc3VtZSB0aGUgc291cmNlIHN0cmVhbSBpbiBsb2Nrc3RlcCwgYW5kIGFueSBvbmUgcmV0dXJuaW5nIG9yXG4gKiB0aHJvd2luZyBlYXJseSB3aWxsIGFmZmVjdCB0aGUgb3RoZXJzLlxuICpcbiAqIEB0ZW1wbGF0ZSBbVD11bmtub3duXVxuICogQHBhcmFtIHtBc3luY0l0ZXJhdG9yPFQsIHZvaWQsIHZvaWQ+fSBzb3VyY2VTdHJlYW1cbiAqIEBwYXJhbSB7bnVtYmVyfSByZWFkZXJDb3VudFxuICovJGjigI1fb25jZS5hbGxWYWx1ZXMoYWxsVmFsdWVzKTtcbmNvbnN0ICAgICAgICBzeW5jaHJvbml6ZWRUZWU9KHNvdXJjZVN0cmVhbSxyZWFkZXJDb3VudCk9Pntcbi8qKiBAdHlwZSB7SXRlcmF0b3JSZXR1cm5SZXN1bHQ8dm9pZD4gfCB1bmRlZmluZWR9ICovXG5sZXQgZG9uZVJlc3VsdDtcblxuLyoqIEB0eXBlZGVmIHtJdGVyYXRvclJlc3VsdDwodmFsdWU6IFByb21pc2VMaWtlPEl0ZXJhdG9yUmVzdWx0PFQ+PikgPT4gdm9pZD59IFF1ZXVlUGF5bG9hZCAqL1xuLyoqIEB0eXBlIHtYaW1wb3J0KCdAZW5kby9zdHJlYW0nKS5Bc3luY1F1ZXVlPFF1ZXVlUGF5bG9hZD5bXX0gKi9cbmNvbnN0IHF1ZXVlcz1bXTtcblxuLyoqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fSAqL1xuY29uc3QgcHVsbE5leHQ9YXN5bmMoKT0+e1xuY29uc3QgcmVxdWVzdHM9YXdhaXQgUHJvbWlzZS5hbGxTZXR0bGVkKHF1ZXVlcy5tYXAoKHF1ZXVlKT0+cXVldWUuZ2V0KCkpKTtcbmNvbnN0IHJlamVjdGlvbnM9W107XG4vKiogQHR5cGUge0FycmF5PCh2YWx1ZTogUHJvbWlzZUxpa2U8SXRlcmF0b3JSZXN1bHQ8VD4+KSA9PiB2b2lkPn0gKi9cbmNvbnN0IHJlc29sdmVycz1bXTtcbmxldCBkb25lPWZhbHNlO1xuZm9yKGNvbnN0IHNldHRsZWRSZXN1bHQgb2YgcmVxdWVzdHMpe1xuaWYoc2V0dGxlZFJlc3VsdC5zdGF0dXM9PT0ncmVqZWN0ZWQnKXtcbnJlamVjdGlvbnMucHVzaChzZXR0bGVkUmVzdWx0LnJlYXNvbik7XG4gfWVsc2V7XG5kb25lfHw9ISFzZXR0bGVkUmVzdWx0LnZhbHVlLmRvbmU7XG5yZXNvbHZlcnMucHVzaChzZXR0bGVkUmVzdWx0LnZhbHVlLnZhbHVlKTtcbiB9XG4gfVxuLyoqIEB0eXBlIHtQcm9taXNlPEl0ZXJhdG9yUmVzdWx0PFQ+Pn0gKi9cbmxldCByZXN1bHQ7XG5pZihkb25lUmVzdWx0KXtcbnJlc3VsdD1Qcm9taXNlLnJlc29sdmUoZG9uZVJlc3VsdCk7XG4gfWVsc2UgaWYocmVqZWN0aW9ucy5sZW5ndGgpe1xuY29uc3QgZXJyb3I9YXNzZXJ0LmVycm9yKGFzc2VydC5kZXRhaWxzIGBUZWVkIHN0cmVhbSB0aHJld2ApO1xuYXNzZXJ0Lm5vdGUoZXJyb3IsYXNzZXJ0LmRldGFpbHMgYFRlZWQgcmVqZWN0aW9uczogJHtyZWplY3Rpb25zfWApO1xucmVzdWx0PVxuc291cmNlU3RyZWFtLnRocm93Py4oZXJyb3IpfHxcblByb21pc2UucmVzb2x2ZShzb3VyY2VTdHJlYW0ucmV0dXJuPy4oKSkudGhlbigoKT0+XG5Qcm9taXNlLnJlamVjdChlcnJvcikpO1xuXG4gfWVsc2UgaWYoZG9uZSl7XG5yZXN1bHQ9XG5zb3VyY2VTdHJlYW0ucmV0dXJuPy4oKXx8XG5Qcm9taXNlLnJlc29sdmUoe2RvbmU6dHJ1ZSx2YWx1ZTp1bmRlZmluZWR9KTtcbiB9ZWxzZXtcbnJlc3VsdD1zb3VyY2VTdHJlYW0ubmV4dCgpO1xuIH1cbnJlc3VsdC50aGVuKFxuKHIpPT57XG5pZihyLmRvbmUpe1xuZG9uZVJlc3VsdD1yO1xuIH1cbiB9LFxuKCk9PntcbmRvbmVSZXN1bHQ9e2RvbmU6dHJ1ZSx2YWx1ZTp1bmRlZmluZWR9O1xuIH0pO1xuXG5yZXNvbHZlcnMuZm9yRWFjaCgocmVzb2x2ZSk9PnJlc29sdmUocmVzdWx0KSk7XG5yZXR1cm4gcHVsbE5leHQoKTtcbiB9O1xuXG5jb25zdCByZWFkZXJzPUFycmF5LmZyb20oe2xlbmd0aDpyZWFkZXJDb3VudH0pLm1hcCgoKT0+e1xuLyoqIEB0eXBlIHtYaW1wb3J0KCdAZW5kby9zdHJlYW0nKS5Bc3luY1F1ZXVlPFF1ZXVlUGF5bG9hZD59ICovXG5jb25zdCBxdWV1ZT1tYWtlUXVldWUoKTtcbnF1ZXVlcy5wdXNoKHF1ZXVlKTtcblxuLyoqIEB0eXBlIHtBc3luY0dlbmVyYXRvcjxULCB2b2lkLCB2b2lkPn0gKi9cbmNvbnN0IHJlYWRlcj1oYXJkZW4oe1xuICAgICAgYXN5bmMgbmV4dCgpe1xuLyoqIEB0eXBlIHtYaW1wb3J0KCdAZW5kby9wcm9taXNlLWtpdCcpLlByb21pc2VLaXQ8SXRlcmF0b3JSZXN1bHQ8VD4+fSAqL1xuY29uc3R7cHJvbWlzZSxyZXNvbHZlfT1tYWtlUHJvbWlzZUtpdCgpO1xucXVldWUucHV0KHt2YWx1ZTpyZXNvbHZlLGRvbmU6ZmFsc2V9KTtcbnJldHVybiBwcm9taXNlO1xuIH0sXG4gICAgICBhc3luYyByZXR1cm4oKXtcbi8qKiBAdHlwZSB7WGltcG9ydCgnQGVuZG8vcHJvbWlzZS1raXQnKS5Qcm9taXNlS2l0PEl0ZXJhdG9yUmVzdWx0PFQ+Pn0gKi9cbmNvbnN0e3Byb21pc2UscmVzb2x2ZX09bWFrZVByb21pc2VLaXQoKTtcbnF1ZXVlLnB1dCh7dmFsdWU6cmVzb2x2ZSxkb25lOnRydWV9KTtcbnJldHVybiBwcm9taXNlO1xuIH0sXG4gICAgICBhc3luYyB0aHJvdyhyZWFzb24pe1xuY29uc3QgcmVqZWN0aW9uPVByb21pc2UucmVqZWN0KHJlYXNvbik7XG5xdWV1ZS5wdXQocmVqZWN0aW9uKTtcbnJldHVybiByZWplY3Rpb247XG4gfSxcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1yZXN0cmljdGVkLWdsb2JhbHMqL1xuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXSgpe1xucmV0dXJuIHJlYWRlcjtcbiB9fSk7XG5cbnJldHVybiByZWFkZXI7XG4gfSk7XG5cbnZvaWQgcHVsbE5leHQoKTtcbnJldHVybiByZWFkZXJzO1xuIH07JGjigI1fb25jZS5zeW5jaHJvbml6ZWRUZWUoc3luY2hyb25pemVkVGVlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJCQVNJU19QT0lOVFMiOlsiQkFTSVNfUE9JTlRTIl0sImZyb21VbmlxdWVFbnRyaWVzIjpbImZyb21VbmlxdWVFbnRyaWVzIl0sIm9iamVjdE1hcCI6WyJvYmplY3RNYXAiXSwibGlzdERpZmZlcmVuY2UiOlsibGlzdERpZmZlcmVuY2UiXSwidGhyb3dMYWJlbGVkIjpbInRocm93TGFiZWxlZCJdLCJhcHBseUxhYmVsaW5nRXJyb3IiOlsiYXBwbHlMYWJlbGluZ0Vycm9yIl0sImRlZXBseUZ1bGZpbGxlZE9iamVjdCI6WyJkZWVwbHlGdWxmaWxsZWRPYmplY3QiXSwibWFrZU1lYXN1cmVTZWNvbmRzIjpbIm1ha2VNZWFzdXJlU2Vjb25kcyJdLCJtYWtlQWdncmVnYXRlRXJyb3IiOlsibWFrZUFnZ3JlZ2F0ZUVycm9yIl0sIlByb21pc2VBbGxPckVycm9ycyI6WyJQcm9taXNlQWxsT3JFcnJvcnMiXSwiYWdncmVnYXRlVHJ5RmluYWxseSI6WyJhZ2dyZWdhdGVUcnlGaW5hbGx5Il0sImFzc2VydEFsbERlZmluZWQiOlsiYXNzZXJ0QWxsRGVmaW5lZCJdLCJmb3JldmVyIjpbImZvcmV2ZXIiXSwid2hpbGVUcnVlIjpbIndoaWxlVHJ1ZSJdLCJ1bnRpbFRydWUiOlsidW50aWxUcnVlIl0sInppcCI6WyJ6aXAiXSwiYWxsVmFsdWVzIjpbImFsbFZhbHVlcyJdLCJzeW5jaHJvbml6ZWRUZWUiOlsic3luY2hyb25pemVkVGVlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGfQxYrVEgAA1RIAADkAAABAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvYXN5bmNJdGVyYWJsZUFkYXB0b3IuanN7ImltcG9ydHMiOlsiLi9zdWJzY3JpYmUuanMiLCIuL3R5cGVzLWFtYmllbnQuanMiLCJAZW5kby9mYXIiXSwiZXhwb3J0cyI6WyJtYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllciIsIm9ic2VydmVJdGVyYXRpb24iLCJvYnNlcnZlSXRlcmF0b3IiLCJvYnNlcnZlTm90aWZpZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRSxzdWJzY3JpYmVMYXRlc3Q7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIi4vc3Vic2NyaWJlLmpzXCIsIFtbXCJzdWJzY3JpYmVMYXRlc3RcIiwgWyRo4oCNX2EgPT4gKHN1YnNjcmliZUxhdGVzdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG4vKipcbiAqIEBkZXByZWNhdGVkIFVzZSBgc3Vic2NyaWJlTGF0ZXN0YCBmcm9tIGBAYWdvcmljL25vdGlmaWVyL3N1YnNjcmliZS5qc2AgaW5zdGVhZC5cbiAqXG4gKiBBZGFwdG9yIGZyb20gYSBub3RpZmllclAgdG8gYW4gYXN5bmMgaXRlcmFibGUuXG4gKiBUaGUgbm90aWZpZXJQIGNhbiBiZSBhbnkgb2JqZWN0IHRoYXQgaGFzIGFuIGV2ZW50dWFsbHkgaW52b2NhYmxlXG4gKiBgZ2V0VXBkYXRlU2luY2VgIG1ldGhvZCB0aGF0IGJlaGF2ZXMgYWNjb3JkaW5nIHRvIHRoZSBub3RpZmllclxuICogc3BlYy4gVGhpcyBjYW4gYmUgYSBub3RpZmllciwgYSBwcm9taXNlIGZvciBhIGxvY2FsIG9yIHJlbW90ZVxuICogbm90aWZpZXIsIG9yIGEgcHJlc2VuY2Ugb2YgYSByZW1vdGUgbm90aWZpZXIuXG4gKlxuICogSXQgaXMgYWxzbyB1c2VkIGludGVybmFsbHkgYnkgbm90aWZpZXIuanMgc28gdGhhdCBhIG5vdGlmaWVyIGl0c2VsZiBpcyBhblxuICogYXN5bmMgaXRlcmFibGUuXG4gKlxuICogQW4gYXN5bmMgaXRlcmFibGUgaXMgYW4gb2JqZWN0IHdpdGggYSBgW1N5bWJvbC5hc3luY0l0ZXJhdG9yXSgpYCBtZXRob2RcbiAqIHRoYXQgcmV0dXJucyBhbiBhc3luYyBpdGVyYXRvci4gVGhlIGFzeW5jIGl0ZXJhdG9yIHdlIHJldHVybiBoZXJlIGhhcyBvbmx5XG4gKiBhIGBuZXh0KClgIG1ldGhvZCwgd2l0aG91dCB0aGUgb3B0aW9uYWwgYHJldHVybmAgYW5kIGB0aHJvd2AgbWV0aG9kcy4gVGhlXG4gKiBvbWl0dGVkIG1ldGhvZHMsIGlmIHByZXNlbnQsIHdvdWxkIGJlIHVzZWQgYnkgdGhlIGZvci9hd2FpdC9vZiBsb29wIHRvXG4gKiBpbmZvcm0gdGhlIGl0ZXJhdG9yIG9mIGVhcmx5IHRlcm1pbmF0aW9uLiBCdXQgdGhpcyBhZGFwdG9yIHdvdWxkIG5vdCBkb1xuICogYW55dGhpbmcgdXNlZnVsIGluIHJlYWN0aW9uIHRvIHRoaXMgbm90aWZpY2F0aW9uLlxuICpcbiAqIEFuIGFzeW5jIGl0ZXJhdG9yJ3MgYG5leHQoKWAgbWV0aG9kIHJldHVybnMgYSBwcm9taXNlIGZvciBhbiBpdGVyYXRpb25cbiAqIHJlc3VsdC4gQW4gaXRlcmF0aW9uIHJlc3VsdCBpcyBhIHJlY29yZCB3aXRoIGB2YWx1ZWAgYW5kIGBkb25lYCBwcm9wZXJ0aWVzLlxuICpcbiAqIFRoZSBwdXJwb3NlIG9mIGJ1aWxkaW5nIG9uIHRoZSBub3RpZmllciBwcm90b2NvbCBpcyB0byBoYXZlIGEgbG9zc3lcbiAqIGFkYXB0b3IsIHdoZXJlIGludGVybWVkaWF0ZSByZXN1bHRzIGNhbiBiZSBtaXNzZWQgaW4gZmF2b3Igb2YgbW9yZSByZWNlbnRcbiAqIHJlc3VsdHMgd2hpY2ggYXJlIHRoZXJlZm9yZSBsZXNzIHN0YWxlLiBTZWVcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvZG9jdW1lbnRhdGlvbi9ibG9iL0hFQUQvbWFpbi9ndWlkZXMvanMtcHJvZ3JhbW1pbmcvbm90aWZpZXJzLm1kXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxCYXNlTm90aWZpZXI8VD4+fSBub3RpZmllclBcbiAqIEByZXR1cm5zIHtGb3JrYWJsZUFzeW5jSXRlcmFibGU8VD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllcj1zdWJzY3JpYmVMYXRlc3Q7XG5cbi8qKlxuICogVGhpcyBhZHZhbmNlcyBgYXN5bmNJdGVyYXRvclBgIHVwZGF0aW5nIGBpdGVyYXRpb25PYnNlcnZlcmAgd2l0aCBlYWNoXG4gKiBzdWNjZXNzaXZlIHZhbHVlLiBUaGUgYGl0ZXJhdGlvbk9ic2VydmVyYCBtYXkgb25seSBiZSBpbnRlcmVzdGVkIGluIGNlcnRhaW5cbiAqIG9jY3VycmVuY2VzIChgdXBkYXRlU3RhdGVgLCBgZmluaXNoYCwgYGZhaWxgKSwgc28gZm9yIGNvbnZlbmllbmNlLFxuICogYG9ic2VydmVJdGVyYXRvcmAgZmVhdHVyZSB0ZXN0cyBmb3IgdGhvc2UgbWV0aG9kcyBiZWZvcmUgY2FsbGluZyB0aGVtLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8QXN5bmNJdGVyYXRvcjxUPj59IGFzeW5jSXRlcmF0b3JQXG4gKiBAcGFyYW0ge1BhcnRpYWw8SXRlcmF0aW9uT2JzZXJ2ZXI8VD4+fSBpdGVyYXRpb25PYnNlcnZlclxuICogQHJldHVybnMge1Byb21pc2U8dW5kZWZpbmVkPn1cbiAqLyRo4oCNX29uY2UubWFrZUFzeW5jSXRlcmFibGVGcm9tTm90aWZpZXIobWFrZUFzeW5jSXRlcmFibGVGcm9tTm90aWZpZXIpO1xuY29uc3QgICAgICAgIG9ic2VydmVJdGVyYXRvcj0oYXN5bmNJdGVyYXRvclAsaXRlcmF0aW9uT2JzZXJ2ZXIpPT57XG5yZXR1cm4gbmV3IFByb21pc2UoKGFjayxvYnNlcnZlckVycm9yKT0+e1xuY29uc3QgcmVjdXI9KCk9PntcbkUud2hlbihcbkUoYXN5bmNJdGVyYXRvclApLm5leHQoKSxcbih7dmFsdWUsZG9uZX0pPT57XG5pZihkb25lKXtcbml0ZXJhdGlvbk9ic2VydmVyLmZpbmlzaCYmaXRlcmF0aW9uT2JzZXJ2ZXIuZmluaXNoKHZhbHVlKTtcbmFjayh1bmRlZmluZWQpO1xuIH1lbHNle1xuaXRlcmF0aW9uT2JzZXJ2ZXIudXBkYXRlU3RhdGUmJlxuaXRlcmF0aW9uT2JzZXJ2ZXIudXBkYXRlU3RhdGUodmFsdWUpO1xucmVjdXIoKTtcbiB9XG4gfSxcbihyZWFzb24pPT57XG5pdGVyYXRpb25PYnNlcnZlci5mYWlsJiZpdGVyYXRpb25PYnNlcnZlci5mYWlsKHJlYXNvbik7XG5hY2sodW5kZWZpbmVkKTtcbiB9KS5cbmNhdGNoKG9ic2VydmVyRXJyb3IpO1xuIH07XG5yZWN1cigpO1xuIH0pO1xuIH07XG5cbi8qKlxuICogVGhpcyByZWFkcyBmcm9tIGBhc3luY0l0ZXJhYmxlUGAgdXBkYXRpbmcgYGl0ZXJhdGlvbk9ic2VydmVyYCB3aXRoIGVhY2hcbiAqIHN1Y2Nlc3NpdmUgdmFsdWUuIFRoZSBgaXRlcmF0aW9uT2JzZXJ2ZXJgIG1heSBvbmx5IGJlIGludGVyZXN0ZWQgaW4gY2VydGFpblxuICogb2NjdXJyZW5jZXMgKGB1cGRhdGVTdGF0ZWAsIGBmaW5pc2hgLCBgZmFpbGApLCBzbyBmb3IgY29udmVuaWVuY2UsXG4gKiBgb2JzZXJ2ZUl0ZXJhdGlvbmAgZmVhdHVyZSB0ZXN0cyBmb3IgdGhvc2UgbWV0aG9kcyBiZWZvcmUgY2FsbGluZyB0aGVtLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8QXN5bmNJdGVyYWJsZTxUPj59IGFzeW5jSXRlcmFibGVQXG4gKiBAcGFyYW0ge1BhcnRpYWw8SXRlcmF0aW9uT2JzZXJ2ZXI8VD4+fSBpdGVyYXRpb25PYnNlcnZlclxuICogQHJldHVybnMge1Byb21pc2U8dW5kZWZpbmVkPn1cbiAqLyRo4oCNX29uY2Uub2JzZXJ2ZUl0ZXJhdG9yKG9ic2VydmVJdGVyYXRvcik7XG5jb25zdCAgICAgICAgb2JzZXJ2ZUl0ZXJhdGlvbj0oYXN5bmNJdGVyYWJsZVAsaXRlcmF0aW9uT2JzZXJ2ZXIpPT57XG5jb25zdCBpdGVyYXRvclA9RShhc3luY0l0ZXJhYmxlUClbU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCk7XG5yZXR1cm4gb2JzZXJ2ZUl0ZXJhdG9yKGl0ZXJhdG9yUCxpdGVyYXRpb25PYnNlcnZlcik7XG4gfTtcblxuLyoqXG4gKiBBcyB1cGRhdGVzIGNvbWUgaW4gZnJvbSB0aGUgcG9zc2libHkgcmVtb3RlIGBub3RpZmllclBgLCB1cGRhdGVcbiAqIHRoZSBsb2NhbCBgdXBkYXRlcmAuIFNpbmNlIHRoZSB1cGRhdGVzIGNvbWUgZnJvbSBhIG5vdGlmaWVyLCB0aGV5XG4gKiBhcmUgbG9zc3ksIGkuZS4sIG9uY2UgYSBtb3JlIHJlY2VudCBzdGF0ZSBjYW4gYmUgcmVwb3J0ZWQsIGxlc3MgcmVjZW50XG4gKiBzdGF0ZXMgYXJlIGFzc3VtZWQgaXJyZWxldmFudCBhbmQgZHJvcHBlZC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPExhdGVzdFRvcGljPFQ+Pn0gbm90aWZpZXJQXG4gKiBAcGFyYW0ge1BhcnRpYWw8SXRlcmF0aW9uT2JzZXJ2ZXI8VD4+fSBpdGVyYXRpb25PYnNlcnZlclxuICogQHJldHVybnMge1Byb21pc2U8dW5kZWZpbmVkPn1cbiAqLyRo4oCNX29uY2Uub2JzZXJ2ZUl0ZXJhdGlvbihvYnNlcnZlSXRlcmF0aW9uKTtcbmNvbnN0ICAgICAgICBvYnNlcnZlTm90aWZpZXI9KG5vdGlmaWVyUCxpdGVyYXRpb25PYnNlcnZlcik9Plxub2JzZXJ2ZUl0ZXJhdGlvbihzdWJzY3JpYmVMYXRlc3Qobm90aWZpZXJQKSxpdGVyYXRpb25PYnNlcnZlcik7JGjigI1fb25jZS5vYnNlcnZlTm90aWZpZXIob2JzZXJ2ZU5vdGlmaWVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllciI6WyJtYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllciJdLCJvYnNlcnZlSXRlcmF0b3IiOlsib2JzZXJ2ZUl0ZXJhdG9yIl0sIm9ic2VydmVJdGVyYXRpb24iOlsib2JzZXJ2ZUl0ZXJhdGlvbiJdLCJvYnNlcnZlTm90aWZpZXIiOlsib2JzZXJ2ZU5vdGlmaWVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAALC+L08cBwAAHAcAACoAAABAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiLi9hc3luY0l0ZXJhYmxlQWRhcHRvci5qcyIsIi4vbm90aWZpZXIuanMiLCIuL3B1Ymxpc2gta2l0LmpzIiwiLi9zdG9yZWQtbm90aWZpZXIuanMiLCIuL3N0b3Jlc3ViLmpzIiwiLi9zdWJzY3JpYmUuanMiLCIuL3N1YnNjcmliZXIuanMiXSwiZXhwb3J0cyI6WyJtYWtlTm90aWZpZXJLaXQiLCJtYWtlTm90aWZpZXJLaXQiLCJtYWtlU3Vic2NyaXB0aW9uS2l0IiwibWFrZVN1YnNjcmlwdGlvbktpdCIsIm9ic2VydmVJdGVyYXRvciIsIm9ic2VydmVJdGVyYXRvciIsInByZXBhcmVEdXJhYmxlUHVibGlzaEtpdCIsInByZXBhcmVEdXJhYmxlUHVibGlzaEtpdCIsInN1YnNjcmliZUxhdGVzdCIsInN1YnNjcmliZUxhdGVzdCJdLCJyZWV4cG9ydHMiOlsiLi9zdG9yZWQtbm90aWZpZXIuanMiLCIuL3N0b3Jlc3ViLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9wdWJsaXNoLWtpdC5qc1wiLCBbXV0sW1wiLi9zdWJzY3JpYmUuanNcIiwgW11dLFtcIi4vbm90aWZpZXIuanNcIiwgW11dLFtcIi4vc3Vic2NyaWJlci5qc1wiLCBbXV0sW1wiLi9hc3luY0l0ZXJhYmxlQWRhcHRvci5qc1wiLCBbXV0sW1wiLi9zdG9yZXN1Yi5qc1wiLCBbXV0sW1wiLi9zdG9yZWQtbm90aWZpZXIuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9wdWJsaXNoLWtpdC5qcyI6W1sibWFrZVB1Ymxpc2hLaXQiLCJtYWtlUHVibGlzaEtpdCJdLFsicHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0IiwicHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0Il0sWyJGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclNoYXBlIiwiRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3JTaGFwZSJdLFsiSXRlcmFibGVFYWNoVG9waWNJIiwiSXRlcmFibGVFYWNoVG9waWNJIl0sWyJJdGVyYWJsZUxhdGVzdFRvcGljSSIsIkl0ZXJhYmxlTGF0ZXN0VG9waWNJIl0sWyJTdWJzY3JpYmVyU2hhcGUiLCJTdWJzY3JpYmVyU2hhcGUiXV0sIi4vc3Vic2NyaWJlLmpzIjpbWyJzdWJzY3JpYmVFYWNoIiwic3Vic2NyaWJlRWFjaCJdLFsic3Vic2NyaWJlTGF0ZXN0Iiwic3Vic2NyaWJlTGF0ZXN0Il1dLCIuL25vdGlmaWVyLmpzIjpbWyJtYWtlTm90aWZpZXIiLCJtYWtlTm90aWZpZXIiXSxbIm1ha2VOb3RpZmllcktpdCIsIm1ha2VOb3RpZmllcktpdCJdLFsibWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGUiLCJtYWtlTm90aWZpZXJGcm9tQXN5bmNJdGVyYWJsZSJdLFsibWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXIiLCJtYWtlTm90aWZpZXJGcm9tU3Vic2NyaWJlciJdXSwiLi9zdWJzY3JpYmVyLmpzIjpbWyJtYWtlU3Vic2NyaXB0aW9uIiwibWFrZVN1YnNjcmlwdGlvbiJdLFsibWFrZVN1YnNjcmlwdGlvbktpdCIsIm1ha2VTdWJzY3JpcHRpb25LaXQiXV0sIi4vYXN5bmNJdGVyYWJsZUFkYXB0b3IuanMiOltbIm9ic2VydmVOb3RpZmllciIsIm9ic2VydmVOb3RpZmllciJdLFsib2JzZXJ2ZUl0ZXJhdG9yIiwib2JzZXJ2ZUl0ZXJhdG9yIl0sWyJvYnNlcnZlSXRlcmF0aW9uIiwib2JzZXJ2ZUl0ZXJhdGlvbiJdLFsibWFrZUFzeW5jSXRlcmFibGVGcm9tTm90aWZpZXIiLCJtYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllciJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA8rAIZVoYAABaGAAALQAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9ub3RpZmllci5qc3siaW1wb3J0cyI6WyIuL3B1Ymxpc2gta2l0LmpzIiwiLi9zdWJzY3JpYmUuanMiLCIuL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL2Fzc2VydCIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbIm1ha2VOb3RpZmllciIsIm1ha2VOb3RpZmllckZyb21Bc3luY0l0ZXJhYmxlIiwibWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXIiLCJtYWtlTm90aWZpZXJLaXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0LEUsRmFyLG1ha2VQdWJsaXNoS2l0LHN1YnNjcmliZUxhdGVzdDskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2Fzc2VydFwiLCBbW1wiYXNzZXJ0XCIsIFskaOKAjV9hID0+IChhc3NlcnQgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVzLWFtYmllbnQuanNcIiwgW11dLFtcIi4vcHVibGlzaC1raXQuanNcIiwgW1tcIm1ha2VQdWJsaXNoS2l0XCIsIFskaOKAjV9hID0+IChtYWtlUHVibGlzaEtpdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3N1YnNjcmliZS5qc1wiLCBbW1wic3Vic2NyaWJlTGF0ZXN0XCIsIFskaOKAjV9hID0+IChzdWJzY3JpYmVMYXRlc3QgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8TGF0ZXN0VG9waWM8VD4+fSBzaGFyYWJsZUludGVybmFsc1BcbiAqIEByZXR1cm5zIHtOb3RpZmllcjxUPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VOb3RpZmllcj0oc2hhcmFibGVJbnRlcm5hbHNQKT0+e1xuLyoqIEB0eXBlIHtOb3RpZmllcjxUPn0gKi9cbmNvbnN0IG5vdGlmaWVyPUZhcignbm90aWZpZXInLHtcbi4uLnN1YnNjcmliZUxhdGVzdChzaGFyYWJsZUludGVybmFsc1ApLFxuZ2V0VXBkYXRlU2luY2U6YXN5bmModXBkYXRlQ291bnQpPT5cbkUoc2hhcmFibGVJbnRlcm5hbHNQKS5nZXRVcGRhdGVTaW5jZSh1cGRhdGVDb3VudCksXG5cbi8qKlxuICogVXNlIHRoaXMgdG8gZGlzdHJpYnV0ZSBhIE5vdGlmaWVyIGVmZmljaWVudGx5IG92ZXIgdGhlIG5ldHdvcmssXG4gKiBieSBvYnRhaW5pbmcgdGhpcyBmcm9tIHRoZSBOb3RpZmllciB0byBiZSByZXBsaWNhdGVkLCBhbmQgYXBwbHlpbmdcbiAqIGBtYWtlTm90aWZpZXJgIHRvIGl0IGF0IHRoZSBuZXcgc2l0ZSB0byBnZXQgYW4gZXF1aXZhbGVudCBsb2NhbFxuICogTm90aWZpZXIgYXQgdGhhdCBzaXRlLlxuICovXG5nZXRTaGFyYWJsZU5vdGlmaWVySW50ZXJuYWxzOmFzeW5jKCk9PnNoYXJhYmxlSW50ZXJuYWxzUCxcbi8qKlxuICogQGRlcHJlY2F0ZWRcbiAqIFVzZWQgb25seSBieSBgbWFrZUNhc3RpbmdTcGVjRnJvbVJlZmAuICBJbnN0ZWFkIHRoYXQgZnVuY3Rpb24gc2hvdWxkIHVzZVxuICogdGhlIGBTdG9yZWRGYWNldGAgQVBJLlxuICovXG5nZXRTdG9yZUtleTooKT0+aGFyZGVuKHtub3RpZmllcn0pfSk7XG5cbnJldHVybiBub3RpZmllcjtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8U3Vic2NyaWJlcjxUPj59IHN1YnNjcmliZXJcbiAqIEByZXR1cm5zIHtOb3RpZmllcjxUPn1cbiAqLyRo4oCNX29uY2UubWFrZU5vdGlmaWVyKG1ha2VOb3RpZmllcik7XG5jb25zdCAgICAgICAgbWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXI9KHN1YnNjcmliZXIpPT57XG4vKipcbiAqIEB0eXBlIHtMYXRlc3RUb3BpYzxUPn1cbiAqL1xuY29uc3QgYmFzZU5vdGlmaWVyPWhhcmRlbih7XG5nZXRVcGRhdGVTaW5jZToodXBkYXRlQ291bnQ9dW5kZWZpbmVkKT0+XG5FKHN1YnNjcmliZXIpLmdldFVwZGF0ZVNpbmNlKHVwZGF0ZUNvdW50KX0pO1xuXG5cbi8qKiBAdHlwZSB7Tm90aWZpZXI8VD59ICovXG5jb25zdCBub3RpZmllcj1GYXIoJ25vdGlmaWVyJyx7XG4uLi5tYWtlTm90aWZpZXIoYmFzZU5vdGlmaWVyKSxcbi4uLmJhc2VOb3RpZmllcn0pO1xuXG5yZXR1cm4gbm90aWZpZXI7XG4gfTskaOKAjV9vbmNlLm1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyKG1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyKTtcbmhhcmRlbihtYWtlTm90aWZpZXJGcm9tU3Vic2NyaWJlcik7XG5cbi8qKlxuICogUHJvZHVjZXMgYSBwYWlyIG9mIG9iamVjdHMsIHdoaWNoIGFsbG93IGEgc2VydmljZSB0byBwcm9kdWNlIGEgc3RyZWFtIG9mXG4gKiB1cGRhdGUgcHJvbWlzZXMuXG4gKlxuICogVGhlIGluaXRpYWwgc3RhdGUgYXJndW1lbnQgaGFzIHRvIGJlIHRydWx5IG9wdGlvbmFsIGV2ZW4gdGhvdWdoIGl0IGNhblxuICogYmUgYW55IGZpcnN0IGNsYXNzIHZhbHVlIGluY2x1ZGluZyBgdW5kZWZpbmVkYC4gV2UgbmVlZCB0byBkaXN0aW5ndWlzaCB0aGVcbiAqIHByZXNlbmNlIHZzIHRoZSBhYnNlbmNlIG9mIGl0LCB3aGljaCB3ZSBjYW5ub3QgZG8gd2l0aCB0aGUgb3B0aW9uYWwgYXJndW1lbnRcbiAqIHN5bnRheC4gUmF0aGVyIHdlIHVzZSB0aGUgYXJpdHkgb2YgdGhlIGBpbml0aWFsU3RhdGVBcnJgIGFycmF5LlxuICpcbiAqIElmIG5vIGluaXRpYWwgc3RhdGUgaXMgcHJvdmlkZWQgdG8gYG1ha2VOb3RpZmllcktpdGAsIHRoZW4gaXQgc3RhcnRzIHdpdGhvdXRcbiAqIGFuIGluaXRpYWwgc3RhdGUuIEl0cyBpbml0aWFsIHN0YXRlIHdpbGwgaW5zdGVhZCBiZSB0aGUgc3RhdGUgb2YgdGhlIGZpcnN0XG4gKiB1cGRhdGUuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7W10gfCBbVF19IGluaXRpYWxTdGF0ZUFyciB0aGUgZmlyc3Qgc3RhdGUgdG8gYmUgcmV0dXJuZWQgKHR5cGVkIGFzIHJlc3QgYXJyYXkgdG8gcGVybWl0IGB1bmRlZmluZWRgKVxuICogQHJldHVybnMge05vdGlmaWVyUmVjb3JkPFQ+fSB0aGUgbm90aWZpZXIgYW5kIHVwZGF0ZXJcbiAqL1xuY29uc3QgICAgICAgIG1ha2VOb3RpZmllcktpdD0oLi4uaW5pdGlhbFN0YXRlQXJyKT0+e1xuLyoqIEB0eXBlIHtQdWJsaXNoS2l0PFQ+fSAqL1xuY29uc3R7cHVibGlzaGVyLHN1YnNjcmliZXJ9PW1ha2VQdWJsaXNoS2l0KCk7XG5cbmNvbnN0IG5vdGlmaWVyPW1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyKHN1YnNjcmliZXIpO1xuXG5jb25zdCB1cGRhdGVyPUZhcigndXBkYXRlcicse1xudXBkYXRlU3RhdGU6KHN0YXRlKT0+cHVibGlzaGVyLnB1Ymxpc2goc3RhdGUpLFxuZmluaXNoOihjb21wbGV0aW9uKT0+cHVibGlzaGVyLmZpbmlzaChjb21wbGV0aW9uKSxcbmZhaWw6KHJlYXNvbik9PnB1Ymxpc2hlci5mYWlsKHJlYXNvbil9KTtcblxuXG5hc3NlcnQoaW5pdGlhbFN0YXRlQXJyLmxlbmd0aDw9MSwndG9vIG1hbnkgYXJndW1lbnRzJyk7XG5pZihpbml0aWFsU3RhdGVBcnIubGVuZ3RoPT09MSl7XG51cGRhdGVyLnVwZGF0ZVN0YXRlKGluaXRpYWxTdGF0ZUFyclswXSk7XG4gfVxuXG4vKiBub3RpZmllciBmYWNldCBpcyBzZXBhcmF0ZSBzbyBpdCBjYW4gYmUgaGFuZGVkIG91dCB3aGlsZSB1cGRhdGVyKi9cbi8qIGlzIHRpZ2h0bHkgaGVsZCovXG5yZXR1cm4gaGFyZGVuKHtub3RpZmllcix1cGRhdGVyfSk7XG4gfTtcblxuLyoqXG4gKiBBZGFwdG9yIGZyb20gYXN5bmMgaXRlcmFibGUgdG8gbm90aWZpZXIuXG4gKlxuICogQGRlcHJlY2F0ZWQgVGhlIHJlc3VsdGluZyBub3RpZmllciBpcyBsb3NzbGVzcywgd2hpY2ggaXMgbm90IGRlc2lyYWJsZS5cbiAqIFByZWZlciBtYWtlTm90aWZpZXJGcm9tU3Vic2NyaWJlciwgYW5kIHJlZmVyIHRvXG4gKiBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzU0MTMgYW5kXG4gKiBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvcHVsbC81Njk1IGZvciBjb250ZXh0LlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8QXN5bmNJdGVyYWJsZTxUPj59IGFzeW5jSXRlcmFibGVQXG4gKiBAcmV0dXJucyB7Tm90aWZpZXI8VD59XG4gKi8kaOKAjV9vbmNlLm1ha2VOb3RpZmllcktpdChtYWtlTm90aWZpZXJLaXQpO1xuY29uc3QgICAgICAgIG1ha2VOb3RpZmllckZyb21Bc3luY0l0ZXJhYmxlPShhc3luY0l0ZXJhYmxlUCk9PntcbmNvbnN0IGl0ZXJhdG9yUD1FKGFzeW5jSXRlcmFibGVQKVtTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKTtcblxuLyoqIEB0eXBlIHtQcm9taXNlPFVwZGF0ZVJlY29yZDxUPj58dW5kZWZpbmVkfSAqL1xubGV0IG9wdE5leHRQcm9taXNlO1xubGV0IGN1cnJlbnRVcGRhdGVDb3VudD0wbjtcbi8qKiBAdHlwZSB7RVJlZjxVcGRhdGVSZWNvcmQ8VD4+fHVuZGVmaW5lZH0gKi9cbmxldCBjdXJyZW50UmVzcG9uc2U7XG5sZXQgZmluYWw9ZmFsc2U7XG5cbi8qKlxuICogQHR5cGUge0xhdGVzdFRvcGljPFQ+fVxuICovXG5jb25zdCBiYXNlTm90aWZpZXI9RmFyKCdiYXNlTm90aWZpZXInLHtcbmdldFVwZGF0ZVNpbmNlKHVwZGF0ZUNvdW50PS0xbil7XG5pZih1cGRhdGVDb3VudDxjdXJyZW50VXBkYXRlQ291bnQpe1xuaWYoY3VycmVudFJlc3BvbnNlKXtcbnJldHVybiBQcm9taXNlLnJlc29sdmUoY3VycmVudFJlc3BvbnNlKTtcbiB9XG4gfWVsc2UgaWYodXBkYXRlQ291bnQhPT1jdXJyZW50VXBkYXRlQ291bnQpe1xudGhyb3cgRXJyb3IoXG4nZ2V0VXBkYXRlU2luY2UgYXJndW1lbnQgbXVzdCBiZSBhIHByZXZpb3VzbHktaXNzdWVkIHVwZGF0ZUNvdW50LicpO1xuXG4gfVxuXG4vKiBSZXR1cm4gYSBmaW5hbCByZXNwb25zZSBpZiB3ZSBoYXZlIG9uZSwgb3RoZXJ3aXNlIGEgcHJvbWlzZSBmb3IgdGhlIG5leHQgc3RhdGUuKi9cbmlmKGZpbmFsKXtcbmFzc2VydChjdXJyZW50UmVzcG9uc2UhPT11bmRlZmluZWQpO1xucmV0dXJuIFByb21pc2UucmVzb2x2ZShjdXJyZW50UmVzcG9uc2UpO1xuIH1cbmlmKCFvcHROZXh0UHJvbWlzZSl7XG5jb25zdCBuZXh0SXRlclJlc3VsdFA9RShpdGVyYXRvclApLm5leHQoKTtcbm9wdE5leHRQcm9taXNlPUUud2hlbihcbm5leHRJdGVyUmVzdWx0UCxcbih7ZG9uZSx2YWx1ZX0pPT57XG5hc3NlcnQoIWZpbmFsKTtcbmlmKGRvbmUpe1xuZmluYWw9dHJ1ZTtcbiB9XG5jdXJyZW50VXBkYXRlQ291bnQrPTFuO1xuY3VycmVudFJlc3BvbnNlPWhhcmRlbih7XG52YWx1ZSxcbnVwZGF0ZUNvdW50OmRvbmU/dW5kZWZpbmVkOmN1cnJlbnRVcGRhdGVDb3VudH0pO1xuXG5vcHROZXh0UHJvbWlzZT11bmRlZmluZWQ7XG5yZXR1cm4gY3VycmVudFJlc3BvbnNlO1xuIH0sXG4oX3JlYXNvbik9PntcbmZpbmFsPXRydWU7XG5jdXJyZW50UmVzcG9uc2U9XG4vKiogQHR5cGUge1Byb21pc2U8VXBkYXRlUmVjb3JkPFQ+Pn0gKi9cbm5leHRJdGVyUmVzdWx0UDtcbm9wdE5leHRQcm9taXNlPXVuZGVmaW5lZDtcbnJldHVybiBjdXJyZW50UmVzcG9uc2U7XG4gfSk7XG5cbiB9XG5yZXR1cm4gb3B0TmV4dFByb21pc2U7XG4gfX0pO1xuXG5cbi8qKiBAdHlwZSB7Tm90aWZpZXI8VD59ICovXG5jb25zdCBub3RpZmllcj1GYXIoJ25vdGlmaWVyJyx7XG4vKiBEb24ndCBsZWFrIHRoZSBvcmlnaW5hbCBhc3luY0l0ZXJhYmxlUCBzaW5jZSBpdCBtYXkgYmUgcmVtb3RlIGFuZCB3ZSBhbHNvKi9cbi8qIHdhbnQgdGhlIHNhbWUgc2VtYW50aWNzIGZvciB0aGlzIGV4cG9zZWQgaXRlcmFibGUgYW5kIHRoZSBiYXNlTm90aWZpZXIuKi9cbi4uLm1ha2VOb3RpZmllcihiYXNlTm90aWZpZXIpLFxuLi4uYmFzZU5vdGlmaWVyfSk7XG5cbnJldHVybiBub3RpZmllcjtcbiB9OyRo4oCNX29uY2UubWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGUobWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGUpO1xuaGFyZGVuKG1ha2VOb3RpZmllckZyb21Bc3luY0l0ZXJhYmxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTm90aWZpZXIiOlsibWFrZU5vdGlmaWVyIl0sIm1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyIjpbIm1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyIl0sIm1ha2VOb3RpZmllcktpdCI6WyJtYWtlTm90aWZpZXJLaXQiXSwibWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGUiOlsibWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAVn+HSH44AAB+OAAAMAAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9wdWJsaXNoLWtpdC5qc3siaW1wb3J0cyI6WyIuL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL3N0b3JlIiwiQGFnb3JpYy92YXQtZGF0YSIsIkBlbmRvL2ZhciIsIkBlbmRvL3Byb21pc2Uta2l0Il0sImV4cG9ydHMiOlsiRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3JTaGFwZSIsIkl0ZXJhYmxlRWFjaFRvcGljSSIsIkl0ZXJhYmxlTGF0ZXN0VG9waWNJIiwiUHVibGlzaGVySSIsIlN1YnNjcmliZXJJIiwiU3Vic2NyaWJlclNoYXBlIiwiVXBkYXRlQ291bnRTaGFwZSIsIm1ha2VQdWJsaXNoS2l0IiwicHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0IiwicHVibGlzaEtpdElLaXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbWFrZVByb21pc2VLaXQsRSxGYXIsTSxjYW5CZUR1cmFibGUscHJlcGFyZUV4b0NsYXNzS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJtYWtlUHJvbWlzZUtpdFwiLCBbJGjigI1fYSA9PiAobWFrZVByb21pc2VLaXQgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcImNhbkJlRHVyYWJsZVwiLCBbJGjigI1fYSA9PiAoY2FuQmVEdXJhYmxlID0gJGjigI1fYSldXSxbXCJwcmVwYXJlRXhvQ2xhc3NLaXRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzc0tpdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5cbmNvbnN0IHNpbms9KCk9PnsgfTtcbmNvbnN0IG1ha2VRdWlldFJlamVjdGlvbj0ocmVhc29uKT0+e1xuY29uc3QgcmVqZWN0aW9uPWhhcmRlbihQcm9taXNlLnJlamVjdChyZWFzb24pKTtcbnZvaWQgRS53aGVuKHJlamVjdGlvbixzaW5rLHNpbmspO1xucmV0dXJuIHJlamVjdGlvbjtcbiB9O1xuY29uc3QgdG9vRmFyUmVqZWN0aW9uPW1ha2VRdWlldFJlamVjdGlvbihcbmhhcmRlbihuZXcgRXJyb3IoJ0Nhbm5vdCByZWFkIHBhc3QgZW5kIG9mIGl0ZXJhdGlvbi4nKSkpO1xuXG5cbmNvbnN0ICAgICAgICBQdWJsaXNoZXJJPU0uaW50ZXJmYWNlKCdQdWJsaXNoZXInLHtcbnB1Ymxpc2g6TS5jYWxsKE0uYW55KCkpLnJldHVybnMoKSxcbmZpbmlzaDpNLmNhbGwoTS5hbnkoKSkucmV0dXJucygpLFxuZmFpbDpNLmNhbGwoTS5hbnkoKSkucmV0dXJucygpfSk7XG5cblxuLyogRm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5IHdpdGggTm90aWZpZXIgYGdldFVwZGF0ZVNpbmNlYC4qLyRo4oCNX29uY2UuUHVibGlzaGVySShQdWJsaXNoZXJJKTtcbmNvbnN0ICAgICAgICBVcGRhdGVDb3VudFNoYXBlPU0ub3IoTS5iaWdpbnQoKSxNLm51bWJlcigpKTskaOKAjV9vbmNlLlVwZGF0ZUNvdW50U2hhcGUoVXBkYXRlQ291bnRTaGFwZSk7XG5jb25zdCAgICAgICAgU3Vic2NyaWJlckk9TS5pbnRlcmZhY2UoJ1N1YnNjcmliZXInLHtcbnN1YnNjcmliZUFmdGVyOk0uY2FsbCgpLm9wdGlvbmFsKE0uYmlnaW50KCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0VXBkYXRlU2luY2U6TS5jYWxsKCkub3B0aW9uYWwoVXBkYXRlQ291bnRTaGFwZSkucmV0dXJucyhNLnByb21pc2UoKSl9KTskaOKAjV9vbmNlLlN1YnNjcmliZXJJKFN1YnNjcmliZXJJKTtcblxuY29uc3QgICAgICAgIHB1Ymxpc2hLaXRJS2l0PWhhcmRlbih7XG5wdWJsaXNoZXI6UHVibGlzaGVySSxcbnN1YnNjcmliZXI6U3Vic2NyaWJlckl9KTskaOKAjV9vbmNlLnB1Ymxpc2hLaXRJS2l0KHB1Ymxpc2hLaXRJS2l0KTtcblxuXG5jb25zdCAgICAgICAgRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3JTaGFwZT1NLmludGVyZmFjZShcbidGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvcicsXG57XG5mb3JrOk0uY2FsbCgpLnJldHVybnMoTS5hbnkoKSksXG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOk0uY2FsbCgpLnJldHVybnMoTS5hbnkoKSksLyogb29wczogcmVjdXJzaXZlIHR5cGUqL1xubmV4dDpNLmNhbGxXaGVuKCkucmV0dXJucyhNLmFueSgpKX0pOyRo4oCNX29uY2UuRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3JTaGFwZShGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclNoYXBlKTtcblxuXG5cbmNvbnN0ICAgICAgICBJdGVyYWJsZUVhY2hUb3BpY0k9TS5pbnRlcmZhY2UoJ0l0ZXJhYmxlRWFjaFRvcGljJyx7XG5zdWJzY3JpYmVBZnRlcjpTdWJzY3JpYmVySS5tZXRob2RHdWFyZHMuc3Vic2NyaWJlQWZ0ZXIsXG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOk0uY2FsbCgpLnJldHVybnMoXG5NLnJlbW90YWJsZSgnRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3InKSl9KTskaOKAjV9vbmNlLkl0ZXJhYmxlRWFjaFRvcGljSShJdGVyYWJsZUVhY2hUb3BpY0kpO1xuXG5cblxuY29uc3QgICAgICAgIEl0ZXJhYmxlTGF0ZXN0VG9waWNJPU0uaW50ZXJmYWNlKCdJdGVyYWJsZUxhdGVzdFRvcGljJyx7XG5nZXRVcGRhdGVTaW5jZTpTdWJzY3JpYmVySS5tZXRob2RHdWFyZHMuZ2V0VXBkYXRlU2luY2UsXG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOk0uY2FsbCgpLnJldHVybnMoXG5NLnJlbW90YWJsZSgnRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3InKSl9KTtcblxuXG5cbi8qKlxuICogQHRlbXBsYXRlIHtvYmplY3R9IEFyZ1xuICogQHRlbXBsYXRlIFJldFxuICogQHBhcmFtIHsoYXJnOiBBcmcpID0+IFJldH0gZm5cbiAqIEByZXR1cm5zIHsoYXJnOiBBcmcpID0+IFJldH1cbiAqLyRo4oCNX29uY2UuSXRlcmFibGVMYXRlc3RUb3BpY0koSXRlcmFibGVMYXRlc3RUb3BpY0kpO1xuY29uc3Qgd2Vha01lbW9pemVVbmFyeT0oZm4pPT57XG5jb25zdCBjYWNoZT1uZXcgV2Vha01hcCgpO1xucmV0dXJuKGFyZyk9Pntcbi8qKiBAdHlwZSB7b2JqZWN0fSAqL1xuY29uc3Qgb2FyZz1hcmc7XG5pZihjYWNoZS5oYXMob2FyZykpe1xucmV0dXJuIGNhY2hlLmdldChvYXJnKTtcbiB9XG5jb25zdCByZXN1bHQ9Zm4oYXJnKTtcbmNhY2hlLnNldChvYXJnLHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH07XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtQdWJsaWNhdGlvblJlY29yZDxUPn0gcmVjb3JkXG4gKiBAcmV0dXJucyB7VXBkYXRlUmVjb3JkPFQ+fVxuICovXG5jb25zdCBtYWtlVXBkYXRlUmVjb3JkRnJvbVB1YmxpY2F0aW9uUmVjb3JkPShyZWNvcmQpPT57XG5jb25zdHtcbmhlYWQ6e3ZhbHVlLGRvbmV9LFxucHVibGlzaENvdW50fT1cbnJlY29yZDtcbmlmKGRvbmUpe1xuLyogRmluYWwgcmVzdWx0cyBoYXZlIHVuZGVmaW5lZCB1cGRhdGVDb3VudC4qL1xucmV0dXJuIGhhcmRlbih7dmFsdWUsdXBkYXRlQ291bnQ6dW5kZWZpbmVkfSk7XG4gfVxucmV0dXJuIGhhcmRlbih7dmFsdWUsdXBkYXRlQ291bnQ6cHVibGlzaENvdW50fSk7XG4gfTtcblxuLyoqXG4gKiBNYWtlcyBhIGB7IHB1Ymxpc2hlciwgc3Vic2NyaWJlciB9YCBwYWlyIGZvciBkb2luZyBlZmZpY2llbnRcbiAqIGRpc3RyaWJ1dGVkIHB1Yi9zdWIgc3VwcG9ydGluZyBib3RoIFwiZWFjaFwiIGFuZCBcImxhdGVzdFwiIGl0ZXJhdGlvblxuICogb2YgcHVibGlzaGVkIHZhbHVlcy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1B1Ymxpc2hLaXQ8VD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlUHVibGlzaEtpdD0oKT0+e1xuLyoqIEB0eXBlIHtQcm9taXNlPFB1YmxpY2F0aW9uUmVjb3JkPFQ+Pn0gKi9cbmxldCB0YWlsUDtcbi8qKiBAdHlwZSB7dW5kZWZpbmVkIHwgKCh2YWx1ZTogRVJlZjxQdWJsaWNhdGlvblJlY29yZDxUPj4pID0+IHZvaWQpfSAqL1xubGV0IHRhaWxSO1xuKHtwcm9taXNlOnRhaWxQLHJlc29sdmU6dGFpbFJ9PW1ha2VQcm9taXNlS2l0KCkpO1xuXG5sZXQgY3VycmVudFB1Ymxpc2hDb3VudD0wbjtcbmxldCBjdXJyZW50UD10YWlsUDtcbmNvbnN0IGFkdmFuY2VDdXJyZW50PShkb25lLHZhbHVlLHJlamVjdGlvbik9PntcbmlmKHRhaWxSPT09dW5kZWZpbmVkKXtcbnRocm93IEVycm9yKCdDYW5ub3QgdXBkYXRlIHN0YXRlIGFmdGVyIHRlcm1pbmF0aW9uLicpO1xuIH1cblxuY3VycmVudFB1Ymxpc2hDb3VudCs9MW47XG5jdXJyZW50UD10YWlsUDtcbmNvbnN0IHJlc29sdmVDdXJyZW50PXRhaWxSO1xuXG5pZihkb25lKXtcbnRhaWxQPXRvb0ZhclJlamVjdGlvbjtcbnRhaWxSPXVuZGVmaW5lZDtcbiB9ZWxzZXtcbih7cHJvbWlzZTp0YWlsUCxyZXNvbHZlOnRhaWxSfT1tYWtlUHJvbWlzZUtpdCgpKTtcbiB9XG5cbmlmKHJlamVjdGlvbil7XG5yZXNvbHZlQ3VycmVudChyZWplY3Rpb24pO1xuIH1lbHNle1xucmVzb2x2ZUN1cnJlbnQoXG5oYXJkZW4oe1xuaGVhZDp7dmFsdWUsZG9uZX0sXG5wdWJsaXNoQ291bnQ6Y3VycmVudFB1Ymxpc2hDb3VudCxcbnRhaWw6dGFpbFB9KSk7XG5cblxuIH1cbiB9O1xuXG5jb25zdCBtYWtlTWVtb2l6ZWRVcGRhdGVSZWNvcmQ9d2Vha01lbW9pemVVbmFyeShcbm1ha2VVcGRhdGVSZWNvcmRGcm9tUHVibGljYXRpb25SZWNvcmQpO1xuXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlIHtTdWJzY3JpYmVyPFQ+fVxuICovXG5jb25zdCBzdWJzY3JpYmVyPUZhcignU3Vic2NyaWJlcicse1xuc3Vic2NyaWJlQWZ0ZXI6KHB1Ymxpc2hDb3VudD0tMW4pPT57XG5hc3NlcnQudHlwZW9mKHB1Ymxpc2hDb3VudCwnYmlnaW50Jyk7XG5pZihwdWJsaXNoQ291bnQ9PT1jdXJyZW50UHVibGlzaENvdW50KXtcbnJldHVybiB0YWlsUDtcbiB9ZWxzZSBpZihwdWJsaXNoQ291bnQ8Y3VycmVudFB1Ymxpc2hDb3VudCl7XG5yZXR1cm4gY3VycmVudFA7XG4gfWVsc2V7XG50aHJvdyBFcnJvcihcbidzdWJzY3JpYmVBZnRlciBhcmd1bWVudCBtdXN0IGJlIGEgcHJldmlvdXNseS1pc3N1ZWQgcHVibGlzaENvdW50LicpO1xuXG4gfVxuIH0sXG5nZXRVcGRhdGVTaW5jZToodXBkYXRlQ291bnQpPT57XG5pZih1cGRhdGVDb3VudD09PXVuZGVmaW5lZCl7XG5yZXR1cm4gc3Vic2NyaWJlci5zdWJzY3JpYmVBZnRlcigpLnRoZW4obWFrZU1lbW9pemVkVXBkYXRlUmVjb3JkKTtcbiB9XG51cGRhdGVDb3VudD1CaWdJbnQodXBkYXRlQ291bnQpO1xucmV0dXJuKFxuc3Vic2NyaWJlclxuLyogYHN1YnNjcmliZUFmdGVyYCBtYXkgcmVzb2x2ZSB3aXRoIHRoZSB1cGRhdGUgcmVjb3JkIG51bWJlcmVkKi9cbi8qIGB1cGRhdGVDb3VudCArIDFgLCBldmVuIGlmIHNldmVyYWwgdXBkYXRlcyBhcmUgcHVibGlzaGVkIGluIHRoZSovXG4vKiBzYW1lIGNyYW5rLi4uKi8uXG5zdWJzY3JpYmVBZnRlcih1cGRhdGVDb3VudClcbi8qIC4uLiBzbyB3ZSBwb2xsIHRoZSBsYXRlc3QgcHVibGlzaGVkIHVwZGF0ZSwgd2l0aG91dCB3YWl0aW5nIGZvciBhbnkqL1xuLyogZnVydGhlciBvbmVzLiovLlxudGhlbigoKT0+c3Vic2NyaWJlci5nZXRVcGRhdGVTaW5jZSgpKSk7XG5cbiB9fSk7XG5cblxuLyoqIEB0eXBlIHtQdWJsaXNoZXI8VD59ICovXG5jb25zdCBwdWJsaXNoZXI9RmFyKCdQdWJsaXNoZXInLHtcbnB1Ymxpc2g6KHZhbHVlKT0+e1xuYWR2YW5jZUN1cnJlbnQoZmFsc2UsdmFsdWUpO1xuIH0sXG5maW5pc2g6KGZpbmFsVmFsdWUpPT57XG5hZHZhbmNlQ3VycmVudCh0cnVlLGZpbmFsVmFsdWUpO1xuIH0sXG5mYWlsOihyZWFzb24pPT57XG5hZHZhbmNlQ3VycmVudCh0cnVlLHVuZGVmaW5lZCxtYWtlUXVpZXRSZWplY3Rpb24ocmVhc29uKSk7XG4gfX0pO1xuXG5yZXR1cm4gaGFyZGVuKHtwdWJsaXNoZXIsc3Vic2NyaWJlcn0pO1xuIH07JGjigI1fb25jZS5tYWtlUHVibGlzaEtpdChtYWtlUHVibGlzaEtpdCk7XG5oYXJkZW4obWFrZVB1Ymxpc2hLaXQpO1xuXG5jb25zdCBEdXJhYmxlUHVibGlzaEtpdFN0YXRlU2hhcGU9aGFyZGVuKHtcbnZhbHVlRHVyYWJpbGl0eTpNLmFueSgpLFxucHVibGlzaENvdW50Ok0uYW55KCksXG5zdGF0dXM6TS5hbnkoKSxcbmhhc1ZhbHVlOk0uYW55KCksXG52YWx1ZTpNLmFueSgpfSk7XG5cblxuLyogVE9ETzogTW92ZSBkdXJhYmxlIHB1Ymxpc2gga2l0IHRvIGEgbmV3IGZpbGU/Ki9cblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdH0gW29wdGlvbnNdXG4gKiBAcGFyYW0ge0R1cmFibGVQdWJsaXNoS2l0VmFsdWVEdXJhYmlsaXR5ICYgJ21hbmRhdG9yeSd9IFtvcHRpb25zLnZhbHVlRHVyYWJpbGl0eT0nbWFuZGF0b3J5J11cbiAqIEByZXR1cm5zIHtEdXJhYmxlUHVibGlzaEtpdFN0YXRlfVxuICovXG5jb25zdCBpbml0RHVyYWJsZVB1Ymxpc2hLaXRTdGF0ZT0ob3B0aW9ucz17fSk9PntcbmNvbnN0e3ZhbHVlRHVyYWJpbGl0eT0nbWFuZGF0b3J5J309b3B0aW9ucztcbmFzc2VydC5lcXVhbCh2YWx1ZUR1cmFiaWxpdHksJ21hbmRhdG9yeScpO1xucmV0dXJue1xuLyogY29uZmlndXJhdGlvbiovXG52YWx1ZUR1cmFiaWxpdHksXG5cbi8qIGxpZmVjeWNsZSBwcm9ncmVzcyovXG5wdWJsaXNoQ291bnQ6MG4sXG5zdGF0dXM6J2xpdmUnLC8qIHwgJ2ZpbmlzaGVkJyB8ICdmYWlsZWQnKi9cblxuLyogcGVyc2lzdGVkIHJlc3VsdCBkYXRhKi9cbi8qIE5vdGUgdGhhdCBpbiBhZGRpdGlvbiB0byBub24tdGVybWluYWwgdmFsdWVzIGZyb20gYHB1Ymxpc2hgLCovXG4vKiB2YWx1ZSBhbHNvIGhvbGRzIHRoZSB0ZXJtaW5hbCB2YWx1ZSBmcm9tIGBmaW5pc2hgIG9yIGBmYWlsYC4qL1xuaGFzVmFsdWU6ZmFsc2UsXG52YWx1ZTp1bmRlZmluZWR9O1xuXG4gfTtcblxuLyogV2UgbmVlZCB0aGUgV2Vha01hcCBrZXkgZm9yIGEga2l0IHRvIGJlIGEgdnJlZi1iZWFyaW5nIG9iamVjdCovXG4vKiBpbiBpdHMgY29ob3J0LCBhbmQgaGF2ZSBhcmJpdHJhcmlseSBjaG9zZW4gdGhlIHB1Ymxpc2hlciBmYWNldC4qL1xuLyoqIEB0eXBlZGVmIHtQdWJsaXNoZXI8Kj59IER1cmFibGVQdWJsaXNoS2l0RXBoZW1lcmFsS2V5ICovXG4vKipcbiAqIEBwYXJhbSB7UHVibGlzaEtpdDwqPn0gZmFjZXRzXG4gKiBAcmV0dXJucyB7RHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxLZXl9XG4gKi9cbmNvbnN0IGdldEVwaGVtZXJhbEtleT0oZmFjZXRzKT0+ZmFjZXRzLnB1Ymxpc2hlcjtcblxuLyoqXG4gKiBAdHlwZWRlZiBEdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGFcbiAqIEBwcm9wZXJ0eSB7UHJvbWlzZTwqPiB8IHVuZGVmaW5lZH0gY3VycmVudFAgVGhlIGN1cnJlbnQtcmVzdWx0IHByb21pc2VcbiAqICAgKHVuZGVmaW5lZCB1bmxlc3MgcmVzb2x2ZWQgd2l0aCB1bnJlY292ZXJhYmxlIGVwaGVtZXJhbCBkYXRhKVxuICogQHByb3BlcnR5IHtQcm9taXNlPCo+fSB0YWlsUCBUaGUgbmV4dC1yZXN1bHQgcHJvbWlzZVxuICogQHByb3BlcnR5IHsoKHZhbHVlOiBhbnkpID0+IHZvaWQpIHwgdW5kZWZpbmVkfSB0YWlsUiBUaGUgbmV4dC1yZXN1bHQgcmVzb2x2ZXJcbiAqICAgKHVuZGVmaW5lZCB3aGVuIHRoZSBwdWJsaXNoIGtpdCBoYXMgdGVybWluYXRlZClcbiAqL1xuXG4vKiogQHR5cGUge1dlYWtNYXA8RHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxLZXksIER1cmFibGVQdWJsaXNoS2l0RXBoZW1lcmFsRGF0YT59ICovXG5jb25zdCBkdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGE9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBSZXR1cm5zIHRoZSBjdXJyZW50LXJlc3VsdCBwcm9taXNlIGFzc29jaWF0ZWQgd2l0aCBhIGdpdmVuIGR1cmFibGVcbiAqIHB1Ymxpc2gga2l0LCByZWNyZWF0ZWQgdW5sZXNzIHdlIGFscmVhZHkgaGF2ZSBvbmUgd2l0aCByZXRhaW5lZFxuICogZXBoZW1lcmFsIGRhdGEuXG4gKlxuICogQHBhcmFtIHtEdXJhYmxlUHVibGlzaEtpdFN0YXRlfSBzdGF0ZVxuICogQHBhcmFtIHtQdWJsaXNoS2l0PCo+fSBmYWNldHNcbiAqIEBwYXJhbSB7UHJvbWlzZTwqPn0gdGFpbFxuICogQHJldHVybnMge1Byb21pc2U8Kj59XG4gKi9cbmNvbnN0IHByb3ZpZGVDdXJyZW50UD0oc3RhdGUsZmFjZXRzLHRhaWwpPT57XG5jb25zdCBlcGhlbWVyYWxLZXk9Z2V0RXBoZW1lcmFsS2V5KGZhY2V0cyk7XG5jb25zdCBmb3VuZERhdGE9ZHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhLmdldChlcGhlbWVyYWxLZXkpO1xuY29uc3QgY3VycmVudFA9Zm91bmREYXRhJiZmb3VuZERhdGEuY3VycmVudFA7XG5pZihjdXJyZW50UCl7XG5yZXR1cm4gY3VycmVudFA7XG4gfVxuXG5jb25zdHtwdWJsaXNoQ291bnQsc3RhdHVzLGhhc1ZhbHVlLHZhbHVlfT1zdGF0ZTtcbmlmKCFoYXNWYWx1ZSl7XG5hc3NlcnQoc3RhdHVzPT09J2xpdmUnKTtcbnJldHVybiB0YWlsO1xuIH1cbmlmKHN0YXR1cz09PSdsaXZlJ3x8c3RhdHVzPT09J2ZpbmlzaGVkJyl7XG5jb25zdCBjZWxsPWhhcmRlbih7XG5oZWFkOnt2YWx1ZSxkb25lOnN0YXR1cyE9PSdsaXZlJ30sXG5wdWJsaXNoQ291bnQsXG50YWlsfSk7XG5cbnJldHVybiBFLnJlc29sdmUoY2VsbCk7XG4gfWVsc2UgaWYoc3RhdHVzPT09J2ZhaWxlZCcpe1xucmV0dXJuIG1ha2VRdWlldFJlamVjdGlvbih2YWx1ZSk7XG4gfWVsc2V7XG50aHJvdyBGYWlsIGBJbnZhbGlkIGR1cmFibGUgcHJvbWlzZSBraXQgc3RhdHVzOiAke3Eoc3RhdHVzKX1gO1xuIH1cbiB9O1xuXG4vKipcbiAqIFJldHVybnMgdGhlIG5leHQtcmVzdWx0IHByb21pc2UgYW5kIHJlc29sdmVyIGFzc29jaWF0ZWQgd2l0aCBhIGdpdmVuXG4gKiBkdXJhYmxlIHB1Ymxpc2gga2l0LlxuICogVGhlc2UgYXJlIGxvc3Qgb24gdXBncmFkZSBidXQgcmVjcmVhdGVkIG9uLWRlbWFuZCwgcHJlc2VydmluZyB0aGVcbiAqIHZhbHVlIGluIChidXQgbm90IHRoZSBpZGVudGl0eSBvZikgdGhlIGN1cnJlbnQgeyB2YWx1ZSwgZG9uZSB9IHJlc3VsdFxuICogd2hlbiBwb3NzaWJsZSwgd2hpY2ggaXMgYWx3YXlzIHRoZSBjYXNlIHdoZW4gdGhhdCB2YWx1ZSBpcyB0ZXJtaW5hbFxuICogKGkuZS4sIGZyb20gYGZpbmlzaGAgb3IgYGZhaWxgKSBvciB3aGVuIHRoZSBkdXJhYmxlIHB1Ymxpc2gga2l0IGlzXG4gKiBjb25maWd1cmVkIHdpdGggYHZhbHVlRHVyYWJpbGl0eTogJ21hbmRhdG9yeSdgLlxuICpcbiAqIEBwYXJhbSB7RHVyYWJsZVB1Ymxpc2hLaXRTdGF0ZX0gc3RhdGVcbiAqIEBwYXJhbSB7UHVibGlzaEtpdDwqPn0gZmFjZXRzXG4gKiBAcmV0dXJucyB7RHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhfVxuICovXG5jb25zdCBwcm92aWRlRHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhPShzdGF0ZSxmYWNldHMpPT57XG5jb25zdCBlcGhlbWVyYWxLZXk9Z2V0RXBoZW1lcmFsS2V5KGZhY2V0cyk7XG5jb25zdCBmb3VuZERhdGE9ZHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhLmdldChlcGhlbWVyYWxLZXkpO1xuaWYoZm91bmREYXRhKXtcbnJldHVybiBmb3VuZERhdGE7XG4gfVxuXG5jb25zdHtzdGF0dXN9PXN0YXRlO1xubGV0IHRhaWxQO1xubGV0IHRhaWxSO1xuaWYoc3RhdHVzPT09J2xpdmUnKXtcbih7cHJvbWlzZTp0YWlsUCxyZXNvbHZlOnRhaWxSfT1tYWtlUHJvbWlzZUtpdCgpKTtcbnZvaWQgRS53aGVuKHRhaWxQLHNpbmssc2luayk7XG4gfWVsc2UgaWYoc3RhdHVzPT09J2ZpbmlzaGVkJ3x8c3RhdHVzPT09J2ZhaWxlZCcpe1xudGFpbFA9dG9vRmFyUmVqZWN0aW9uO1xuIH1lbHNle1xudGhyb3cgRmFpbCBgSW52YWxpZCBkdXJhYmxlIHByb21pc2Uga2l0IHN0YXR1czogJHtxKHN0YXR1cyl9YDtcbiB9XG4vKiBjdXJyZW50UCBpcyBub3QgZXBoZW1lcmFsIHdoZW4gcmVzdG9yaW5nIGZyb20gcGVyc2lzdGVkIHN0YXRlLiovXG5jb25zdCBvYmo9aGFyZGVuKHtjdXJyZW50UDp1bmRlZmluZWQsdGFpbFAsdGFpbFJ9KTtcbmR1cmFibGVQdWJsaXNoS2l0RXBoZW1lcmFsRGF0YS5zZXQoZXBoZW1lcmFsS2V5LG9iaik7XG5yZXR1cm4gb2JqO1xuIH07XG5cbi8qKlxuICogRXh0ZW5kcyB0aGUgc2VxdWVuY2Ugb2YgcmVzdWx0cy5cbiAqXG4gKiBAcGFyYW0ge3tzdGF0ZTogRHVyYWJsZVB1Ymxpc2hLaXRTdGF0ZSwgZmFjZXRzOiBQdWJsaXNoS2l0PCo+fX0gY29udGV4dFxuICogQHBhcmFtIHthbnl9IHZhbHVlXG4gKiBAcGFyYW0ge0R1cmFibGVQdWJsaXNoS2l0U3RhdGVbJ3N0YXR1cyddfSBbdGFyZ2V0U3RhdHVzXVxuICovXG5jb25zdCBhZHZhbmNlRHVyYWJsZVB1Ymxpc2hLaXQ9KGNvbnRleHQsdmFsdWUsdGFyZ2V0U3RhdHVzPSdsaXZlJyk9PntcbmNvbnN0e3N0YXRlLGZhY2V0c309Y29udGV4dDtcbmNvbnN0e3ZhbHVlRHVyYWJpbGl0eSxzdGF0dXN9PXN0YXRlO1xuaWYoc3RhdHVzIT09J2xpdmUnKXtcbnRocm93IEVycm9yKCdDYW5ub3QgdXBkYXRlIHN0YXRlIGFmdGVyIHRlcm1pbmF0aW9uLicpO1xuIH1cbmNvbnN0IGRvbmU9dGFyZ2V0U3RhdHVzIT09J2xpdmUnO1xuaWYoZG9uZXx8dmFsdWVEdXJhYmlsaXR5PT09J21hbmRhdG9yeScpe1xuY2FuQmVEdXJhYmxlKHZhbHVlKXx8RmFpbCBgQ2Fubm90IGFjY2VwdCBub24tZHVyYWJsZSB2YWx1ZTogJHt2YWx1ZX1gO1xuIH1cbmNvbnN0e3RhaWxQOm9sZFRhaWxQLHRhaWxSOnJlc29sdmVPbGRUYWlsfT1cbnByb3ZpZGVEdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGEoc3RhdGUsZmFjZXRzKTtcbmFzc2VydC50eXBlb2YocmVzb2x2ZU9sZFRhaWwsJ2Z1bmN0aW9uJyk7XG5cbmNvbnN0IHB1Ymxpc2hDb3VudD1zdGF0ZS5wdWJsaXNoQ291bnQrMW47XG5zdGF0ZS5wdWJsaXNoQ291bnQ9cHVibGlzaENvdW50O1xuXG5sZXQgdGFpbFA7XG5sZXQgdGFpbFI7XG5pZihkb25lKXtcbnN0YXRlLnN0YXR1cz10YXJnZXRTdGF0dXM7XG50YWlsUD10b29GYXJSZWplY3Rpb247XG50YWlsUj11bmRlZmluZWQ7XG4gfWVsc2V7XG4oe3Byb21pc2U6dGFpbFAscmVzb2x2ZTp0YWlsUn09bWFrZVByb21pc2VLaXQoKSk7XG52b2lkIEUud2hlbih0YWlsUCxzaW5rLHNpbmspO1xuIH1cblxubGV0IGN1cnJlbnRQO1xuaWYodGFyZ2V0U3RhdHVzPT09J2ZhaWxlZCcpe1xuc3RhdGUuaGFzVmFsdWU9dHJ1ZTtcbnN0YXRlLnZhbHVlPXZhbHVlO1xuY29uc3QgcmVqZWN0aW9uPW1ha2VRdWlldFJlamVjdGlvbih2YWx1ZSk7XG5yZXNvbHZlT2xkVGFpbChyZWplY3Rpb24pO1xuIH1lbHNle1xuLyogUGVyc2lzdCBhIHRlcm1pbmFsIHZhbHVlLCBvciBhIG5vbi10ZXJtaW5hbCB2YWx1ZSovXG4vKiBpZiBjb25maWd1cmVkIGFzICdtYW5kYXRvcnknIG9yICdvcHBvcnR1bmlzdGljJy4qL1xuaWYoZG9uZXx8dmFsdWVEdXJhYmlsaXR5IT09J2lnbm9yZWQnJiZjYW5CZUR1cmFibGUodmFsdWUpKXtcbnN0YXRlLmhhc1ZhbHVlPXRydWU7XG5zdGF0ZS52YWx1ZT12YWx1ZTtcbiB9ZWxzZXtcbnN0YXRlLmhhc1ZhbHVlPWZhbHNlO1xuc3RhdGUudmFsdWU9dW5kZWZpbmVkO1xuLyogUmV0YWluIGFueSBwcm9taXNlIHdpdGggbm9uLWR1cmFibGUgcmVzb2x1dGlvbi4qL1xuY3VycmVudFA9b2xkVGFpbFA7XG4gfVxuXG5yZXNvbHZlT2xkVGFpbChcbmhhcmRlbih7XG5oZWFkOnt2YWx1ZSxkb25lfSxcbnB1Ymxpc2hDb3VudCxcbnRhaWw6dGFpbFB9KSk7XG5cblxuIH1cblxuZHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhLnNldChcbmdldEVwaGVtZXJhbEtleShmYWNldHMpLFxuaGFyZGVuKHtjdXJyZW50UCx0YWlsUCx0YWlsUn0pKTtcblxuIH07XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuLi8uLi92YXQtZGF0YS9zcmMvdHlwZXMuanMnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2luZE5hbWVcbiAqL1xuY29uc3QgICAgICAgIHByZXBhcmVEdXJhYmxlUHVibGlzaEtpdD0oYmFnZ2FnZSxraW5kTmFtZSk9Pntcbi8qIFRPRE86IE9uY2Ugd2UgdW5pZnkgd2l0aCBtYWtlUHVibGlzaEtpdCwgd2Ugd2lsbCB1c2UgYSBab25lLWNvbXBhdGlibGUgd2VhayovXG4vKiBtYXAgZm9yIG1lbW9pemF0aW9uLiovXG5jb25zdCBtYWtlTWVtb2l6ZWRVcGRhdGVSZWNvcmQ9bWFrZVVwZGF0ZVJlY29yZEZyb21QdWJsaWNhdGlvblJlY29yZDtcblxuLyoqXG4gKiBAcmV0dXJucyB7KCkgPT4gUHVibGlzaEtpdDwqPn1cbiAqL1xucmV0dXJuIHByZXBhcmVFeG9DbGFzc0tpdChcbmJhZ2dhZ2UsXG5raW5kTmFtZSxcbnB1Ymxpc2hLaXRJS2l0LFxuaW5pdER1cmFibGVQdWJsaXNoS2l0U3RhdGUsXG57XG4vKiBUaGUgcHVibGlzaGVyIGZhY2V0IG9mIGEgZHVyYWJsZSBwdWJsaXNoIGtpdCovXG4vKiBhY2NlcHRzIG5ldyB2YWx1ZXMuKi9cbnB1Ymxpc2hlcjp7XG5wdWJsaXNoKHZhbHVlKXtcbmFkdmFuY2VEdXJhYmxlUHVibGlzaEtpdCh0aGlzLHZhbHVlKTtcbiB9LFxuZmluaXNoKGZpbmFsVmFsdWUpe1xuYWR2YW5jZUR1cmFibGVQdWJsaXNoS2l0KHRoaXMsZmluYWxWYWx1ZSwnZmluaXNoZWQnKTtcbiB9LFxuZmFpbChyZWFzb24pe1xuYWR2YW5jZUR1cmFibGVQdWJsaXNoS2l0KHRoaXMscmVhc29uLCdmYWlsZWQnKTtcbiB9fSxcblxuXG4vKiBUaGUgc3Vic2NyaWJlciBmYWNldCBvZiBhIGR1cmFibGUgcHVibGlzaCBraXQqL1xuLyogcHJvcGFnYXRlcyB2YWx1ZXMuKi9cbnN1YnNjcmliZXI6e1xuc3Vic2NyaWJlQWZ0ZXIocHVibGlzaENvdW50PS0xbil7XG5jb25zdHtzdGF0ZSxmYWNldHN9PXRoaXM7XG5jb25zdHtwdWJsaXNoQ291bnQ6Y3VycmVudFB1Ymxpc2hDb3VudH09c3RhdGU7XG5jb25zdHtjdXJyZW50UCx0YWlsUH09cHJvdmlkZUR1cmFibGVQdWJsaXNoS2l0RXBoZW1lcmFsRGF0YShcbnN0YXRlLFxuZmFjZXRzKTtcblxuaWYocHVibGlzaENvdW50PT09Y3VycmVudFB1Ymxpc2hDb3VudCl7XG5yZXR1cm4gdGFpbFA7XG4gfWVsc2UgaWYocHVibGlzaENvdW50PGN1cnJlbnRQdWJsaXNoQ291bnQpe1xucmV0dXJuIGN1cnJlbnRQfHxwcm92aWRlQ3VycmVudFAoc3RhdGUsZmFjZXRzLHRhaWxQKTtcbiB9ZWxzZXtcbnRocm93IEVycm9yKFxuJ3N1YnNjcmliZUFmdGVyIGFyZ3VtZW50IG11c3QgYmUgYSBwcmV2aW91c2x5LWlzc3VlZCBwdWJsaXNoQ291bnQuJyk7XG5cbiB9XG4gfSxcbmdldFVwZGF0ZVNpbmNlKHVwZGF0ZUNvdW50KXtcbmNvbnN0e1xuZmFjZXRzOntzdWJzY3JpYmVyfX09XG50aGlzO1xuaWYodXBkYXRlQ291bnQ9PT11bmRlZmluZWQpe1xucmV0dXJuIHN1YnNjcmliZXIuc3Vic2NyaWJlQWZ0ZXIoKS50aGVuKG1ha2VNZW1vaXplZFVwZGF0ZVJlY29yZCk7XG4gfVxudXBkYXRlQ291bnQ9QmlnSW50KHVwZGF0ZUNvdW50KTtcbnJldHVybihcbnN1YnNjcmliZXJcbi8qIGBzdWJzY3JpYmVBZnRlcmAgbWF5IHJlc29sdmUgd2l0aCB0aGUgdXBkYXRlIHJlY29yZCBudW1iZXJlZCovXG4vKiBgdXBkYXRlQ291bnQgKyAxYCwgZXZlbiBpZiBzZXZlcmFsIHVwZGF0ZXMgYXJlIHB1Ymxpc2hlZCBpbiB0aGUqL1xuLyogc2FtZSBjcmFuay4uLiovLlxuc3Vic2NyaWJlQWZ0ZXIodXBkYXRlQ291bnQpXG4vKiAuLi4gc28gd2UgcG9sbCB0aGUgbGF0ZXN0IHB1Ymxpc2hlZCB1cGRhdGUsIHdpdGhvdXQgd2FpdGluZyBmb3IgYW55Ki9cbi8qIGZ1cnRoZXIgb25lcy4qLy5cbnRoZW4oKCk9PnN1YnNjcmliZXIuZ2V0VXBkYXRlU2luY2UoKSkpO1xuXG4gfX19LFxuXG5cbntcbnN0YXRlU2hhcGU6RHVyYWJsZVB1Ymxpc2hLaXRTdGF0ZVNoYXBlfSk7XG5cblxuIH07JGjigI1fb25jZS5wcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQocHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0KTtcbmhhcmRlbihwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQpO1xuXG5jb25zdCAgICAgICAgU3Vic2NyaWJlclNoYXBlPU0ucmVtb3RhYmxlKCdTdWJzY3JpYmVyJyk7JGjigI1fb25jZS5TdWJzY3JpYmVyU2hhcGUoU3Vic2NyaWJlclNoYXBlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJQdWJsaXNoZXJJIjpbIlB1Ymxpc2hlckkiXSwiVXBkYXRlQ291bnRTaGFwZSI6WyJVcGRhdGVDb3VudFNoYXBlIl0sIlN1YnNjcmliZXJJIjpbIlN1YnNjcmliZXJJIl0sInB1Ymxpc2hLaXRJS2l0IjpbInB1Ymxpc2hLaXRJS2l0Il0sIkZvcmthYmxlQXN5bmNJdGVyYWJsZUl0ZXJhdG9yU2hhcGUiOlsiRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3JTaGFwZSJdLCJJdGVyYWJsZUVhY2hUb3BpY0kiOlsiSXRlcmFibGVFYWNoVG9waWNJIl0sIkl0ZXJhYmxlTGF0ZXN0VG9waWNJIjpbIkl0ZXJhYmxlTGF0ZXN0VG9waWNJIl0sIm1ha2VQdWJsaXNoS2l0IjpbIm1ha2VQdWJsaXNoS2l0Il0sInByZXBhcmVEdXJhYmxlUHVibGlzaEtpdCI6WyJwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQiXSwiU3Vic2NyaWJlclNoYXBlIjpbIlN1YnNjcmliZXJTaGFwZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAC+ATAkgwoAAIMKAAA0AAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3N0b3JlZC1ub3RpZmllci5qc3siaW1wb3J0cyI6WyIuL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzIiwiQGFnb3JpYy9pbnRlcm5hbCIsIkBhZ29yaWMvaW50ZXJuYWwvc3JjL2xpYi1jaGFpblN0b3JhZ2UuanMiLCJAZW5kby9mYXIiXSwiZXhwb3J0cyI6WyJtYWtlU3RvcmVkTm90aWZpZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0QWxsRGVmaW5lZCxtYWtlU2VyaWFsaXplVG9TdG9yYWdlLEUsRmFyLG9ic2VydmVOb3RpZmllcjskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2ludGVybmFsXCIsIFtbXCJhc3NlcnRBbGxEZWZpbmVkXCIsIFskaOKAjV9hID0+IChhc3NlcnRBbGxEZWZpbmVkID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvaW50ZXJuYWwvc3JjL2xpYi1jaGFpblN0b3JhZ2UuanNcIiwgW1tcIm1ha2VTZXJpYWxpemVUb1N0b3JhZ2VcIiwgWyRo4oCNX2EgPT4gKG1ha2VTZXJpYWxpemVUb1N0b3JhZ2UgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCIuL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzXCIsIFtbXCJvYnNlcnZlTm90aWZpZXJcIiwgWyRo4oCNX2EgPT4gKG9ic2VydmVOb3RpZmllciA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge0Jhc2VOb3RpZmllcjxUPiAmIE9taXQ8U3RvcmVkRmFjZXQsICdnZXRTdG9yZUtleSc+fSBTdG9yZWROb3RpZmllclxuICovXG5cbi8qKlxuICogQmVnaW4gaXRlcmF0aW5nIHRoZSBzb3VyY2UsIHN0b3Jpbmcgc2VyaWFsaXplZCBpdGVyYXRpb24gdmFsdWVzLiAgSWYgdGhlXG4gKiBzdG9yYWdlTm9kZSdzIGBzZXRWYWx1ZWAgb3BlcmF0aW9uIHJlamVjdHMsIG5vIGZ1cnRoZXIgd3JpdGVzIHRvIGl0IHdpbGxcbiAqIGJlIGF0dGVtcHRlZCAoYnV0IHJlc3VsdHMgd2lsbCByZW1haW4gYXZhaWxhYmxlIGZyb20gdGhlIHN1YnNjcmliZXIpLlxuICpcbiAqIFJldHVybnMgYSBTdG9yZWROb3RpZmllciB0aGF0IGNhbiBiZSB1c2VkIGJ5IGEgY2xpZW50IHRvIGRpcmVjdGx5IGZvbGxvd1xuICogdGhlIGl0ZXJhdGlvbiB0aGVtc2VsdmVzLCBvciBvYnRhaW4gaW5mb3JtYXRpb24gdG8gc3Vic2NyaWJlIHRvIHRoZSBzdG9yZWRcbiAqIGRhdGEgb3V0LW9mLWJhbmQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxOb3RpZmllcjxUPj59IG5vdGlmaWVyXG4gKiBAcGFyYW0ge0VSZWY8U3RvcmFnZU5vZGU+fSBzdG9yYWdlTm9kZVxuICogQHBhcmFtIHtFUmVmPE1hcnNoYWxsZXI+fSBtYXJzaGFsbGVyXG4gKiBAcmV0dXJucyB7U3RvcmVkTm90aWZpZXI8VD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlU3RvcmVkTm90aWZpZXI9KG5vdGlmaWVyLHN0b3JhZ2VOb2RlLG1hcnNoYWxsZXIpPT57XG5hc3NlcnRBbGxEZWZpbmVkKHtub3RpZmllcixzdG9yYWdlTm9kZSxtYXJzaGFsbGVyfSk7XG5cbmNvbnN0IG1hcnNoYWxsVG9TdG9yYWdlPW1ha2VTZXJpYWxpemVUb1N0b3JhZ2Uoc3RvcmFnZU5vZGUsbWFyc2hhbGxlcik7XG5cbm9ic2VydmVOb3RpZmllcihub3RpZmllcix7XG51cGRhdGVTdGF0ZSh2YWx1ZSl7XG5tYXJzaGFsbFRvU3RvcmFnZSh2YWx1ZSkuY2F0Y2goKHJlYXNvbik9PlxuY29uc29sZS5lcnJvcignU3RvcmVkTm90aWZpZXIgZmFpbGVkIHRvIHVwZGF0ZVN0YXRlJyxyZWFzb24pKTtcblxuIH0sXG5mYWlsKHJlYXNvbil7XG5jb25zb2xlLmVycm9yKCdTdG9yZWROb3RpZmllciBmYWlsZWQgdG8gaXRlcmF0ZScscmVhc29uKTtcbiB9fSkuXG5jYXRjaCgocmVhc29uKT0+e1xuY29uc29sZS5lcnJvcignU3RvcmVkTm90aWZpZXIgaGFsdGVkIGl0ZXJhdGlvbicscmVhc29uKTtcbiB9KTtcblxuLyoqIEB0eXBlIHtVbnNlcmlhbGl6ZXJ9ICovXG5jb25zdCB1bnNlcmlhbGl6ZXI9RmFyKCd1bnNlcmlhbGl6ZXInLHtcbmZyb21DYXBEYXRhOihkYXRhKT0+RShtYXJzaGFsbGVyKS5mcm9tQ2FwRGF0YShkYXRhKSxcbnVuc2VyaWFsaXplOihkYXRhKT0+RShtYXJzaGFsbGVyKS5mcm9tQ2FwRGF0YShkYXRhKX0pO1xuXG5cbi8qKiBAdHlwZSB7U3RvcmVkTm90aWZpZXI8VD59ICovXG5jb25zdCBzdG9yZWROb3RpZmllcj1GYXIoJ1N0b3JlZE5vdGlmaWVyJyx7XG5nZXRVcGRhdGVTaW5jZToodXBkYXRlQ291bnQpPT5FKG5vdGlmaWVyKS5nZXRVcGRhdGVTaW5jZSh1cGRhdGVDb3VudCksXG5nZXRQYXRoOigpPT5FKHN0b3JhZ2VOb2RlKS5nZXRQYXRoKCksXG5nZXRVbnNlcmlhbGl6ZXI6KCk9PnVuc2VyaWFsaXplcn0pO1xuXG5yZXR1cm4gc3RvcmVkTm90aWZpZXI7XG4gfTskaOKAjV9vbmNlLm1ha2VTdG9yZWROb3RpZmllcihtYWtlU3RvcmVkTm90aWZpZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VTdG9yZWROb3RpZmllciI6WyJtYWtlU3RvcmVkTm90aWZpZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA6z5UarAiAACwIgAALQAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9zdG9yZXN1Yi5qc3siaW1wb3J0cyI6WyIuL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzIiwiLi9wdWJsaXNoLWtpdC5qcyIsIi4vc3Vic2NyaWJlLmpzIiwiLi9zdWJzY3JpYmVyLmpzIiwiQGFnb3JpYy9pbnRlcm5hbCIsIkBhZ29yaWMvaW50ZXJuYWwvc3JjL2xpYi1jaGFpblN0b3JhZ2UuanMiLCJAZW5kby9mYXIiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiZm9yRWFjaFB1YmxpY2F0aW9uUmVjb3JkIiwibWFrZVN0b3JlZFB1Ymxpc2hLaXQiLCJtYWtlU3RvcmVkUHVibGlzaGVyS2l0IiwibWFrZVN0b3JlZFN1YnNjcmliZXIiLCJtYWtlU3RvcmVkU3Vic2NyaXB0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsRmFyLG1ha2VNYXJzaGFsLGFzc2VydEFsbERlZmluZWQsbWFrZVNlcmlhbGl6ZVRvU3RvcmFnZSxvYnNlcnZlSXRlcmF0aW9uLG1ha2VQdWJsaXNoS2l0LG1ha2VTdWJzY3JpcHRpb25LaXQsc3Vic2NyaWJlRWFjaDskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcIm1ha2VNYXJzaGFsXCIsIFskaOKAjV9hID0+IChtYWtlTWFyc2hhbCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL2ludGVybmFsXCIsIFtbXCJhc3NlcnRBbGxEZWZpbmVkXCIsIFskaOKAjV9hID0+IChhc3NlcnRBbGxEZWZpbmVkID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvaW50ZXJuYWwvc3JjL2xpYi1jaGFpblN0b3JhZ2UuanNcIiwgW1tcIm1ha2VTZXJpYWxpemVUb1N0b3JhZ2VcIiwgWyRo4oCNX2EgPT4gKG1ha2VTZXJpYWxpemVUb1N0b3JhZ2UgPSAkaOKAjV9hKV1dXV0sW1wiLi9hc3luY0l0ZXJhYmxlQWRhcHRvci5qc1wiLCBbW1wib2JzZXJ2ZUl0ZXJhdGlvblwiLCBbJGjigI1fYSA9PiAob2JzZXJ2ZUl0ZXJhdGlvbiA9ICRo4oCNX2EpXV1dXSxbXCIuL3B1Ymxpc2gta2l0LmpzXCIsIFtbXCJtYWtlUHVibGlzaEtpdFwiLCBbJGjigI1fYSA9PiAobWFrZVB1Ymxpc2hLaXQgPSAkaOKAjV9hKV1dXV0sW1wiLi9zdWJzY3JpYmVyLmpzXCIsIFtbXCJtYWtlU3Vic2NyaXB0aW9uS2l0XCIsIFskaOKAjV9hID0+IChtYWtlU3Vic2NyaXB0aW9uS2l0ID0gJGjigI1fYSldXV1dLFtcIi4vc3Vic2NyaWJlLmpzXCIsIFtbXCJzdWJzY3JpYmVFYWNoXCIsIFskaOKAjV9hID0+IChzdWJzY3JpYmVFYWNoID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBOQjogZG9lcyBub3QgeWV0IHN1cnZpdmUgdXBncmFkZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzY4OTNcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtTdWJzY3JpYmVyPFQ+fSBzdWJzY3JpYmVyXG4gKiBAcGFyYW0geyh2OiBUKSA9PiB2b2lkfSBjb25zdW1lVmFsdWVcbiAqL1xuY29uc3QgICAgICAgIGZvckVhY2hQdWJsaWNhdGlvblJlY29yZD1hc3luYyhzdWJzY3JpYmVyLGNvbnN1bWVWYWx1ZSk9Pntcbi8qIFdlIG9wZW4tY29kZSB0aGUgZm9yLWF3YWl0LW9mIGltcGxlbWVudGF0aW9uIHJhdGhlciB0aGFuIHVzaW5nIHRoYXQgc3ludGF4Ki9cbi8qIGRpcmVjdGx5IGJlY2F1c2Ugd2Ugd2FudCB0byBydW4gdGhlIGNvbnN1bWVyIG9uIHRoZSBkb25lIHZhbHVlIGFzIHdlbGwuKi9cbmNvbnN0IGl0ZXJhdG9yPXN1YnNjcmliZUVhY2goc3Vic2NyaWJlcilbU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCk7XG5cbmxldCBmaW5pc2hlZD1mYWxzZTtcbndoaWxlKCFmaW5pc2hlZCl7XG4vKiBBbGxvdyBuZXN0ZWQgYXdhaXRzIChpbiBsb29wKSBiZWNhdXNlIGl0J3Mgc2FmZSBmb3IgZWFjaCB0byBydW4gaW4gYSB0dXJuKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1hd2FpdC1pbi1sb29wLCBAamVzc2llLmpzL25vLW5lc3RlZC1hd2FpdCovXG5jb25zdHt2YWx1ZSxkb25lfT1hd2FpdCBpdGVyYXRvci5uZXh0KCk7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tYXdhaXQtaW4tbG9vcCwgQGplc3NpZS5qcy9uby1uZXN0ZWQtYXdhaXQqL1xuYXdhaXQgY29uc3VtZVZhbHVlKHZhbHVlKTtcbmZpbmlzaGVkPSEhZG9uZTtcbiB9XG4gfTtcblxuLyoqXG4gKiBCZWdpbiBpdGVyYXRpbmcgdGhlIHNvdXJjZSwgc3RvcmluZyBzZXJpYWxpemVkIGl0ZXJhdGlvbiB2YWx1ZXMuICBJZiB0aGVcbiAqIHN0b3JhZ2VOb2RlJ3MgYHNldFZhbHVlYCBvcGVyYXRpb24gcmVqZWN0cywgbm8gZnVydGhlciB3cml0ZXMgdG8gaXQgd2lsbFxuICogYmUgYXR0ZW1wdGVkIChidXQgcmVzdWx0cyB3aWxsIHJlbWFpbiBhdmFpbGFibGUgZnJvbSB0aGUgc3Vic2NyaWJlcikuXG4gKlxuICogUmV0dXJucyBhIFN0b3JlZFN1YnNjcmliZXIgdGhhdCBjYW4gYmUgdXNlZCBieSBhIGNsaWVudCB0byBkaXJlY3RseSBmb2xsb3dcbiAqIHRoZSBpdGVyYXRpb24gdGhlbXNlbHZlcywgb3Igb2J0YWluIGluZm9ybWF0aW9uIHRvIHN1YnNjcmliZSB0byB0aGUgc3RvcmVkXG4gKiBkYXRhIG91dC1vZi1iYW5kLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1N1YnNjcmliZXI8VD59IHN1YnNjcmliZXJcbiAqIEBwYXJhbSB7RVJlZjxTdG9yYWdlTm9kZT59IHN0b3JhZ2VOb2RlXG4gKiBAcGFyYW0ge0VSZWY8UmV0dXJuVHlwZTx0eXBlb2YgbWFrZU1hcnNoYWw+Pn0gbWFyc2hhbGxlclxuICogQHJldHVybnMge1N0b3JlZFN1YnNjcmliZXI8VD59XG4gKi8kaOKAjV9vbmNlLmZvckVhY2hQdWJsaWNhdGlvblJlY29yZChmb3JFYWNoUHVibGljYXRpb25SZWNvcmQpO1xuY29uc3QgICAgICAgIG1ha2VTdG9yZWRTdWJzY3JpYmVyPShzdWJzY3JpYmVyLHN0b3JhZ2VOb2RlLG1hcnNoYWxsZXIpPT57XG5hc3NlcnRBbGxEZWZpbmVkKHtzdWJzY3JpYmVyLHN0b3JhZ2VOb2RlLG1hcnNoYWxsZXJ9KTtcblxuY29uc3QgbWFyc2hhbGxUb1N0b3JhZ2U9bWFrZVNlcmlhbGl6ZVRvU3RvcmFnZShzdG9yYWdlTm9kZSxtYXJzaGFsbGVyKTtcblxuLyogU3RhcnQgcHVibGlzaGluZyB0aGUgc291cmNlLiovXG5mb3JFYWNoUHVibGljYXRpb25SZWNvcmQoc3Vic2NyaWJlcixtYXJzaGFsbFRvU3RvcmFnZSkuY2F0Y2goKGVycik9Pntcbi8qIFRPRE86IEhvdyBzaG91bGQgd2UgaGFuZGxlIGFuZC9vciBzdXJmYWNlIHRoaXMgZmFpbHVyZT8qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL3B1bGwvNTc2NiNkaXNjdXNzaW9uX3I5MjI0OTgwODgqL1xuY29uc29sZS5lcnJvcignU3RvcmVkU3Vic2NyaWJlciBmYWlsZWQgdG8gaXRlcmF0ZScsZXJyKTtcbiB9KTtcblxuLyoqIEB0eXBlIHtVbnNlcmlhbGl6ZXJ9ICovXG5jb25zdCB1bnNlcmlhbGl6ZXI9RmFyKCd1bnNlcmlhbGl6ZXInLHtcbmZyb21DYXBEYXRhOihkYXRhKT0+RShtYXJzaGFsbGVyKS5mcm9tQ2FwRGF0YShkYXRhKSxcbnVuc2VyaWFsaXplOihkYXRhKT0+RShtYXJzaGFsbGVyKS5mcm9tQ2FwRGF0YShkYXRhKX0pO1xuXG5cbi8qKiBAdHlwZSB7U3RvcmVkU3Vic2NyaWJlcjxUPn0gKi9cbmNvbnN0IHN0b3Jlc3ViPUZhcignU3RvcmVkU3Vic2NyaWJlcicse1xuc3Vic2NyaWJlQWZ0ZXI6KHB1Ymxpc2hDb3VudCk9PnN1YnNjcmliZXIuc3Vic2NyaWJlQWZ0ZXIocHVibGlzaENvdW50KSxcbmdldFVwZGF0ZVNpbmNlOih1cGRhdGVDb3VudCk9PnN1YnNjcmliZXIuZ2V0VXBkYXRlU2luY2UodXBkYXRlQ291bnQpLFxuZ2V0UGF0aDooKT0+RShzdG9yYWdlTm9kZSkuZ2V0UGF0aCgpLFxuZ2V0U3RvcmVLZXk6KCk9PkUoc3RvcmFnZU5vZGUpLmdldFN0b3JlS2V5KCksXG5nZXRVbnNlcmlhbGl6ZXI6KCk9PnVuc2VyaWFsaXplcn0pO1xuXG5yZXR1cm4gc3RvcmVzdWI7XG4gfTtcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCB1c2UgbWFrZVN0b3JlZFN1YnNjcmliZXJcbiAqXG4gKiBCZWdpbiBpdGVyYXRpbmcgdGhlIHNvdXJjZSwgc3RvcmluZyBzZXJpYWxpemVkIGl0ZXJhdGlvbiB2YWx1ZXMuICBJZiB0aGVcbiAqIHN0b3JhZ2VOb2RlJ3MgYHNldFZhbHVlYCBvcGVyYXRpb24gcmVqZWN0cywgdGhlIGl0ZXJhdGlvbiB3aWxsIGJlIHRlcm1pbmF0ZWQuXG4gKlxuICogUmV0dXJucyBhIFN0b3JlZFN1YnNjcmlwdGlvbiB0aGF0IGNhbiBiZSB1c2VkIGJ5IGEgY2xpZW50IHRvIGRpcmVjdGx5IGZvbGxvd1xuICogdGhlIGl0ZXJhdGlvbiB0aGVtc2VsdmVzLCBvciBvYnRhaW4gaW5mb3JtYXRpb24gdG8gc3Vic2NyaWJlIHRvIHRoZSBzdG9yZWRcbiAqIGRhdGEgb3V0LW9mLWJhbmQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7U3Vic2NyaXB0aW9uPFQ+fSBzdWJzY3JpcHRpb25cbiAqIEBwYXJhbSB7RVJlZjxTdG9yYWdlTm9kZT59IFtzdG9yYWdlTm9kZV1cbiAqIEBwYXJhbSB7RVJlZjxSZXR1cm5UeXBlPHR5cGVvZiBtYWtlTWFyc2hhbD4+fSBbbWFyc2hhbGxlcl1cbiAqIEByZXR1cm5zIHtTdG9yZWRTdWJzY3JpcHRpb248VD59XG4gKi8kaOKAjV9vbmNlLm1ha2VTdG9yZWRTdWJzY3JpYmVyKG1ha2VTdG9yZWRTdWJzY3JpYmVyKTtcbmNvbnN0ICAgICAgICBtYWtlU3RvcmVkU3Vic2NyaXB0aW9uPShcbnN1YnNjcmlwdGlvbixcbnN0b3JhZ2VOb2RlLFxubWFyc2hhbGxlcj1tYWtlTWFyc2hhbCh1bmRlZmluZWQsdW5kZWZpbmVkLHtcbm1hcnNoYWxTYXZlRXJyb3I6KCk9PnsgfSxcbnNlcmlhbGl6ZUJvZHlGb3JtYXQ6J3NtYWxsY2Fwcyd9KSk9PlxuXG57XG4vKiogQHR5cGUge1Vuc2VyaWFsaXplcn0gKi9cbmNvbnN0IHVuc2VyaWFsaXplcj1GYXIoJ3Vuc2VyaWFsaXplcicse1xuZnJvbUNhcERhdGE6KGRhdGEpPT5FKG1hcnNoYWxsZXIpLmZyb21DYXBEYXRhKGRhdGEpLFxudW5zZXJpYWxpemU6KGRhdGEpPT5FKG1hcnNoYWxsZXIpLmZyb21DYXBEYXRhKGRhdGEpfSk7XG5cblxuLyogQWJvcnQgdGhlIGl0ZXJhdGlvbiBvbiB0aGUgbmV4dCBvYnNlcnZhdGlvbiBpZiB0aGUgcHVibGlzaGVyIGV2ZXIgZmFpbHMuKi9cbmxldCBwdWJsaXNoRmFpbGVkPWZhbHNlO1xubGV0IHB1Ymxpc2hFeGNlcHRpb247XG5cbmNvbnN0IGZhaWw9KGVycik9PntcbnB1Ymxpc2hGYWlsZWQ9dHJ1ZTtcbnB1Ymxpc2hFeGNlcHRpb249ZXJyO1xuIH07XG5cbi8qIE11c3QgKm5vdCogYmUgYW4gYXN5bmMgZnVuY3Rpb24sIGJlY2F1c2UgaXQgc29tZXRpbWVzIG11c3QgdGhyb3cgdG8gYWJvcnQqL1xuLyogdGhlIGl0ZXJhdGlvbi4qL1xuY29uc3QgcHVibGlzaFZhbHVlPShvYmopPT57XG5hc3NlcnQoc3RvcmFnZU5vZGUpO1xuaWYocHVibGlzaEZhaWxlZCl7XG4vKiBUbyBwcm9wZXJseSBhYm9ydCB0aGUgaXRlcmF0aW9uLCB0aGlzIG11c3QgYmUgYSBzeW5jaHJvbm91cyBleGNlcHRpb24uKi9cbnRocm93IHB1Ymxpc2hFeGNlcHRpb247XG4gfVxuXG4vKiBQdWJsaXNoIHRoZSB2YWx1ZSwgY2FwdHVyaW5nIGFueSBlcnJvci4qL1xuRShtYXJzaGFsbGVyKS5cbnRvQ2FwRGF0YShvYmopLlxudGhlbigoc2VyaWFsaXplZCk9PntcbmNvbnN0IGVuY29kZWQ9SlNPTi5zdHJpbmdpZnkoc2VyaWFsaXplZCk7XG5yZXR1cm4gRShzdG9yYWdlTm9kZSkuc2V0VmFsdWUoZW5jb2RlZCk7XG4gfSkuXG5jYXRjaChmYWlsKTtcbiB9O1xuXG5pZihzdG9yYWdlTm9kZSl7XG4vKiBTdGFydCBwdWJsaXNoaW5nIHRoZSBzb3VyY2UuKi9cbm9ic2VydmVJdGVyYXRpb24oc3Vic2NyaXB0aW9uLHtcbnVwZGF0ZVN0YXRlOnB1Ymxpc2hWYWx1ZSxcbmZpbmlzaDpwdWJsaXNoVmFsdWV9KS5cbmNhdGNoKGZhaWwpO1xuIH1cblxuLyoqIEB0eXBlIHtTdG9yZWRTdWJzY3JpcHRpb248VD59ICovXG5jb25zdCBzdG9yZXN1Yj1GYXIoJ1N0b3JlZFN1YnNjcmlwdGlvbicse1xuLyogQHRzLWV4cGVjdC1lcnJvciBnZXRTdG9yZUtleSB0eXBlIGRvZXMgbm90IGhhdmUgYHN1YnNjcmlwdGlvbmAqL1xuZ2V0U3RvcmVLZXk6YXN5bmMoKT0+e1xuaWYoIXN0b3JhZ2VOb2RlKXtcbnJldHVybiBoYXJkZW4oe3N1YnNjcmlwdGlvbn0pO1xuIH1cbmNvbnN0IHN0b3JlS2V5PWF3YWl0IEUoc3RvcmFnZU5vZGUpLmdldFN0b3JlS2V5KCk7XG5yZXR1cm4gaGFyZGVuKHsuLi5zdG9yZUtleSxzdWJzY3JpcHRpb259KTtcbiB9LFxuZ2V0VW5zZXJpYWxpemVyOigpPT51bnNlcmlhbGl6ZXIsXG5nZXRTaGFyYWJsZVN1YnNjcmlwdGlvbkludGVybmFsczooKT0+XG5zdWJzY3JpcHRpb24uZ2V0U2hhcmFibGVTdWJzY3JpcHRpb25JbnRlcm5hbHMoKSxcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06KCk9PnN1YnNjcmlwdGlvbltTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKSxcbnN1YnNjcmliZUFmdGVyOihwdWJsaXNoQ291bnQpPT5zdWJzY3JpcHRpb24uc3Vic2NyaWJlQWZ0ZXIocHVibGlzaENvdW50KX0pO1xuXG5yZXR1cm4gc3RvcmVzdWI7XG4gfTskaOKAjV9vbmNlLm1ha2VTdG9yZWRTdWJzY3JpcHRpb24obWFrZVN0b3JlZFN1YnNjcmlwdGlvbik7XG5oYXJkZW4obWFrZVN0b3JlZFN1YnNjcmlwdGlvbik7XG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgdXNlIFN0b3JlZFB1Ymxpc2hLaXRcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yZWRQdWJsaXNoZXJLaXRcbiAqIEBwcm9wZXJ0eSB7U3RvcmVkU3Vic2NyaXB0aW9uPFQ+fSBzdWJzY3JpYmVyXG4gKiBAcHJvcGVydHkge0l0ZXJhdGlvbk9ic2VydmVyPFQ+fSBwdWJsaXNoZXJcbiAqL1xuXG4vKipcbiAqIEBkZXByZWNhdGVkIGluY29tcGF0aWJsZSB3aXRoIGR1cmFiaWxpdHk7IGluc3RlYWQgaGFuZGxlIHZzdG9yYWdlIGVwaGVtZXJhbGx5IG9uIGEgZHVyYWJsZSBQdWJsaXNoS2l0XG4gKlxuICogQHRlbXBsYXRlIFtUPXVua25vd25dXG4gKiBAcGFyYW0ge0VSZWY8U3RvcmFnZU5vZGU+fSBbc3RvcmFnZU5vZGVdXG4gKiBAcGFyYW0ge0VSZWY8TWFyc2hhbGxlcj59IFttYXJzaGFsbGVyXVxuICogQHBhcmFtIHtzdHJpbmd9IFtjaGlsZFBhdGhdXG4gKiBAcmV0dXJucyB7U3RvcmVkUHVibGlzaGVyS2l0PFQ+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVN0b3JlZFB1Ymxpc2hlcktpdD0oc3RvcmFnZU5vZGUsbWFyc2hhbGxlcixjaGlsZFBhdGgpPT57XG5jb25zdHtwdWJsaWNhdGlvbixzdWJzY3JpcHRpb259PW1ha2VTdWJzY3JpcHRpb25LaXQoKTtcblxuaWYoc3RvcmFnZU5vZGUmJmNoaWxkUGF0aCl7XG5zdG9yYWdlTm9kZT1FKHN0b3JhZ2VOb2RlKS5tYWtlQ2hpbGROb2RlKGNoaWxkUGF0aCk7XG4gfVxuXG4vKiB3cmFwIHRoZSBzdWJzY3JpcHRpb24gdG8gdGVlIGV2ZW50cyB0byBzdG9yYWdlLCByZXBlYXRpbmcgdG8gdGhpcyBgc3Vic2NyaWJlcmAqL1xuY29uc3Qgc3Vic2NyaWJlcj1tYWtlU3RvcmVkU3Vic2NyaXB0aW9uKFxuc3Vic2NyaXB0aW9uLFxuc3RvcmFnZU5vZGUsXG5tYXJzaGFsbGVyKTtcblxuXG5yZXR1cm57XG5wdWJsaXNoZXI6cHVibGljYXRpb24sXG5zdWJzY3JpYmVyfTtcblxuIH07XG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgaW5jb21wYXRpYmxlIHdpdGggZHVyYWJpbGl0eTsgaW5zdGVhZCBoYW5kbGUgdnN0b3JhZ2UgZXBoZW1lcmFsbHkgb24gYSBkdXJhYmxlIFB1Ymxpc2hLaXRcbiAqXG4gKiBMaWtlIG1ha2VQdWJsaXNoS2l0IHRoaXMgbWFrZXMgYSBgeyBwdWJsaXNoZXIsIHN1YnNjcmliZXIgfWAgcGFpciBmb3IgZG9pbmcgZWZmaWNpZW50XG4gKiBkaXN0cmlidXRlZCBwdWIvc3ViIHN1cHBvcnRpbmcgYm90aCBcImVhY2hcIiBhbmQgXCJsYXRlc3RcIiBpdGVyYXRpb25cbiAqIG9mIHB1Ymxpc2hlZCB2YWx1ZXMuXG4gKlxuICogV2hhdCdzIGRpZmZlcmVudCBpcyBgc3Vic2NyaWJlcmAgdGVlcyByZWNvcmRzLCB3cml0aW5nIG91dCB0byBzdG9yYWdlTm9kZS5cbiAqXG4gKiBAdGVtcGxhdGUgW1Q9dW5rbm93bl1cbiAqIEBwYXJhbSB7RVJlZjxTdG9yYWdlTm9kZT59IHN0b3JhZ2VOb2RlXG4gKiBAcGFyYW0ge0VSZWY8TWFyc2hhbGxlcj59IG1hcnNoYWxsZXJcbiAqIEByZXR1cm5zIHtTdG9yZWRQdWJsaXNoS2l0PFQ+fVxuICovJGjigI1fb25jZS5tYWtlU3RvcmVkUHVibGlzaGVyS2l0KG1ha2VTdG9yZWRQdWJsaXNoZXJLaXQpO1xuY29uc3QgICAgICAgIG1ha2VTdG9yZWRQdWJsaXNoS2l0PShzdG9yYWdlTm9kZSxtYXJzaGFsbGVyKT0+e1xuY29uc3R7cHVibGlzaGVyLHN1YnNjcmliZXJ9PW1ha2VQdWJsaXNoS2l0KCk7XG5cbnJldHVybntcbnB1Ymxpc2hlcixcbi8qIHdyYXAgdGhlIHN1YnNjcmliZXIgdG8gdGVlIGV2ZW50cyB0byBzdG9yYWdlKi9cbnN1YnNjcmliZXI6bWFrZVN0b3JlZFN1YnNjcmliZXIoc3Vic2NyaWJlcixzdG9yYWdlTm9kZSxtYXJzaGFsbGVyKX07XG5cbiB9OyRo4oCNX29uY2UubWFrZVN0b3JlZFB1Ymxpc2hLaXQobWFrZVN0b3JlZFB1Ymxpc2hLaXQpO1xuaGFyZGVuKG1ha2VTdG9yZWRQdWJsaXNoS2l0KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJmb3JFYWNoUHVibGljYXRpb25SZWNvcmQiOlsiZm9yRWFjaFB1YmxpY2F0aW9uUmVjb3JkIl0sIm1ha2VTdG9yZWRTdWJzY3JpYmVyIjpbIm1ha2VTdG9yZWRTdWJzY3JpYmVyIl0sIm1ha2VTdG9yZWRTdWJzY3JpcHRpb24iOlsibWFrZVN0b3JlZFN1YnNjcmlwdGlvbiJdLCJtYWtlU3RvcmVkUHVibGlzaGVyS2l0IjpbIm1ha2VTdG9yZWRQdWJsaXNoZXJLaXQiXSwibWFrZVN0b3JlZFB1Ymxpc2hLaXQiOlsibWFrZVN0b3JlZFB1Ymxpc2hLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAdWLjKG4kAABuJAAALgAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9zdWJzY3JpYmUuanN7ImltcG9ydHMiOlsiLi90eXBlcy1hbWJpZW50LmpzIiwiQGFnb3JpYy9pbnRlcm5hbC9zcmMvdXBncmFkZS1hcGkuanMiLCJAZW5kby9mYXIiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsic3Vic2NyaWJlIiwic3Vic2NyaWJlRWFjaCIsInN1YnNjcmliZUxhdGVzdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixpc09iamVjdCxpc1VwZ3JhZGVEaXNjb25uZWN0aW9uOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2ZhclwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV0sW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiaXNPYmplY3RcIiwgWyRo4oCNX2EgPT4gKGlzT2JqZWN0ID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvaW50ZXJuYWwvc3JjL3VwZ3JhZGUtYXBpLmpzXCIsIFtbXCJpc1VwZ3JhZGVEaXNjb25uZWN0aW9uXCIsIFskaOKAjV9hID0+IChpc1VwZ3JhZGVEaXNjb25uZWN0aW9uID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZXMtYW1iaWVudC5qc1wiLCBbXV1dKTsgICBcblxuXG5cblxuXG5jb25zdHtkZXRhaWxzOlgsRmFpbH09YXNzZXJ0O1xuY29uc3Qgc2luaz0oKT0+eyB9O1xuXG4vKipcbiAqIENoZWNrIHRoZSBwcm9taXNlIHJldHVybmVkIGJ5IGEgZnVuY3Rpb24gZm9yIHJlamVjdGlvbiBieSB2YXQgdXBncmFkZSxcbiAqIGFuZCByZWZldGNoIHVwb24gZW5jb3VudGVyaW5nIHRoYXQgY29uZGl0aW9uLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0geygpID0+IEVSZWY8VD59IGdldHRlclxuICogQHBhcmFtIHtFUmVmPFQ+W119IFtzZWVkXVxuICogQHJldHVybnMge1Byb21pc2U8VD59XG4gKi9cbmNvbnN0IHJlY29ubmVjdEFzTmVlZGVkPWFzeW5jKGdldHRlcixzZWVkPVtdKT0+e1xubGV0IGRpc2Nvbm5lY3Rpb247XG5sZXQgbGFzdFZlcnNpb249LUluZmluaXR5O1xuLyogRW5kIHN5bmNocm9ub3VzIHByZWx1ZGUuKi9cbmF3YWl0IG51bGw7XG5mb3IobGV0IGk9MDs7aSs9MSl7XG50cnl7XG5jb25zdCByZXN1bHRQPWk8c2VlZC5sZW5ndGg/c2VlZFtpXTpnZXR0ZXIoKTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1hd2FpdC1pbi1sb29wLCBAamVzc2llLmpzL25vLW5lc3RlZC1hd2FpdCovXG5jb25zdCByZXN1bHQ9YXdhaXQgcmVzdWx0UDtcbnJldHVybiByZXN1bHQ7XG4gfWNhdGNoKGVycil7XG5pZihpc1VwZ3JhZGVEaXNjb25uZWN0aW9uKGVycikpe1xuaWYoIWRpc2Nvbm5lY3Rpb24pe1xuZGlzY29ubmVjdGlvbj1lcnI7XG4gfVxuY29uc3R7aW5jYXJuYXRpb25OdW1iZXI6dmVyc2lvbn09ZXJyO1xuaWYodmVyc2lvbj5sYXN0VmVyc2lvbil7XG4vKiBXZSBkb24ndCBleHBlY3QgYW5vdGhlciB1cGdyYWRlIGluIGJldHdlZW4gcmVjZWl2aW5nKi9cbi8qIGEgZGlzY29ubmVjdGlvbiBhbmQgcmUtcmVxdWVzdGluZyBhbiB1cGRhdGUsIGJ1dCBtdXN0Ki9cbi8qIG5ldmVydGhlbGVzcyBiZSBwcmVwYXJlZCBmb3IgdGhhdC4qL1xubGFzdFZlcnNpb249dmVyc2lvbjtcbmNvbnRpbnVlO1xuIH1cbiB9XG4vKiBpZiBgZXJyYCBpcyBhbiAoRXJyb3IpIG9iamVjdCwgd2UgY2FuIHRyeSB0byBhc3NvY2lhdGUgaXQgd2l0aCovXG4vKiBpbmZvcm1hdGlvbiBhYm91dCB0aGUgZGlzY29ubmVjdGlvbiB0aGF0IHByb21wdGVkIHRoZSByZXF1ZXN0Ki9cbi8qIGZvciB3aGljaCBpdCBpcyBhIHJlc3VsdC4qL1xuaWYoaXNPYmplY3QoZXJyKSYmZGlzY29ubmVjdGlvbiYmZGlzY29ubmVjdGlvbiE9PWVycil7XG50cnl7XG5hc3NlcnQubm90ZShcbmVycixcblggYEF0dGVtcHRpbmcgdG8gcmVjb3ZlciBmcm9tIGRpc2Nvbm5lY3Rpb246ICR7ZGlzY29ubmVjdGlvbn1gKTtcblxuIH1jYXRjaChfZXJyKXtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1lbXB0eSovXG4gfVxuIH1cbnRocm93IGVycjtcbiB9XG4gfVxuIH07XG5cbi8qKlxuICogQ3JlYXRlIGEgbmVhciBpdGVyYWJsZSB0aGF0IGNvcnJlc3BvbmRzIHRvIGEgcG90ZW50aWFsbHkgZmFyIG9uZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPEFzeW5jSXRlcmFibGVJdGVyYXRvcjxUPj59IGl0UFxuICovXG5jb25zdCAgICAgICAgc3Vic2NyaWJlPShpdFApPT5cbkZhcignQXN5bmNJdGVyYWJsZScse1xuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXTooKT0+e1xuY29uc3QgaXQ9RShpdFApW1N5bWJvbC5hc3luY0l0ZXJhdG9yXSgpO1xuY29uc3Qgc2VsZj1GYXIoJ0FzeW5jSXRlcmFibGVJdGVyYXRvcicse1xuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXTooKT0+c2VsZixcbm5leHQ6YXN5bmMoKT0+RShpdCkubmV4dCgpfSk7XG5cbnJldHVybiBzZWxmO1xuIH19KTtcblxuXG4vKipcbiAqIEFzeW5jcm9ub3VzbHkgaXRlcmF0ZXMgb3ZlciB0aGUgY29udGVudHMgb2YgYSBQdWJsaWNhdGlvblJlY29yZCBjaGFpbiBhcyB0aGV5XG4gKiBhcHBlYXIuICBUaGlzIGl0ZXJhdGlvbiBtdXN0IGRyb3AgcGFydHMgb2YgcHVibGljYXRpb24gcmVjb3JkcyB0aGF0IGFyZSBub1xuICogbG9uZ2VyIG5lZWRlZCBzbyB0aGV5IGNhbiBiZSBnYXJiYWdlIGNvbGxlY3RlZC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPEVhY2hUb3BpYzxUPj59IHRvcGljXG4gKiBAcGFyYW0ge0VSZWY8UHVibGljYXRpb25SZWNvcmQ8VD4+fSBuZXh0Q2VsbFBcbiAqICAgUHVibGljYXRpb25SZWNvcmQgY29ycmVzcG9uZGluZyB3aXRoIHRoZSBmaXJzdCBpdGVyYXRpb24gcmVzdWx0XG4gKiBAcmV0dXJucyB7Rm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3I8VCwgVD59XG4gKi8kaOKAjV9vbmNlLnN1YnNjcmliZShzdWJzY3JpYmUpO1xuY29uc3QgbWFrZUVhY2hJdGVyYXRvcj0odG9waWMsbmV4dENlbGxQKT0+e1xuLyogVG8gdW5kZXJzdGFuZCB0aGUgaW1wbGVtZW50YXRpb24sIHN0YXJ0IHdpdGgqL1xuLyogaHR0cHM6Ly93ZWIuYXJjaGl2ZS5vcmcvd2ViLzIwMTYwNDA0MTIyMjUwL2h0dHA6Ly93aWtpLmVjbWFzY3JpcHQub3JnL2Rva3UucGhwP2lkPXN0cmF3bWFuOmNvbmN1cnJlbmN5I2luZmluaXRlX3F1ZXVlKi9cbmNvbnN0IHNlbGY9RmFyKCdFYWNoSXRlcmF0b3InLHtcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06KCk9PnNlbGYsXG5uZXh0OigpPT57XG5jb25zdHtcbmhlYWQ6cmVzdWx0UCxcbnB1Ymxpc2hDb3VudDpwdWJsaXNoQ291bnRQLFxudGFpbDp0YWlsUH09XG5FLmdldChuZXh0Q2VsbFApO1xuXG4vKiBJZiB0YWlsUCBpcyBicm9rZW4gYnkgdXBncmFkZSwgd2Ugd2lsbCBuZWVkIHRvIHJlLXJlcXVlc3QgaXQqL1xuLyogZGlyZWN0bHkgZnJvbSBgdG9waWNgLiovXG5jb25zdCBnZXRTdWNjZXNzb3I9YXN5bmMoKT0+e1xuY29uc3QgcHVibGlzaENvdW50PWF3YWl0IHB1Ymxpc2hDb3VudFA7XG5hc3NlcnQudHlwZW9mKHB1Ymxpc2hDb3VudCwnYmlnaW50Jyk7XG5jb25zdCBzdWNjZXNzb3I9YXdhaXQgRSh0b3BpYykuc3Vic2NyaWJlQWZ0ZXIocHVibGlzaENvdW50KTtcbmNvbnN0IG5ld1B1Ymxpc2hDb3VudD1zdWNjZXNzb3IucHVibGlzaENvdW50O1xuaWYobmV3UHVibGlzaENvdW50IT09cHVibGlzaENvdW50KzFuKXtcbkZhaWwgYGVhY2hJdGVyYXRvciBicm9rZW4gYnkgZ2FwIGZyb20gcHVibGlzaENvdW50ICR7cHVibGlzaENvdW50fSB0byAke25ld1B1Ymxpc2hDb3VudH1gO1xuIH1cbnJldHVybiBzdWNjZXNzb3I7XG4gfTtcblxuLyogUmVwbGFjZSBuZXh0Q2VsbFAgb24gZXZlcnkgY2FsbCB0byBuZXh0KCkgc28gdGhpbmdzIHdvcmsgZXZlbiovXG4vKiB3aXRoIGFuIGVhZ2VyIGNvbnN1bWVyIHRoYXQgZG9lc24ndCB3YWl0IGZvciByZXN1bHRzIHRvIHNldHRsZS4qL1xubmV4dENlbGxQPXJlY29ubmVjdEFzTmVlZGVkKGdldFN1Y2Nlc3NvcixbdGFpbFBdKTtcblxuLyogQXZvaWQgdW5oYW5kbGVkIHJlamVjdGlvbiB3YXJuaW5ncyBoZXJlIGlmIHRoZSBwcmV2aW91cyBjZWxsIHdhcyByZWplY3RlZCBvciovXG4vKiB0aGVyZSBpcyBubyBmdXJ0aGVyIHJlcXVlc3Qgb2YgdGhpcyBpdGVyYXRvci4qL1xuLyogYHRhaWxQYCBpcyBoYW5kbGVkIGluc2lkZSBgcmVjb25uZWN0QXNOZWVkZWRgIGFuZCBgcmVzdWx0UGAgaXMgdGhlIGNhbGxlcidzKi9cbi8qIGNvbmNlcm4sIGxlYXZpbmcgb25seSBgcHVibGlzaENvdW50UGAgYW5kIHRoZSBuZXcgYG5leHRDZWxsUGAuKi9cbnZvaWQgRS53aGVuKHB1Ymxpc2hDb3VudFAsc2luayxzaW5rKTtcbnZvaWQgRS53aGVuKG5leHRDZWxsUCxzaW5rLHNpbmspO1xucmV0dXJuIHJlc3VsdFA7XG4gfSxcbmZvcms6KCk9Pm1ha2VFYWNoSXRlcmF0b3IodG9waWMsbmV4dENlbGxQKX0pO1xuXG5yZXR1cm4gc2VsZjtcbiB9O1xuXG4vKipcbiAqIEdpdmVuIGEgbG9jYWwgb3IgcmVtb3RlIHN1YnNjcmliZXIsIHJldHVybnMgYSBsb2NhbCBBc3luY0l0ZXJhYmxlIHdoaWNoXG4gKiBwcm92aWRlcyBcInByZWZpeCBsb3NzeVwiIGl0ZXJhdGlvbnMgb2YgdGhlIHVuZGVybHlpbmcgUHVibGljYXRpb25MaXN0LlxuICogQnkgXCJwcmVmaXggbG9zc3lcIiwgd2UgbWVhbiB0aGF0IHlvdSBtYXkgbWlzcyBldmVyeXRoaW5nIHB1Ymxpc2hlZCBiZWZvcmVcbiAqIHlvdSBhc2sgdGhlIHJldHVybmVkIGl0ZXJhYmxlIGZvciBhbiBpdGVyYXRvci4gQnV0IHRoZSByZXR1cm5lZCBpdGVyYXRvclxuICogd2lsbCBlbnVtZXJhdGUgZWFjaCB0aGluZyBwdWJsaXNoZWQgZnJvbSB0aGF0IGl0ZXJhdG9yJ3Mgc3RhcnRpbmcgcG9pbnRcbiAqIHVwIHRvIGEgZGlzY29ubmVjdGlvbiByZXN1bHQgaW5kaWNhdGluZyB1cGdyYWRlIG9mIHRoZSBwcm9kdWNlclxuICogKHdoaWNoIGJyZWFrcyB0aGUgZ2FwLWZyZWUgZ3VhcmFudGVlIGFuZCB0aGVyZWZvcmUgdGVybWluYXRlcyBhbnkgYWN0aXZlXG4gKiBpdGVyYXRvciB3aGlsZSBzdGlsbCBzdXBwb3J0aW5nIGNyZWF0aW9uIG9mIG5ldyBpdGVyYXRvcnMpLlxuICpcbiAqIElmIHRoZSB1bmRlcmx5aW5nIFB1YmxpY2F0aW9uTGlzdCBpcyB0ZXJtaW5hdGVkLCB0aGF0IHRlcm1pbmFsIHZhbHVlIHdpbGwgYmVcbiAqIHJlcG9ydGVkIGxvc3NsZXNzbHkuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxFYWNoVG9waWM8VD4+fSB0b3BpY1xuICovXG5jb25zdCAgICAgICAgc3Vic2NyaWJlRWFjaD0odG9waWMpPT57XG5jb25zdCBpdGVyYWJsZT1GYXIoJ0VhY2hJdGVyYWJsZScse1xuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXTooKT0+e1xuY29uc3QgZmlyc3RDZWxsUD1yZWNvbm5lY3RBc05lZWRlZCgoKT0+RSh0b3BpYykuc3Vic2NyaWJlQWZ0ZXIoKSk7XG5yZXR1cm4gbWFrZUVhY2hJdGVyYXRvcih0b3BpYyxmaXJzdENlbGxQKTtcbiB9fSk7XG5cbnJldHVybiBpdGVyYWJsZTtcbiB9OyRo4oCNX29uY2Uuc3Vic2NyaWJlRWFjaChzdWJzY3JpYmVFYWNoKTtcbmhhcmRlbihzdWJzY3JpYmVFYWNoKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPExhdGVzdFRvcGljPFQ+Pn0gdG9waWNcbiAqIEBwYXJhbSB7YmlnaW50fSBbbG9jYWxVcGRhdGVDb3VudF1cbiAqIEBwYXJhbSB7SXRlcmF0b3JSZXR1cm5SZXN1bHQ8VD59IFt0ZXJtaW5hbFJlc3VsdF1cbiAqIEByZXR1cm5zIHtGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvcjxULCBUPn1cbiAqL1xuY29uc3QgY2xvbmVMYXRlc3RJdGVyYXRvcj0odG9waWMsbG9jYWxVcGRhdGVDb3VudCx0ZXJtaW5hbFJlc3VsdCk9PntcbmxldCBtdXRleD1Qcm9taXNlLnJlc29sdmUoKTtcblxuLyoqXG4gKiBSZXF1ZXN0IHRoZSBuZXh0IHVwZGF0ZSByZWNvcmQgZnJvbSB0aGUgdG9waWMsIHVwZGF0aW5nIG91ciBsb2NhbCBzdGF0ZSxcbiAqIGFuZCBjb252ZXJ0IGl0IHRvIGFuIGl0ZXJhdG9yIHJlc3VsdC5cbiAqXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxJdGVyYXRvclJlc3VsdDxULCBUPj59XG4gKi9cbmNvbnN0IG1heWJlUmVxdWVzdE5leHRSZXN1bHQ9YXN5bmMoKT0+e1xuaWYodGVybWluYWxSZXN1bHQpe1xuLyogV2UndmUgcmVhY2hlZCB0aGUgZW5kIG9mIHRoZSB0b3BpYywganVzdCBrZWVwIHJldHVybmluZyB0aGUgbGFzdCByZXN1bHQqL1xuLyogd2l0aG91dCBmdXJ0aGVyIHJlcXVlc3RzLiovXG5yZXR1cm4gdGVybWluYWxSZXN1bHQ7XG4gfVxuXG4vKiBTZW5kIHRoZSBuZXh0IHJlcXVlc3Qgbm93LCBza2lwcGluZyBwYXN0IGludGVybWVkaWF0ZSB1cGRhdGVzKi9cbi8qIGFuZCB1cGdyYWRlIGRpc2Nvbm5lY3Rpb25zLiovXG5jb25zdHt2YWx1ZSx1cGRhdGVDb3VudH09YXdhaXQgcmVjb25uZWN0QXNOZWVkZWQoKCk9PlxuRSh0b3BpYykuZ2V0VXBkYXRlU2luY2UobG9jYWxVcGRhdGVDb3VudCkpO1xuXG4vKiBNYWtlIHN1cmUgdGhlIG5leHQgcmVxdWVzdCBpcyBmb3IgYSBmcmVzaGVyIHZhbHVlLiovXG5sb2NhbFVwZGF0ZUNvdW50PXVwZGF0ZUNvdW50O1xuXG4vKiBNYWtlIGFuIEl0ZXJhdG9yUmVzdWx0LiovXG5pZih1cGRhdGVDb3VudD09PXVuZGVmaW5lZCl7XG50ZXJtaW5hbFJlc3VsdD1oYXJkZW4oe2RvbmU6dHJ1ZSx2YWx1ZX0pO1xucmV0dXJuIHRlcm1pbmFsUmVzdWx0O1xuIH1cbnJldHVybiBoYXJkZW4oe2RvbmU6ZmFsc2UsdmFsdWV9KTtcbiB9O1xuXG5jb25zdCBzZWxmPUZhcignTGF0ZXN0SXRlcmF0b3InLHtcbmZvcms6KCk9PmNsb25lTGF0ZXN0SXRlcmF0b3IodG9waWMsbG9jYWxVcGRhdGVDb3VudCx0ZXJtaW5hbFJlc3VsdCksXG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOigpPT5zZWxmLFxubmV4dDphc3luYygpPT57XG4vKiBJbiB0aGlzIGFkYXB0b3IsIG9uY2UgYG5leHQoKWAgaXMgY2FsbGVkIGFuZCByZXR1cm5zIGFuIHVucmVzb2x2ZWQqL1xuLyogcHJvbWlzZSwgZnVydGhlciBgbmV4dCgpYCBjYWxscyB3aWxsIGFsc28gcmV0dXJuIHVucmVzb2x2ZWQgcHJvbWlzZXMqL1xuLyogYnV0IGVhY2ggY2FsbCB3aWxsIG5vdCB0cmlnZ2VyIGFub3RoZXIgYHRvcGljYCByZXF1ZXN0IHVudGlsIHRoZSBwcmlvciovXG4vKiBvbmUgaGFzIHNldHRsZWQuKi9cbi8qKi9cbi8qIFRoaXMgbGluZWFyIHF1ZXVlaW5nIGJlaGF2aW9yIGlzIG9ubHkgbmVlZGVkIGZvciBjb2RlIHRoYXQgdXNlcyB0aGUqL1xuLyogYXN5bmMgaXRlcmF0b3IgcHJvdG9jb2wgZXhwbGljaXRseS4gV2hlbiB0aGlzIGFzeW5jIGl0ZXJhdG9yIGlzKi9cbi8qIGNvbnN1bWVkIGJ5IGEgZm9yL2F3YWl0L29mIGxvb3AsIGBuZXh0KClgIHdpbGwgb25seSBiZSBjYWxsZWQgYWZ0ZXIgdGhlKi9cbi8qIHByb21pc2UgZm9yIHRoZSBwcmV2aW91cyBpdGVyYXRpb24gcmVzdWx0IGhhcyBmdWxmaWxsZWQuIElmIGl0IGZ1bGZpbGxzKi9cbi8qIHdpdGggYGRvbmU6IHRydWVgLCB0aGUgZm9yL2F3YWl0L29mIGxvb3Agd2lsbCBuZXZlciBjYWxsIGBuZXh0KClgKi9cbi8qIGFnYWluLiovXG4vKiovXG4vKiBTZWUqL1xuLyogaHR0cHM6Ly8yYWxpdHkuY29tLzIwMTYvMTAvYXN5bmNocm9ub3VzLWl0ZXJhdGlvbi5odG1sI3F1ZXVpbmctbmV4dCgpLWludm9jYXRpb25zKi9cbi8qIGZvciBhbiBleHBsaWNpdCB1c2UgdGhhdCBzZW5kcyBgbmV4dCgpYCB3aXRob3V0IHdhaXRpbmcuKi9cblxuaWYodGVybWluYWxSZXN1bHQpe1xuLyogV2UndmUgcmVhY2hlZCB0aGUgZW5kIG9mIHRoZSB0b3BpYywganVzdCBrZWVwIHJldHVybmluZyB0aGUgbGFzdCovXG4vKiByZXN1bHQuKi9cbnJldHVybiB0ZXJtaW5hbFJlc3VsdDtcbiB9XG5cbi8qIEJFR0lOIENSSVRJQ0FMIFNFQ1RJT04gLSBzeW5jaHJvbm91c2x5IGVucXVldWUgYW5kIHJlYXNzaWduIGBtdXRleGAqL1xuLyoqL1xuLyogVXNlIGBtdXRleGAgdG8gZW5zdXJlIHRoYXQgd2UgaGF2ZSBubyBtb3JlIHRoYW4gYSBzaW5nbGUgcmVxdWVzdCBpbiovXG4vKiBmbGlnaHQuKi9cbmNvbnN0IG5leHRSZXN1bHQ9bXV0ZXgudGhlbihtYXliZVJlcXVlc3ROZXh0UmVzdWx0KTtcbm11dGV4PW5leHRSZXN1bHQudGhlbihzaW5rLHNpbmspO1xuLyogRU5EIENSSVRJQ0FMIFNFQ1RJT04qL1xuXG5yZXR1cm4gbmV4dFJlc3VsdDtcbiB9fSk7XG5cbnJldHVybiBzZWxmO1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxMYXRlc3RUb3BpYzxUPj59IHRvcGljXG4gKiBAcmV0dXJucyB7Rm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3I8VCwgVD59XG4gKi9cbmNvbnN0IG1ha2VMYXRlc3RJdGVyYXRvcj0odG9waWMpPT5jbG9uZUxhdGVzdEl0ZXJhdG9yKHRvcGljKTtcblxuLyoqXG4gKiBHaXZlbiBhIGxvY2FsIG9yIHJlbW90ZSBzdWJzY3JpYmVyLCByZXR1cm5zIGEgbG9jYWwgQXN5bmNJdGVyYWJsZSB3aGljaFxuICogcHJvdmlkZXMgXCJsb3NzeVwiIGl0ZXJhdGlvbnMgb2YgdGhlIHVuZGVybHlpbmcgUHVibGljYXRpb25MaXN0LlxuICogQnkgXCJsb3NzeVwiLCB3ZSBtZWFuIHRoYXQgeW91IG1heSBtaXNzIGFueSBwdWJsaXNoZWQgc3RhdGUgaWYgYSBtb3JlXG4gKiByZWNlbnQgcHVibGlzaGVkIHN0YXRlIGNhbiBiZSByZXBvcnRlZCBpbnN0ZWFkLlxuICpcbiAqIElmIHRoZSB1bmRlcmx5aW5nIFB1YmxpY2F0aW9uTGlzdCBpcyB0ZXJtaW5hdGVkIGJ5IHVwZ3JhZGUgb2YgdGhlIHByb2R1Y2VyLFxuICogaXQgd2lsbCBiZSByZS1yZXF1ZXN0ZWQuIEFsbCBvdGhlciB0ZXJtaW5hbCB2YWx1ZXMgd2lsbCBiZSBsb3NzbGVzc2x5XG4gKiBwcm9wYWdhdGVkLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8TGF0ZXN0VG9waWM8VD4+fSB0b3BpY1xuICovXG5jb25zdCAgICAgICAgc3Vic2NyaWJlTGF0ZXN0PSh0b3BpYyk9PntcbmNvbnN0IGl0ZXJhYmxlPUZhcignTGF0ZXN0SXRlcmFibGUnLHtcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06KCk9Pm1ha2VMYXRlc3RJdGVyYXRvcih0b3BpYyl9KTtcblxucmV0dXJuIGl0ZXJhYmxlO1xuIH07JGjigI1fb25jZS5zdWJzY3JpYmVMYXRlc3Qoc3Vic2NyaWJlTGF0ZXN0KTtcbmhhcmRlbihzdWJzY3JpYmVMYXRlc3QpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InN1YnNjcmliZSI6WyJzdWJzY3JpYmUiXSwic3Vic2NyaWJlRWFjaCI6WyJzdWJzY3JpYmVFYWNoIl0sInN1YnNjcmliZUxhdGVzdCI6WyJzdWJzY3JpYmVMYXRlc3QiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAJ7I7I8ULAADFCwAALwAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9zdWJzY3JpYmVyLmpzeyJpbXBvcnRzIjpbIi4vcHVibGlzaC1raXQuanMiLCIuL3N1YnNjcmliZS5qcyIsIi4vdG9waWMuanMiLCIuL3R5cGVzLWFtYmllbnQuanMiLCJAZW5kby9mYXIiXSwiZXhwb3J0cyI6WyJtYWtlU3Vic2NyaXB0aW9uIiwibWFrZVN1YnNjcmlwdGlvbktpdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixzdWJzY3JpYmVFYWNoLG1ha2VQdWJsaXNoS2l0LG1ha2VQaW5uZWRIaXN0b3J5VG9waWM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCIuL3N1YnNjcmliZS5qc1wiLCBbW1wic3Vic2NyaWJlRWFjaFwiLCBbJGjigI1fYSA9PiAoc3Vic2NyaWJlRWFjaCA9ICRo4oCNX2EpXV1dXSxbXCIuL3B1Ymxpc2gta2l0LmpzXCIsIFtbXCJtYWtlUHVibGlzaEtpdFwiLCBbJGjigI1fYSA9PiAobWFrZVB1Ymxpc2hLaXQgPSAkaOKAjV9hKV1dXV0sW1wiLi90b3BpYy5qc1wiLCBbW1wibWFrZVBpbm5lZEhpc3RvcnlUb3BpY1wiLCBbJGjigI1fYSA9PiAobWFrZVBpbm5lZEhpc3RvcnlUb3BpYyA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPEVhY2hUb3BpYzxUPj59IHRvcGljXG4gKiBAcmV0dXJucyB7U3Vic2NyaXB0aW9uPFQ+fVxuICovXG5jb25zdCBtYWtlU3Vic2NyaXB0aW9uPSh0b3BpYyk9PntcbmNvbnN0IHN1YnNjcmlwdGlvbj1GYXIoJ1N1YnNjcmlwdGlvbicse1xuLi4uc3Vic2NyaWJlRWFjaCh0b3BpYyksXG5zdWJzY3JpYmVBZnRlcjphc3luYyhwdWJsaXNoQ291bnQpPT5FKHRvcGljKS5zdWJzY3JpYmVBZnRlcihwdWJsaXNoQ291bnQpLFxuXG4vKipcbiAqIFVzZSB0aGlzIHRvIGRpc3RyaWJ1dGUgYSBTdWJzY3JpcHRpb24gZWZmaWNpZW50bHkgb3ZlciB0aGUgbmV0d29yayxcbiAqIGJ5IG9idGFpbmluZyB0aGlzIGZyb20gdGhlIFN1YnNjcmlwdGlvbiB0byBiZSByZXBsaWNhdGVkLCBhbmQgYXBwbHlpbmdcbiAqIGBtYWtlU3Vic2NyaXB0aW9uYCB0byBpdCBhdCB0aGUgbmV3IHNpdGUgdG8gZ2V0IGFuIGVxdWl2YWxlbnQgbG9jYWxcbiAqIFN1YnNjcmlwdGlvbiBhdCB0aGF0IHNpdGUuXG4gKi9cbmdldFNoYXJhYmxlU3Vic2NyaXB0aW9uSW50ZXJuYWxzOmFzeW5jKCk9PnRvcGljLFxuXG5nZXRTdG9yZUtleTooKT0+aGFyZGVuKHtzdWJzY3JpcHRpb259KX0pO1xuXG5yZXR1cm4gc3Vic2NyaXB0aW9uO1xuIH07JGjigI1fb25jZS5tYWtlU3Vic2NyaXB0aW9uKG1ha2VTdWJzY3JpcHRpb24pO1xuaGFyZGVuKG1ha2VTdWJzY3JpcHRpb24pO1xuXG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgUHJvZHVjZXJzIHNob3VsZCB1c2VcbiAqIGBgYGpzXG4gKiBjb25zdCB7IHB1Ymxpc2hlciwgc3Vic2NyaWJlciB9ID0gbWFrZVB1Ymxpc2hLaXQoKTtcbiAqIGNvbnN0IHRvcGljID0gbWFrZVBpbm5lZEhpc3RvcnlUb3BpYyhzdWJzY3JpYmVyKTtcbiAqIGBgYFxuICogaW5zdGVhZCwgd2hpY2ggbWFrZXMgaXQgY2xlYXJlciB0aGF0IGFsbCB0aGUgc3Vic2NyaWJlcidzIGhpc3RvcnkgaXNcbiAqIHJldGFpbmVkLCBwcmV2ZW50aW5nIEdDLiAgUG90ZW50aWFsbHkgcmVtb3RlIGNvbnN1bWVycyB1c2VcbiAqIGBgYGpzXG4gKiBmb3IgYXdhaXQgKGNvbnN0IHZhbHVlIG9mIHN1YnNjcmliZUVhY2godG9waWMpKSB7IC4uLiB9XG4gKiBgYGBcbiAqXG4gKiBNYWtlcyBhIGB7IHB1YmxpY2F0aW9uLCBzdWJzY3JpcHRpb24gfWAgZm9yIGRvaW5nIGxvc3NsZXNzIGVmZmljaWVudFxuICogZGlzdHJpYnV0ZWQgcHViL3N1Yi5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1N1YnNjcmlwdGlvblJlY29yZDxUPn1cbiAqL1xuY29uc3QgbWFrZVN1YnNjcmlwdGlvbktpdD0oKT0+e1xuY29uc3R7cHVibGlzaGVyLHN1YnNjcmliZXJ9PW1ha2VQdWJsaXNoS2l0KCk7XG5cbi8qIFRoZSBwdWJsaXNoIGtpdCBzdWJzY3JpYmVyIGlzIHByZWZpeC1sb3NzeSwgc28gbWFraW5nICp0aGlzKiBzdWJzY3JpYmVyIGNvbXBsZXRlbHkqL1xuLyogbG9zc2xlc3MgZnJvbSBpbml0aWFsaXNhdGlvbiByZXF1aXJlcyBwaW5uaW5nIHRoZSBmb3JtZXIncyBoaXN0b3J5LiovXG5cbmNvbnN0IHBpbm5lZEhpc3RvcnlUb3BpYz1tYWtlUGlubmVkSGlzdG9yeVRvcGljKHN1YnNjcmliZXIpO1xuY29uc3Qgc3Vic2NyaXB0aW9uPW1ha2VTdWJzY3JpcHRpb24ocGlubmVkSGlzdG9yeVRvcGljKTtcblxuLyoqIEB0eXBlIHtJdGVyYXRpb25PYnNlcnZlcjxUPn0gKi9cbmNvbnN0IHB1YmxpY2F0aW9uPUZhcigncHVibGljYXRpb24nLHtcbnVwZGF0ZVN0YXRlOihub25GaW5hbFZhbHVlKT0+cHVibGlzaGVyLnB1Ymxpc2gobm9uRmluYWxWYWx1ZSksXG5maW5pc2g6KGNvbXBsZXRpb24pPT5wdWJsaXNoZXIuZmluaXNoKGNvbXBsZXRpb24pLFxuZmFpbDoocmVhc29uKT0+cHVibGlzaGVyLmZhaWwocmVhc29uKX0pO1xuXG5cbnJldHVybiBoYXJkZW4oe3B1YmxpY2F0aW9uLHN1YnNjcmlwdGlvbn0pO1xuIH07JGjigI1fb25jZS5tYWtlU3Vic2NyaXB0aW9uS2l0KG1ha2VTdWJzY3JpcHRpb25LaXQpO1xuaGFyZGVuKG1ha2VTdWJzY3JpcHRpb25LaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VTdWJzY3JpcHRpb24iOlsibWFrZVN1YnNjcmlwdGlvbiJdLCJtYWtlU3Vic2NyaXB0aW9uS2l0IjpbIm1ha2VTdWJzY3JpcHRpb25LaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAIYEWcgwGAAAMBgAAKgAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy90b3BpYy5qc3siaW1wb3J0cyI6WyIuL3R5cGVzLWFtYmllbnQuanMiLCJAZW5kby9mYXIiXSwiZXhwb3J0cyI6WyJtYWtlUGlubmVkSGlzdG9yeVRvcGljIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhcjskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9mYXJcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZXMtYW1iaWVudC5qc1wiLCBbXV1dKTsgICBcblxuXG5cblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBBIHBpbm5lZC1oaXN0b3J5IHRvcGljIHByZXNlcnZlcyBhbGwgb2YgaXRzIHB1Ymxpc2hlZCB2YWx1ZXMgaW5cbiAqIG1lbW9yeS4gIFVzZSBhIHByZWZpeC1sb3NzeSBtYWtlUHVibGlzaEtpdCBpbnN0ZWFkLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VhY2hUb3BpYzxUPiAmIExhdGVzdFRvcGljPFQ+fSB0b3BpYyBuZWVkcyB0byBiZSBuZWFyIGluIG9yZGVyIHRvXG4gKiBwcmVzZXJ2ZSBzdWJzY3JpcHRpb24gdGltaW5ncy4gIFRPRE86IGRyb3AgTGF0ZXN0VG9waWM8VD4gcmVxdWlyZW1lbnRcbiAqIEByZXR1cm5zIHtFYWNoVG9waWM8VD4gJiBMYXRlc3RUb3BpYzxUPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VQaW5uZWRIaXN0b3J5VG9waWM9KHRvcGljKT0+e1xuLyogU3VjaCBsb3NzbGVzc25lc3MgaW5oaWJpdHMgR0MsIHdoaWNoIGlzIHdoeSB3ZSdyZSBtb3ZpbmcgYXdheSBmcm9tIGl0LiovXG5cbi8qIFdlIG5lZWQgdG8gdGFrZSBhbiBpbW1lZGlhdGUgc25hcHNob3Qgb2YgdGhlIHRvcGljJ3MgY3VycmVudCBzdGF0ZS4qL1xuY29uc3QgcGlubmVkUHViTGlzdD10b3BpYy5zdWJzY3JpYmVBZnRlcigpO1xuXG5yZXR1cm4gRmFyKCdQaW5uZWRIaXN0b3J5VG9waWMnLHtcbnN1YnNjcmliZUFmdGVyOmFzeW5jKHB1Ymxpc2hDb3VudD0tMW4pPT57XG5pZihwdWJsaXNoQ291bnQ9PT0tMW4pe1xucmV0dXJuIHBpbm5lZFB1Ykxpc3Q7XG4gfVxucmV0dXJuIHRvcGljLnN1YnNjcmliZUFmdGVyKHB1Ymxpc2hDb3VudCk7XG4gfSxcbmdldFVwZGF0ZVNpbmNlOmFzeW5jKHVwZGF0ZUNvdW50PXVuZGVmaW5lZCk9Pntcbi8qIFRPRE86IEJ1aWxkIHRoaXMgb3V0IG9mIEVhY2hUb3BpYzxUPi4qL1xucmV0dXJuIHRvcGljLmdldFVwZGF0ZVNpbmNlKHVwZGF0ZUNvdW50KTtcbiB9fSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZVBpbm5lZEhpc3RvcnlUb3BpYyhtYWtlUGlubmVkSGlzdG9yeVRvcGljKTtcbmhhcmRlbihtYWtlUGlubmVkSGlzdG9yeVRvcGljKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlUGlubmVkSGlzdG9yeVRvcGljIjpbIm1ha2VQaW5uZWRIaXN0b3J5VG9waWMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA+FEPEz8wAAA/MAAAMgAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy90eXBlcy1hbWJpZW50LmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQGplc3NpZS1jaGVjayovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9mYXInKS5FUmVmPFQ+fSBFUmVmXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Byb21pc2Uta2l0JykuUHJvbWlzZUtpdDxUPn0gUHJvbWlzZUtpdFxuICovXG5cbi8qKlxuICogRGVwcmVjYXRlZC4gVXNlIFByb21pc2VLaXQgaW5zdGVhZC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Byb21pc2Uta2l0JykuUHJvbWlzZVJlY29yZDxUPn0gUHJvbWlzZVJlY29yZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0ZW1wbGF0ZSBbVFJldHVybj1hbnldXG4gKiBAdGVtcGxhdGUgW1ROZXh0PXVuZGVmaW5lZF1cbiAqIEB0eXBlZGVmIHtBc3luY0l0ZXJhdG9yPFQsIFRSZXR1cm4sIFROZXh0PiAmIHtcbiAqICAgZm9yaygpOiBGb3JrYWJsZUFzeW5jSXRlcmF0b3I8VCwgVFJldHVybiwgVE5leHQ+XG4gKiB9fSBGb3JrYWJsZUFzeW5jSXRlcmF0b3IgQW4gQXN5bmNJdGVyYXRvciB0aGF0IGNhbiBiZSBmb3JrZWQgYXQgYSBnaXZlbiBwb3NpdGlvblxuICogaW50byBtdWx0aXBsZSBpbmRlcGVuZGVudCBGb3JrYWJsZUFzeW5jSXRlcmF0b3JzIHN0YXJ0aW5nIGZyb20gdGhhdCBwb3NpdGlvbi5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdGVtcGxhdGUgW1RSZXR1cm49YW55XVxuICogQHRlbXBsYXRlIFtUTmV4dD11bmRlZmluZWRdXG4gKiBAdHlwZWRlZiB7eyBbU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCk6IEFzeW5jSXRlcmFibGVJdGVyYXRvcjxULCBUUmV0dXJuLCBUTmV4dD4gfX0gQXN5bmNJdGVyYWJsZU9ubHlcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdGVtcGxhdGUgW1RSZXR1cm49YW55XVxuICogQHRlbXBsYXRlIFtUTmV4dD11bmRlZmluZWRdXG4gKiBAdHlwZWRlZiB7e1xuICogICBbU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCk6IEZvcmthYmxlQXN5bmNJdGVyYWJsZUl0ZXJhdG9yPFQsIFRSZXR1cm4sIFROZXh0PixcbiAqICAgZm9yaygpOiBGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvcjxULCBUUmV0dXJuLCBUTmV4dD4gfSAmXG4gKiAgIEZvcmthYmxlQXN5bmNJdGVyYXRvcjxULCBUUmV0dXJuLCBUTmV4dD5cbiAqIH0gRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3JcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdGVtcGxhdGUgW1RSZXR1cm49YW55XVxuICogQHRlbXBsYXRlIFtUTmV4dD11bmRlZmluZWRdXG4gKiBAdHlwZWRlZiB7e1xuICogICBbU3ltYm9sLmFzeW5jSXRlcmF0b3JdOiAoKSA9PiBGb3JrYWJsZUFzeW5jSXRlcmF0b3I8VCwgVFJldHVybiwgVE5leHQ+XG4gKiB9fSBGb3JrYWJsZUFzeW5jSXRlcmFibGVcbiAqIEFuIEFzeW5jSXRlcmFibGUgdGhhdCBwcm9kdWNlcyBGb3JrYWJsZUFzeW5jSXRlcmF0b3JzLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEl0ZXJhdGlvbk9ic2VydmVyPFQ+XG4gKiBBIHZhbGlkIHNlcXVlbmNlIG9mIGNhbGxzIHRvIHRoZSBtZXRob2RzIG9mIGFuIGBJdGVyYXRpb25PYnNlcnZlcmBcbiAqIHJlcHJlc2VudHMgYW4gaXRlcmF0aW9uLiBBIHZhbGlkIHNlcXVlbmNlIGNvbnNpc3RzIG9mIGFueSBudW1iZXIgb2YgY2FsbHNcbiAqIHRvIGB1cGRhdGVTdGF0ZWAgd2l0aCB0aGUgc3VjY2Vzc2l2ZSBub24tZmluYWwgdmFsdWVzLCBmb2xsb3dlZCBieSBhXG4gKiBmaW5hbCBjYWxsIHRvIGVpdGhlciBgZmluaXNoYCB3aXRoIGEgc3VjY2Vzc2Z1bCBgY29tcGxldGlvbmAgdmFsdWVcbiAqIG9yIGBmYWlsYCB3aXRoIHRoZSBhbGxlZ2VkIGByZWFzb25gIGZvciBmYWlsdXJlLiBBZnRlciBhdCBtb3N0IG9uZVxuICogdGVybWluYXRpbmcgY2FsbHMsIG5vIGZ1cnRoZXIgY2FsbHMgdG8gdGhlc2UgbWV0aG9kcyBhcmUgdmFsaWQgYW5kIG11c3QgYmVcbiAqIHJlamVjdGVkLlxuICogQHByb3BlcnR5IHsobm9uRmluYWxWYWx1ZTogVCkgPT4gdm9pZH0gdXBkYXRlU3RhdGVcbiAqIEBwcm9wZXJ0eSB7KGNvbXBsZXRpb246IFQpID0+IHZvaWR9IGZpbmlzaFxuICogQHByb3BlcnR5IHsocmVhc29uOiB1bmtub3duKSA9PiB2b2lkfSBmYWlsXG4gKi9cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQdWJsaWNhdGlvblJlY29yZFxuICogV2lsbCBiZSBzaGFyZWQgYmV0d2VlbiBtYWNoaW5lcywgc28gaXQgbXVzdCBiZSBzYWZlIHRvIGV4cG9zZS4gQnV0IHNvZnR3YXJlXG4gKiBvdXRzaWRlIHRoZSBjdXJyZW50IHBhY2thZ2Ugc2hvdWxkIGNvbnNpZGVyIGl0IG9wYXF1ZSwgbm90IGRlcGVuZGluZyBvbiBpdHNcbiAqIGludGVybmFsIHN0cnVjdHVyZS5cbiAqIEBwcm9wZXJ0eSB7SXRlcmF0b3JSZXN1bHQ8VD59IGhlYWRcbiAqIEBwcm9wZXJ0eSB7YmlnaW50fSBwdWJsaXNoQ291bnQgc3RhcnRzIGF0IDEgZm9yIHRoZSBmaXJzdCByZXN1bHRcbiAqICAgYW5kIGFkdmFuY2VzIGJ5IDEgZm9yIGVhY2ggc3Vic2VxdWVudCByZXN1bHRcbiAqIEBwcm9wZXJ0eSB7UHJvbWlzZTxQdWJsaWNhdGlvblJlY29yZDxUPj59IHRhaWxcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFYWNoVG9waWNcbiAqIEBwcm9wZXJ0eSB7KHB1Ymxpc2hDb3VudD86IGJpZ2ludCkgPT4gUHJvbWlzZTxQdWJsaWNhdGlvblJlY29yZDxUPj59IHN1YnNjcmliZUFmdGVyXG4gKiBSZXR1cm5zIGEgcHJvbWlzZSBmb3IgYSBcImN1cnJlbnRcIiBQdWJsaWNhdGlvblJlY29yZCAocmVmZXJlbmNpbmcgaXRzXG4gKiBpbW1lZGlhdGUgc3VjY2Vzc29yIHZpYSBhIGB0YWlsYCBwcm9taXNlKSB0aGF0IGlzIGxhdGVyIHRoYW4gdGhlXG4gKiBwcm92aWRlZCBwdWJsaXNoQ291bnQuXG4gKiBVc2VkIHRvIG1ha2UgZm9yd2FyZC1sb3NzbGVzcyAoXCJlYWNoXCIpIGl0ZXJhdG9ycy5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7Rm9ya2FibGVBc3luY0l0ZXJhYmxlPFQsIFQ+ICYgRWFjaFRvcGljPFQ+fSBJdGVyYWJsZUVhY2hUb3BpY1xuICogQW4gRWFjaFRvcGljIHdpdGggZGVmYXVsdCBhc3luY0l0ZXJhYmxlIGJlaGF2aW91ci5cbiAqXG4gKiBOT1RFOiB0aGUgcHVibGljYXRpb24gcmVjb3JkcyBhbmQgaXRlcmF0b3JzIHJldHVybmVkIGJ5IHRoaXMgb2JqZWN0IGFyZVxuICogZXBoZW1lcmFsIGFuZCB3aWxsIGJlIHNldmVyZWQgZHVyaW5nIHVwZ3JhZGUuICBBIGNhbGxlciBzaG91bGQgdXNlXG4gKiBgc3Vic2NyaWJlRWFjaGAgdG8gd3JhcCB0aGlzIHRvcGljIGluIGEgbG9jYWwgaXRlcmFibGUgd2hpY2ggYXV0b21hdGljYWxseVxuICogYXR0ZW1wdHMgdG8gcmVjb25uZWN0IHVwb24gYmVpbmcgc2V2ZXJlZC5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7QXN5bmNJdGVyYWJsZU9ubHk8VCwgVD4gJiBMYXRlc3RUb3BpYzxUPn0gSXRlcmFibGVMYXRlc3RUb3BpY1xuICogQSBMYXRlc3RUb3BpYyB3aXRoIGRlZmF1bHQgYXN5bmNJdGVyYWJsZSBiZWhhdmlvdXIuXG4gKlxuICogTk9URTogdGhlIGl0ZXJhdG9ycyByZXR1cm5lZCBieSB0aGlzIG9iamVjdCBhcmUgZXBoZW1lcmFsIGFuZCB3aWxsIGJlIHNldmVyZWRcbiAqIGR1cmluZyB1cGdyYWRlLiAgQSBjYWxsZXIgc2hvdWxkIHVzZSBgc3Vic2NyaWJlTGF0ZXN0YCB0byB3cmFwIHRoaXMgdG9waWMgaW5cbiAqIGEgbG9jYWwgaXRlcmFibGUgd2hpY2ggYXV0b21hdGljYWxseSBhdHRlbXB0cyB0byByZWNvbm5lY3QgdXBvbiBiZWluZ1xuICogc2V2ZXJlZC5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBMYXRlc3RUb3BpY1xuICogQHByb3BlcnR5IHsodXBkYXRlQ291bnQ/OiBiaWdpbnQgfCBudW1iZXIpID0+IFByb21pc2U8VXBkYXRlUmVjb3JkPFQ+Pn0gZ2V0VXBkYXRlU2luY2VcbiAqIFJldHVybnMgYSBwcm9taXNlIGZvciBhbiB1cGRhdGUgcmVjb3JkIGFzIG9mIGFuIHVwZGF0ZSBjb3VudC5cbiAqIElmIHRoZSBgdXBkYXRlQ291bnRgIGFyZ3VtZW50IGlzIG9taXR0ZWQgb3IgZGlmZmVycyBmcm9tIHRoZSBjdXJyZW50IHVwZGF0ZSBjb3VudCxcbiAqIHRoZSBwcm9taXNlIHByb21wdGx5IHJlc29sdmVzIHRvIHRoZSBjdXJyZW50IHJlY29yZC5cbiAqIE90aGVyd2lzZSwgYWZ0ZXIgdGhlIG5leHQgc3RhdGUgY2hhbmdlLCB0aGUgcHJvbWlzZSByZXNvbHZlcyB0byB0aGUgcmVzdWx0aW5nIHJlY29yZC5cbiAqIFRoaXMgaXMgYW4gYXR0ZW51YXRlZCBmb3JtIG9mIGBzdWJzY3JpYmVBZnRlcmAgd2hvc2UgcmV0dXJuIHZhbHVlIHN0YW5kcyBhbG9uZSBhbmRcbiAqIGRvZXMgbm90IGFsbG93IGNvbnN1bWVycyB0byBwaW4gYSBjaGFpbiBvZiBoaXN0b3JpY2FsIFB1YmxpY2F0aW9uUmVjb3Jkcy5cbiAqIFVzZWQgdG8gbWFrZSBsb3NzeSAoXCJsYXRlc3RcIikgaXRlcmF0b3JzLlxuICogTk9URTogVXNlIG9mIGBudW1iZXJgIGFzIGFuIGB1cGRhdGVDb3VudGAgaXMgZGVwcmVjYXRlZC5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7TGF0ZXN0VG9waWM8VD59IEJhc2VOb3RpZmllciBUaGlzIHR5cGUgaXMgZGVwcmVjYXRlZCBidXQgaXMgc3RpbGxcbiAqIHVzZWQgZXh0ZXJuYWxseS5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7TGF0ZXN0VG9waWM8VD4gJiBFYWNoVG9waWM8VD59IFN1YnNjcmliZXJcbiAqIEEgc3RyZWFtIG9mIHJlc3VsdHMgdGhhdCBhbGxvd3MgY29uc3VtZXJzIHRvIGNvbmZpZ3VyZVxuICogZm9yd2FyZC1sb3NzbGVzcyBcImVhY2hcIiBpdGVyYXRpb24gd2l0aCBgc3Vic2NyaWJlRWFjaGAgYW5kXG4gKiBsb3NzeSBcImxhdGVzdFwiIGl0ZXJhdGlvbiB3aXRoIGBzdWJzY3JpYmVMYXRlc3RgLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFB1Ymxpc2hlclxuICogQSB2YWxpZCBzZXF1ZW5jZSBvZiBjYWxscyB0byB0aGUgbWV0aG9kcyBvZiBhbiBgSXRlcmF0aW9uT2JzZXJ2ZXJgXG4gKiByZXByZXNlbnRzIGFuIGl0ZXJhdGlvbi4gQSB2YWxpZCBzZXF1ZW5jZSBjb25zaXN0cyBvZiBhbnkgbnVtYmVyIG9mIGNhbGxzXG4gKiB0byBgcHVibGlzaGAgd2l0aCB0aGUgc3VjY2Vzc2l2ZSBub24tZmluYWwgdmFsdWVzLCBmb2xsb3dlZCBieSBhXG4gKiBmaW5hbCBjYWxsIHRvIGVpdGhlciBgZmluaXNoYCB3aXRoIGEgc3VjY2Vzc2Z1bCBgY29tcGxldGlvbmAgdmFsdWVcbiAqIG9yIGBmYWlsYCB3aXRoIHRoZSBhbGxlZ2VkIGByZWFzb25gIGZvciBmYWlsdXJlLiBBZnRlciBhdCBtb3N0IG9uZVxuICogdGVybWluYXRpbmcgY2FsbHMsIG5vIGZ1cnRoZXIgY2FsbHMgdG8gdGhlc2UgbWV0aG9kcyBhcmUgdmFsaWQgYW5kIG11c3QgYmVcbiAqIHJlamVjdGVkLlxuICogQHByb3BlcnR5IHsobm9uRmluYWxWYWx1ZTogVCkgPT4gdm9pZH0gcHVibGlzaFxuICogQHByb3BlcnR5IHsoY29tcGxldGlvbjogVCkgPT4gdm9pZH0gZmluaXNoXG4gKiBAcHJvcGVydHkgeyhyZWFzb246IGFueSkgPT4gdm9pZH0gZmFpbFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtQYXJ0aWFsPFB1Ymxpc2hlcjxUPj59IFB1Ymxpc2hPYnNlcnZlclxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFB1Ymxpc2hLaXQ8VD5cbiAqIEBwcm9wZXJ0eSB7UHVibGlzaGVyPFQ+fSBwdWJsaXNoZXJcbiAqIEBwcm9wZXJ0eSB7U3Vic2NyaWJlcjxUPn0gc3Vic2NyaWJlclxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN0b3JlZFB1Ymxpc2hLaXQ8VD5cbiAqIEBwcm9wZXJ0eSB7UHVibGlzaGVyPFQ+fSBwdWJsaXNoZXJcbiAqIEBwcm9wZXJ0eSB7U3RvcmVkU3Vic2NyaWJlcjxUPn0gc3Vic2NyaWJlclxuICovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7J21hbmRhdG9yeScgfCAnb3Bwb3J0dW5pc3RpYycgfCAnaWdub3JlZCd9IER1cmFibGVQdWJsaXNoS2l0VmFsdWVEdXJhYmlsaXR5XG4gKlxuICogRHVyYWJpbGl0eSBjb25maWd1cmVzIGNvbnN0cmFpbnRzIG9uIG5vbi10ZXJtaW5hbCB2YWx1ZXMgdGhhdCBjYW4gYmVcbiAqIHB1Ymxpc2hlZCB0byBhIGR1cmFibGUgcHVibGlzaCBraXQgKHRlcm1pbmFsIHZhbHVlcyBzZW50IHRvIGZpbmlzaCBvciBmYWlsXG4gKiBtdXN0IGFsd2F5cyBiZSBkdXJhYmxlKS5cbiAqIC0gJ21hbmRhdG9yeScgbWVhbnMgdGhhdCBlYWNoIHZhbHVlIG11c3QgYmUgZHVyYWJsZSwgc28gaXQgY2FuIGJlIHJlc3RvcmVkXG4gKiAgIG9uIHVwZ3JhZGUuXG4gKiAtICdvcHBvcnR1bmlzdGljJyBtZWFucyB0aGF0IGEgZHVyYWJsZSB2YWx1ZSBpcyBwZXJzaXN0ZWQgZm9yIHBvc3QtdXBncmFkZVxuICogICByZXN0b3JhdGlvbiwgYnV0IGEgbm9uLWR1cmFibGUgdmFsdWUgaXMgc3RpbGwgYWNjZXB0ZWQgKGFuZCB3aWxsIHJlc3VsdCBpblxuICogICB2YWx1ZWxlc3MgcmVzdG9yYXRpb24pLlxuICogLSAnaWdub3JlZCcgbWVhbnMgdGhhdCBhIHZhbHVlIGlzIG5vdCBwZXJzaXN0ZWQgZm9yIHJlc3RvcmF0aW9uIGV2ZW4gaWYgaXRcbiAqICAgaXMgZHVyYWJsZS5cbiAqXG4gKiAnbWFuZGF0b3J5JyBpcyB0aGUgb25seSBjdXJyZW50bHktc3VwcG9ydGVkIHZhbHVlLCBhbmQgb3RoZXJzIG11c3Qgbm90IGJlXG4gKiBlbmFibGVkIHdpdGhvdXQgdGVzdCBjb3ZlcmFnZS5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IER1cmFibGVQdWJsaXNoS2l0U3RhdGVcbiAqXG4gKiBAcHJvcGVydHkge0R1cmFibGVQdWJsaXNoS2l0VmFsdWVEdXJhYmlsaXR5fSB2YWx1ZUR1cmFiaWxpdHlcbiAqXG4gKiBAcHJvcGVydHkge2JpZ2ludH0gcHVibGlzaENvdW50XG4gKlxuICogQHByb3BlcnR5IHsnbGl2ZScgfCAnZmluaXNoZWQnIHwgJ2ZhaWxlZCd9IHN0YXR1c1xuICpcbiAqIEBwcm9wZXJ0eSB7Ym9vbGVhbn0gaGFzVmFsdWVcbiAqIGhhc1ZhbHVlIGluZGljYXRlcyB0aGUgcHJlc2VuY2Ugb2YgdmFsdWUuIEl0IHN0YXJ0cyBvZmYgZmFsc2UsXG4gKiBhbmQgY2FuIGJlIHJlc2V0IHRvIGZhbHNlIHdoZW4gYSBkdXJhYmxlIHB1Ymxpc2gga2l0IGlzIHJlc3RvcmVkIGFuZFxuICogdGhlIHByZXZpb3VzIHZhbHVlIHdhcyBub3QgZHVyYWJsZSwgb3Igbm9uLXRlcm1pbmFsIGFuZCB2YWx1ZUR1cmFibGl0eSBpcyAnaWdub3JlZCcuXG4gKlxuICogQHByb3BlcnR5IHthbnl9IHZhbHVlXG4gKiB2YWx1ZSBob2xkcyBlaXRoZXIgYSBub24tdGVybWluYWwgdmFsdWUgZnJvbSBgcHVibGlzaGAgb3IgYSB0ZXJtaW5hbCB2YWx1ZVxuICogZnJvbSBgZmluaXNoYCBvciBgZmFpbGAsIGRlcGVuZGluZyB1cG9uIHRoZSB2YWx1ZSBpbiBzdGF0dXMuXG4gKi9cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBVcGRhdGVSZWNvcmQ8VD5cbiAqIEBwcm9wZXJ0eSB7VH0gdmFsdWUgaXMgd2hhdGV2ZXIgc3RhdGUgdGhlIHNlcnZpY2Ugd2FudHMgdG8gcHVibGlzaFxuICogQHByb3BlcnR5IHtiaWdpbnR9IFt1cGRhdGVDb3VudF0gaXMgYSB2YWx1ZSB0aGF0IGlkZW50aWZpZXMgdGhlIHVwZGF0ZS4gIEZvclxuICogdGhlIGxhc3QgdXBkYXRlLCBpdCBpcyBgdW5kZWZpbmVkYC5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7QmFzZU5vdGlmaWVyPFQ+fSBOb3RpZmllckludGVybmFscyBXaWxsIGJlIHNoYXJlZCBiZXR3ZWVuIG1hY2hpbmVzLFxuICogc28gaXQgbXVzdCBiZSBzYWZlIHRvIGV4cG9zZS4gQnV0IG90aGVyIHNvZnR3YXJlIHNob3VsZCBhdm9pZCBkZXBlbmRpbmcgb25cbiAqIGl0cyBpbnRlcm5hbCBzdHJ1Y3R1cmUuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge05vdGlmaWVySW50ZXJuYWxzPFQ+ICZcbiAqICAgRm9ya2FibGVBc3luY0l0ZXJhYmxlPFQsIFQ+ICZcbiAqICAgU2hhcmFibGVOb3RpZmllcjxUPlxuICogfSBOb3RpZmllcjxUPiBhbiBvYmplY3QgdGhhdCBjYW4gYmUgdXNlZCB0byBnZXQgdGhlIGN1cnJlbnQgc3RhdGUgb3IgdXBkYXRlc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFNoYXJhYmxlTm90aWZpZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxOb3RpZmllckludGVybmFsczxUPj59IGdldFNoYXJhYmxlTm90aWZpZXJJbnRlcm5hbHNcbiAqIFVzZWQgdG8gcmVwbGljYXRlIHRoZSBtdWx0aWNhc3QgdmFsdWVzIGF0IG90aGVyIHNpdGVzLiBUbyBtYW51YWxseSBjcmVhdGUgYVxuICogbG9jYWwgcmVwcmVzZW50YXRpdmUgb2YgYSBOb3RpZmljYXRpb24sIGRvXG4gKiBgYGBqc1xuICogbG9jYWxJdGVyYWJsZSA9XG4gKiAgIG1ha2VOb3RpZmllcihFKHJlbW90ZUl0ZXJhYmxlKS5nZXRTaGFyYWJsZU5vdGlmaWVySW50ZXJuYWxzKCkpO1xuICogYGBgXG4gKiBUaGUgcmVzdWx0aW5nIGBsb2NhbEl0ZXJhYmxlYCBhbHNvIHN1cHBvcnRzIHN1Y2ggcmVtb3RlIHVzZSwgYW5kXG4gKiB3aWxsIHJldHVybiBhY2Nlc3MgdG8gdGhlIHNhbWUgcmVwcmVzZW50YXRpb24uXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gTm90aWZpZXJSZWNvcmQ8VD4gdGhlIHByb2R1Y2VkIG5vdGlmaWVyL3VwZGF0ZXIgcGFpclxuICogQHByb3BlcnR5IHtJdGVyYXRpb25PYnNlcnZlcjxUPn0gdXBkYXRlciB0aGUgKGNsb3NlbHktaGVsZCkgbm90aWZpZXIgcHJvZHVjZXJcbiAqIEBwcm9wZXJ0eSB7Tm90aWZpZXI8VD59IG5vdGlmaWVyIHRoZSAod2lkZWx5LWhlbGQpIG5vdGlmaWVyIGNvbnN1bWVyXG4gKi9cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7SXRlcmFibGVFYWNoVG9waWM8VD4gJiBFYWNoVG9waWM8VD4gJlxuICogICBTaGFyYWJsZVN1YnNjcmlwdGlvbjxUPn0gU3Vic2NyaXB0aW9uPFQ+XG4gKiBBIGZvcm0gb2YgQXN5bmNJdGVyYWJsZSBzdXBwb3J0aW5nIGRpc3RyaWJ1dGVkIGFuZCBtdWx0aWNhc3QgdXNhZ2UuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gU2hhcmFibGVTdWJzY3JpcHRpb25cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxFYWNoVG9waWM8VD4+fSBnZXRTaGFyYWJsZVN1YnNjcmlwdGlvbkludGVybmFsc1xuICogVXNlZCB0byByZXBsaWNhdGUgdGhlIG11bHRpY2FzdCB2YWx1ZXMgYXQgb3RoZXIgc2l0ZXMuIFRvIG1hbnVhbGx5IGNyZWF0ZSBhXG4gKiBsb2NhbCByZXByZXNlbnRhdGl2ZSBvZiBhIFN1YnNjcmlwdGlvbiwgZG9cbiAqIGBgYGpzXG4gKiBsb2NhbEl0ZXJhYmxlID1cbiAqICAgbWFrZVN1YnNjcmlwdGlvbihFKHJlbW90ZUl0ZXJhYmxlKS5nZXRTaGFyYWJsZVN1YnNjcmlwdGlvbkludGVybmFscygpKTtcbiAqIGBgYFxuICogVGhlIHJlc3VsdGluZyBgbG9jYWxJdGVyYWJsZWAgYWxzbyBzdXBwb3J0cyBzdWNoIHJlbW90ZSB1c2UsIGFuZFxuICogd2lsbCByZXR1cm4gYWNjZXNzIHRvIHRoZSBzYW1lIHJlcHJlc2VudGF0aW9uLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN1YnNjcmlwdGlvblJlY29yZDxUPlxuICogQHByb3BlcnR5IHtJdGVyYXRpb25PYnNlcnZlcjxUPn0gcHVibGljYXRpb25cbiAqIEBwcm9wZXJ0eSB7U3Vic2NyaXB0aW9uPFQ+fSBzdWJzY3JpcHRpb25cbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKiBAdGVtcGxhdGUgW1Nsb3Q9dW5rbm93bl0gQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5NYXJzaGFsPFNsb3Q+fSBNYXJzaGFsbGVyICovXG4vKiogQHR5cGVkZWYge1BpY2s8TWFyc2hhbGxlciwgJ2Zyb21DYXBEYXRhJz59IFVuc2VyaWFsaXplciAqL1xuXG4vKipcbiAqIERlZmluZWQgYnkgdnN0b3JhZ2VTdG9yZUtleSBpbiB2c3RvcmFnZS5nb1xuICpcbiAqIEB0eXBlZGVmIFZTdG9yYWdlS2V5XG4gKiBAcHJvcGVydHkge3N0cmluZ30gc3RvcmVOYW1lXG4gKiBAcHJvcGVydHkge3N0cmluZ30gc3RvcmVTdWJrZXlcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBkYXRhUHJlZml4Qnl0ZXNcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBbbm9EYXRhVmFsdWVdXG4gKi9cblxuLyoqXG4gKiBUaGlzIHJlcHJlc2VudHMgYSBub2RlIGluIGFuIElBVkwgdHJlZS5cbiAqXG4gKiBUaGUgYWN0aXZlIGltcGxlbWVudGF0aW9uIGlzIHgvdnN0b3JhZ2UsIGFuIEFnb3JpYyBleHRlbnNpb24gb2YgdGhlIENvc21vcyBTREsuXG4gKlxuICogVnN0b3JhZ2UgaXMgYSBoaWVyYXJjaGljYWwgZXh0ZXJuYWxseS1yZWFjaGFibGUgc3RvcmFnZSBzdHJ1Y3R1cmUgdGhhdFxuICogaWRlbnRpZmllcyBjaGlsZHJlbiBieSByZXN0cmljdGVkIEFTQ0lJIG5hbWUgYW5kIGlzIGFzc29jaWF0ZWQgd2l0aCBhcmJpdHJhcnlcbiAqIHN0cmluZy12YWx1ZWQgZGF0YSBmb3IgZWFjaCBub2RlLCBkZWZhdWx0aW5nIHRvIHRoZSBlbXB0eSBzdHJpbmcuXG4gKlxuICogQHR5cGVkZWYge29iamVjdH0gU3RvcmFnZU5vZGVcbiAqIEBwcm9wZXJ0eSB7KGRhdGE6IHN0cmluZykgPT4gUHJvbWlzZTx2b2lkPn0gc2V0VmFsdWUgcHVibGlzaGVzIHNvbWUgZGF0YSAoYXBwZW5kIHRvIHRoZSBub2RlKVxuICogQHByb3BlcnR5IHsoKSA9PiBzdHJpbmd9IGdldFBhdGggdGhlIGNoYWluIHN0b3JhZ2UgcGF0aCBhdCB3aGljaCB0aGUgbm9kZSB3YXMgY29uc3RydWN0ZWRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxWU3RvcmFnZUtleT59IGdldFN0b3JlS2V5IERFUFJFQ0FURUQgdXNlIGdldFBhdGhcbiAqIEBwcm9wZXJ0eSB7KHN1YlBhdGg6IHN0cmluZywgb3B0aW9ucz86IHtzZXF1ZW5jZT86IGJvb2xlYW59KSA9PiBTdG9yYWdlTm9kZX0gbWFrZUNoaWxkTm9kZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gU3RvcmVkRmFjZXRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxzdHJpbmc+fSBnZXRQYXRoIHRoZSBjaGFpbiBzdG9yYWdlIHBhdGggYXQgd2hpY2ggdGhlIG5vZGUgd2FzIGNvbnN0cnVjdGVkXG4gKiBAcHJvcGVydHkge1N0b3JhZ2VOb2RlWydnZXRTdG9yZUtleSddfSBnZXRTdG9yZUtleSBERVBSRUNBVEVEIHVzZSBnZXRQYXRoXG4gKiBAcHJvcGVydHkgeygpID0+IFVuc2VyaWFsaXplcn0gZ2V0VW5zZXJpYWxpemVyIGdldCB0aGUgdW5zZXJpYWxpemVyIGZvciB0aGUgc3RvcmVkIGRhdGFcbiAqL1xuXG4vKipcbiAqIEBkZXByZWNhdGVkIHVzZSBTdG9yZWRTdWJzY3JpYmVyXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1N1YnNjcmlwdGlvbjxUPiAmIHtcbiAqICAgZ2V0U3RvcmVLZXk6ICgpID0+IFByb21pc2U8VlN0b3JhZ2VLZXkgJiB7IHN1YnNjcmlwdGlvbjogU3Vic2NyaXB0aW9uPFQ+IH0+LFxuICogICBnZXRVbnNlcmlhbGl6ZXI6ICgpID0+IFVuc2VyaWFsaXplcixcbiAqIH19IFN0b3JlZFN1YnNjcmlwdGlvblxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtTdWJzY3JpYmVyPFQ+ICYgU3RvcmVkRmFjZXR9IFN0b3JlZFN1YnNjcmliZXJcbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA+Ylw2XAEAAFwBAAAmAAAAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvZXhwb3J0ZWQuanN7ImltcG9ydHMiOlsiLi9zcmMvdHlwZXMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGqAqO/cCwAA3AsAACcAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiLi9sZWdhY3kvbGVnYWN5TWFwLmpzIiwiLi9sZWdhY3kvbGVnYWN5V2Vha01hcC5qcyIsIi4vc3RvcmVzL3NjYWxhck1hcFN0b3JlLmpzIiwiLi9zdG9yZXMvc2NhbGFyU2V0U3RvcmUuanMiLCIuL3N0b3Jlcy9zY2FsYXJXZWFrTWFwU3RvcmUuanMiLCIuL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanMiLCIuL3N0b3Jlcy9zdG9yZS11dGlscy5qcyIsIkBlbmRvL2V4byIsIkBlbmRvL3BhdHRlcm5zIl0sImV4cG9ydHMiOlsiYXNzZXJ0S2V5IiwiYXNzZXJ0S2V5IiwiZGVmaW5lRXhvQ2xhc3MiLCJkZWZpbmVFeG9DbGFzcyIsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsLG51bGwsbnVsbF0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGF0dGVybnNcIiwgW11dLFtcIkBlbmRvL2V4b1wiLCBbXV0sW1wiLi9zdG9yZXMvc2NhbGFyV2Vha1NldFN0b3JlLmpzXCIsIFtdXSxbXCIuL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qc1wiLCBbXV0sW1wiLi9zdG9yZXMvc2NhbGFyV2Vha01hcFN0b3JlLmpzXCIsIFtdXSxbXCIuL3N0b3Jlcy9zY2FsYXJNYXBTdG9yZS5qc1wiLCBbXV0sW1wiLi9zdG9yZXMvc3RvcmUtdXRpbHMuanNcIiwgW11dLFtcIi4vbGVnYWN5L2xlZ2FjeU1hcC5qc1wiLCBbXV0sW1wiLi9sZWdhY3kvbGVnYWN5V2Vha01hcC5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyJAZW5kby9wYXR0ZXJucyI6W1siaXNLZXkiLCJpc0tleSJdLFsiYXNzZXJ0S2V5IiwiYXNzZXJ0S2V5Il0sWyJhc3NlcnRTY2FsYXJLZXkiLCJhc3NlcnRTY2FsYXJLZXkiXSxbIm1ha2VDb3B5U2V0IiwibWFrZUNvcHlTZXQiXSxbImdldENvcHlTZXRLZXlzIiwiZ2V0Q29weVNldEtleXMiXSxbIm1ha2VDb3B5QmFnIiwibWFrZUNvcHlCYWciXSxbIm1ha2VDb3B5QmFnRnJvbUVsZW1lbnRzIiwibWFrZUNvcHlCYWdGcm9tRWxlbWVudHMiXSxbImdldENvcHlCYWdFbnRyaWVzIiwiZ2V0Q29weUJhZ0VudHJpZXMiXSxbIm1ha2VDb3B5TWFwIiwibWFrZUNvcHlNYXAiXSxbImdldENvcHlNYXBFbnRyaWVzIiwiZ2V0Q29weU1hcEVudHJpZXMiXSxbImNvZXJjZVRvRWxlbWVudHMiLCJjb2VyY2VUb0VsZW1lbnRzIl0sWyJjb2VyY2VUb0JhZ0VudHJpZXMiLCJjb2VyY2VUb0JhZ0VudHJpZXMiXSxbImNvbXBhcmVLZXlzIiwiY29tcGFyZUtleXMiXSxbImtleUxUIiwia2V5TFQiXSxbImtleUxURSIsImtleUxURSJdLFsia2V5RVEiLCJrZXlFUSJdLFsia2V5R1RFIiwia2V5R1RFIl0sWyJrZXlHVCIsImtleUdUIl0sWyJlbGVtZW50c0lzU3VwZXJzZXQiLCJlbGVtZW50c0lzU3VwZXJzZXQiXSxbImVsZW1lbnRzSXNEaXNqb2ludCIsImVsZW1lbnRzSXNEaXNqb2ludCJdLFsiZWxlbWVudHNDb21wYXJlIiwiZWxlbWVudHNDb21wYXJlIl0sWyJlbGVtZW50c1VuaW9uIiwiZWxlbWVudHNVbmlvbiJdLFsiZWxlbWVudHNEaXNqb2ludFVuaW9uIiwiZWxlbWVudHNEaXNqb2ludFVuaW9uIl0sWyJlbGVtZW50c0ludGVyc2VjdGlvbiIsImVsZW1lbnRzSW50ZXJzZWN0aW9uIl0sWyJlbGVtZW50c0Rpc2pvaW50U3VidHJhY3QiLCJlbGVtZW50c0Rpc2pvaW50U3VidHJhY3QiXSxbInNldElzU3VwZXJzZXQiLCJzZXRJc1N1cGVyc2V0Il0sWyJzZXRJc0Rpc2pvaW50Iiwic2V0SXNEaXNqb2ludCJdLFsic2V0Q29tcGFyZSIsInNldENvbXBhcmUiXSxbInNldFVuaW9uIiwic2V0VW5pb24iXSxbInNldERpc2pvaW50VW5pb24iLCJzZXREaXNqb2ludFVuaW9uIl0sWyJzZXRJbnRlcnNlY3Rpb24iLCJzZXRJbnRlcnNlY3Rpb24iXSxbInNldERpc2pvaW50U3VidHJhY3QiLCJzZXREaXNqb2ludFN1YnRyYWN0Il0sWyJiYWdJc1N1cGVyYmFnIiwiYmFnSXNTdXBlcmJhZyJdLFsiYmFnQ29tcGFyZSIsImJhZ0NvbXBhcmUiXSxbImJhZ1VuaW9uIiwiYmFnVW5pb24iXSxbImJhZ0ludGVyc2VjdGlvbiIsImJhZ0ludGVyc2VjdGlvbiJdLFsiYmFnRGlzam9pbnRTdWJ0cmFjdCIsImJhZ0Rpc2pvaW50U3VidHJhY3QiXSxbIk0iLCJNIl0sWyJnZXRSYW5rQ292ZXIiLCJnZXRSYW5rQ292ZXIiXSxbImlzUGF0dGVybiIsImlzUGF0dGVybiJdLFsiYXNzZXJ0UGF0dGVybiIsImFzc2VydFBhdHRlcm4iXSxbIm1hdGNoZXMiLCJtYXRjaGVzIl0sWyJtdXN0TWF0Y2giLCJtdXN0TWF0Y2giXV0sIkBlbmRvL2V4byI6W1siaW5pdEVtcHR5IiwiaW5pdEVtcHR5Il0sWyJkZWZpbmVFeG9DbGFzcyIsImRlZmluZUV4b0NsYXNzIl0sWyJkZWZpbmVFeG9DbGFzc0tpdCIsImRlZmluZUV4b0NsYXNzS2l0Il0sWyJtYWtlRXhvIiwibWFrZUV4byJdXSwiLi9zdG9yZXMvc2NhbGFyV2Vha1NldFN0b3JlLmpzIjpbWyJtYWtlU2NhbGFyV2Vha1NldFN0b3JlIiwibWFrZVNjYWxhcldlYWtTZXRTdG9yZSJdXSwiLi9zdG9yZXMvc2NhbGFyU2V0U3RvcmUuanMiOltbIm1ha2VTY2FsYXJTZXRTdG9yZSIsIm1ha2VTY2FsYXJTZXRTdG9yZSJdXSwiLi9zdG9yZXMvc2NhbGFyV2Vha01hcFN0b3JlLmpzIjpbWyJtYWtlU2NhbGFyV2Vha01hcFN0b3JlIiwibWFrZVNjYWxhcldlYWtNYXBTdG9yZSJdXSwiLi9zdG9yZXMvc2NhbGFyTWFwU3RvcmUuanMiOltbIm1ha2VTY2FsYXJNYXBTdG9yZSIsIm1ha2VTY2FsYXJNYXBTdG9yZSJdXSwiLi9zdG9yZXMvc3RvcmUtdXRpbHMuanMiOltbInByb3ZpZGVMYXp5IiwicHJvdmlkZUxhenkiXV0sIi4vbGVnYWN5L2xlZ2FjeU1hcC5qcyI6W1sibWFrZUxlZ2FjeU1hcCIsIm1ha2VMZWdhY3lNYXAiXV0sIi4vbGVnYWN5L2xlZ2FjeVdlYWtNYXAuanMiOltbIm1ha2VMZWdhY3lXZWFrTWFwIiwibWFrZUxlZ2FjeVdlYWtNYXAiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAOKvgH1GCwAARgsAADIAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvbGVnYWN5L2xlZ2FjeU1hcC5qc3siaW1wb3J0cyI6WyIuLi90eXBlcy5qcyIsIkBhZ29yaWMvYXNzZXJ0Il0sImV4cG9ydHMiOlsibWFrZUxlZ2FjeU1hcCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBxLEZhaWw7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9hc3NlcnRcIiwgW1tcInFcIiwgWyRo4oCNX2EgPT4gKHEgPSAkaOKAjV9hKV1dLFtcIkZhaWxcIiwgWyRo4oCNX2EgPT4gKEZhaWwgPSAkaOKAjV9hKV1dXV0sW1wiLi4vdHlwZXMuanNcIiwgW11dXSk7ICAgXG5cblxuXG4vKipcbiAqIFRoaXMgbW9kdWxlIGFuZCBpdHMgZnJhdGVybmFsIHNpYmxpbmcgbGVnYWN5V2Vha01hcCBleGlzdCBvbmx5IHRvXG4gKiBlYXNlIGEgdHJhbnNpdGlvbiB0byB0aGUgbW9kZXJuIGBzdG9yZWAgc3lzdGVtLCBhcmUgZGVwcmVjYXRlZCxcbiAqIGFuZCB3aWxsIGV2ZW50dWFsbHkgZGlzYXBwZWFyLiBUaGV5IGFyZSBuZWVkZWQgZm9yIG5vdyB0byBzdXBwb3J0XG4gKiBzb21lIG9mIHRoZSB1c2VzIG9mIHRoZSBvbGQgYmVoYXZpb3IgdGhhdCBhcmUgbm90IGNvbXBhdGlibGUgd2l0aFxuICogdGhlIG5ldy4gVGhlIGNvbnN0cmFpbnQgaW1wb3NlZCBieSB0aGUgbmV3IGlzIHRoYXQgb25seSBwYXNzYWJsZXMgY2FuXG4gKiBiZSB1c2VkIGFzIHZhbHVlcywgYW5kIG9ubHkga2V5cyAocm91Z2hseSwgc3RydWN0dXJlcywgYWthIGNvbXBhcmFibGVzKVxuICogY2FuIGJlIHVzZWQgYXMgdmFsdWVzLlxuICpcbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvcHVsbC8zNTY3XG4gKiBUT0RPIE9uY2UgdGhhdCBQUiBpcyBtZXJnZWQsIGxpbmsgdG8gdGhlIGRvY3VtZW50cyByYXRoZXIgdGhhbiB0aGUgUFJzLlxuICpcbiAqIEVhY2ggb2YgdGhlc2Ugbm9uLWNvbmZvcm1pbmcgdXNlcyBzaG91bGQgYmUgbWFya2VkIHdpdGggYVxuICogYGBganNcbiAqIC8vIExlZ2FjeSBiZWNhdXNlLi4uXG4gKiBgYGBcbiAqIGNvbW1lbnQgZXhwbGFpbmluZyB0aGUgcHJvYmxlbSBpbmhpYml0aW5nIGNvbnZlcnNpb24gdG8gdGhlIG5ld1xuICogc3lzdGVtLiBTb21lIG9mIHRoZXNlIHByb2JsZW1zIGFzIG9mIHRoaXMgd3JpdGluZzpcbiAqICAgICogQSBwcm9taXNlS2l0IHVzZWQgYXMgYSB2YWx1ZSwgZXZlbiB0aG91Z2ggYSBwcm9taXNlS2l0IGlzIG5vdFxuICogICAgICBhIHBhc3NhYmxlLiBTb2x1dGlvbnMgYXJlIHRvIG1ha2UgaXQgYSBwYXNzYWJsZSwgb3IgdG8gY29udmVydFxuICogICAgICB0aGUgY29udGFpbmVyIGJhY2sgdG8gYSBjb252ZW50aW9uYWwgSmF2YVNjcmlwdCBNYXAuXG4gKiAgICAqIEEgbXV0YWJsZSBhcnJheSB1c2VkIGFzIGEgdmFsdWUsIHRoYXQgaXMgc3Vic2VxdWVudGx5IG11dGF0ZWQuXG4gKiAgICAgIEZyZWV6aW5nIHRoZSBhcnJheSB3b3VsZG4ndCB3b3JrIG9mIGNvdXJzZSBiZWNhdXNlIGl0IHdvdWxkIGJyZWFrXG4gKiAgICAgIHRoZSBzdWJzZXF1ZW50IG11dGF0aW9uLiBVc2luZyBhIGZhciBvYmplY3Qgd3JhcHBpbmcgYW4gYXJyYXkgd291bGRcbiAqICAgICAgbGlrZWx5IHdvcmsgZmluZS5cbiAqXG4gKiBAZGVwcmVjYXRlZCBzd2l0Y2ggdG8gU2NhbGFyTWFwIGlmIHBvc3NpYmxlLCBNYXAgb3RoZXJ3aXNlXG4gKiBAdGVtcGxhdGUgSyxWXG4gKiBAcGFyYW0ge3N0cmluZ30gW3RhZz0na2V5J10gLSB0YWcgZm9yIGRlYnVnZ2luZ1xuICogQHJldHVybnMge0xlZ2FjeU1hcDxLLFY+fVxuICovXG5jb25zdCAgICAgICAgbWFrZUxlZ2FjeU1hcD0odGFnPSdrZXknKT0+e1xuY29uc3QgbT1uZXcgTWFwKCk7XG5jb25zdCBhc3NlcnRLZXlEb2VzTm90RXhpc3Q9KGtleSk9PlxuIW0uaGFzKGtleSl8fEZhaWwgYCR7cSh0YWcpfSBhbHJlYWR5IHJlZ2lzdGVyZWQ6ICR7a2V5fWA7XG5jb25zdCBhc3NlcnRLZXlFeGlzdHM9KGtleSk9PlxubS5oYXMoa2V5KXx8RmFpbCBgJHtxKHRhZyl9IG5vdCBmb3VuZDogJHtrZXl9YDtcbnJldHVybiBoYXJkZW4oe1xuaGFzOihrZXkpPT57XG4vKiBDaGVjayBpZiBhIGtleSBleGlzdHMuIFRoZSBrZXkgY2FuIGJlIGFueSBKYXZhU2NyaXB0IHZhbHVlLCovXG4vKiB0aG91Z2ggdGhlIGFuc3dlciB3aWxsIGFsd2F5cyBiZSBmYWxzZSBmb3Iga2V5cyB0aGF0IGNhbm5vdCBiZSBmb3VuZCovXG4vKiBpbiB0aGlzIG1hcC4qL1xucmV0dXJuIG0uaGFzKGtleSk7XG4gfSxcbmluaXQ6KGtleSx2YWx1ZSk9PntcbmFzc2VydEtleURvZXNOb3RFeGlzdChrZXkpO1xubS5zZXQoa2V5LHZhbHVlKTtcbiB9LFxuZ2V0OihrZXkpPT57XG5hc3NlcnRLZXlFeGlzdHMoa2V5KTtcbnJldHVybiBtLmdldChrZXkpO1xuIH0sXG5zZXQ6KGtleSx2YWx1ZSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xubS5zZXQoa2V5LHZhbHVlKTtcbiB9LFxuZGVsZXRlOihrZXkpPT57XG5hc3NlcnRLZXlFeGlzdHMoa2V5KTtcbm0uZGVsZXRlKGtleSk7XG4gfSxcbmtleXM6KCk9Pm0ua2V5cygpLFxudmFsdWVzOigpPT5tLnZhbHVlcygpLFxuZW50cmllczooKT0+bS5lbnRyaWVzKCksXG5nZXRTaXplOigpPT5tLnNpemUsXG5jbGVhcjooKT0+bS5jbGVhcigpfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZUxlZ2FjeU1hcChtYWtlTGVnYWN5TWFwKTtcbmhhcmRlbihtYWtlTGVnYWN5TWFwKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTGVnYWN5TWFwIjpbIm1ha2VMZWdhY3lNYXAiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAApoNNtMIGAADCBgAANgAAAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy9sZWdhY3kvbGVnYWN5V2Vha01hcC5qc3siaW1wb3J0cyI6WyIuLi90eXBlcy5qcyIsIkBhZ29yaWMvYXNzZXJ0Il0sImV4cG9ydHMiOlsibWFrZUxlZ2FjeVdlYWtNYXAiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcSxGYWlsOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJxXCIsIFskaOKAjV9hID0+IChxID0gJGjigI1fYSldXSxbXCJGYWlsXCIsIFskaOKAjV9hID0+IChGYWlsID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxuXG5cbi8qKlxuICogU2VlIGRvY2NvbW1lbnQgaW4gdGhlIGNsb3NlbHkgcmVsYXRlZCBgbGVnYWN5TWFwLmpzYCBtb2R1bGUuXG4gKlxuICogQGRlcHJlY2F0ZWQgc3dpdGNoIHRvIFNjYWxhcldlYWtNYXAgaWYgcG9zc2libGUsIFdlYWtNYXAgb3RoZXJ3aXNlXG4gKiBAdGVtcGxhdGUgSyxWXG4gKiBAcGFyYW0ge3N0cmluZ30gW3RhZz0na2V5J10gLSB0YWcgZm9yIGRlYnVnZ2luZ1xuICogQHJldHVybnMge0xlZ2FjeVdlYWtNYXA8SyxWPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VMZWdhY3lXZWFrTWFwPSh0YWc9J2tleScpPT57XG4vKiogQHR5cGUge1dlYWtNYXA8SyAmIG9iamVjdCwgVj59ICovXG5jb25zdCB3bT1uZXcgV2Vha01hcCgpO1xuY29uc3QgYXNzZXJ0S2V5RG9lc05vdEV4aXN0PShrZXkpPT5cbiF3bS5oYXMoa2V5KXx8RmFpbCBgJHtxKHRhZyl9IGFscmVhZHkgcmVnaXN0ZXJlZDogJHtrZXl9YDtcbmNvbnN0IGFzc2VydEtleUV4aXN0cz0oa2V5KT0+XG53bS5oYXMoa2V5KXx8RmFpbCBgJHtxKHRhZyl9IG5vdCBmb3VuZDogJHtrZXl9YDtcbnJldHVybiBoYXJkZW4oe1xuaGFzOihrZXkpPT57XG4vKiBDaGVjayBpZiBhIGtleSBleGlzdHMuIFRoZSBrZXkgY2FuIGJlIGFueSBKYXZhU2NyaXB0IHZhbHVlLCovXG4vKiB0aG91Z2ggdGhlIGFuc3dlciB3aWxsIGFsd2F5cyBiZSBmYWxzZSBmb3Iga2V5cyB0aGF0IGNhbm5vdCBiZSBmb3VuZCovXG4vKiBpbiB0aGlzIG1hcC4qL1xucmV0dXJuIHdtLmhhcyhrZXkpO1xuIH0sXG5pbml0OihrZXksdmFsdWUpPT57XG5hc3NlcnRLZXlEb2VzTm90RXhpc3Qoa2V5KTtcbndtLnNldChrZXksdmFsdWUpO1xuIH0sXG5nZXQ6KGtleSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xuLyogSG93IHRvIHRlbGwgdHlwZXNjcmlwdCBJIGJlbGlldmUgdGhlIGBnZXRgIHdpbGwgc3VjY2VlZC4qL1xucmV0dXJuICgvKiogQHR5cGUge1Z9ICovd20uZ2V0KGtleSkpO1xuIH0sXG5zZXQ6KGtleSx2YWx1ZSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xud20uc2V0KGtleSx2YWx1ZSk7XG4gfSxcbmRlbGV0ZTooa2V5KT0+e1xuYXNzZXJ0S2V5RXhpc3RzKGtleSk7XG53bS5kZWxldGUoa2V5KTtcbiB9fSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZUxlZ2FjeVdlYWtNYXAobWFrZUxlZ2FjeVdlYWtNYXApO1xuaGFyZGVuKG1ha2VMZWdhY3lXZWFrTWFwKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTGVnYWN5V2Vha01hcCI6WyJtYWtlTGVnYWN5V2Vha01hcCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACaA7rXFhYAABYWAAA3AAAAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL3N0b3Jlcy9zY2FsYXJNYXBTdG9yZS5qc3siaW1wb3J0cyI6WyIuL3NjYWxhcldlYWtNYXBTdG9yZS5qcyIsIi4vc3RvcmUtdXRpbHMuanMiLCJAZW5kby9tYXJzaGFsIiwiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL3BhdHRlcm5zIl0sImV4cG9ydHMiOlsibWFrZU1hcFN0b3JlTWV0aG9kcyIsIm1ha2VTY2FsYXJNYXBTdG9yZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYXIsYXNzZXJ0UGFzc2FibGUsZmlsdGVySXRlcmFibGUsbWFwSXRlcmFibGUsY29tcGFyZVJhbmssYXNzZXJ0U2NhbGFyS2V5LG1ha2VDb3B5TWFwLG1hdGNoZXMsbXVzdE1hdGNoLGFzc2VydFBhdHRlcm4sbWFrZVdlYWtNYXBTdG9yZU1ldGhvZHMsbWFrZUN1cnJlbnRLZXlzS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaOKAjV9hKV1dLFtcImZpbHRlckl0ZXJhYmxlXCIsIFskaOKAjV9hID0+IChmaWx0ZXJJdGVyYWJsZSA9ICRo4oCNX2EpXV0sW1wibWFwSXRlcmFibGVcIiwgWyRo4oCNX2EgPT4gKG1hcEl0ZXJhYmxlID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcImNvbXBhcmVSYW5rXCIsIFskaOKAjV9hID0+IChjb21wYXJlUmFuayA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wYXR0ZXJuc1wiLCBbW1wiYXNzZXJ0U2NhbGFyS2V5XCIsIFskaOKAjV9hID0+IChhc3NlcnRTY2FsYXJLZXkgPSAkaOKAjV9hKV1dLFtcIm1ha2VDb3B5TWFwXCIsIFskaOKAjV9hID0+IChtYWtlQ29weU1hcCA9ICRo4oCNX2EpXV0sW1wibWF0Y2hlc1wiLCBbJGjigI1fYSA9PiAobWF0Y2hlcyA9ICRo4oCNX2EpXV0sW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dLFtcImFzc2VydFBhdHRlcm5cIiwgWyRo4oCNX2EgPT4gKGFzc2VydFBhdHRlcm4gPSAkaOKAjV9hKV1dXV0sW1wiLi9zY2FsYXJXZWFrTWFwU3RvcmUuanNcIiwgW1tcIm1ha2VXZWFrTWFwU3RvcmVNZXRob2RzXCIsIFskaOKAjV9hID0+IChtYWtlV2Vha01hcFN0b3JlTWV0aG9kcyA9ICRo4oCNX2EpXV1dXSxbXCIuL3N0b3JlLXV0aWxzLmpzXCIsIFtbXCJtYWtlQ3VycmVudEtleXNLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VDdXJyZW50S2V5c0tpdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtxdW90ZTpxfT1hc3NlcnQ7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IEtcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFZcbiAqIEBwYXJhbSB7TWFwPEssVj59IGpzbWFwXG4gKiBAcGFyYW0geyhrOiBLLCB2OiBWKSA9PiB2b2lkfSBhc3NlcnRLVk9rVG9BZGRcbiAqIEBwYXJhbSB7KGs6IEssIHY6IFYpID0+IHZvaWR9IGFzc2VydEtWT2tUb1NldFxuICogQHBhcmFtIHsoKGs6IEspID0+IHZvaWQpfSBbYXNzZXJ0S2V5T2tUb0RlbGV0ZV1cbiAqIEBwYXJhbSB7c3RyaW5nfSBbdGFnXVxuICogQHJldHVybnMge01hcFN0b3JlPEssVj59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlTWFwU3RvcmVNZXRob2RzPShcbmpzbWFwLFxuYXNzZXJ0S1ZPa1RvQWRkLFxuYXNzZXJ0S1ZPa1RvU2V0LFxuYXNzZXJ0S2V5T2tUb0RlbGV0ZT11bmRlZmluZWQsXG50YWc9J2tleScpPT5cbntcbmNvbnN0e2Fzc2VydFVwZGF0ZU9uQWRkLGFzc2VydFVwZGF0ZU9uRGVsZXRlLGl0ZXJhYmxlS2V5c309XG5tYWtlQ3VycmVudEtleXNLaXQoXG4oKT0+anNtYXAua2V5cygpLFxuKGspPT5qc21hcC5oYXMoayksXG5jb21wYXJlUmFuayxcbmFzc2VydEtWT2tUb0FkZCxcbmFzc2VydEtleU9rVG9EZWxldGUsXG50YWcpO1xuXG5cbi8qKlxuICogQHBhcmFtIHtQYXR0ZXJufSBba2V5UGF0dF1cbiAqIEBwYXJhbSB7UGF0dGVybn0gW3ZhbHVlUGF0dF1cbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxLPn1cbiAqL1xuY29uc3Qga2V5cz0oa2V5UGF0dD11bmRlZmluZWQsdmFsdWVQYXR0PXVuZGVmaW5lZCk9PntcbmlmKGtleVBhdHQ9PT11bmRlZmluZWQmJnZhbHVlUGF0dD09PXVuZGVmaW5lZCl7XG5yZXR1cm4gaXRlcmFibGVLZXlzO1xuIH1cbmNvbnN0IGZpbHRlcj0oayk9PntcbmlmKGtleVBhdHQhPT11bmRlZmluZWQmJiFtYXRjaGVzKGssa2V5UGF0dCkpe1xucmV0dXJuIGZhbHNlO1xuIH1cbi8qIFVzZXMgdGhlIGN1cnJlbnQganNtYXAgdmFsdWUsIHNpbmNlIHRoZSBpdGVyYXRhdG9yIHN1cnZpdmVzIGAuc2V0YCovXG5pZih2YWx1ZVBhdHQhPT11bmRlZmluZWQmJiFtYXRjaGVzKGpzbWFwLmdldChrKSx2YWx1ZVBhdHQpKXtcbnJldHVybiBmYWxzZTtcbiB9XG5yZXR1cm4gdHJ1ZTtcbiB9O1xucmV0dXJuIGZpbHRlckl0ZXJhYmxlKGl0ZXJhYmxlS2V5cyxmaWx0ZXIpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXR0ZXJufSBba2V5UGF0dF1cbiAqIEBwYXJhbSB7UGF0dGVybn0gW3ZhbHVlUGF0dF1cbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxWPn1cbiAqL1xuY29uc3QgdmFsdWVzPShrZXlQYXR0PXVuZGVmaW5lZCx2YWx1ZVBhdHQ9dW5kZWZpbmVkKT0+XG5tYXBJdGVyYWJsZShrZXlzKGtleVBhdHQsdmFsdWVQYXR0KSwoayk9Pi8qKiBAdHlwZSB7Vn0gKi9qc21hcC5nZXQoaykpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGF0dGVybn0gW2tleVBhdHRdXG4gKiBAcGFyYW0ge1BhdHRlcm59IFt2YWx1ZVBhdHRdXG4gKiBAcmV0dXJucyB7SXRlcmFibGU8W0ssVl0+fVxuICovXG5jb25zdCBlbnRyaWVzPShrZXlQYXR0PXVuZGVmaW5lZCx2YWx1ZVBhdHQ9dW5kZWZpbmVkKT0+XG5tYXBJdGVyYWJsZShrZXlzKGtleVBhdHQsdmFsdWVQYXR0KSwoayk9PltcbmssXG4vKiogQHR5cGUge1Z9ICovanNtYXAuZ2V0KGspXSk7XG5cblxucmV0dXJuIGhhcmRlbih7XG4uLi5tYWtlV2Vha01hcFN0b3JlTWV0aG9kcyhcbmpzbWFwLFxuLyoqIEB0eXBlIHsoazogSywgdjogVikgPT4gdm9pZH0gKi9hc3NlcnRVcGRhdGVPbkFkZCxcbmFzc2VydEtWT2tUb1NldCxcbmFzc2VydFVwZGF0ZU9uRGVsZXRlLFxudGFnKSxcblxua2V5cyxcbnZhbHVlcyxcbmVudHJpZXMsXG5cbnNuYXBzaG90OihrZXlQYXR0PXVuZGVmaW5lZCx2YWx1ZVBhdHQ9dW5kZWZpbmVkKT0+XG5tYWtlQ29weU1hcChlbnRyaWVzKGtleVBhdHQsdmFsdWVQYXR0KSksXG5cbmdldFNpemU6KGtleVBhdHQ9dW5kZWZpbmVkLHZhbHVlUGF0dD11bmRlZmluZWQpPT5cbmtleVBhdHQ9PT11bmRlZmluZWQmJnZhbHVlUGF0dD09PXVuZGVmaW5lZD9cbmpzbWFwLnNpemU6XG5bLi4ua2V5cyhrZXlQYXR0LHZhbHVlUGF0dCldLmxlbmd0aCxcblxuY2xlYXI6KGtleVBhdHQ9dW5kZWZpbmVkLHZhbHVlUGF0dD11bmRlZmluZWQpPT57XG5pZihrZXlQYXR0PT09dW5kZWZpbmVkJiZ2YWx1ZVBhdHQ9PT11bmRlZmluZWQpe1xuanNtYXAuY2xlYXIoKTtcbiB9XG5mb3IoY29uc3Qga2V5IG9mIGtleXMoa2V5UGF0dCx2YWx1ZVBhdHQpKXtcbmpzbWFwLmRlbGV0ZShrZXkpO1xuIH1cbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIERpc3Rpbmd1aXNoZXMgYmV0d2VlbiBhZGRpbmcgYSBuZXcga2V5IChpbml0KSBhbmQgdXBkYXRpbmcgb3JcbiAqIHJlZmVyZW5jaW5nIGEga2V5IChnZXQsIHNldCwgZGVsZXRlKS5cbiAqXG4gKiBgaW5pdGAgaXMgb25seSBhbGxvd2VkIGlmIHRoZSBrZXkgZG9lcyBub3QgYWxyZWFkeSBleGlzdC4gYEdldGAsXG4gKiBgc2V0YCBhbmQgYGRlbGV0ZWAgYXJlIG9ubHkgYWxsb3dlZCBpZiB0aGUga2V5IGRvZXMgYWxyZWFkeSBleGlzdC5cbiAqXG4gKiBUaGlzIGlzIGEgKnNjYWxhciogbWFwIGluIHRoYXQgdGhlIGtleXMgY2FuIG9ubHkgYmUgYXRvbWljIHZhbHVlcywgcHJpbWl0aXZlc1xuICogb3IgcmVtb3RhYmxlcy4gT3RoZXIgc3RvcmVNYXBzIHdpbGwgYWNjZXB0LCBmb3IgZXhhbXBsZSwgY29weUFycmF5cyBhbmRcbiAqIGNvcHlSZWNvcmRzLCBhcyBrZXlzIGFuZCBsb29rIHRoZW0gdXAgYmFzZWQgb24gZXF1YWxpdHkgb2YgdGhlaXIgY29udGVudHMuXG4gKlxuICogQHRlbXBsYXRlIHtLZXl9IEtcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFZcbiAqIEBwYXJhbSB7c3RyaW5nfSBbdGFnPSdrZXknXSAtIHRoZSBjb2x1bW4gbmFtZSBmb3IgdGhlIGtleVxuICogQHBhcmFtIHtTdG9yZU9wdGlvbnN9IFtvcHRpb25zXVxuICogQHJldHVybnMge01hcFN0b3JlPEssVj59XG4gKi8kaOKAjV9vbmNlLm1ha2VNYXBTdG9yZU1ldGhvZHMobWFrZU1hcFN0b3JlTWV0aG9kcyk7XG5jb25zdCAgICAgICAgbWFrZVNjYWxhck1hcFN0b3JlPShcbnRhZz0na2V5JyxcbntrZXlTaGFwZT11bmRlZmluZWQsdmFsdWVTaGFwZT11bmRlZmluZWR9PXt9KT0+XG57XG5jb25zdCBqc21hcD1uZXcgTWFwKCk7XG5pZihrZXlTaGFwZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnRQYXR0ZXJuKGtleVNoYXBlKTtcbiB9XG5pZih2YWx1ZVNoYXBlIT09dW5kZWZpbmVkKXtcbmFzc2VydFBhdHRlcm4odmFsdWVTaGFwZSk7XG4gfVxuXG5jb25zdCBhc3NlcnRLVk9rVG9TZXQ9KF9rZXksdmFsdWUpPT57XG4vKiBUT0RPOiBKdXN0IGEgdHJhbnNpdGlvbiBrbHVkZ2UuIFJlbW92ZSB3aGVuIHBvc3NpYmxlLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNjA2Ki9cbmhhcmRlbih2YWx1ZSk7XG5cbmFzc2VydFBhc3NhYmxlKHZhbHVlKTtcbmlmKHZhbHVlU2hhcGUhPT11bmRlZmluZWQpe1xubXVzdE1hdGNoKHZhbHVlLHZhbHVlU2hhcGUsJ21hcFN0b3JlIHZhbHVlJyk7XG4gfVxuIH07XG5cbmNvbnN0IGFzc2VydEtWT2tUb0FkZD0oa2V5LHZhbHVlKT0+e1xuLyogVE9ETzogSnVzdCBhIHRyYW5zaXRpb24ga2x1ZGdlLiBSZW1vdmUgd2hlbiBwb3NzaWJsZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvMzYwNiovXG5oYXJkZW4oa2V5KTtcblxuYXNzZXJ0U2NhbGFyS2V5KGtleSk7XG5pZihrZXlTaGFwZSE9PXVuZGVmaW5lZCl7XG5tdXN0TWF0Y2goa2V5LGtleVNoYXBlLCdtYXBTdG9yZSBrZXknKTtcbiB9XG5hc3NlcnRLVk9rVG9TZXQoa2V5LHZhbHVlKTtcbiB9O1xuXG5yZXR1cm4gRmFyKCBgc2NhbGFyIE1hcFN0b3JlIG9mICR7cSh0YWcpfWAse1xuLi4ubWFrZU1hcFN0b3JlTWV0aG9kcyhcbmpzbWFwLFxuYXNzZXJ0S1ZPa1RvQWRkLFxuYXNzZXJ0S1ZPa1RvU2V0LFxudW5kZWZpbmVkLFxudGFnKX0pO1xuXG5cbiB9OyRo4oCNX29uY2UubWFrZVNjYWxhck1hcFN0b3JlKG1ha2VTY2FsYXJNYXBTdG9yZSk7XG5oYXJkZW4obWFrZVNjYWxhck1hcFN0b3JlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTWFwU3RvcmVNZXRob2RzIjpbIm1ha2VNYXBTdG9yZU1ldGhvZHMiXSwibWFrZVNjYWxhck1hcFN0b3JlIjpbIm1ha2VTY2FsYXJNYXBTdG9yZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACdA5YgQQ8AAEEPAAA3AAAAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qc3siaW1wb3J0cyI6WyIuL3NjYWxhcldlYWtTZXRTdG9yZS5qcyIsIi4vc3RvcmUtdXRpbHMuanMiLCJAZW5kby9tYXJzaGFsIiwiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL3BhdHRlcm5zIl0sImV4cG9ydHMiOlsibWFrZVNjYWxhclNldFN0b3JlIiwibWFrZVNldFN0b3JlTWV0aG9kcyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYXIsZmlsdGVySXRlcmFibGUsY29tcGFyZVJhbmssYXNzZXJ0U2NhbGFyS2V5LG1ha2VDb3B5U2V0LG1hdGNoZXMsbXVzdE1hdGNoLGFzc2VydFBhdHRlcm4sbWFrZVdlYWtTZXRTdG9yZU1ldGhvZHMsbWFrZUN1cnJlbnRLZXlzS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXSxbXCJmaWx0ZXJJdGVyYWJsZVwiLCBbJGjigI1fYSA9PiAoZmlsdGVySXRlcmFibGUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiY29tcGFyZVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVSYW5rID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3BhdHRlcm5zXCIsIFtbXCJhc3NlcnRTY2FsYXJLZXlcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFNjYWxhcktleSA9ICRo4oCNX2EpXV0sW1wibWFrZUNvcHlTZXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VDb3B5U2V0ID0gJGjigI1fYSldXSxbXCJtYXRjaGVzXCIsIFskaOKAjV9hID0+IChtYXRjaGVzID0gJGjigI1fYSldXSxbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UGF0dGVyblwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGF0dGVybiA9ICRo4oCNX2EpXV1dXSxbXCIuL3NjYWxhcldlYWtTZXRTdG9yZS5qc1wiLCBbW1wibWFrZVdlYWtTZXRTdG9yZU1ldGhvZHNcIiwgWyRo4oCNX2EgPT4gKG1ha2VXZWFrU2V0U3RvcmVNZXRob2RzID0gJGjigI1fYSldXV1dLFtcIi4vc3RvcmUtdXRpbHMuanNcIiwgW1tcIm1ha2VDdXJyZW50S2V5c0tpdFwiLCBbJGjigI1fYSA9PiAobWFrZUN1cnJlbnRLZXlzS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuY29uc3R7cXVvdGU6cX09YXNzZXJ0O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAcGFyYW0ge1NldDxLPn0ganNzZXRcbiAqIEBwYXJhbSB7KGs6IEspID0+IHZvaWR9IGFzc2VydEtleU9rVG9BZGRcbiAqIEBwYXJhbSB7KGs6IEspID0+IHZvaWR9IFthc3NlcnRLZXlPa1RvRGVsZXRlXVxuICogQHBhcmFtIHtzdHJpbmd9IFtrZXlOYW1lXVxuICogQHJldHVybnMge1NldFN0b3JlPEs+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVNldFN0b3JlTWV0aG9kcz0oXG5qc3NldCxcbmFzc2VydEtleU9rVG9BZGQsXG5hc3NlcnRLZXlPa1RvRGVsZXRlPXVuZGVmaW5lZCxcbmtleU5hbWU9J2tleScpPT5cbntcbmNvbnN0e2Fzc2VydFVwZGF0ZU9uQWRkLGFzc2VydFVwZGF0ZU9uRGVsZXRlLGl0ZXJhYmxlS2V5c309XG5tYWtlQ3VycmVudEtleXNLaXQoXG4oKT0+anNzZXQua2V5cygpLFxuKGspPT5qc3NldC5oYXMoayksXG5jb21wYXJlUmFuayxcbmFzc2VydEtleU9rVG9BZGQsXG5hc3NlcnRLZXlPa1RvRGVsZXRlLFxua2V5TmFtZSk7XG5cblxuLyoqXG4gKiBAcGFyYW0ge1BhdHRlcm59IFtrZXlQYXR0XVxuICogQHJldHVybnMge0l0ZXJhYmxlPEs+fVxuICovXG5jb25zdCBrZXlzPShrZXlQYXR0PXVuZGVmaW5lZCk9Plxua2V5UGF0dD09PXVuZGVmaW5lZD9cbml0ZXJhYmxlS2V5czpcbmZpbHRlckl0ZXJhYmxlKGl0ZXJhYmxlS2V5cywoayk9Pm1hdGNoZXMoayxrZXlQYXR0KSk7XG5cbnJldHVybiBoYXJkZW4oe1xuLi4ubWFrZVdlYWtTZXRTdG9yZU1ldGhvZHMoXG5qc3NldCxcbmFzc2VydFVwZGF0ZU9uQWRkLFxuYXNzZXJ0VXBkYXRlT25EZWxldGUsXG5rZXlOYW1lKSxcblxuXG5rZXlzLFxuXG52YWx1ZXM6a2V5cyxcblxuc25hcHNob3Q6KGtleVBhdHQ9dW5kZWZpbmVkKT0+bWFrZUNvcHlTZXQoa2V5cyhrZXlQYXR0KSksXG5cbmdldFNpemU6KGtleVBhdHQ9dW5kZWZpbmVkKT0+XG5rZXlQYXR0PT09dW5kZWZpbmVkP2pzc2V0LnNpemU6Wy4uLmtleXMoa2V5UGF0dCldLmxlbmd0aCxcblxuY2xlYXI6KGtleVBhdHQ9dW5kZWZpbmVkKT0+e1xuaWYoa2V5UGF0dD09PXVuZGVmaW5lZCl7XG5qc3NldC5jbGVhcigpO1xuIH1cbmZvcihjb25zdCBrZXkgb2Yga2V5cyhrZXlQYXR0KSl7XG5qc3NldC5kZWxldGUoa2V5KTtcbiB9XG4gfX0pO1xuXG4gfTtcblxuLyoqXG4gKiBEaXN0aW5ndWlzaGVzIGJldHdlZW4gYWRkaW5nIGEgbmV3IGtleSAoaW5pdCkgYW5kIHVwZGF0aW5nIG9yXG4gKiByZWZlcmVuY2luZyBhIGtleSAoZ2V0LCBzZXQsIGRlbGV0ZSkuXG4gKlxuICogYGluaXRgIGlzIG9ubHkgYWxsb3dlZCBpZiB0aGUga2V5IGRvZXMgbm90IGFscmVhZHkgZXhpc3QuIGBHZXRgLFxuICogYHNldGAgYW5kIGBkZWxldGVgIGFyZSBvbmx5IGFsbG93ZWQgaWYgdGhlIGtleSBkb2VzIGFscmVhZHkgZXhpc3QuXG4gKlxuICogVGhpcyBpcyBhICpzY2FsYXIqIHNldCBpbiB0aGF0IHRoZSBrZXlzIGNhbiBvbmx5IGJlIGF0b21pYyB2YWx1ZXMsIHByaW1pdGl2ZXNcbiAqIG9yIHJlbW90YWJsZXMuIE90aGVyIHN0b3JlU2V0cyB3aWxsIGFjY2VwdCwgZm9yIGV4YW1wbGUsIGNvcHlBcnJheXMgYW5kXG4gKiBjb3B5UmVjb3JkcywgYXMga2V5cyBhbmQgbG9vayB0aGVtIHVwIGJhc2VkIG9uIGVxdWFsaXR5IG9mIHRoZWlyIGNvbnRlbnRzLlxuICpcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAcGFyYW0ge3N0cmluZ30gW3RhZz0na2V5J10gLSB0YWcgZm9yIGRlYnVnZ2luZ1xuICogQHBhcmFtIHtTdG9yZU9wdGlvbnN9IFtvcHRpb25zXVxuICogQHJldHVybnMge1NldFN0b3JlPEs+fVxuICovJGjigI1fb25jZS5tYWtlU2V0U3RvcmVNZXRob2RzKG1ha2VTZXRTdG9yZU1ldGhvZHMpO1xuY29uc3QgICAgICAgIG1ha2VTY2FsYXJTZXRTdG9yZT0oXG50YWc9J2tleScsXG57a2V5U2hhcGU9dW5kZWZpbmVkfT17fSk9Plxue1xuY29uc3QganNzZXQ9bmV3IFNldCgpO1xuaWYoa2V5U2hhcGUhPT11bmRlZmluZWQpe1xuYXNzZXJ0UGF0dGVybihrZXlTaGFwZSk7XG4gfVxuXG5jb25zdCBhc3NlcnRLZXlPa1RvQWRkPShrZXkpPT57XG4vKiBUT0RPOiBKdXN0IGEgdHJhbnNpdGlvbiBrbHVkZ2UuIFJlbW92ZSB3aGVuIHBvc3NpYmxlLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNjA2Ki9cbmhhcmRlbihrZXkpO1xuXG5hc3NlcnRTY2FsYXJLZXkoa2V5KTtcbmlmKGtleVNoYXBlIT09dW5kZWZpbmVkKXtcbm11c3RNYXRjaChrZXksa2V5U2hhcGUsJ3NldFN0b3JlIGtleScpO1xuIH1cbiB9O1xuXG5yZXR1cm4gRmFyKCBgc2NhbGFyIFNldFN0b3JlIG9mICR7cSh0YWcpfWAse1xuLi4ubWFrZVNldFN0b3JlTWV0aG9kcyhqc3NldCxhc3NlcnRLZXlPa1RvQWRkLHVuZGVmaW5lZCx0YWcpfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZVNjYWxhclNldFN0b3JlKG1ha2VTY2FsYXJTZXRTdG9yZSk7XG5oYXJkZW4obWFrZVNjYWxhclNldFN0b3JlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlU2V0U3RvcmVNZXRob2RzIjpbIm1ha2VTZXRTdG9yZU1ldGhvZHMiXSwibWFrZVNjYWxhclNldFN0b3JlIjpbIm1ha2VTY2FsYXJTZXRTdG9yZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAZQWnY4xIAAOMSAAA7AAAAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL3N0b3Jlcy9zY2FsYXJXZWFrTWFwU3RvcmUuanN7ImltcG9ydHMiOlsiLi9zdG9yZS11dGlscy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiLCJAZW5kby9wYXR0ZXJucyJdLCJleHBvcnRzIjpbIm1ha2VTY2FsYXJXZWFrTWFwU3RvcmUiLCJtYWtlV2Vha01hcFN0b3JlTWV0aG9kcyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYXIsYXNzZXJ0UGFzc2FibGUscGFzc1N0eWxlT2YsZ2V0Q29weU1hcEVudHJpZXMsbXVzdE1hdGNoLGFzc2VydFBhdHRlcm4saXNDb3B5TWFwOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaOKAjV9hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wYXR0ZXJuc1wiLCBbW1wiZ2V0Q29weU1hcEVudHJpZXNcIiwgWyRo4oCNX2EgPT4gKGdldENvcHlNYXBFbnRyaWVzID0gJGjigI1fYSldXSxbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UGF0dGVyblwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGF0dGVybiA9ICRo4oCNX2EpXV1dXSxbXCIuL3N0b3JlLXV0aWxzLmpzXCIsIFtbXCJpc0NvcHlNYXBcIiwgWyRo4oCNX2EgPT4gKGlzQ29weU1hcCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3R7cXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5cbi8qKlxuICogQHRlbXBsYXRlIEssVlxuICogQHBhcmFtIHtXZWFrTWFwPEsgJiBvYmplY3QsIFY+fSBqc21hcFxuICogQHBhcmFtIHsoazogSywgdjogVikgPT4gdm9pZH0gYXNzZXJ0S1ZPa1RvQWRkXG4gKiBAcGFyYW0geyhrOiBLLCB2OiBWKSA9PiB2b2lkfSBhc3NlcnRLVk9rVG9TZXRcbiAqIEBwYXJhbSB7KGs6IEspID0+IHZvaWR9IFthc3NlcnRLZXlPa1RvRGVsZXRlXVxuICogQHBhcmFtIHtzdHJpbmd9IFtrZXlOYW1lXVxuICogQHJldHVybnMge1dlYWtNYXBTdG9yZTxLLFY+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVdlYWtNYXBTdG9yZU1ldGhvZHM9KFxuanNtYXAsXG5hc3NlcnRLVk9rVG9BZGQsXG5hc3NlcnRLVk9rVG9TZXQsXG5hc3NlcnRLZXlPa1RvRGVsZXRlPXVuZGVmaW5lZCxcbmtleU5hbWU9J2tleScpPT5cbntcbmNvbnN0IGFzc2VydEtleURvZXNOb3RFeGlzdD0oa2V5KT0+XG4hanNtYXAuaGFzKGtleSl8fEZhaWwgYCR7cShrZXlOYW1lKX0gYWxyZWFkeSByZWdpc3RlcmVkOiAke2tleX1gO1xuXG5jb25zdCBhc3NlcnRLZXlFeGlzdHM9KGtleSk9PlxuanNtYXAuaGFzKGtleSl8fEZhaWwgYCR7cShrZXlOYW1lKX0gbm90IGZvdW5kOiAke2tleX1gO1xuXG5yZXR1cm4gaGFyZGVuKHtcbmhhczooa2V5KT0+e1xuLyogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzLiBUaGUga2V5IGNhbiBiZSBhbnkgSmF2YVNjcmlwdCB2YWx1ZSwqL1xuLyogdGhvdWdoIHRoZSBhbnN3ZXIgd2lsbCBhbHdheXMgYmUgZmFsc2UgZm9yIGtleXMgdGhhdCBjYW5ub3QgYmUgZm91bmQqL1xuLyogaW4gdGhpcyBtYXAuKi9cbnJldHVybiBqc21hcC5oYXMoa2V5KTtcbiB9LFxuZ2V0OihrZXkpPT57XG5hc3NlcnRLZXlFeGlzdHMoa2V5KTtcbi8qIEhvdyB0byB0ZWxsIHR5cGVzY3JpcHQgSSBiZWxpZXZlIHRoZSBgZ2V0YCB3aWxsIHN1Y2NlZWQuKi9cbnJldHVybiAoLyoqIEB0eXBlIHtWfSAqL2pzbWFwLmdldChrZXkpKTtcbiB9LFxuXG5pbml0OihrZXksdmFsdWUpPT57XG5hc3NlcnRLZXlEb2VzTm90RXhpc3Qoa2V5KTtcbmFzc2VydEtWT2tUb0FkZChrZXksdmFsdWUpO1xuanNtYXAuc2V0KGtleSx2YWx1ZSk7XG4gfSxcbnNldDooa2V5LHZhbHVlKT0+e1xuYXNzZXJ0S2V5RXhpc3RzKGtleSk7XG5hc3NlcnRLVk9rVG9TZXQoa2V5LHZhbHVlKTtcbmpzbWFwLnNldChrZXksdmFsdWUpO1xuIH0sXG5kZWxldGU6KGtleSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xuaWYoYXNzZXJ0S2V5T2tUb0RlbGV0ZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnRLZXlPa1RvRGVsZXRlKGtleSk7XG4gfVxuanNtYXAuZGVsZXRlKGtleSk7XG4gfSxcblxuYWRkQWxsOihlbnRyaWVzKT0+e1xuaWYoaXNDb3B5TWFwKGVudHJpZXMpKXtcbmVudHJpZXM9Z2V0Q29weU1hcEVudHJpZXMoZW50cmllcyk7XG4gfVxuZm9yKGNvbnN0W2tleSx2YWx1ZV1vZi8qKiBAdHlwZSB7SXRlcmFibGU8W0ssIFZdPn0gKi9lbnRyaWVzKXtcbi8qIERvbid0IGFzc2VydCB0aGF0IHRoZSBrZXkgZWl0aGVyIGRvZXMgb3IgZG9lcyBub3QgZXhpc3QuKi9cbmFzc2VydEtWT2tUb0FkZChrZXksdmFsdWUpO1xuanNtYXAuc2V0KGtleSx2YWx1ZSk7XG4gfVxuIH19KTtcblxuIH07XG5cbi8qKlxuICogVGhpcyBpcyBhICpzY2FsYXIqIG1hcFN0b3JlIGluIHRoYXQgdGhlIGtleXMgY2FuIG9ubHkgYmUgYXRvbWljIHZhbHVlczpcbiAqIHByaW1pdGl2ZXMgb3IgcmVtb3RhYmxlcy5cbiAqIE90aGVyIG1hcFN0b3JlcyB3aWxsIGFjY2VwdCwgZm9yIGV4YW1wbGUsIGNvcHlBcnJheXMgYW5kXG4gKiBjb3B5UmVjb3JkcyBhcyBrZXlzIGFuZCBsb29rIHRoZW0gdXAgYmFzZWQgb24gZXF1YWxpdHkgb2YgdGhlaXIgY29udGVudHMuXG4gKlxuICogVE9ETyBGb3Igbm93LCB0aGlzIHNjYWxhcldlYWtNYXAgYWNjZXB0cyBvbmx5IHJlbW90YWJsZXMsIHJlZmxlY3RpbmcgdGhlXG4gKiBjb25zdHJhaW50cyBvZiB0aGUgdW5kZXJseWluZyBKYXZhU2NyaXB0IFdlYWtNYXAgaXQgdXNlcyBpbnRlcm5hbGx5LiBCdXRcbiAqIGl0IHNob3VsZCBhY2NlcHQgdGhlIHByaW1pdGl2ZXMgYXMgd2VsbCwgc3RvcmluZyB0aGVtIGluIGEgc2VwYXJhdGUgaW50ZXJuYWxcbiAqIG1hcC4gV2hhdCBtYWtlcyBpdCBcIndlYWtcIiBpcyB0aGF0IGl0IHByb3ZpZGVzIG5vIEFQSSBmb3IgZW51bWVyYXRpbmcgd2hhdCdzXG4gKiB0aGVyZS4gVGhvdWdoIG5vdGUgdGhhdCB0aGlzIHdvdWxkIG9ubHkgZW5hYmxlcyBjb2xsZWN0aW9uIG9mIHRoZVxuICogcmVtb3RhYmxlcywgc2luY2UgdGhlIG90aGVyIHByaW1pdGl2ZXMgbWF5IGFsd2F5cyByZWFwcGVhci5cbiAqXG4gKiBAdGVtcGxhdGUgSyxWXG4gKiBAcGFyYW0ge3N0cmluZ30gW3RhZz0na2V5J10gLSB0YWcgZm9yIGRlYnVnZ2luZ1xuICogQHBhcmFtIHtTdG9yZU9wdGlvbnN9IFtvcHRpb25zXVxuICogQHJldHVybnMge1dlYWtNYXBTdG9yZTxLLFY+fVxuICovJGjigI1fb25jZS5tYWtlV2Vha01hcFN0b3JlTWV0aG9kcyhtYWtlV2Vha01hcFN0b3JlTWV0aG9kcyk7XG5jb25zdCAgICAgICAgbWFrZVNjYWxhcldlYWtNYXBTdG9yZT0oXG50YWc9J2tleScsXG57bG9uZ0xpdmVkPXRydWUsa2V5U2hhcGU9dW5kZWZpbmVkLHZhbHVlU2hhcGU9dW5kZWZpbmVkfT17fSk9Plxue1xuY29uc3QganNtYXA9bmV3KGxvbmdMaXZlZD9XZWFrTWFwOk1hcCkoKTtcbmlmKGtleVNoYXBlIT09dW5kZWZpbmVkKXtcbmFzc2VydFBhdHRlcm4oa2V5U2hhcGUpO1xuIH1cbmlmKHZhbHVlU2hhcGUhPT11bmRlZmluZWQpe1xuYXNzZXJ0UGF0dGVybih2YWx1ZVNoYXBlKTtcbiB9XG5cbmNvbnN0IGFzc2VydEtWT2tUb1NldD0oX2tleSx2YWx1ZSk9Pntcbi8qIFRPRE86IEp1c3QgYSB0cmFuc2l0aW9uIGtsdWRnZS4gUmVtb3ZlIHdoZW4gcG9zc2libGUuKi9cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzM2MDYqL1xuaGFyZGVuKHZhbHVlKTtcblxuYXNzZXJ0UGFzc2FibGUodmFsdWUpO1xuaWYodmFsdWVTaGFwZSE9PXVuZGVmaW5lZCl7XG5tdXN0TWF0Y2godmFsdWUsdmFsdWVTaGFwZSwnd2Vha01hcFN0b3JlIHZhbHVlJyk7XG4gfVxuIH07XG5cbmNvbnN0IGFzc2VydEtWT2tUb0FkZD0oa2V5LHZhbHVlKT0+e1xuLyogVE9ETzogSnVzdCBhIHRyYW5zaXRpb24ga2x1ZGdlLiBSZW1vdmUgd2hlbiBwb3NzaWJsZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvMzYwNiovXG5oYXJkZW4oa2V5KTtcbnBhc3NTdHlsZU9mKGtleSk9PT0ncmVtb3RhYmxlJ3x8XG5GYWlsIGBPbmx5IHJlbW90YWJsZXMgY2FuIGJlIGtleXMgb2Ygc2NhbGFyIFdlYWtNYXBTdG9yZXM6ICR7a2V5fWA7XG5pZihrZXlTaGFwZSE9PXVuZGVmaW5lZCl7XG5tdXN0TWF0Y2goa2V5LGtleVNoYXBlLCd3ZWFrTWFwU3RvcmUga2V5Jyk7XG4gfVxuYXNzZXJ0S1ZPa1RvU2V0KGtleSx2YWx1ZSk7XG4gfTtcblxucmV0dXJuIEZhciggYHNjYWxhciBXZWFrTWFwU3RvcmUgb2YgJHtxKHRhZyl9YCx7XG4uLi5tYWtlV2Vha01hcFN0b3JlTWV0aG9kcyhcbmpzbWFwLFxuYXNzZXJ0S1ZPa1RvQWRkLFxuYXNzZXJ0S1ZPa1RvU2V0LFxudW5kZWZpbmVkLFxudGFnKX0pO1xuXG5cbiB9OyRo4oCNX29uY2UubWFrZVNjYWxhcldlYWtNYXBTdG9yZShtYWtlU2NhbGFyV2Vha01hcFN0b3JlKTtcbmhhcmRlbihtYWtlU2NhbGFyV2Vha01hcFN0b3JlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlV2Vha01hcFN0b3JlTWV0aG9kcyI6WyJtYWtlV2Vha01hcFN0b3JlTWV0aG9kcyJdLCJtYWtlU2NhbGFyV2Vha01hcFN0b3JlIjpbIm1ha2VTY2FsYXJXZWFrTWFwU3RvcmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAbaw/vYQOAACEDgAAOwAAAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy9zdG9yZXMvc2NhbGFyV2Vha1NldFN0b3JlLmpzeyJpbXBvcnRzIjpbIi4vc3RvcmUtdXRpbHMuanMiLCJAZW5kby9wYXNzLXN0eWxlIiwiQGVuZG8vcGF0dGVybnMiXSwiZXhwb3J0cyI6WyJtYWtlU2NhbGFyV2Vha1NldFN0b3JlIiwibWFrZVdlYWtTZXRTdG9yZU1ldGhvZHMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRmFyLHBhc3NTdHlsZU9mLGdldENvcHlTZXRLZXlzLG11c3RNYXRjaCxhc3NlcnRQYXR0ZXJuLGlzQ29weVNldDskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3BhdHRlcm5zXCIsIFtbXCJnZXRDb3B5U2V0S2V5c1wiLCBbJGjigI1fYSA9PiAoZ2V0Q29weVNldEtleXMgPSAkaOKAjV9hKV1dLFtcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJhc3NlcnRQYXR0ZXJuXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXR0ZXJuID0gJGjigI1fYSldXV1dLFtcIi4vc3RvcmUtdXRpbHMuanNcIiwgW1tcImlzQ29weVNldFwiLCBbJGjigI1fYSA9PiAoaXNDb3B5U2V0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuLyoqXG4gKiBAdGVtcGxhdGUgS1xuICogQHBhcmFtIHtXZWFrU2V0PEsgJiBvYmplY3Q+fSBqc3NldFxuICogQHBhcmFtIHsoazogSykgPT4gdm9pZH0gYXNzZXJ0S2V5T2tUb0FkZFxuICogQHBhcmFtIHsoazogSykgPT4gdm9pZH0gW2Fzc2VydEtleU9rVG9EZWxldGVdXG4gKiBAcGFyYW0ge3N0cmluZ30gW2tleU5hbWVdXG4gKiBAcmV0dXJucyB7V2Vha1NldFN0b3JlPEs+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVdlYWtTZXRTdG9yZU1ldGhvZHM9KFxuanNzZXQsXG5hc3NlcnRLZXlPa1RvQWRkLFxuYXNzZXJ0S2V5T2tUb0RlbGV0ZT11bmRlZmluZWQsXG5rZXlOYW1lPSdrZXknKT0+XG57XG5jb25zdCBhc3NlcnRLZXlFeGlzdHM9KGtleSk9PlxuanNzZXQuaGFzKGtleSl8fEZhaWwgYCR7cShrZXlOYW1lKX0gbm90IGZvdW5kOiAke2tleX1gO1xuXG5yZXR1cm4gaGFyZGVuKHtcbmhhczooa2V5KT0+e1xuLyogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzLiBUaGUga2V5IGNhbiBiZSBhbnkgSmF2YVNjcmlwdCB2YWx1ZSwqL1xuLyogdGhvdWdoIHRoZSBhbnN3ZXIgd2lsbCBhbHdheXMgYmUgZmFsc2UgZm9yIGtleXMgdGhhdCBjYW5ub3QgYmUgZm91bmQqL1xuLyogaW4gdGhpcyBzZXQuKi9cbnJldHVybiBqc3NldC5oYXMoa2V5KTtcbiB9LFxuXG5hZGQ6KGtleSk9PntcbmFzc2VydEtleU9rVG9BZGQoa2V5KTtcbmpzc2V0LmFkZChrZXkpO1xuIH0sXG5kZWxldGU6KGtleSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xuaWYoYXNzZXJ0S2V5T2tUb0RlbGV0ZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnRLZXlPa1RvRGVsZXRlKGtleSk7XG4gfVxuanNzZXQuZGVsZXRlKGtleSk7XG4gfSxcblxuYWRkQWxsOihrZXlzKT0+e1xuaWYoaXNDb3B5U2V0KGtleXMpKXtcbmtleXM9Z2V0Q29weVNldEtleXMoa2V5cyk7XG4gfVxuZm9yKGNvbnN0IGtleSBvZi8qKiBAdHlwZSB7SXRlcmFibGU8Sz59ICova2V5cyl7XG5hc3NlcnRLZXlPa1RvQWRkKGtleSk7XG5qc3NldC5hZGQoa2V5KTtcbiB9XG4gfX0pO1xuXG4gfTtcblxuLyoqXG4gKiBUaGlzIGlzIGEgKnNjYWxhciogc2V0IGluIHRoYXQgdGhlIGtleXMgY2FuIG9ubHkgYmUgYXRvbWljIHZhbHVlcywgcHJpbWl0aXZlc1xuICogb3IgcmVtb3RhYmxlcy4gT3RoZXIgc3RvcmVTZXRzIHdpbGwgYWNjZXB0LCBmb3IgZXhhbXBsZSwgY29weUFycmF5cyBhbmRcbiAqIGNvcHlSZWNvcmRzLCBhcyBrZXlzIGFuZCBsb29rIHRoZW0gdXAgYmFzZWQgb24gZXF1YWxpdHkgb2YgdGhlaXIgY29udGVudHMuXG4gKlxuICogVE9ETyBGb3Igbm93LCB0aGlzIHNjYWxhcldlYWtTZXQgYWNjZXB0cyBvbmx5IHJlbW90YWJsZXMsIHJlZmxlY3RpbmcgdGhlXG4gKiBjb25zdHJhaW50cyBvZiB0aGUgdW5kZXJseWluZyBKYXZhU2NyaXB0IFdlYWtTZXQgaXQgdXNlcyBpbnRlcm5hbGx5LiBCdXRcbiAqIGl0IHNob3VsZCBhY2NlcHQgdGhlIHByaW1pdGl2ZXMgYXMgd2VsbCwgc3RvcmluZyB0aGVtIGluIGEgc2VwYXJhdGUgaW50ZXJuYWxcbiAqIHNldC4gV2hhdCBtYWtlcyBpdCBcIndlYWtcIiBpcyB0aGF0IGl0IHByb3ZpZGVzIG5vIEFQSSBmb3IgZW51bWVyYXRpbmcgd2hhdCdzXG4gKiB0aGVyZS4gVGhvdWdoIG5vdGUgdGhhdCB0aGlzIHdvdWxkIG9ubHkgZW5hYmxlcyBjb2xsZWN0aW9uIG9mIHRoZVxuICogcmVtb3RhYmxlcywgc2luY2UgdGhlIG90aGVyIHByaW1pdGl2ZXMgbWF5IGFsd2F5cyBhcHBlYXIuXG4gKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7c3RyaW5nfSBbdGFnPSdrZXknXSAtIHRhZyBmb3IgZGVidWdnaW5nXG4gKiBAcGFyYW0ge1N0b3JlT3B0aW9uc30gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7V2Vha1NldFN0b3JlPEs+fVxuICovJGjigI1fb25jZS5tYWtlV2Vha1NldFN0b3JlTWV0aG9kcyhtYWtlV2Vha1NldFN0b3JlTWV0aG9kcyk7XG5jb25zdCAgICAgICAgbWFrZVNjYWxhcldlYWtTZXRTdG9yZT0oXG50YWc9J2tleScsXG57bG9uZ0xpdmVkPXRydWUsa2V5U2hhcGU9dW5kZWZpbmVkfT17fSk9Plxue1xuY29uc3QganNzZXQ9bmV3KGxvbmdMaXZlZD9XZWFrU2V0OlNldCkoKTtcbmlmKGtleVNoYXBlIT09dW5kZWZpbmVkKXtcbmFzc2VydFBhdHRlcm4oa2V5U2hhcGUpO1xuIH1cblxuY29uc3QgYXNzZXJ0S2V5T2tUb0FkZD0oa2V5KT0+e1xuLyogVE9ETzogSnVzdCBhIHRyYW5zaXRpb24ga2x1ZGdlLiBSZW1vdmUgd2hlbiBwb3NzaWJsZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvMzYwNiovXG5oYXJkZW4oa2V5KTtcbnBhc3NTdHlsZU9mKGtleSk9PT0ncmVtb3RhYmxlJ3x8XG5GYWlsIGBPbmx5IHJlbW90YWJsZXMgY2FuIGJlIGtleXMgb2Ygc2NhbGFyIFdlYWtTdG9yZXM6ICR7a2V5fWA7XG5pZihrZXlTaGFwZSE9PXVuZGVmaW5lZCl7XG5tdXN0TWF0Y2goa2V5LGtleVNoYXBlLCd3ZWFrU2V0U3RvcmUga2V5Jyk7XG4gfVxuIH07XG5cbnJldHVybiBGYXIoIGBzY2FsYXIgV2Vha1NldFN0b3JlIG9mICR7cSh0YWcpfWAse1xuLi4ubWFrZVdlYWtTZXRTdG9yZU1ldGhvZHMoanNzZXQsYXNzZXJ0S2V5T2tUb0FkZCx1bmRlZmluZWQsdGFnKX0pO1xuXG4gfTskaOKAjV9vbmNlLm1ha2VTY2FsYXJXZWFrU2V0U3RvcmUobWFrZVNjYWxhcldlYWtTZXRTdG9yZSk7XG5oYXJkZW4obWFrZVNjYWxhcldlYWtTZXRTdG9yZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVdlYWtTZXRTdG9yZU1ldGhvZHMiOlsibWFrZVdlYWtTZXRTdG9yZU1ldGhvZHMiXSwibWFrZVNjYWxhcldlYWtTZXRTdG9yZSI6WyJtYWtlU2NhbGFyV2Vha1NldFN0b3JlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAALLXYwidGQAAnRkAADQAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3N0b3JlLXV0aWxzLmpzeyJpbXBvcnRzIjpbIkBlbmRvL21hcnNoYWwiLCJAZW5kby9wYXR0ZXJucyJdLCJleHBvcnRzIjpbImFwcGVuZFRvU3RvcmVkQXJyYXkiLCJpc0NvcHlNYXAiLCJpc0NvcHlTZXQiLCJtYWtlQXRvbWljUHJvdmlkZXIiLCJtYWtlQ3VycmVudEtleXNLaXQiLCJwcm92aWRlTGF6eSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYXIsTSxtYXRjaGVzOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL21hcnNoYWxcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3BhdHRlcm5zXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJtYXRjaGVzXCIsIFskaOKAjV9hID0+IChtYXRjaGVzID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5cbi8qKlxuICogU2hvdWxkIGJlaGF2ZSBpZGVudGljYWxseSB0byB0aGUgb25lIGluIGBAZW5kby9wYXR0ZXJuc2AsIGJ1dFxuICogcmVpbXBsZW1lbnRlZCBmb3Igbm93IGJlY2F1c2UgYEBlbmRvL3BhdHRlcm5zYCBmb3Jnb3QgdG8gZXhwb3J0IHRoaXMgb25lLlxuICogVGhpcyBvbmUgaXMgc2ltcGxlIGVub3VnaCB0aGF0IEkgcHJlZmVyIGEgcmVpbXBsZW1lbnRhdGlvbiB0byBhIGRlZXAgaW1wb3J0LlxuICogVE9ETzogVW5kYXRlIGBAZW5kby9wYXR0ZXJuc2AgdG8gZXhwb3J0IHRoZSBvcmlnaW5hbCwgYW5kIGRlbGV0ZSB0aGVcbiAqIHJlaW1wbGVtZW50YXRpb24gaGVyZS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBzXG4gKiBAcmV0dXJucyB7cyBpcyBDb3B5U2V0fVxuICovXG5jb25zdCAgICAgICAgaXNDb3B5U2V0PShzKT0+bWF0Y2hlcyhzLE0uc2V0KCkpO1xuXG4vKipcbiAqIFNob3VsZCBiZWhhdmUgaWRlbnRpY2FsbHkgdG8gdGhlIG9uZSBpbiBgQGVuZG8vcGF0dGVybnNgLCBidXRcbiAqIHJlaW1wbGVtZW50ZWQgZm9yIG5vdyBiZWNhdXNlIGBAZW5kby9wYXR0ZXJuc2AgZm9yZ290IHRvIGV4cG9ydCB0aGlzIG9uZS5cbiAqIFRoaXMgb25lIGlzIHNpbXBsZSBlbm91Z2ggdGhhdCBJIHByZWZlciBhIHJlaW1wbGVtZW50YXRpb24gdG8gYSBkZWVwIGltcG9ydC5cbiAqIFRPRE86IFVuZGF0ZSBgQGVuZG8vcGF0dGVybnNgIHRvIGV4cG9ydCB0aGUgb3JpZ2luYWwsIGFuZCBkZWxldGUgdGhlXG4gKiByZWltcGxlbWVudGF0aW9uIGhlcmUuXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gbVxuICogQHJldHVybnMge20gaXMgQ29weU1hcH1cbiAqLyRo4oCNX29uY2UuaXNDb3B5U2V0KGlzQ29weVNldCk7XG5jb25zdCAgICAgICAgaXNDb3B5TWFwPShtKT0+bWF0Y2hlcyhtLE0ubWFwKCkpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEN1cnJlbnRLZXlzS2l0XG4gKiBAcHJvcGVydHkgeyhrOiBLLCB2PzogVikgPT4gdm9pZH0gYXNzZXJ0VXBkYXRlT25BZGRcbiAqIEBwcm9wZXJ0eSB7KGs6IEspID0+IHZvaWR9IGFzc2VydFVwZGF0ZU9uRGVsZXRlXG4gKiBAcHJvcGVydHkge0l0ZXJhYmxlPEs+fSBpdGVyYWJsZUtleXNcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEBwYXJhbSB7KCkgPT4gSXRlcmFibGU8Sz59IGdldFJhd0tleXNcbiAqIEBwYXJhbSB7KGs6IEspID0+IGJvb2xlYW59IGNoZWNrSGFzXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0geyhrOiBLLCB2PzogVikgPT4gdm9pZH0gYXNzZXJ0T2tUb0FkZFxuICogQHBhcmFtIHsoazogSykgPT4gdm9pZH0gW2Fzc2VydE9rVG9EZWxldGVdXG4gKiBAcGFyYW0ge3N0cmluZ30gW2tleU5hbWVdXG4gKiBAcmV0dXJucyB7Q3VycmVudEtleXNLaXQ8SyxWPn1cbiAqLyRo4oCNX29uY2UuaXNDb3B5TWFwKGlzQ29weU1hcCk7XG5jb25zdCAgICAgICAgbWFrZUN1cnJlbnRLZXlzS2l0PShcbmdldFJhd0tleXMsXG5jaGVja0hhcyxcbmNvbXBhcmUsXG5hc3NlcnRPa1RvQWRkLFxuYXNzZXJ0T2tUb0RlbGV0ZT11bmRlZmluZWQsXG5rZXlOYW1lPSdrZXknKT0+XG57XG5sZXQgdXBkYXRlQ291bnQ9MDtcbmxldCBzb3J0ZWRLZXlzTWVtbztcblxuY29uc3QgYXNzZXJ0VXBkYXRlT25BZGQ9KGssdj11bmRlZmluZWQpPT57XG5hc3NlcnRPa1RvQWRkKGssdik7XG51cGRhdGVDb3VudCs9MTtcbnNvcnRlZEtleXNNZW1vPXVuZGVmaW5lZDtcbiB9O1xuXG5jb25zdCBhc3NlcnRVcGRhdGVPbkRlbGV0ZT0oayk9PmFzc2VydE9rVG9EZWxldGUmJmFzc2VydE9rVG9EZWxldGUoayk7XG5cbmNvbnN0IGdldFNvcnRlZEtleXM9KCk9PntcbmlmKHNvcnRlZEtleXNNZW1vPT09dW5kZWZpbmVkKXtcbnNvcnRlZEtleXNNZW1vPWhhcmRlbihbLi4uZ2V0UmF3S2V5cygpXS5zb3J0KGNvbXBhcmUpKTtcbiB9XG5yZXR1cm4gc29ydGVkS2V5c01lbW87XG4gfTtcblxuY29uc3QgaXRlcmFibGVLZXlzPUZhcignSXRlcmFibGUgb2Yga2V5cycse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGdlbmVyYXRpb249dXBkYXRlQ291bnQ7XG5nZXRTb3J0ZWRLZXlzKCk7XG5jb25zdCBsZW49c29ydGVkS2V5c01lbW8ubGVuZ3RoO1xubGV0IGk9MDtcbnJldHVybiBGYXIoJ0l0ZXJhdG9yIG9mIGtleXMnLHtcbm5leHQ6KCk9PntcbmdlbmVyYXRpb249PT11cGRhdGVDb3VudHx8RmFpbCBgU3RvcmUgJHtxKGtleU5hbWUpfSBjdXJzb3Igc3RhbGVgO1xuLyogSWYgdGhleSdyZSBlcXVhbCwgdGhlbiB0aGUgc29ydGVkS2V5TWVtbyBpcyB0aGUgc2FtZSBvbmUqL1xuLyogd2Ugc3RhcnRlZCB3aXRoLiovXG5mb3IoOzspe1xuaWYoaTxsZW4pe1xuY29uc3QgdmFsdWU9c29ydGVkS2V5c01lbW9baV07XG5pKz0xO1xuaWYoY2hlY2tIYXModmFsdWUpKXtcbnJldHVybiBoYXJkZW4oe2RvbmU6ZmFsc2UsdmFsdWV9KTtcbiB9XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHtkb25lOnRydWUsdmFsdWU6dW5kZWZpbmVkfSk7XG4gfVxuIH1cbiB9fSk7XG5cbiB9fSk7XG5cblxucmV0dXJuIGhhcmRlbih7XG5hc3NlcnRVcGRhdGVPbkFkZCxcbmFzc2VydFVwZGF0ZU9uRGVsZXRlLFxuaXRlcmFibGVLZXlzfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZUN1cnJlbnRLZXlzS2l0KG1ha2VDdXJyZW50S2V5c0tpdCk7XG5oYXJkZW4obWFrZUN1cnJlbnRLZXlzS2l0KTtcblxuLyoqXG4gKiBDYWxsIGBwcm92aWRlTGF6eWAgdG8gZ2V0IG9yIG1ha2UgdGhlIHZhbHVlIGFzc29jaWF0ZWQgd2l0aCB0aGUga2V5LlxuICogSWYgdGhlcmUgYWxyZWFkeSBpcyBvbmUsIHJldHVybiB0aGF0LiBPdGhlcndpc2UsXG4gKiBjYWxsIGBtYWtlVmFsdWUoa2V5KWAsIHJlbWVtYmVyIGl0IGFzIHRoZSB2YWx1ZSBmb3JcbiAqIHRoYXQga2V5LCBhbmQgcmV0dXJuIGl0LlxuICpcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEBwYXJhbSB7V2Vha01hcFN0b3JlPEssVj59IG1hcFN0b3JlXG4gKiBAcGFyYW0ge0t9IGtleVxuICogQHBhcmFtIHsoa2V5OiBLKSA9PiBWfSBtYWtlVmFsdWVcbiAqIEByZXR1cm5zIHtWfVxuICovXG5jb25zdCAgICAgICAgcHJvdmlkZUxhenk9KG1hcFN0b3JlLGtleSxtYWtlVmFsdWUpPT57XG5pZighbWFwU3RvcmUuaGFzKGtleSkpe1xubWFwU3RvcmUuaW5pdChrZXksbWFrZVZhbHVlKGtleSkpO1xuIH1cbnJldHVybiBtYXBTdG9yZS5nZXQoa2V5KTtcbiB9OyRo4oCNX29uY2UucHJvdmlkZUxhenkocHJvdmlkZUxhenkpO1xuaGFyZGVuKHByb3ZpZGVMYXp5KTtcblxuLyoqXG4gKiBIZWxwZXIgZm9yIHVzZSBjYXNlcyBpbiB3aGljaCB0aGUgbWFrZXIgZnVuY3Rpb24gaXMgYXN5bmMuXG4gKiBGb3IgdHdvIHByb3ZpZGVMYXp5IGNhbGxzIHdpdGggdGhlIHNhbWUga2V5LCBvbmUgbWF5IGJlIG1ha2luZyB3aGVuIHRoZVxuICogb3RoZXIgY2FsbCBzdGFydHMgYW5kIGl0IHdvdWxkIG1ha2UgYWdhaW4uXG4gKiAoVGhlbiB0aGVyZSdkIGJlIGEgY29sbGlzaW9uIHdoZW4gdGhlIHNlY29uZCB0cmllcyB0byBzdG9yZVxuICogdGhlIGtleS4pIFRoaXMgcHJldmVudHMgdGhhdCByYWNlIGNvbmRpdGlvbiBieSBpbW1lZGlhdGVseSBzdG9yaW5nIGEgUHJvbWlzZVxuICogZm9yIHRoZSBtYWtlciBpbiBhbiBlcGhlbWVyYWwgc3RvcmUuXG4gKlxuICogV2hlbiB0aGUgYHN0b3JlYCBhcmd1bWVudCBpcyBkdXJhYmxlIHN0b3JhZ2UsIG5vdGUgdGhhdCBpdCdzIHBvc3NpYmxlIGZvclxuICogdGVybWluYXRpb24gdG8gaGFwcGVuIGFmdGVyIHRoZSBtYWtlIGNvbXBsZXRlcyBhbmQgYmVmb3JlIGl0IHJlYWNoZXMgZHVyYWJsZVxuICogc3RvcmFnZS5cbiAqXG4gKiBAdGVtcGxhdGUgS1xuICogQHRlbXBsYXRlIFZcbiAqIEBwYXJhbSB7V2Vha01hcFN0b3JlPEssIFY+fSBzdG9yZVxuICovXG5jb25zdCAgICAgICAgbWFrZUF0b21pY1Byb3ZpZGVyPShzdG9yZSk9Pntcbi8qKiBAdHlwZSB7TWFwPEssIFByb21pc2U8Vj4+fSAqL1xuY29uc3QgcGVuZGluZz1uZXcgTWFwKCk7XG5cbi8qKlxuICogQ2FsbCBgcHJvdmlkZUFzeW5jYCB0byBnZXQgb3IgbWFrZSB0aGUgdmFsdWUgYXNzb2NpYXRlZCB3aXRoIHRoZSBrZXksXG4gKiB3aGVuIHRoZSBtYWtlciBpcyBhc3luY2hyb25vdXMuXG4gKiBJZiB0aGVyZSBhbHJlYWR5IGlzIG9uZSwgcmV0dXJuIHRoYXQuIE90aGVyd2lzZSxcbiAqIGNhbGwgYG1ha2VWYWx1ZShrZXkpYCwgcmVtZW1iZXIgaXQgYXMgdGhlIHZhbHVlIGZvclxuICogdGhhdCBrZXksIGFuZCByZXR1cm4gaXQuXG4gKlxuICogQHBhcmFtIHtLfSBrZXlcbiAqIEBwYXJhbSB7KGtleTogSykgPT4gUHJvbWlzZTxWPn0gbWFrZVZhbHVlIG1ha2UgdGhlIHZhbHVlIGZvciB0aGUgc3RvcmVcbiAqIGlmIGl0IGhhc24ndCBiZWVuIG1hZGUgeWV0IG9yIHRoZSBsYXN0IG1ha2UgZmFpbGVkXG4gKiBAcGFyYW0geyhrZXk6IEssIHZhbHVlOiBWKSA9PiBQcm9taXNlPHZvaWQ+fSBbZmluaXNoVmFsdWVdIHJ1bnMgZXhhY3RseVxuICogb25jZSBhZnRlciBhIG5ldyB2YWx1ZSBpcyBhZGRlZCB0byB0aGUgc3RvcmVcbiAqIEByZXR1cm5zIHtQcm9taXNlPFY+fVxuICovXG5jb25zdCBwcm92aWRlQXN5bmM9KGtleSxtYWtlVmFsdWUsZmluaXNoVmFsdWUpPT57XG5pZihzdG9yZS5oYXMoa2V5KSl7XG5yZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHN0b3JlLmdldChrZXkpKTtcbiB9XG5pZighcGVuZGluZy5oYXMoa2V5KSl7XG5jb25zdCB2YWxQPW1ha2VWYWx1ZShrZXkpLlxudGhlbigodik9PntcbnN0b3JlLmluaXQoa2V5LHYpO1xucmV0dXJuIHY7XG4gfSkuXG50aGVuKCh2KT0+e1xuaWYoZmluaXNoVmFsdWUpe1xucmV0dXJuIGZpbmlzaFZhbHVlKGtleSx2KS50aGVuKCgpPT52KTtcbiB9XG5yZXR1cm4gdjtcbiB9KS5cbmZpbmFsbHkoKCk9PntcbnBlbmRpbmcuZGVsZXRlKGtleSk7XG4gfSk7XG5wZW5kaW5nLnNldChrZXksdmFsUCk7XG4gfVxuY29uc3QgdmFsUD1wZW5kaW5nLmdldChrZXkpO1xuYXNzZXJ0KHZhbFApO1xucmV0dXJuIHZhbFA7XG4gfTtcblxucmV0dXJuIGhhcmRlbih7cHJvdmlkZUFzeW5jfSk7XG4gfTskaOKAjV9vbmNlLm1ha2VBdG9taWNQcm92aWRlcihtYWtlQXRvbWljUHJvdmlkZXIpO1xuaGFyZGVuKG1ha2VBdG9taWNQcm92aWRlcik7XG4vKipcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAdGVtcGxhdGUgVlxuICogQHR5cGVkZWYge1JldHVyblR5cGU8dHlwZW9mIG1ha2VBdG9taWNQcm92aWRlcjxLLCBWPj59IEF0b21pY1Byb3ZpZGVyPEssIFY+XG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgSywgVlxuICogQHBhcmFtIHtNYXBTdG9yZTxLLCBWW10+fSBtYXBTdG9yZVxuICogQHBhcmFtIHtLfSBrZXlcbiAqIEBwYXJhbSB7Vn0gaXRlbVxuICovXG5jb25zdCAgICAgICAgYXBwZW5kVG9TdG9yZWRBcnJheT0obWFwU3RvcmUsa2V5LGl0ZW0pPT57XG5pZihtYXBTdG9yZS5oYXMoa2V5KSl7XG5jb25zdCBleHRhbnQ9bWFwU3RvcmUuZ2V0KGtleSk7XG5tYXBTdG9yZS5zZXQoa2V5LGhhcmRlbihbLi4uZXh0YW50LGl0ZW1dKSk7XG4gfWVsc2V7XG5tYXBTdG9yZS5pbml0KGtleSxoYXJkZW4oW2l0ZW1dKSk7XG4gfVxuIH07JGjigI1fb25jZS5hcHBlbmRUb1N0b3JlZEFycmF5KGFwcGVuZFRvU3RvcmVkQXJyYXkpO1xuaGFyZGVuKGFwcGVuZFRvU3RvcmVkQXJyYXkpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzQ29weVNldCI6WyJpc0NvcHlTZXQiXSwiaXNDb3B5TWFwIjpbImlzQ29weU1hcCJdLCJtYWtlQ3VycmVudEtleXNLaXQiOlsibWFrZUN1cnJlbnRLZXlzS2l0Il0sInByb3ZpZGVMYXp5IjpbInByb3ZpZGVMYXp5Il0sIm1ha2VBdG9taWNQcm92aWRlciI6WyJtYWtlQXRvbWljUHJvdmlkZXIiXSwiYXBwZW5kVG9TdG9yZWRBcnJheSI6WyJhcHBlbmRUb1N0b3JlZEFycmF5Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMUArIJYKgAAWCoAACcAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5Db3B5VGFnZ2VkfSBDb3B5VGFnZ2VkICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5Db3B5UmVjb3JkPFQ+fSBDb3B5UmVjb3JkICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5Db3B5QXJyYXk8VD59IENvcHlBcnJheSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsL3NyYy9yYW5rT3JkZXInKS5SYW5rQ29tcGFyZX0gUmFua0NvbXBhcmUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbC9zcmMvcmFua09yZGVyJykuUmFua0NvbXBhcmlzb259IFJhbmtDb21wYXJpc29uICovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cbi8qIFBsYWNlaG9sZGVyIHJlZHVuZGFudCB0eXBlcywgdG8gYmUgaW1wb3J0ZWQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWQuKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7UGFzc2FibGV9IEtleVxuICogVE9ETyBwbGFjZWhvbGRlci4gRmlndXJlIG91dCBob3cgdG8gaW1wb3J0IGZyb20gYEBlbmRvL3BhdHRlcm5zYCBpbnN0ZWFkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7UGFzc2FibGV9IFBhdHRlcm5cbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV1cbiAqIEB0eXBlZGVmIHtDb3B5VGFnZ2VkICYge1xuICogICBbU3ltYm9sLnRvU3RyaW5nVGFnXTogJ2NvcHlTZXQnLFxuICogICBwYXlsb2FkOiBBcnJheTxLPixcbiAqIH19IENvcHlTZXRcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV1cbiAqIEB0eXBlZGVmIHtDb3B5VGFnZ2VkICYge1xuICogICBbU3ltYm9sLnRvU3RyaW5nVGFnXTogJ2NvcHlCYWcnLFxuICogICBwYXlsb2FkOiBBcnJheTxbSywgYmlnaW50XT4sXG4gKiB9fSBDb3B5QmFnXG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7S2V5fSBbSz1LZXldXG4gKiBAdGVtcGxhdGUge1Bhc3NhYmxlfSBbVj1QYXNzYWJsZV1cbiAqIEB0eXBlZGVmIHtDb3B5VGFnZ2VkICYge1xuICogICBbU3ltYm9sLnRvU3RyaW5nVGFnXTogJ2NvcHlNYXAnLFxuICogICBwYXlsb2FkOiB7IGtleXM6IEFycmF5PEs+LCB2YWx1ZXM6IEFycmF5PFY+IH0sXG4gKiB9fSBDb3B5TWFwXG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEd1YXJkTWFrZXJzXG4gKiBAcHJvcGVydHkgezxNIGV4dGVuZHMgUmVjb3JkPGFueSwgYW55Pj4oaW50ZXJmYWNlTmFtZTogc3RyaW5nLFxuICogICAgICAgICAgICAgbWV0aG9kR3VhcmRzOiBNLFxuICogICAgICAgICAgICAgb3B0aW9ucz86IHtzbG9wcHk/OiBib29sZWFufVxuICogKSA9PiBJbnRlcmZhY2VHdWFyZH0gaW50ZXJmYWNlXG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqXG4gKiBAcHJvcGVydHkgeyguLi5hcmdHdWFyZHM6IEFyZ0d1YXJkW10pID0+IE1ldGhvZEd1YXJkTWFrZXJ9IGNhbGwgR3VhcmQgYSBzeW5jaHJvbm91cyBjYWxsXG4gKlxuICogQHByb3BlcnR5IHsoLi4uYXJnR3VhcmRzOiBBcmdHdWFyZFtdKSA9PiBNZXRob2RHdWFyZE1ha2VyfSBjYWxsV2hlbiBHdWFyZCBhbiBhc3luYyBjYWxsXG4gKlxuICogQHByb3BlcnR5IHsoYXJnR3VhcmQ6IEFyZ0d1YXJkKSA9PiBBcmdHdWFyZH0gYXdhaXQgR3VhcmQgYW4gYXdhaXRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gTWV0aG9kXG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHt7XG4gKiBrbGFzczogJ0ludGVyZmFjZScsXG4gKiBpbnRlcmZhY2VOYW1lOiBzdHJpbmcsXG4gKiBtZXRob2RHdWFyZHM6IFJlY29yZDxzdHJpbmcgfCBzeW1ib2wsIE1ldGhvZEd1YXJkPlxuICogc2xvcHB5PzogYm9vbGVhblxuICogfX0gSW50ZXJmYWNlR3VhcmRcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge2FueX0gTWV0aG9kR3VhcmRNYWtlclxuICogVE9ETyBwbGFjZWhvbGRlci4gRmlndXJlIG91dCBob3cgdG8gaW1wb3J0IGZyb20gYEBlbmRvL3BhdHRlcm5zYCBpbnN0ZWFkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7eyBrbGFzczogJ21ldGhvZEd1YXJkJywgY2FsbEtpbmQ6ICdzeW5jJyB8ICdhc3luYycsIHJldHVybkd1YXJkOiB1bmtub3duIH19IE1ldGhvZEd1YXJkXG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHthbnl9IEFyZ0d1YXJkXG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gU3RvcmVPcHRpb25zXG4gKiBPZiB0aGUgZGltZW5zaW9ucyBvbiB3aGljaCBLZXllZFN0b3JlcyBjYW4gZGlmZmVyLCB3ZSBvbmx5IHJlcHJlc2VudCBhIGZld1xuICogb2YgdGhlbSBhcyBzdGFuZGFyZCBvcHRpb25zLiBBIGdpdmVuIHN0b3JlIG1ha2VyIHNob3VsZCBkb2N1bWVudCB3aGljaFxuICogb3B0aW9ucyBpdCBzdXBwb3J0cywgYXMgd2VsbCBhcyBpdHMgcG9zaXRpb25zIG9uIGRpbWVuc2lvbnMgZm9yIHdoaWNoIGl0XG4gKiBkb2VzIG5vdCBzdXBwb3J0IG9wdGlvbnMuXG4gKiBAcHJvcGVydHkge2Jvb2xlYW59IFtsb25nTGl2ZWQ9dHJ1ZV0gV2hpY2ggd2F5IHRvIG9wdGltaXplIGEgd2VhayBzdG9yZS4gVHJ1ZSBtZWFuc1xuICogdGhhdCB3ZSBleHBlY3QgdGhpcyB3ZWFrIHN0b3JlIHRvIG91dGxpdmUgbW9zdCBvZiBpdHMga2V5cywgaW4gd2hpY2hcbiAqIGNhc2Ugd2UgaW50ZXJuYWxseSBtYXkgdXNlIGEgSmF2YVNjcmlwdCBgV2Vha01hcGAuIE90aGVyd2lzZSB3ZSBpbnRlcm5hbGx5XG4gKiBtYXkgdXNlIGEgSmF2YVNjcmlwdCBgTWFwYC5cbiAqIERlZmF1bHRzIHRvIHRydWUsIHNvIHBsZWFzZSBtYXJrIHNob3J0IGxpdmVkIHN0b3JlcyBleHBsaWNpdGx5LlxuICogQHByb3BlcnR5IHtib29sZWFufSBbZHVyYWJsZT1mYWxzZV0gIFRoZSBjb250ZW50cyBvZiB0aGlzIHN0b3JlIHN1cnZpdmUgdGVybWluYXRpb25cbiAqICAgb2YgaXRzIGNvbnRhaW5pbmcgcHJvY2VzcywgYWxsb3dpbmcgZm9yIHJlc3RhcnQgb3IgdXBncmFkZSBidXQgYXQgdGhlIGNvc3RcbiAqICAgb2YgZm9yYmlkZGluZyBzdG9yYWdlIG9mIHJlZmVyZW5jZXMgdG8gZXBoZW1lcmFsIGRhdGEuICBEZWZhdWx0cyB0byBmYWxzZS5cbiAqIEBwcm9wZXJ0eSB7Ym9vbGVhbn0gW2Zha2VEdXJhYmxlPWZhbHNlXSAgVGhpcyBzdG9yZSBwcmV0ZW5kcyB0byBiZSBhIGR1cmFibGUgc3RvcmVcbiAqICAgYnV0IGRvZXMgbm90IGVuZm9yY2UgdGhhdCB0aGUgdGhpbmdzIHN0b3JlZCBpbiBpdCBhY3R1YWxseSBiZSB0aGVtc2VsdmVzXG4gKiAgIGR1cmFibGUgKHdoZXJlYXMgYW4gYWN0dWFsIGR1cmFibGUgc3RvcmUgd291bGQgZm9yYmlkIHN0b3JhZ2Ugb2Ygc3VjaFxuICogICBpdGVtcykuICBUaGlzIGlzIGluIHNlcnZpY2Ugb2YgYWxsb3dpbmcgaW5jcmVtZW50YWwgdHJhbnNpdGlvbiB0byB1c2Ugb2ZcbiAqICAgZHVyYWJsZSBzdG9yZXMsIHRvIGVuYWJsZSBub3JtYWwgb3BlcmF0aW9uIGFuZCB0ZXN0aW5nIHdoZW4gc29tZSBzdHVmZlxuICogICBpbnRlbmRlZCB0byBldmVudHVhbGx5IGJlIGR1cmFibGUgaGFzIG5vdCB5ZXQgYmVlbiBtYWRlIGR1cmFibGUuICBBIHN0b3JlXG4gKiAgIG1hcmtlZCBhcyBmYWtlRHVyYWJsZSB3aWxsIGFwcGVhciB0byBvcGVyYXRlIG5vcm1hbGx5IGJ1dCBhbnkgYXR0ZW1wdCB0b1xuICogICB1cGdyYWRlIGl0cyBjb250YWluaW5nIHZhdCB3aWxsIGZhaWwgd2l0aCBhbiBlcnJvci5cbiAqIEBwcm9wZXJ0eSB7UGF0dGVybn0gW2tleVNoYXBlXVxuICogQHByb3BlcnR5IHtQYXR0ZXJufSBbdmFsdWVTaGFwZV1cbiAqL1xuXG4vKipcbiAqIE1vc3Qgc3RvcmUgbWV0aG9kcyBhcmUgaW4gb25lIG9mIHRocmVlIGNhdGVnb3JpZXNcbiAqICAgKiBsb29rdXAgbWV0aG9kcyAoYGhhc2AsYGdldGApXG4gKiAgICogdXBkYXRlIG1ldGhvZHMgKGBhZGRgLGBpbml0YCxgc2V0YCxgZGVsZXRlYCxgYWRkQWxsYClcbiAqICAgKiBxdWVyeSBtZXRob2RzIChgc25hcHNob3RgLGBrZXlzYCxgdmFsdWVzYCxgZW50cmllc2AsYGdldFNpemVgKVxuICogICAqIHF1ZXJ5LXVwZGF0ZSBtZXRob2RzIChgY2xlYXJgKVxuICpcbiAqIFdlYWtTdG9yZXMgaGF2ZSB0aGUgbG9va3VwIGFuZCB1cGRhdGUgbWV0aG9kcyBidXQgbm90IHRoZSBxdWVyeVxuICogb3IgcXVlcnktdXBkYXRlIG1ldGhvZHMuXG4gKiBOb24td2VhayBTdG9yZXMgYXJlIGxpa2UgdGhlaXIgY29ycmVzcG9uZGluZyBXZWFrU3RvcmVzLCBidXQgd2l0aCB0aGVcbiAqIGFkZGl0aW9uYWwgcXVlcnkgYW5kIHF1ZXJ5LXVwZGF0ZSBtZXRob2RzLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXkgJiBvYmplY3R9IFtLPUtleV1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IFdlYWtTZXRTdG9yZVxuICogQHByb3BlcnR5IHsoa2V5OiBLKSA9PiBib29sZWFufSBoYXNcbiAqIENoZWNrIGlmIGEga2V5IGV4aXN0cy4gVGhlIGtleSBjYW4gYmUgYW55IEphdmFTY3JpcHQgdmFsdWUsIHRob3VnaCB0aGVcbiAqIGFuc3dlciB3aWxsIGFsd2F5cyBiZSBmYWxzZSBmb3Iga2V5cyB0aGF0IGNhbm5vdCBiZSBmb3VuZCBpbiB0aGlzIHN0b3JlLlxuICogQHByb3BlcnR5IHsoa2V5OiBLKSA9PiB2b2lkfSBhZGRcbiAqIEFkZCB0aGUga2V5IHRvIHRoZSBzZXQgaWYgaXQgaXMgbm90IGFscmVhZHkgdGhlcmUuIERvIG5vdGhpbmcgc2lsZW50bHkgaWZcbiAqIGFscmVhZHkgdGhlcmUuXG4gKiBUaGUga2V5IG11c3QgYmUgb25lIGFsbG93ZWQgYnkgdGhpcyBzdG9yZS4gRm9yIGV4YW1wbGUgYSBzY2FsYXIgc3RvcmUgb25seVxuICogYWxsb3dzIHByaW1pdGl2ZXMgYW5kIHJlbW90YWJsZXMuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IHZvaWR9IGRlbGV0ZVxuICogUmVtb3ZlIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXlzOiBDb3B5U2V0PEs+IHwgSXRlcmFibGU8Sz4pID0+IHZvaWR9IGFkZEFsbFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IFNldFN0b3JlXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IGJvb2xlYW59IGhhc1xuICogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzLiBUaGUga2V5IGNhbiBiZSBhbnkgSmF2YVNjcmlwdCB2YWx1ZSwgdGhvdWdoIHRoZVxuICogYW5zd2VyIHdpbGwgYWx3YXlzIGJlIGZhbHNlIGZvciBrZXlzIHRoYXQgY2Fubm90IGJlIGZvdW5kIGluIHRoaXMgc3RvcmUuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IHZvaWR9IGFkZFxuICogQWRkIHRoZSBrZXkgdG8gdGhlIHNldCBpZiBpdCBpcyBub3QgYWxyZWFkeSB0aGVyZS4gRG8gbm90aGluZyBzaWxlbnRseSBpZlxuICogYWxyZWFkeSB0aGVyZS5cbiAqIFRoZSBrZXkgbXVzdCBiZSBvbmUgYWxsb3dlZCBieSB0aGlzIHN0b3JlLiBGb3IgZXhhbXBsZSBhIHNjYWxhciBzdG9yZSBvbmx5XG4gKiBhbGxvd3MgcHJpbWl0aXZlcyBhbmQgcmVtb3RhYmxlcy5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gdm9pZH0gZGVsZXRlXG4gKiBSZW1vdmUgdGhlIGtleS4gVGhyb3dzIGlmIG5vdCBmb3VuZC5cbiAqIEBwcm9wZXJ0eSB7KGtleXM6IENvcHlTZXQ8Sz4gfCBJdGVyYWJsZTxLPikgPT4gdm9pZH0gYWRkQWxsXG4gKiBAcHJvcGVydHkgeyhrZXlQYXR0PzogUGF0dGVybikgPT4gSXRlcmFibGU8Sz59IGtleXNcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuKSA9PiBJdGVyYWJsZTxLPn0gdmFsdWVzXG4gKiBAcHJvcGVydHkgeyhrZXlQYXR0PzogUGF0dGVybikgPT4gQ29weVNldDxLPn0gc25hcHNob3RcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuKSA9PiBudW1iZXJ9IGdldFNpemVcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuKSA9PiB2b2lkfSBjbGVhclxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXkgJiBvYmplY3R9IFtLPUtleV1cbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFtWPVBhc3NhYmxlXVxuICogQHR5cGVkZWYge29iamVjdH0gV2Vha01hcFN0b3JlXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IGJvb2xlYW59IGhhc1xuICogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzLiBUaGUga2V5IGNhbiBiZSBhbnkgSmF2YVNjcmlwdCB2YWx1ZSwgdGhvdWdoIHRoZVxuICogYW5zd2VyIHdpbGwgYWx3YXlzIGJlIGZhbHNlIGZvciBrZXlzIHRoYXQgY2Fubm90IGJlIGZvdW5kIGluIHRoaXMgc3RvcmUuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IFZ9IGdldFxuICogUmV0dXJuIGEgdmFsdWUgZm9yIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBpbml0XG4gKiBJbml0aWFsaXplIHRoZSBrZXkgb25seSBpZiBpdCBkb2Vzbid0IGFscmVhZHkgZXhpc3QuXG4gKiBUaGUga2V5IG11c3QgYmUgb25lIGFsbG93ZWQgYnkgdGhpcyBzdG9yZS4gRm9yIGV4YW1wbGUgYSBzY2FsYXIgc3RvcmUgb25seVxuICogYWxsb3dzIHByaW1pdGl2ZXMgYW5kIHJlbW90YWJsZXMuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBzZXRcbiAqIFNldCB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoa2V5OiBLKSA9PiB2b2lkfSBkZWxldGVcbiAqIFJlbW92ZSB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoZW50cmllczogQ29weU1hcDxLLFY+IHwgSXRlcmFibGU8W0ssVl0+KSA9PiB2b2lkfSBhZGRBbGxcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7S2V5fSBbSz1LZXldXG4gKiBAdGVtcGxhdGUge1Bhc3NhYmxlfSBbVj1QYXNzYWJsZV1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IE1hcFN0b3JlXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IGJvb2xlYW59IGhhc1xuICogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzLiBUaGUga2V5IGNhbiBiZSBhbnkgSmF2YVNjcmlwdCB2YWx1ZSwgdGhvdWdoIHRoZVxuICogYW5zd2VyIHdpbGwgYWx3YXlzIGJlIGZhbHNlIGZvciBrZXlzIHRoYXQgY2Fubm90IGJlIGZvdW5kIGluIHRoaXMgbWFwXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IFZ9IGdldFxuICogUmV0dXJuIGEgdmFsdWUgZm9yIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBpbml0XG4gKiBJbml0aWFsaXplIHRoZSBrZXkgb25seSBpZiBpdCBkb2Vzbid0IGFscmVhZHkgZXhpc3QuXG4gKiBUaGUga2V5IG11c3QgYmUgb25lIGFsbG93ZWQgYnkgdGhpcyBzdG9yZS4gRm9yIGV4YW1wbGUgYSBzY2FsYXIgc3RvcmUgb25seVxuICogYWxsb3dzIHByaW1pdGl2ZXMgYW5kIHJlbW90YWJsZXMuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBzZXRcbiAqIFNldCB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoa2V5OiBLKSA9PiB2b2lkfSBkZWxldGVcbiAqIFJlbW92ZSB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoZW50cmllczogQ29weU1hcDxLLFY+IHwgSXRlcmFibGU8W0ssVl0+KSA9PiB2b2lkfSBhZGRBbGxcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuLCB2YWx1ZVBhdHQ/OiBQYXR0ZXJuKSA9PiBJdGVyYWJsZTxLPn0ga2V5c1xuICogQHByb3BlcnR5IHsoa2V5UGF0dD86IFBhdHRlcm4sIHZhbHVlUGF0dD86IFBhdHRlcm4pID0+IEl0ZXJhYmxlPFY+fSB2YWx1ZXNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICBrZXlQYXR0PzogUGF0dGVybixcbiAqICAgdmFsdWVQYXR0PzogUGF0dGVyblxuICogKSA9PiBJdGVyYWJsZTxbSyxWXT59IGVudHJpZXNcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuLCB2YWx1ZVBhdHQ/OiBQYXR0ZXJuKSA9PiBDb3B5TWFwPEssVj59IHNuYXBzaG90XG4gKiBAcHJvcGVydHkgeyhrZXlQYXR0PzogUGF0dGVybiwgdmFsdWVQYXR0PzogUGF0dGVybikgPT4gbnVtYmVyfSBnZXRTaXplXG4gKiBAcHJvcGVydHkgeyhrZXlQYXR0PzogUGF0dGVybiwgdmFsdWVQYXR0PzogUGF0dGVybikgPT4gdm9pZH0gY2xlYXJcbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIERlcHJlY2F0ZWQgTGVnYWN5IC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHRlbXBsYXRlIEssVlxuICogQHR5cGVkZWYge29iamVjdH0gTGVnYWN5V2Vha01hcFxuICogTGVnYWN5V2Vha01hcCBpcyBkZXByZWNhdGVkLiBVc2UgV2Vha01hcFN0b3JlIGluc3RlYWQgaWYgcG9zc2libGUuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IGJvb2xlYW59IGhhc1xuICogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IFZ9IGdldFxuICogUmV0dXJuIGEgdmFsdWUgZm9yIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBpbml0XG4gKiBJbml0aWFsaXplIHRoZSBrZXkgb25seSBpZiBpdFxuICogZG9lc24ndCBhbHJlYWR5IGV4aXN0XG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBzZXRcbiAqIFNldCB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoa2V5OiBLKSA9PiB2b2lkfSBkZWxldGVcbiAqIFJlbW92ZSB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIEssVlxuICogQHR5cGVkZWYge29iamVjdH0gTGVnYWN5TWFwXG4gKiBMZWdhY3lNYXAgaXMgZGVwcmVjYXRlZC4gVXNlIE1hcFN0b3JlIGluc3RlYWQgaWYgcG9zc2libGUuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IGJvb2xlYW59IGhhc1xuICogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IFZ9IGdldFxuICogUmV0dXJuIGEgdmFsdWUgZm9yIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBpbml0XG4gKiBJbml0aWFsaXplIHRoZSBrZXkgb25seSBpZiBpdFxuICogZG9lc24ndCBhbHJlYWR5IGV4aXN0XG4gKiBAcHJvcGVydHkgeyhrZXk6IEssIHZhbHVlOiBWKSA9PiB2b2lkfSBzZXRcbiAqIFNldCB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoa2V5OiBLKSA9PiB2b2lkfSBkZWxldGVcbiAqIFJlbW92ZSB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoKSA9PiBJdGVyYWJsZTxLPn0ga2V5c1xuICogQHByb3BlcnR5IHsoKSA9PiBJdGVyYWJsZTxWPn0gdmFsdWVzXG4gKiBAcHJvcGVydHkgeygpID0+IEl0ZXJhYmxlPFtLLFZdPn0gZW50cmllc1xuICogQHByb3BlcnR5IHsoKSA9PiBudW1iZXJ9IGdldFNpemVcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gdm9pZH0gY2xlYXJcbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAhmCHYvwEAAL8BAAAiAAAAQGFnb3JpYy90aW1lLXYwLjMuMy11MTEuMC9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy90aW1lTWF0aC5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3NyYy90aW1lTWF0aC5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy90aW1lTWF0aC5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZUd1YXJkcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAwEA35qgiAACoIgAAKQAAAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3RpbWVNYXRoLmpzeyJpbXBvcnRzIjpbIi4vdHlwZUd1YXJkcy5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAZW5kby9uYXQiXSwiZXhwb3J0cyI6WyJUaW1lTWF0aCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtdXN0TWF0Y2gsTmF0LFJlbGF0aXZlVGltZVJlY29yZFNoYXBlLFRpbWVzdGFtcFJlY29yZFNoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL25hdFwiLCBbW1wiTmF0XCIsIFskaOKAjV9hID0+IChOYXQgPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJSZWxhdGl2ZVRpbWVSZWNvcmRTaGFwZVwiLCBbJGjigI1fYSA9PiAoUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlRpbWVzdGFtcFJlY29yZFNoYXBlXCIsIFskaOKAjV9hID0+IChUaW1lc3RhbXBSZWNvcmRTaGFwZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzJykuVGltZXJCcmFuZH0gVGltZXJCcmFuZFxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMnKS5UaW1lc3RhbXB9IFRpbWVzdGFtcFxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMnKS5SZWxhdGl2ZVRpbWV9IFJlbGF0aXZlVGltZVxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMnKS5SZWxhdGl2ZVRpbWVWYWx1ZX0gUmVsYXRpdmVUaW1lVmFsdWVcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzJykuVGltZXN0YW1wVmFsdWV9IFRpbWVzdGFtcFZhbHVlXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcycpLlRpbWVNYXRoVHlwZX0gVGltZU1hdGhUeXBlXG4gKlxuICovXG5cbi8qKlxuICogYGFncmVlZFRpbWVyQnJhbmRgIGlzIGludGVybmFsIHRvIHRoaXMgbW9kdWxlLlxuICpcbiAqIEBwYXJhbSB7VGltZXJCcmFuZCB8IHVuZGVmaW5lZH0gbGVmdEJyYW5kXG4gKiBAcGFyYW0ge1RpbWVyQnJhbmQgfCB1bmRlZmluZWR9IHJpZ2h0QnJhbmRcbiAqIEByZXR1cm5zIHtUaW1lckJyYW5kIHwgdW5kZWZpbmVkfVxuICovXG5jb25zdCBhZ3JlZWRUaW1lckJyYW5kPShsZWZ0QnJhbmQscmlnaHRCcmFuZCk9PntcbmlmKGxlZnRCcmFuZD09PXVuZGVmaW5lZCl7XG5pZihyaWdodEJyYW5kPT09dW5kZWZpbmVkKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfWVsc2V7XG5yZXR1cm4gcmlnaHRCcmFuZDtcbiB9XG4gfWVsc2UgaWYocmlnaHRCcmFuZD09PXVuZGVmaW5lZCl7XG5yZXR1cm4gbGVmdEJyYW5kO1xuIH1lbHNle1xubGVmdEJyYW5kPT09cmlnaHRCcmFuZHx8XG5GYWlsIGBUaW1lckJyYW5kcyBtdXN0IG1hdGNoOiAke3EobGVmdEJyYW5kKX0gdnMgJHtxKHJpZ2h0QnJhbmQpfWA7XG5yZXR1cm4gbGVmdEJyYW5kO1xuIH1cbiB9O1xuXG4vKipcbiAqIGBzaGFyZWRUaW1lckJyYW5kYCBpcyBpbnRlcm5hbCB0byB0aGlzIG1vZHVsZSwgYW5kIGltcGxlbWVudHMgdGhlXG4gKiB0cmFuc2l0aW9uYWwgYnJhbmQgY2hlY2tpbmcgYW5kIGNvbnRhaWdpb24gbG9naWMgZXhwbGFpbmVkIGluIHRoZSBgVGltZU1hdGhgXG4gKiBjb21tZW50LiBJdCBpcyB1c2VkIHRvIGRlZmluZSB0aGUgYmluYXJ5IG9wZXJhdG9ycyB0aGF0IHNob3VsZCBmb2xsb3dcbiAqIHRoaXMgbG9naWMuIEl0IGRvZXMgdGhlIGVycm9yIGNoZWNraW5nIGJldHdlZW4gdGhlIG9wZXJhbmRzLCBhbmQgcmV0dXJuc1xuICogdGhlIGJyYW5kLCBpZiBhbnksIHRoYXQgc2hvdWxkIGxhYmVsIHRoZSByZXN1bHRpbmcgdGltZSB2YWx1ZS5cbiAqXG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gbGVmdFxuICogQHBhcmFtIHtUaW1lc3RhbXAgfCBSZWxhdGl2ZVRpbWV9IHJpZ2h0XG4gKiBAcmV0dXJucyB7VGltZXJCcmFuZCB8IHVuZGVmaW5lZH1cbiAqL1xuY29uc3Qgc2hhcmVkVGltZXJCcmFuZD0obGVmdCxyaWdodCk9PntcbmNvbnN0IGxlZnRCcmFuZD10eXBlb2YgbGVmdD09PSdiaWdpbnQnP3VuZGVmaW5lZDpsZWZ0LnRpbWVyQnJhbmQ7XG5jb25zdCByaWdodEJyYW5kPXR5cGVvZiByaWdodD09PSdiaWdpbnQnP3VuZGVmaW5lZDpyaWdodC50aW1lckJyYW5kO1xucmV0dXJuIGFncmVlZFRpbWVyQnJhbmQobGVmdEJyYW5kLHJpZ2h0QnJhbmQpO1xuIH07XG5cbi8qKlxuICogYGFic0xpa2VgIGlzIGludGVybmFsIHRvIHRoaXMgbW9kdWxlLCBhbmQgdXNlZCB0byBpbXBsZW1lbnQgdGhlIGJpbmFyeVxuICogb3BlcmF0b3JzIGluIHRoZSBjYXNlIHdoZXJlIHRoZSByZXR1cm5lZCB0aW1lIHNob3VsZCBiZSBhIGBUaW1lc3RhbXBgXG4gKiByYXRoZXIgdGhhbiBhIGBSZWxhdGl2ZVRpbWVgLlxuICpcbiAqIEBwYXJhbSB7VGltZXN0YW1wIHwgUmVsYXRpdmVUaW1lfSBsZWZ0XG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gcmlnaHRcbiAqIEBwYXJhbSB7VGltZXN0YW1wVmFsdWV9IGFic1ZhbHVlXG4gKiBAcmV0dXJucyB7VGltZXN0YW1wfVxuICovXG5jb25zdCBhYnNMaWtlPShsZWZ0LHJpZ2h0LGFic1ZhbHVlKT0+e1xuTmF0KGFic1ZhbHVlKTtcbmNvbnN0IHRpbWVyQnJhbmQ9c2hhcmVkVGltZXJCcmFuZChsZWZ0LHJpZ2h0KTtcbmlmKHRpbWVyQnJhbmQpe1xucmV0dXJuIGhhcmRlbih7XG50aW1lckJyYW5kLFxuYWJzVmFsdWV9KTtcblxuIH1lbHNle1xucmV0dXJuIGFic1ZhbHVlO1xuIH1cbiB9O1xuXG4vKipcbiAqIGByZWxMaWtlYCBpcyBpbnRlcm5hbCB0byB0aGlzIG1vZHVsZSwgYW5kIHVzZWQgdG8gaW1wbGVtZW50IHRoZSBiaW5hcnlcbiAqIG9wZXJhdG9ycyBpbiB0aGUgY2FzZSB3aGVyZSB0aGUgcmV0dXJuZWQgdGltZSBzaG91bGQgYmUgYSBgUmVsYXRpdmVUaW1lYFxuICogcmF0aGVyIHRoYW4gYSBgVGltZXN0YW1wYC5cbiAqXG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gbGVmdFxuICogQHBhcmFtIHtUaW1lc3RhbXAgfCBSZWxhdGl2ZVRpbWV9IHJpZ2h0XG4gKiBAcGFyYW0ge1JlbGF0aXZlVGltZVZhbHVlfSByZWxWYWx1ZVxuICogQHJldHVybnMge1JlbGF0aXZlVGltZX1cbiAqL1xuY29uc3QgcmVsTGlrZT0obGVmdCxyaWdodCxyZWxWYWx1ZSk9Pntcbk5hdChyZWxWYWx1ZSk7XG5jb25zdCB0aW1lckJyYW5kPXNoYXJlZFRpbWVyQnJhbmQobGVmdCxyaWdodCk7XG5pZih0aW1lckJyYW5kKXtcbnJldHVybiBoYXJkZW4oe1xudGltZXJCcmFuZCxcbnJlbFZhbHVlfSk7XG5cbiB9ZWxzZXtcbnJldHVybiByZWxWYWx1ZTtcbiB9XG4gfTtcblxuLyogRm9yIGFsbCB0aGUgZm9sbG93aW5nIHRpbWUgb3BlcmF0b3JzLCB0aGVpciBkb2N1bWVudGF0aW9uIGlzIGluKi9cbi8qIHRoZSBgVGltZU1hdGhUeXBlYCwgc2luY2UgdGhhdCBpcyB0aGUgZG9jdW1lbnRhdGlvbiB0aGF0IHNob3dzIHVwKi9cbi8qIGluIHRoZSBJREUuIFdlbGwsIGF0IGxlYXN0IHRoZSB2c2NvZGUgSURFLiovXG5cbmNvbnN0IGFic1ZhbHVlPShhYnMpPT57XG5pZih0eXBlb2YgYWJzPT09J2JpZ2ludCcpe1xucmV0dXJuIE5hdChhYnMpO1xuIH1cbm11c3RNYXRjaChhYnMsVGltZXN0YW1wUmVjb3JkU2hhcGUsJ3RpbWVzdGFtcCcpO1xucmV0dXJuIE5hdChhYnMuYWJzVmFsdWUpO1xuIH07XG5cbmNvbnN0IHJlbFZhbHVlPShyZWwpPT57XG5pZih0eXBlb2YgcmVsPT09J2JpZ2ludCcpe1xucmV0dXJuIE5hdChyZWwpO1xuIH1cbm11c3RNYXRjaChyZWwsUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUsJ3JlbGF0aXZlJyk7XG5yZXR1cm4gTmF0KHJlbC5yZWxWYWx1ZSk7XG4gfTtcblxuY29uc3QgbWFrZVRpbWVzdGFtcFJlY29yZD0oYWJzLHRpbWVyQnJhbmQpPT5cbmhhcmRlbih7YWJzVmFsdWU6YWJzLHRpbWVyQnJhbmR9KTtcbmNvbnN0IG1ha2VSZWxhdGl2ZVRpbWVSZWNvcmQ9KHJlbCx0aW1lckJyYW5kKT0+XG5oYXJkZW4oe3JlbFZhbHVlOnJlbCx0aW1lckJyYW5kfSk7XG5cbmNvbnN0IGNvZXJjZVRpbWVzdGFtcFJlY29yZD0odHMsYnJhbmQpPT57XG5icmFuZHx8RmFpbCBgbXVzdCBoYXZlIGEgYnJhbmRgO1xuaWYodHlwZW9mIHRzPT09J251bWJlcicpe1xudHM9TmF0KHRzKTtcbiB9XG5pZih0eXBlb2YgdHM9PT0nYmlnaW50Jyl7XG5yZXR1cm4gbWFrZVRpbWVzdGFtcFJlY29yZCh0cyxicmFuZCk7XG4gfWVsc2V7XG5jb25zdHt0aW1lckJyYW5kfT10cztcbm11c3RNYXRjaCh0cyxUaW1lc3RhbXBSZWNvcmRTaGFwZSwndGltZXN0YW1wJyk7XG5hZ3JlZWRUaW1lckJyYW5kKHRpbWVyQnJhbmQsYnJhbmQpO1xucmV0dXJuIHRzO1xuIH1cbiB9O1xuXG5jb25zdCBjb2VyY2VSZWxhdGl2ZVRpbWVSZWNvcmQ9KHJ0LGJyYW5kKT0+e1xuYnJhbmR8fEZhaWwgYG11c3QgaGF2ZSBhIGJyYW5kYDtcbmlmKHR5cGVvZiBydD09PSdudW1iZXInKXtcbnJ0PU5hdChydCk7XG4gfVxuaWYodHlwZW9mIHJ0PT09J2JpZ2ludCcpe1xucmV0dXJuIG1ha2VSZWxhdGl2ZVRpbWVSZWNvcmQocnQsYnJhbmQpO1xuIH1lbHNle1xuY29uc3R7dGltZXJCcmFuZH09cnQ7XG5tdXN0TWF0Y2gocnQsUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUsJ3JlbGF0aXZlVGltZScpO1xuYWdyZWVkVGltZXJCcmFuZCh0aW1lckJyYW5kLGJyYW5kKTtcbnJldHVybiBydDtcbiB9XG4gfTtcblxuY29uc3QgYWRkQWJzUmVsPShhYnMscmVsKT0+XG5hYnNMaWtlKGFicyxyZWwsYWJzVmFsdWUoYWJzKStyZWxWYWx1ZShyZWwpKTtcblxuY29uc3QgYWRkUmVsUmVsPShyZWwxLHJlbDIpPT5cbnJlbExpa2UocmVsMSxyZWwyLHJlbFZhbHVlKHJlbDEpK3JlbFZhbHVlKHJlbDIpKTtcblxuY29uc3Qgc3VidHJhY3RBYnNBYnM9KGFiczEsYWJzMik9PlxucmVsTGlrZShhYnMxLGFiczIsYWJzVmFsdWUoYWJzMSktYWJzVmFsdWUoYWJzMikpO1xuXG5jb25zdCBjbGFtcGVkU3VidHJhY3RBYnNBYnM9KGFiczEsYWJzMik9PntcbmNvbnN0IHZhbDE9YWJzVmFsdWUoYWJzMSk7XG5jb25zdCB2YWwyPWFic1ZhbHVlKGFiczIpO1xucmV0dXJuIHJlbExpa2UoYWJzMSxhYnMyLHZhbDE+dmFsMj92YWwxLXZhbDI6MG4pO1xuIH07XG5cbmNvbnN0IHN1YnRyYWN0QWJzUmVsPShhYnMscmVsKT0+XG5hYnNMaWtlKGFicyxyZWwsYWJzVmFsdWUoYWJzKS1yZWxWYWx1ZShyZWwpKTtcblxuY29uc3Qgc3VidHJhY3RSZWxSZWw9KHJlbDEscmVsMik9PlxucmVsTGlrZShyZWwxLHJlbDIscmVsVmFsdWUocmVsMSktcmVsVmFsdWUocmVsMikpO1xuXG5jb25zdCBpc1JlbFplcm89KHJlbCk9PnJlbFZhbHVlKHJlbCk9PT0wbjtcblxuY29uc3QgbXVsdGlwbHlSZWxOYXQ9KHJlbCxuYXQpPT5yZWxMaWtlKHJlbCxuYXQscmVsVmFsdWUocmVsKSpuYXQpO1xuXG5jb25zdCBkaXZpZGVSZWxOYXQ9KHJlbCxuYXQpPT5yZWxMaWtlKHJlbCxuYXQscmVsVmFsdWUocmVsKS9uYXQpO1xuXG5jb25zdCBkaXZpZGVSZWxSZWw9KHJlbDEscmVsMik9PntcbnNoYXJlZFRpbWVyQnJhbmQocmVsMSxyZWwyKTsvKiBqdXN0IGVycm9yIGNoZWNrKi9cbnJldHVybiByZWxWYWx1ZShyZWwxKS9yZWxWYWx1ZShyZWwyKTtcbiB9O1xuXG5jb25zdCBtb2RBYnNSZWw9KGFicyxzdGVwKT0+XG5yZWxMaWtlKGFicyxzdGVwLGFic1ZhbHVlKGFicyklcmVsVmFsdWUoc3RlcCkpO1xuXG5jb25zdCBtb2RSZWxSZWw9KHJlbCxzdGVwKT0+XG5yZWxMaWtlKHJlbCxzdGVwLHJlbFZhbHVlKHJlbCklcmVsVmFsdWUoc3RlcCkpO1xuXG4vKipcbiAqIGBjb21wYXJlVmFsdWVzYCBpcyBpbnRlcm5hbCB0byB0aGlzIG1vZHVsZSwgYW5kIHVzZWQgdG8gaW1wbGVtZW50XG4gKiB0aGUgdGltZSBjb21wYXJpc29uIG9wZXJhdG9ycy5cbiAqXG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gbGVmdFxuICogQHBhcmFtIHtUaW1lc3RhbXAgfCBSZWxhdGl2ZVRpbWV9IHJpZ2h0XG4gKiBAcGFyYW0ge2JpZ2ludH0gdjFcbiAqIEBwYXJhbSB7YmlnaW50fSB2MlxuICogQHJldHVybnMge1JhbmtDb21wYXJpc29ufVxuICovXG5jb25zdCBjb21wYXJlVmFsdWVzPShsZWZ0LHJpZ2h0LHYxLHYyKT0+e1xuc2hhcmVkVGltZXJCcmFuZChsZWZ0LHJpZ2h0KTtcbmlmKHYxPHYyKXtcbnJldHVybi0xO1xuIH1lbHNlIGlmKHYxPT09djIpe1xucmV0dXJuIDA7XG4gfWVsc2V7XG5hc3NlcnQodjE+djIpO1xucmV0dXJuIDE7XG4gfVxuIH07XG5cbi8qKlxuICogVGhlIGBUaW1lTWF0aGAgb2JqZWN0IHByb3ZpZGVzIGhlbHBlciBtZXRob2RzIHRvIGRvIGFyaXRobWV0aWMgb24gbGFiZWxlZFxuICogdGltZSB2YWx1ZXMsIG11Y2ggbGlrZSBgQW1vdW50TWF0aGAgcHJvdmlkZXMgaGVscGVyIG1ldGhvZHMgdG8gZG8gYXJpdGhtZXRpY1xuICogb24gbGFiZWxlZCBhc3NldC9tb25leSB2YWx1ZXMuIEJvdGggY2hlY2sgZm9yIGNvbnNpc3RlbmN5IG9mIGxhYmVsczogYVxuICogYmluYXJ5IG9wZXJhdGlvbiBvbiB0d28gbGFiZWxlZCBvYmplY3RzIGVuc3VyZXMgdGhhdCB0aGUgYm90aCBjYXJyeVxuICogdGhlIHNhbWUgbGFiZWwuIElmIHRoZXkgcHJvZHVjZSBhbm90aGVyIG9iamVjdCBmcm9tIHRoZSBzYW1lIGRvbWFpbiwgaXRcbiAqIHdpbGwgY2FycnkgdGhlIHNhbWUgbGFiZWwuIElmIHRoZSBvcGVyYW5kcyBoYXZlIGluY29tcGF0aWJsZSBsYWJlbHMsXG4gKiBhbiBlcnJvciBpcyB0aHJvd24uXG4gKlxuICogVW5saWtlIGFtb3VudCBhcml0aG1ldGljLCB0aW1lIGFyaXRobWV0aWMgZGVhbHMgaW4gdHdvIGtpbmRzIG9mIHRpbWUgb2JqZWN0czpcbiAqIFRpbWVzdGFtcHMsIHdoaWNoIHJlcHJlc2VudCBhYnNvbHV0ZSB0aW1lLCBhbmQgUmVsYXRpdmVUaW1lLCB3aGljaCByZXByZXNlbnRzXG4gKiB0aGUgZHVyYXRpb24gYmV0d2VlbiB0d28gYWJzb2x1dGUgdGltZXMuIEJvdGgga2luZHMgb2YgdGltZSBvYmplY3RcbiAqIGFyZSBsYWJlbGVkIGJ5IGEgYFRpbWVyQnJhbmRgLiBGb3IgYSBUaW1lc3RhbXAgb2JqZWN0LCB0aGUgdmFsdWUgaXNcbiAqIGEgYmlnaW50IGluIGFuIGBhYnNWYWx1ZWAgcHJvcGVydHkuIEZvciBhIFJlbGF0aXZlVGltZSBvYmplY3QsIHRoZSB2YWx1ZVxuICogaXMgYSBiaWdpbnQgaW4gYSBgcmVsVmFsdWVgIHByb3BlcnR5LiBUaHVzIHdlIGhhdmUgYSBydW50aW1lIHNhZmV0eSBjaGVja1xuICogdG8gZW5zdXJlIHRoYXQgd2UgZG9uJ3QgY29uZnVzZWQgdGhlIHR3bywgZXZlbiBpZiB3ZSBoYXZlIG1hbmFnZWQgdG8gZm9vbFxuICogdGhlICh1bnNvdW5kKSBzdGF0aWMgdHlwZSBzeXN0ZW0uXG4gKlxuICogQXMgYSB0cmFuc2l0aW9uYWwgbWVhc3VyZSwgY3VycmVudGx5IG1hbnkgVGltZXN0YW1wcyBhbmQgUmVsYXRpdmVUaW1lcyBhcmVcbiAqIHN0aWxsIHJlcHJlc2VudGVkIGJ5IHVubGFiZWxlZCBiaWdpbnRzLiBEdXJpbmcgdGhpcyB0cmFuc2l0aW9uYWwgcGVyaW9kLFxuICogd2UgYWxsb3cgdGhpcywgYm90aCBzdGF0aWNhbGx5IGFuZCBkeW5hbWljYWxseS4gRm9yIGEgbm9ybWFsIGJpbmFyeVxuICogb3BlcmF0aW9uLCBpZiBib3RoIGlucHV0cyBhcmUgbGFiZWxlZCwgdGhlbiB3ZSBkbyB0aGUgZnVsbCBjaGVja2luZyBhc1xuICogZXhwbGFpbmVkIGFib3ZlIGFuZCByZXR1cm4gYSBsYWJlbGVkIHJlc3VsdC4gSWYgYm90aCBpbnB1dHMgYXJlIHVubGFiZWxlZFxuICogYmlnaW50cywgd2UgKmFzc3VtZSogdGhhdCB0aGV5IGluZGljYXRlIGEgdGltZSBvZiB0aGUgcmlnaHQga2luZFxuICogKFRpbWVzdGFtcCB2cyBSZWxhdGl2ZVRpbWUpIGFuZCB0aW1lciBicmFuZC4gU2luY2Ugd2UgZG9uJ3Qga25vdyB3aGF0XG4gKiBicmFuZCB3YXMgaW50ZW5kZWQsIHdlIGNhbiBvbmx5IHJldHVybiB5ZXQgYW5vdGhlciB1bmxhYmVsZWQgYmlnaW50LlxuICpcbiAqIElmIG9uZSBvcGVyYW5kIGlzIGxhYmVsZWQgYW5kIHRoZSBvdGhlciBpcyBub3QsIHdlIGNoZWNrIHRoZSBsYWJlbGVkIG9wZXJhbmQsXG4gKiAqYXNzdW1lKiB0aGUgdW5sYWJlbGVkIGJpZ2ludCByZXByZXNlbnRzIHRoZSB2YWx1ZSBuZWVkZWQgZm9yIHRoZSBvdGhlclxuICogb3BlcmFuZCwgYW5kIHJldHVybiBhIGxhYmVsZWQgdGltZSBvYmplY3Qgd2l0aCB0aGUgYnJhbmQgb2YgdGhlIGxhYmVsZWRcbiAqIG9wZXJhbmQuXG4gKlxuICogQHR5cGUge1RpbWVNYXRoVHlwZX1cbiAqL1xuY29uc3QgICAgICAgIFRpbWVNYXRoPWhhcmRlbih7XG5hYnNWYWx1ZSxcbnJlbFZhbHVlLFxuY29lcmNlVGltZXN0YW1wUmVjb3JkLFxuY29lcmNlUmVsYXRpdmVUaW1lUmVjb3JkLFxuYWRkQWJzUmVsLFxuYWRkUmVsUmVsLFxuc3VidHJhY3RBYnNBYnMsXG5jbGFtcGVkU3VidHJhY3RBYnNBYnMsXG5zdWJ0cmFjdEFic1JlbCxcbnN1YnRyYWN0UmVsUmVsLFxuaXNSZWxaZXJvLFxubXVsdGlwbHlSZWxOYXQsXG5kaXZpZGVSZWxOYXQsXG5kaXZpZGVSZWxSZWwsXG5tb2RBYnNSZWwsXG5tb2RSZWxSZWwsXG5jb21wYXJlQWJzOihhYnMxLGFiczIpPT5cbmNvbXBhcmVWYWx1ZXMoYWJzMSxhYnMyLGFic1ZhbHVlKGFiczEpLGFic1ZhbHVlKGFiczIpKSxcbmNvbXBhcmVSZWw6KHJlbDEscmVsMik9PlxuY29tcGFyZVZhbHVlcyhyZWwxLHJlbDIscmVsVmFsdWUocmVsMSkscmVsVmFsdWUocmVsMikpfSk7JGjigI1fb25jZS5UaW1lTWF0aChUaW1lTWF0aCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGltZU1hdGgiOlsiVGltZU1hdGgiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAbrMeqqcHAACnBwAAKwAAAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbIlJlbGF0aXZlVGltZVJlY29yZFNoYXBlIiwiUmVsYXRpdmVUaW1lU2hhcGUiLCJSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlIiwiVGltZXJCcmFuZFNoYXBlIiwiVGltZXJTZXJ2aWNlU2hhcGUiLCJUaW1lc3RhbXBSZWNvcmRTaGFwZSIsIlRpbWVzdGFtcFNoYXBlIiwiVGltZXN0YW1wVmFsdWVTaGFwZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuY29uc3QgICAgICAgIFRpbWVyQnJhbmRTaGFwZT1NLnJlbW90YWJsZSgnVGltZXJCcmFuZCcpOyRo4oCNX29uY2UuVGltZXJCcmFuZFNoYXBlKFRpbWVyQnJhbmRTaGFwZSk7XG5jb25zdCAgICAgICAgVGltZXN0YW1wVmFsdWVTaGFwZT1NLm5hdCgpOyRo4oCNX29uY2UuVGltZXN0YW1wVmFsdWVTaGFwZShUaW1lc3RhbXBWYWx1ZVNoYXBlKTtcbmNvbnN0ICAgICAgICBSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlPU0ubmF0KCk7LyogU2hvdWxkIHdlIGFsbG93IG5lZ2F0aXZlcz8qLyRo4oCNX29uY2UuUmVsYXRpdmVUaW1lVmFsdWVTaGFwZShSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlKTtcblxuY29uc3QgICAgICAgIFRpbWVzdGFtcFJlY29yZFNoYXBlPWhhcmRlbih7XG50aW1lckJyYW5kOlRpbWVyQnJhbmRTaGFwZSxcbmFic1ZhbHVlOlRpbWVzdGFtcFZhbHVlU2hhcGV9KTskaOKAjV9vbmNlLlRpbWVzdGFtcFJlY29yZFNoYXBlKFRpbWVzdGFtcFJlY29yZFNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGU9aGFyZGVuKHtcbnRpbWVyQnJhbmQ6VGltZXJCcmFuZFNoYXBlLFxucmVsVmFsdWU6UmVsYXRpdmVUaW1lVmFsdWVTaGFwZX0pOyRo4oCNX29uY2UuUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUoUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBUaW1lc3RhbXBTaGFwZT1NLm9yKFRpbWVzdGFtcFJlY29yZFNoYXBlLFRpbWVzdGFtcFZhbHVlU2hhcGUpOyRo4oCNX29uY2UuVGltZXN0YW1wU2hhcGUoVGltZXN0YW1wU2hhcGUpO1xuY29uc3QgICAgICAgIFJlbGF0aXZlVGltZVNoYXBlPU0ub3IoXG5SZWxhdGl2ZVRpbWVSZWNvcmRTaGFwZSxcblJlbGF0aXZlVGltZVZhbHVlU2hhcGUpOyRo4oCNX29uY2UuUmVsYXRpdmVUaW1lU2hhcGUoUmVsYXRpdmVUaW1lU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBUaW1lclNlcnZpY2VTaGFwZT1NLnJlbW90YWJsZSgnVGltZXJTZXJ2aWNlJyk7JGjigI1fb25jZS5UaW1lclNlcnZpY2VTaGFwZShUaW1lclNlcnZpY2VTaGFwZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGltZXJCcmFuZFNoYXBlIjpbIlRpbWVyQnJhbmRTaGFwZSJdLCJUaW1lc3RhbXBWYWx1ZVNoYXBlIjpbIlRpbWVzdGFtcFZhbHVlU2hhcGUiXSwiUmVsYXRpdmVUaW1lVmFsdWVTaGFwZSI6WyJSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlIl0sIlRpbWVzdGFtcFJlY29yZFNoYXBlIjpbIlRpbWVzdGFtcFJlY29yZFNoYXBlIl0sIlJlbGF0aXZlVGltZVJlY29yZFNoYXBlIjpbIlJlbGF0aXZlVGltZVJlY29yZFNoYXBlIl0sIlRpbWVzdGFtcFNoYXBlIjpbIlRpbWVzdGFtcFNoYXBlIl0sIlJlbGF0aXZlVGltZVNoYXBlIjpbIlJlbGF0aXZlVGltZVNoYXBlIl0sIlRpbWVyU2VydmljZVNoYXBlIjpbIlRpbWVyU2VydmljZVNoYXBlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAL7URGNjKAAAYygAAC4AAABAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMC9zcmMvZXhvLXV0aWxzLmpzeyJpbXBvcnRzIjpbIi4vdmF0LWRhdGEtYmluZGluZ3MuanMiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiZGVmaW5lRHVyYWJsZUV4b0NsYXNzIiwiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0IiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzIiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0IiwiaWdub3JlQ29udGV4dCIsIm1ha2VFeG9VdGlscyIsInByZXBhcmVFeG8iLCJwcmVwYXJlRXhvQ2xhc3MiLCJwcmVwYXJlRXhvQ2xhc3NLaXQiLCJwcmVwYXJlS2luZCIsInByZXBhcmVLaW5kTXVsdGkiLCJwcmVwYXJlU2luZ2xldG9uIiwicHJvdmlkZUtpbmRIYW5kbGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgaW5pdEVtcHR5LHByb3ZpZGUsZ2xvYmFsVmF0RGF0YTskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJpbml0RW1wdHlcIiwgWyRo4oCNX2EgPT4gKGluaXRFbXB0eSA9ICRo4oCNX2EpXV1dXSxbXCIuL3ZhdC1kYXRhLWJpbmRpbmdzLmpzXCIsIFtbXCJwcm92aWRlXCIsIFskaOKAjV9hID0+IChwcm92aWRlID0gJGjigI1fYSldXSxbXCJWYXREYXRhXCIsIFskaOKAjV9hID0+IChnbG9iYWxWYXREYXRhID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyoqIEB0ZW1wbGF0ZSBMLFIgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDxMLCBSPn0gUmVtb3RhYmxlQnJhbmQgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjxUPn0gRVJlZiAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQmFnZ2FnZX0gQmFnZ2FnZSAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRGVmaW5lS2luZE9wdGlvbnM8VD59IERlZmluZUtpbmRPcHRpb25zICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5LaW5kRmFjZXQ8VD59IEtpbmRGYWNldCAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuS2luZEZhY2V0czxUPn0gS2luZEZhY2V0cyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRHVyYWJsZUtpbmRIYW5kbGV9IER1cmFibGVLaW5kSGFuZGxlICovXG5cbi8qKlxuICogTWFrZSBhIHZlcnNpb24gb2YgdGhlIGFyZ3VtZW50IGZ1bmN0aW9uIHRoYXQgdGFrZXMgYSBraW5kIGNvbnRleHQgYnV0XG4gKiBpZ25vcmVzIGl0LlxuICpcbiAqIEB0eXBlIHs8VCBleHRlbmRzIEZ1bmN0aW9uPihmbjogVCkgPT4gWGltcG9ydCgnLi90eXBlcy5qcycpLlBsdXNDb250ZXh0PG5ldmVyLCBUPn1cbiAqL1xuY29uc3QgICAgICAgIGlnbm9yZUNvbnRleHQ9XG4oZm4pPT5cbihfY29udGV4dCwuLi5hcmdzKT0+XG5mbiguLi5hcmdzKTskaOKAjV9vbmNlLmlnbm9yZUNvbnRleHQoaWdub3JlQ29udGV4dCk7XG5oYXJkZW4oaWdub3JlQ29udGV4dCk7XG5cbi8qIFRPRE86IEZpbmQgYSBnb29kIGhvbWUgZm9yIHRoaXMgZnVuY3Rpb24gdXNlZCBieSBAYWdvcmljL3ZhdC1kYXRhIGFuZCB0ZXN0aW5nIGNvZGUqL1xuY29uc3QgICAgICAgIG1ha2VFeG9VdGlscz0oVmF0RGF0YSk9PntcbmNvbnN0e1xuZGVmaW5lS2luZCxcbmRlZmluZUtpbmRNdWx0aSxcbmRlZmluZUR1cmFibGVLaW5kLFxuZGVmaW5lRHVyYWJsZUtpbmRNdWx0aSxcbm1ha2VLaW5kSGFuZGxlfT1cblZhdERhdGE7XG5cbi8qKlxuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2luZE5hbWVcbiAqIEByZXR1cm5zIHtEdXJhYmxlS2luZEhhbmRsZX1cbiAqL1xuY29uc3QgcHJvdmlkZUtpbmRIYW5kbGU9KGJhZ2dhZ2Usa2luZE5hbWUpPT5cbnByb3ZpZGUoYmFnZ2FnZSwgYCR7a2luZE5hbWV9X2tpbmRIYW5kbGVgLCgpPT5tYWtlS2luZEhhbmRsZShraW5kTmFtZSkpO1xuaGFyZGVuKHByb3ZpZGVLaW5kSGFuZGxlKTtcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2UgcHJlcGFyZUV4b0NsYXNzIGluc3RlYWRcbiAqIEB0eXBlIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUHJlcGFyZUtpbmR9XG4gKi9cbmNvbnN0IHByZXBhcmVLaW5kPShcbmJhZ2dhZ2UsXG5raW5kTmFtZSxcbmluaXQsXG5iZWhhdmlvcixcbm9wdGlvbnM9dW5kZWZpbmVkKT0+XG5cbmRlZmluZUR1cmFibGVLaW5kKFxucHJvdmlkZUtpbmRIYW5kbGUoYmFnZ2FnZSxraW5kTmFtZSksXG5pbml0LFxuYmVoYXZpb3IsXG5vcHRpb25zKTtcblxuaGFyZGVuKHByZXBhcmVLaW5kKTtcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2UgcHJlcGFyZUV4b0NsYXNzS2l0IGluc3RlYWRcbiAqIEB0eXBlIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUHJlcGFyZUtpbmRNdWx0aX1cbiAqL1xuY29uc3QgcHJlcGFyZUtpbmRNdWx0aT0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbml0LFxuYmVoYXZpb3IsXG5vcHRpb25zPXVuZGVmaW5lZCk9PlxuXG5kZWZpbmVEdXJhYmxlS2luZE11bHRpKFxucHJvdmlkZUtpbmRIYW5kbGUoYmFnZ2FnZSxraW5kTmFtZSksXG5pbml0LFxuYmVoYXZpb3IsXG5vcHRpb25zKTtcblxuaGFyZGVuKHByZXBhcmVLaW5kTXVsdGkpO1xuXG4vKiBUT0RPIGludGVyZmFjZUd1YXJkIHR5cGUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy82MjA2Ki9cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55KSA9PiBhbnl9IEkgaW5pdCBzdGF0ZSBmdW5jdGlvblxuICogQHRlbXBsYXRlIFQgYmVoYXZpb3JcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZFxuICogQHBhcmFtIHtJfSBpbml0XG4gKiBAcGFyYW0ge1QgJiBUaGlzVHlwZTx7IHNlbGY6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+IH0+fSBtZXRob2RzXG4gKiBAcGFyYW0ge0RlZmluZUtpbmRPcHRpb25zPHsgc2VsZjogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IGRlZmluZVZpcnR1YWxFeG9DbGFzcz0odGFnLGludGVyZmFjZUd1YXJkLGluaXQsbWV0aG9kcyxvcHRpb25zKT0+XG5kZWZpbmVLaW5kKHRhZyxpbml0LG1ldGhvZHMse1xuLi4ub3B0aW9ucyxcbnRoaXNmdWxNZXRob2RzOnRydWUsXG5pbnRlcmZhY2VHdWFyZH0pO1xuXG5oYXJkZW4oZGVmaW5lVmlydHVhbEV4b0NsYXNzKTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueSkgPT4gYW55fSBJIGluaXQgc3RhdGUgZnVuY3Rpb25cbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgUmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj4+fSBUIGZhY2V0c1xuICogQHBhcmFtIHtzdHJpbmd9IHRhZ1xuICogQHBhcmFtIHthbnl9IGludGVyZmFjZUd1YXJkS2l0XG4gKiBAcGFyYW0ge0l9IGluaXRcbiAqIEBwYXJhbSB7VCAmIFRoaXNUeXBlPHsgZmFjZXRzOiBULCBzdGF0ZTogUmV0dXJuVHlwZTxJPiB9PiB9IGZhY2V0c1xuICogQHBhcmFtIHtEZWZpbmVLaW5kT3B0aW9uczx7IGZhY2V0czogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IGRlZmluZVZpcnR1YWxFeG9DbGFzc0tpdD0oXG50YWcsXG5pbnRlcmZhY2VHdWFyZEtpdCxcbmluaXQsXG5mYWNldHMsXG5vcHRpb25zKT0+XG5cbmRlZmluZUtpbmRNdWx0aSh0YWcsaW5pdCxmYWNldHMse1xuLi4ub3B0aW9ucyxcbnRoaXNmdWxNZXRob2RzOnRydWUsXG5pbnRlcmZhY2VHdWFyZDppbnRlcmZhY2VHdWFyZEtpdH0pO1xuXG5oYXJkZW4oZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0KTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueSkgPT4gYW55fSBJIGluaXQgc3RhdGUgZnVuY3Rpb25cbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IFQgbWV0aG9kc1xuICogQHBhcmFtIHtEdXJhYmxlS2luZEhhbmRsZX0ga2luZEhhbmRsZVxuICogQHBhcmFtIHthbnl9IGludGVyZmFjZUd1YXJkXG4gKiBAcGFyYW0ge0l9IGluaXRcbiAqIEBwYXJhbSB7VCAmIFRoaXNUeXBlPHsgc2VsZjogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IG1ldGhvZHNcbiAqIEBwYXJhbSB7RGVmaW5lS2luZE9wdGlvbnM8eyBzZWxmOiBULCBzdGF0ZTogUmV0dXJuVHlwZTxJPiB9Pn0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7KC4uLmFyZ3M6IFBhcmFtZXRlcnM8ST4pID0+IChUICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+KX1cbiAqL1xuY29uc3QgZGVmaW5lRHVyYWJsZUV4b0NsYXNzPShcbmtpbmRIYW5kbGUsXG5pbnRlcmZhY2VHdWFyZCxcbmluaXQsXG5tZXRob2RzLFxub3B0aW9ucyk9PlxuXG5kZWZpbmVEdXJhYmxlS2luZChraW5kSGFuZGxlLGluaXQsbWV0aG9kcyx7XG4uLi5vcHRpb25zLFxudGhpc2Z1bE1ldGhvZHM6dHJ1ZSxcbmludGVyZmFjZUd1YXJkfSk7XG5cbmhhcmRlbihkZWZpbmVEdXJhYmxlRXhvQ2xhc3MpO1xuXG4vKiBUT0RPIGludGVyZmFjZUd1YXJkIHR5cGUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy82MjA2Ki9cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55KSA9PiBhbnl9IEkgaW5pdCBzdGF0ZSBmdW5jdGlvblxuICogQHRlbXBsYXRlIHtSZWNvcmQ8c3RyaW5nLCBSZWNvcmQ8c3RyaW5nIHwgc3ltYm9sLCBDYWxsYWJsZUZ1bmN0aW9uPj59IFQgZmFjZXRzXG4gKiBAcGFyYW0ge0R1cmFibGVLaW5kSGFuZGxlfSBraW5kSGFuZGxlXG4gKiBAcGFyYW0ge2FueX0gaW50ZXJmYWNlR3VhcmRLaXRcbiAqIEBwYXJhbSB7SX0gaW5pdFxuICogQHBhcmFtIHtUICYgVGhpc1R5cGU8eyBmYWNldHM6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+fT4gfSBmYWNldHNcbiAqIEBwYXJhbSB7RGVmaW5lS2luZE9wdGlvbnM8eyBmYWNldHM6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+fT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IGRlZmluZUR1cmFibGVFeG9DbGFzc0tpdD0oXG5raW5kSGFuZGxlLFxuaW50ZXJmYWNlR3VhcmRLaXQsXG5pbml0LFxuZmFjZXRzLFxub3B0aW9ucyk9PlxuXG5kZWZpbmVEdXJhYmxlS2luZE11bHRpKGtpbmRIYW5kbGUsaW5pdCxmYWNldHMse1xuLi4ub3B0aW9ucyxcbnRoaXNmdWxNZXRob2RzOnRydWUsXG5pbnRlcmZhY2VHdWFyZDppbnRlcmZhY2VHdWFyZEtpdH0pO1xuXG5oYXJkZW4oZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0KTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueSkgPT4gYW55fSBJIGluaXQgc3RhdGUgZnVuY3Rpb25cbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IFQgbWV0aG9kc1xuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2luZE5hbWVcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZFxuICogQHBhcmFtIHtJfSBpbml0XG4gKiBAcGFyYW0ge1QgJiBUaGlzVHlwZTx7IHNlbGY6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+IH0+fSBtZXRob2RzXG4gKiBAcGFyYW0ge0RlZmluZUtpbmRPcHRpb25zPHsgc2VsZjogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IHByZXBhcmVFeG9DbGFzcz0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZCxcbmluaXQsXG5tZXRob2RzLFxub3B0aW9ucz11bmRlZmluZWQpPT5cblxuZGVmaW5lRHVyYWJsZUV4b0NsYXNzKFxucHJvdmlkZUtpbmRIYW5kbGUoYmFnZ2FnZSxraW5kTmFtZSksXG5pbnRlcmZhY2VHdWFyZCxcbmluaXQsXG5tZXRob2RzLFxub3B0aW9ucyk7XG5cbmhhcmRlbihwcmVwYXJlRXhvQ2xhc3MpO1xuXG4vKiBUT0RPIGludGVyZmFjZUd1YXJkIHR5cGUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy82MjA2Ki9cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55KSA9PiBhbnl9IEkgaW5pdCBzdGF0ZSBmdW5jdGlvblxuICogQHRlbXBsYXRlIHtSZWNvcmQ8c3RyaW5nLCBSZWNvcmQ8c3RyaW5nIHwgc3ltYm9sLCBDYWxsYWJsZUZ1bmN0aW9uPj59IFQgZmFjZXRzXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBraW5kTmFtZVxuICogQHBhcmFtIHthbnl9IGludGVyZmFjZUd1YXJkS2l0XG4gKiBAcGFyYW0ge0l9IGluaXRcbiAqIEBwYXJhbSB7VCAmIFRoaXNUeXBlPHsgZmFjZXRzOiBULCBzdGF0ZTogUmV0dXJuVHlwZTxJPiB9PiB9IGZhY2V0c1xuICogQHBhcmFtIHtEZWZpbmVLaW5kT3B0aW9uczx7IGZhY2V0czogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IHByZXBhcmVFeG9DbGFzc0tpdD0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZEtpdCxcbmluaXQsXG5mYWNldHMsXG5vcHRpb25zPXVuZGVmaW5lZCk9PlxuXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3NLaXQoXG5wcm92aWRlS2luZEhhbmRsZShiYWdnYWdlLGtpbmROYW1lKSxcbmludGVyZmFjZUd1YXJkS2l0LFxuaW5pdCxcbmZhY2V0cyxcbm9wdGlvbnMpO1xuXG5oYXJkZW4ocHJlcGFyZUV4b0NsYXNzS2l0KTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IE0gbWV0aG9kc1xuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2luZE5hbWVcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZFxuICogQHBhcmFtIHtNfSBtZXRob2RzXG4gKiBAcGFyYW0ge0RlZmluZUtpbmRPcHRpb25zPHsgc2VsZjogTSB9Pn0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7TSAmIFJlbW90YWJsZUJyYW5kPHt9LCBNPn1cbiAqL1xuY29uc3QgcHJlcGFyZUV4bz0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZCxcbm1ldGhvZHMsXG5vcHRpb25zPXVuZGVmaW5lZCk9Plxue1xuY29uc3QgbWFrZVNpbmdsZXRvbj1wcmVwYXJlRXhvQ2xhc3MoXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZCxcbmluaXRFbXB0eSxcbm1ldGhvZHMsXG5vcHRpb25zKTtcblxuXG5yZXR1cm4gcHJvdmlkZShiYWdnYWdlLCBgJHtraW5kTmFtZX1fc2luZ2xldG9uYCwoKT0+bWFrZVNpbmdsZXRvbigpKTtcbiB9O1xuaGFyZGVuKHByZXBhcmVFeG8pO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IE0gbWV0aG9kc1xuICogQGRlcHJlY2F0ZWQgVXNlIHByZXBhcmVFeG8gaW5zdGVhZC5cbiAqIEBwYXJhbSB7QmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtzdHJpbmd9IGtpbmROYW1lXG4gKiBAcGFyYW0ge019IG1ldGhvZHNcbiAqIEBwYXJhbSB7RGVmaW5lS2luZE9wdGlvbnM8eyBzZWxmOiBNIH0+fSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHtNICYgUmVtb3RhYmxlQnJhbmQ8e30sIE0+fVxuICovXG5jb25zdCBwcmVwYXJlU2luZ2xldG9uPShiYWdnYWdlLGtpbmROYW1lLG1ldGhvZHMsb3B0aW9ucz11bmRlZmluZWQpPT5cbnByZXBhcmVFeG8oYmFnZ2FnZSxraW5kTmFtZSx1bmRlZmluZWQsbWV0aG9kcyxvcHRpb25zKTtcbmhhcmRlbihwcmVwYXJlU2luZ2xldG9uKTtcblxucmV0dXJuIGhhcmRlbih7XG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3MsXG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3MsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvQ2xhc3MsXG5wcmVwYXJlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvLFxucHJlcGFyZVNpbmdsZXRvbixcblxucHJvdmlkZUtpbmRIYW5kbGUsXG5wcmVwYXJlS2luZCxcbnByZXBhcmVLaW5kTXVsdGl9KTtcblxuIH07JGjigI1fb25jZS5tYWtlRXhvVXRpbHMobWFrZUV4b1V0aWxzKTtcblxuY29uc3QgZ2xvYmFsRXhvVXRpbHM9bWFrZUV4b1V0aWxzKGdsb2JhbFZhdERhdGEpO1xuXG5jb25zdCAgICAgICB7XG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3MsXG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3MsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvQ2xhc3MsXG5wcmVwYXJlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvLFxucHJlcGFyZVNpbmdsZXRvbn09XG5nbG9iYWxFeG9VdGlscztcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2UgRXhvcy9FeG9DbGFzc2VzIGluc3RlYWQgb2YgS2luZHNcbiAqLyRo4oCNX29uY2UuZGVmaW5lVmlydHVhbEV4b0NsYXNzKGRlZmluZVZpcnR1YWxFeG9DbGFzcyk7JGjigI1fb25jZS5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQoZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0KTskaOKAjV9vbmNlLmRlZmluZUR1cmFibGVFeG9DbGFzcyhkZWZpbmVEdXJhYmxlRXhvQ2xhc3MpOyRo4oCNX29uY2UuZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0KGRlZmluZUR1cmFibGVFeG9DbGFzc0tpdCk7JGjigI1fb25jZS5wcmVwYXJlRXhvQ2xhc3MocHJlcGFyZUV4b0NsYXNzKTskaOKAjV9vbmNlLnByZXBhcmVFeG9DbGFzc0tpdChwcmVwYXJlRXhvQ2xhc3NLaXQpOyRo4oCNX29uY2UucHJlcGFyZUV4byhwcmVwYXJlRXhvKTskaOKAjV9vbmNlLnByZXBhcmVTaW5nbGV0b24ocHJlcGFyZVNpbmdsZXRvbik7XG5jb25zdCAgICAgICB7cHJvdmlkZUtpbmRIYW5kbGUscHJlcGFyZUtpbmQscHJlcGFyZUtpbmRNdWx0aX09XG5nbG9iYWxFeG9VdGlsczskaOKAjV9vbmNlLnByb3ZpZGVLaW5kSGFuZGxlKHByb3ZpZGVLaW5kSGFuZGxlKTskaOKAjV9vbmNlLnByZXBhcmVLaW5kKHByZXBhcmVLaW5kKTskaOKAjV9vbmNlLnByZXBhcmVLaW5kTXVsdGkocHJlcGFyZUtpbmRNdWx0aSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaWdub3JlQ29udGV4dCI6WyJpZ25vcmVDb250ZXh0Il0sIm1ha2VFeG9VdGlscyI6WyJtYWtlRXhvVXRpbHMiXSwiZGVmaW5lVmlydHVhbEV4b0NsYXNzIjpbImRlZmluZVZpcnR1YWxFeG9DbGFzcyJdLCJkZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQiOlsiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0Il0sImRlZmluZUR1cmFibGVFeG9DbGFzcyI6WyJkZWZpbmVEdXJhYmxlRXhvQ2xhc3MiXSwiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0IjpbImRlZmluZUR1cmFibGVFeG9DbGFzc0tpdCJdLCJwcmVwYXJlRXhvQ2xhc3MiOlsicHJlcGFyZUV4b0NsYXNzIl0sInByZXBhcmVFeG9DbGFzc0tpdCI6WyJwcmVwYXJlRXhvQ2xhc3NLaXQiXSwicHJlcGFyZUV4byI6WyJwcmVwYXJlRXhvIl0sInByZXBhcmVTaW5nbGV0b24iOlsicHJlcGFyZVNpbmdsZXRvbiJdLCJwcm92aWRlS2luZEhhbmRsZSI6WyJwcm92aWRlS2luZEhhbmRsZSJdLCJwcmVwYXJlS2luZCI6WyJwcmVwYXJlS2luZCJdLCJwcmVwYXJlS2luZE11bHRpIjpbInByZXBhcmVLaW5kTXVsdGkiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAO+M9iJIIAACSCAAAKgAAAEBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6WyIuL2V4by11dGlscy5qcyIsIi4vdmF0LWRhdGEtYmluZGluZ3MuanMiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0IiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0IiwibWFrZVNjYWxhck1hcFN0b3JlIiwibWFrZVNjYWxhck1hcFN0b3JlIiwicHJvdmlkZVByb21pc2VXYXRjaGVyIiwicHJvdmlkZVByb21pc2VXYXRjaGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbXV0sW1wiLi92YXQtZGF0YS1iaW5kaW5ncy5qc1wiLCBbXV0sW1wiLi9leG8tdXRpbHMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiQGFnb3JpYy9zdG9yZSI6W1siTSIsIk0iXSxbIm1ha2VTY2FsYXJNYXBTdG9yZSIsIm1ha2VTY2FsYXJNYXBTdG9yZSJdLFsibWFrZVNjYWxhcldlYWtNYXBTdG9yZSIsIm1ha2VTY2FsYXJXZWFrTWFwU3RvcmUiXSxbIm1ha2VTY2FsYXJTZXRTdG9yZSIsIm1ha2VTY2FsYXJTZXRTdG9yZSJdLFsibWFrZVNjYWxhcldlYWtTZXRTdG9yZSIsIm1ha2VTY2FsYXJXZWFrU2V0U3RvcmUiXV0sIi4vdmF0LWRhdGEtYmluZGluZ3MuanMiOltbIm1ha2VLaW5kSGFuZGxlIiwibWFrZUtpbmRIYW5kbGUiXSxbInByb3ZpZGVQcm9taXNlV2F0Y2hlciIsInByb3ZpZGVQcm9taXNlV2F0Y2hlciJdLFsid2F0Y2hQcm9taXNlIiwid2F0Y2hQcm9taXNlIl0sWyJtYWtlU2NhbGFyQmlnTWFwU3RvcmUiLCJtYWtlU2NhbGFyQmlnTWFwU3RvcmUiXSxbIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUiLCJtYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlIl0sWyJtYWtlU2NhbGFyQmlnU2V0U3RvcmUiLCJtYWtlU2NhbGFyQmlnU2V0U3RvcmUiXSxbIm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmUiLCJtYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlIl0sWyJjYW5CZUR1cmFibGUiLCJjYW5CZUR1cmFibGUiXSxbInBpY2tGYWNldCIsInBpY2tGYWNldCJdLFsicGFydGlhbEFzc2lnbiIsInBhcnRpYWxBc3NpZ24iXSxbInByb3ZpZGUiLCJwcm92aWRlIl0sWyJwcm92aWRlRHVyYWJsZU1hcFN0b3JlIiwicHJvdmlkZUR1cmFibGVNYXBTdG9yZSJdLFsicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiLCJwcm92aWRlRHVyYWJsZVdlYWtNYXBTdG9yZSJdLFsicHJvdmlkZUR1cmFibGVTZXRTdG9yZSIsInByb3ZpZGVEdXJhYmxlU2V0U3RvcmUiXSxbInByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlIiwicHJvdmlkZUR1cmFibGVXZWFrU2V0U3RvcmUiXSxbImRlZmluZUtpbmQiLCJkZWZpbmVLaW5kIl0sWyJkZWZpbmVLaW5kTXVsdGkiLCJkZWZpbmVLaW5kTXVsdGkiXSxbImRlZmluZUR1cmFibGVLaW5kIiwiZGVmaW5lRHVyYWJsZUtpbmQiXSxbImRlZmluZUR1cmFibGVLaW5kTXVsdGkiLCJkZWZpbmVEdXJhYmxlS2luZE11bHRpIl1dLCIuL2V4by11dGlscy5qcyI6W1siZGVmaW5lVmlydHVhbEV4b0NsYXNzIiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzIl0sWyJkZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQiLCJkZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQiXSxbImRlZmluZUR1cmFibGVFeG9DbGFzcyIsImRlZmluZUR1cmFibGVFeG9DbGFzcyJdLFsiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0IiwiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0Il0sWyJwcmVwYXJlRXhvQ2xhc3MiLCJwcmVwYXJlRXhvQ2xhc3MiXSxbInByZXBhcmVFeG9DbGFzc0tpdCIsInByZXBhcmVFeG9DbGFzc0tpdCJdLFsicHJlcGFyZUV4byIsInByZXBhcmVFeG8iXSxbInByZXBhcmVTaW5nbGV0b24iLCJwcmVwYXJlU2luZ2xldG9uIl0sWyJpZ25vcmVDb250ZXh0IiwiaWdub3JlQ29udGV4dCJdLFsicHJvdmlkZUtpbmRIYW5kbGUiLCJwcm92aWRlS2luZEhhbmRsZSJdLFsicHJlcGFyZUtpbmQiLCJwcmVwYXJlS2luZCJdLFsicHJlcGFyZUtpbmRNdWx0aSIsInByZXBhcmVLaW5kTXVsdGkiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAN70jyBTKAAAUygAADYAAABAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMC9zcmMvdmF0LWRhdGEtYmluZGluZ3MuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9hc3NlcnQiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiVmF0RGF0YSIsImNhbkJlRHVyYWJsZSIsImRlZmluZUR1cmFibGVLaW5kIiwiZGVmaW5lRHVyYWJsZUtpbmRNdWx0aSIsImRlZmluZUtpbmQiLCJkZWZpbmVLaW5kTXVsdGkiLCJtYWtlS2luZEhhbmRsZSIsIm1ha2VTY2FsYXJCaWdNYXBTdG9yZSIsIm1ha2VTY2FsYXJCaWdTZXRTdG9yZSIsIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUiLCJtYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlIiwibWFrZVN0b3JlVXRpbHMiLCJwYXJ0aWFsQXNzaWduIiwicGlja0ZhY2V0IiwicHJvdmlkZSIsInByb3ZpZGVEdXJhYmxlTWFwU3RvcmUiLCJwcm92aWRlRHVyYWJsZVNldFN0b3JlIiwicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiLCJwcm92aWRlRHVyYWJsZVdlYWtTZXRTdG9yZSIsInByb3ZpZGVQcm9taXNlV2F0Y2hlciIsIndhdGNoUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYWlsLHByb3ZpZGVMYXp5OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJGYWlsXCIsIFskaOKAjV9hID0+IChGYWlsID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcInByb3ZpZGVMYXp5XCIsIFskaOKAjV9hID0+IChwcm92aWRlTGF6eSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG4vKiogQHR5cGUge1hpbXBvcnQoJy4vdHlwZXMnKS5WYXREYXRhfSAqL1xubGV0IFZhdERhdGFHbG9iYWw7XG5pZignVmF0RGF0YSdpbiBnbG9iYWxUaGlzKXtcbmdsb2JhbFRoaXMuVmF0RGF0YXx8RmFpbCBgVmF0RGF0YSBkZWZpbmVkIGluIGdsb2JhbCBhcyBudWxsIG9yIHVuZGVmaW5lZGA7XG5WYXREYXRhR2xvYmFsPWdsb2JhbFRoaXMuVmF0RGF0YTtcbiB9ZWxzZXtcbi8qIFhYWCB0aGlzIG1vZHVsZSBoYXMgYmVlbiBrbm93biB0byBnZXQgaW1wb3J0ZWQgKHRyYW5zaXRpdmVseSkgaW4gY2FzZXMgdGhhdCovXG4vKiBuZXZlciB1c2UgaXQgc28gd2UgbWFrZSBhIHZlcnNpb24gdGhhdCB3aWxsIHNhdGlzZnkgbW9kdWxlIHJlc29sdXRpb24gYnV0Ki9cbi8qIGZhaWwgYXQgcnVudGltZS4qL1xuY29uc3QgdW52YWlsYWJsZT0oKT0+RmFpbCBgVmF0RGF0YSB1bmF2YWlsYWJsZWA7XG5WYXREYXRhR2xvYmFsPXtcbmRlZmluZUtpbmQ6dW52YWlsYWJsZSxcbmRlZmluZUtpbmRNdWx0aTp1bnZhaWxhYmxlLFxuZGVmaW5lRHVyYWJsZUtpbmQ6dW52YWlsYWJsZSxcbmRlZmluZUR1cmFibGVLaW5kTXVsdGk6dW52YWlsYWJsZSxcbm1ha2VLaW5kSGFuZGxlOnVudmFpbGFibGUsXG5wcm92aWRlUHJvbWlzZVdhdGNoZXI6dW52YWlsYWJsZSxcbndhdGNoUHJvbWlzZTp1bnZhaWxhYmxlLFxubWFrZVNjYWxhckJpZ01hcFN0b3JlOnVudmFpbGFibGUsXG5tYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlOnVudmFpbGFibGUsXG5tYWtlU2NhbGFyQmlnU2V0U3RvcmU6dW52YWlsYWJsZSxcbm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmU6dW52YWlsYWJsZSxcbmNhbkJlRHVyYWJsZTp1bnZhaWxhYmxlfTtcblxuIH1cblxuY29uc3QgVmF0RGF0YUV4cG9ydD1WYXREYXRhR2xvYmFsOyRo4oCNX29uY2UuVmF0RGF0YUV4cG9ydChWYXREYXRhRXhwb3J0KTtcblxuXG4vKipcbiAqIEBkZXByZWNhdGVkIFVzZSBFeG9zL0V4b0NsYXNzZXMgaW5zdGVhZCBvZiBLaW5kc1xuICovXG5jb25zdCAgICAgICB7XG5kZWZpbmVLaW5kLFxuZGVmaW5lS2luZE11bHRpLFxuZGVmaW5lRHVyYWJsZUtpbmQsXG5kZWZpbmVEdXJhYmxlS2luZE11bHRpfT1cblZhdERhdGFHbG9iYWw7JGjigI1fb25jZS5kZWZpbmVLaW5kKGRlZmluZUtpbmQpOyRo4oCNX29uY2UuZGVmaW5lS2luZE11bHRpKGRlZmluZUtpbmRNdWx0aSk7JGjigI1fb25jZS5kZWZpbmVEdXJhYmxlS2luZChkZWZpbmVEdXJhYmxlS2luZCk7JGjigI1fb25jZS5kZWZpbmVEdXJhYmxlS2luZE11bHRpKGRlZmluZUR1cmFibGVLaW5kTXVsdGkpO1xuXG5jb25zdCAgICAgICB7XG5tYWtlS2luZEhhbmRsZSxcbnByb3ZpZGVQcm9taXNlV2F0Y2hlcixcbndhdGNoUHJvbWlzZSxcbm1ha2VTY2FsYXJCaWdNYXBTdG9yZSxcbm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUsXG5tYWtlU2NhbGFyQmlnU2V0U3RvcmUsXG5tYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlLFxuY2FuQmVEdXJhYmxlfT1cblZhdERhdGFHbG9iYWw7XG5cbi8qKlxuICogV2hlbiBtYWtpbmcgYSBtdWx0aS1mYWNldCBraW5kLCBpdCdzIGNvbW1vbiB0byBwaWNrIG9uZSBmYWNldCB0byBleHBvc2UuIEUuZy4sXG4gKlxuICogICAgIGNvbnN0IG1ha2VGb28gPSAoYSwgYiwgYywgZCkgPT4gbWFrZUZvb0Jhc2UoYSwgYiwgYywgZCkuc2VsZjtcbiAqXG4gKiBUaGlzIGhlbHBlciByZWR1Y2VzIHRoZSBkdXBsaWNhdGlvbjpcbiAqXG4gKiAgICAgY29uc3QgbWFrZUZvbyA9IHBpY2tGYWNldChtYWtlRm9vQmFzZSwgJ3NlbGYnKTtcbiAqXG4gKiBAdHlwZSB7WGltcG9ydCgnLi90eXBlcycpLlBpY2tGYWNldH1cbiAqLyRo4oCNX29uY2UubWFrZUtpbmRIYW5kbGUobWFrZUtpbmRIYW5kbGUpOyRo4oCNX29uY2UucHJvdmlkZVByb21pc2VXYXRjaGVyKHByb3ZpZGVQcm9taXNlV2F0Y2hlcik7JGjigI1fb25jZS53YXRjaFByb21pc2Uod2F0Y2hQcm9taXNlKTskaOKAjV9vbmNlLm1ha2VTY2FsYXJCaWdNYXBTdG9yZShtYWtlU2NhbGFyQmlnTWFwU3RvcmUpOyRo4oCNX29uY2UubWFrZVNjYWxhckJpZ1dlYWtNYXBTdG9yZShtYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlKTskaOKAjV9vbmNlLm1ha2VTY2FsYXJCaWdTZXRTdG9yZShtYWtlU2NhbGFyQmlnU2V0U3RvcmUpOyRo4oCNX29uY2UubWFrZVNjYWxhckJpZ1dlYWtTZXRTdG9yZShtYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlKTskaOKAjV9vbmNlLmNhbkJlRHVyYWJsZShjYW5CZUR1cmFibGUpO1xuY29uc3QgICAgICAgIHBpY2tGYWNldD1cbihtYWtlcixmYWNldE5hbWUpPT5cbiguLi5hcmdzKT0+XG5tYWtlciguLi5hcmdzKVtmYWNldE5hbWVdOyRo4oCNX29uY2UucGlja0ZhY2V0KHBpY2tGYWNldCk7XG5oYXJkZW4ocGlja0ZhY2V0KTtcblxuLyoqXG4gKiBBc3NpZ24gdGhlIHZhbHVlcyBvZiBhbGwgb2YgdGhlIGVudW1lcmFibGUgb3duIHByb3BlcnRpZXMgZnJvbSB0aGUgc291cmNlXG4gKiBvYmplY3QgdG8gdGhlaXIga2V5cyBpbiB0aGUgdGFyZ2V0IG9iamVjdC5cbiAqXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge1R9IHRhcmdldFxuICogQHBhcmFtIHtQYXJ0aWFsPFQ+fSBzb3VyY2VcbiAqL1xuY29uc3QgICAgICAgIHBhcnRpYWxBc3NpZ249KHRhcmdldCxzb3VyY2UpPT57XG5PYmplY3QuYXNzaWduKHRhcmdldCxzb3VyY2UpO1xuIH07JGjigI1fb25jZS5wYXJ0aWFsQXNzaWduKHBhcnRpYWxBc3NpZ24pO1xuaGFyZGVuKHBhcnRpYWxBc3NpZ24pO1xuXG4vKiBYWFggY29waWVkIGZyb20gQGFnb3JpYy9zdG9yZSB0eXBlcyovXG4vKiBVTlRJTCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQ1NjAqL1xuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yZU9wdGlvbnNcbiAqIE9mIHRoZSBkaW1lbnNpb25zIG9uIHdoaWNoIEtleWVkU3RvcmVzIGNhbiBkaWZmZXIsIHdlIG9ubHkgcmVwcmVzZW50IGEgZmV3XG4gKiBvZiB0aGVtIGFzIHN0YW5kYXJkIG9wdGlvbnMuIEEgZ2l2ZW4gc3RvcmUgbWFrZXIgc2hvdWxkIGRvY3VtZW50IHdoaWNoXG4gKiBvcHRpb25zIGl0IHN1cHBvcnRzLCBhcyB3ZWxsIGFzIGl0cyBwb3NpdGlvbnMgb24gZGltZW5zaW9ucyBmb3Igd2hpY2ggaXRcbiAqIGRvZXMgbm90IHN1cHBvcnQgb3B0aW9ucy5cbiAqIEBwcm9wZXJ0eSB7Ym9vbGVhbn0gW2xvbmdMaXZlZD10cnVlXSBXaGljaCB3YXkgdG8gb3B0aW1pemUgYSB3ZWFrIHN0b3JlLiBUcnVlIG1lYW5zXG4gKiB0aGF0IHdlIGV4cGVjdCB0aGlzIHdlYWsgc3RvcmUgdG8gb3V0bGl2ZSBtb3N0IG9mIGl0cyBrZXlzLCBpbiB3aGljaFxuICogY2FzZSB3ZSBpbnRlcm5hbGx5IG1heSB1c2UgYSBKYXZhU2NyaXB0IGBXZWFrTWFwYC4gT3RoZXJ3aXNlIHdlIGludGVybmFsbHlcbiAqIG1heSB1c2UgYSBKYXZhU2NyaXB0IGBNYXBgLlxuICogRGVmYXVsdHMgdG8gdHJ1ZSwgc28gcGxlYXNlIG1hcmsgc2hvcnQgbGl2ZWQgc3RvcmVzIGV4cGxpY2l0bHkuXG4gKiBAcHJvcGVydHkge2Jvb2xlYW59IFtkdXJhYmxlPWZhbHNlXSAgVGhlIGNvbnRlbnRzIG9mIHRoaXMgc3RvcmUgc3Vydml2ZSB0ZXJtaW5hdGlvblxuICogICBvZiBpdHMgY29udGFpbmluZyBwcm9jZXNzLCBhbGxvd2luZyBmb3IgcmVzdGFydCBvciB1cGdyYWRlIGJ1dCBhdCB0aGUgY29zdFxuICogICBvZiBmb3JiaWRkaW5nIHN0b3JhZ2Ugb2YgcmVmZXJlbmNlcyB0byBlcGhlbWVyYWwgZGF0YS4gIERlZmF1bHRzIHRvIGZhbHNlLlxuICogQHByb3BlcnR5IHtib29sZWFufSBbZmFrZUR1cmFibGU9ZmFsc2VdICBUaGlzIHN0b3JlIHByZXRlbmRzIHRvIGJlIGEgZHVyYWJsZSBzdG9yZVxuICogICBidXQgZG9lcyBub3QgZW5mb3JjZSB0aGF0IHRoZSB0aGluZ3Mgc3RvcmVkIGluIGl0IGFjdHVhbGx5IGJlIHRoZW1zZWx2ZXNcbiAqICAgZHVyYWJsZSAod2hlcmVhcyBhbiBhY3R1YWwgZHVyYWJsZSBzdG9yZSB3b3VsZCBmb3JiaWQgc3RvcmFnZSBvZiBzdWNoXG4gKiAgIGl0ZW1zKS4gIFRoaXMgaXMgaW4gc2VydmljZSBvZiBhbGxvd2luZyBpbmNyZW1lbnRhbCB0cmFuc2l0aW9uIHRvIHVzZSBvZlxuICogICBkdXJhYmxlIHN0b3JlcywgdG8gZW5hYmxlIG5vcm1hbCBvcGVyYXRpb24gYW5kIHRlc3Rpbmcgd2hlbiBzb21lIHN0dWZmXG4gKiAgIGludGVuZGVkIHRvIGV2ZW50dWFsbHkgYmUgZHVyYWJsZSBoYXMgbm90IHlldCBiZWVuIG1hZGUgZHVyYWJsZS4gIEEgc3RvcmVcbiAqICAgbWFya2VkIGFzIGZha2VEdXJhYmxlIHdpbGwgYXBwZWFyIHRvIG9wZXJhdGUgbm9ybWFsbHkgYnV0IGFueSBhdHRlbXB0IHRvXG4gKiAgIHVwZ3JhZGUgaXRzIGNvbnRhaW5pbmcgdmF0IHdpbGwgZmFpbCB3aXRoIGFuIGVycm9yLlxuICogQHByb3BlcnR5IHtYaW1wb3J0KCcuL3R5cGVzJykuUGF0dGVybn0gW2tleVNoYXBlXVxuICogQHByb3BlcnR5IHtYaW1wb3J0KCcuL3R5cGVzJykuUGF0dGVybn0gW3ZhbHVlU2hhcGVdXG4gKi9cbi8qKlxuICogVW5saWtlIGBwcm92aWRlTGF6eWAsIGBwcm92aWRlYCBzaG91bGQgYmUgY2FsbGVkIGF0IG1vc3Qgb25jZVxuICogd2l0aGluIGFueSB2YXQgaW5jYXJuYXRpb24gd2l0aCBhIGdpdmVuIGBiYWdnYWdlYCxga2V5YCBwYWlyLlxuICpcbiAqIGBwcm92aWRlYCBzaG91bGQgb25seSB0byBiZSB1c2VkIHRvIHBvcHVsYXRlIGJhZ2dhZ2UsXG4gKiB3aGVyZSB0aGUgdG90YWwgbnVtYmVyIG9mIGNhbGxzIHRvIGBwcm92aWRlYCBtdXN0IGJlXG4gKiBsb3cgY2FyZGluYWxpdHksIHNpbmNlIHdlIGtlZXAgdGhlIGJvb2trZWVwaW5nIHRvIGRldGVjdCBjb2xsaXNpb25zXG4gKiBpbiBub3JtYWwgbGFuZ3VhZ2UtaGVhcCBtZW1vcnkuIEFsbCB0aGUgb3RoZXIgYmFnZ2FnZS1vcmllbnRlZFxuICogYHByb3ZpZGUqYCBhbmQgYHByZXBhcmUqYCBmdW5jdGlvbnMgY2FsbCBgcHJvdmlkZWAsXG4gKiBhbmQgc28gaW1wb3NlIHRoZSBzYW1lIGNvbnN0cmFpbnRzLiBUaGlzIGlzIGNvbnNpc3RlbnQgd2l0aFxuICogb3VyIGV4cGVjdGVkIGR1cmFiaWxpdHkgcGF0dGVybnM6IFdoYXQgd2Ugc3RvcmUgaW4gYmFnZ2FnZSBhcmVcbiAqICAgICoga2luZEhhbmRsZXMsIHdoaWNoIGFyZSBwZXIga2luZCwgd2hpY2ggbXVzdCBiZSBsb3cgY2FyZGluYWxpdHlcbiAqICAgICogZGF0YSBcInZhcmlhYmxlc1wiIGZvciByZWVzdGFibGlzaGluZyB0aGUgbGV4aWNhbCBzY29wZSwgZXNwZWNpYWxseVxuICogICAgICBvZiBzaW5nbGV0b25zXG4gKiAgICAqIG5hbWVkIG5vbi1iYWdnYWdlIGNvbGxlY3Rpb25zIGF0IHRoZSBsZWF2ZXMgb2YgdGhlIGJhZ2dhZ2UgdHJlZS5cbiAqXG4gKiBXaGF0IGlzIGV4cGVjdGVkIHRvIGJlIGhpZ2ggY2FyZGluYWxpdHkgYXJlIHRoZSBpbnN0YW5jZXMgb2YgdGhlIGtpbmRzLFxuICogYW5kIHRoZSBtZW1iZXJzIG9mIHRoZSBub24tYmFnZ2dhZ2UgY29sbGVjdGlvbnMuXG4gKlxuICogVE9ETyBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvcHVsbC81ODc1IDpcbiAqIEltcGxlbWVudCBkZXZlbG9wbWVudC10aW1lIGluc3RydW1lbnRhdGlvbiB0byBkZXRlY3Qgd2hlblxuICogYHByb3ZpZGVgIHZpb2xhdGVzIHRoZSBhYm92ZSBwcmVzY3JpcHRpb24sIGFuZCBpcyBjYWxsZWQgbW9yZVxuICogdGhhbiBvbmNlIGluIHRoZSBzYW1lIHZhdCBpbmNhcm5hdGlvbiB3aXRoIHRoZSBzYW1lXG4gKiBiYWdnYWdlLGtleSBwYWlyLlxuICovXG5cbmNvbnN0ICAgICAgICBwcm92aWRlPVxuLyogWFhYIGNhc3QgYmVjYXVzZSBwcm92aWRlTGF6eSBpcyBgYW55YCBkdWUgdG8gYnJva2VuIHR5cGUgaW1wb3J0Ki9cbi8qKiBAdHlwZSB7PEssIFY+KGJhZ2dhZ2U6IFhpbXBvcnQoJy4vdHlwZXMuanMnKS5CYWdnYWdlLCBrZXk6IEssIG1ha2VWYWx1ZTogKGtleTogSykgPT4gVikgPT4gVn0gKi9cbnByb3ZpZGVMYXp5O1xuXG5cbi8qIFRPRE86IEZpbmQgYSBnb29kIGhvbWUgZm9yIHRoaXMgZnVuY3Rpb24gdXNlZCBieSBAYWdvcmljL3ZhdC1kYXRhIGFuZCB0ZXN0aW5nIGNvZGUqL1xuLyoqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YS9zcmMvdHlwZXMnKS5WYXREYXRhfSBWYXREYXRhICovJGjigI1fb25jZS5wcm92aWRlKHByb3ZpZGUpO1xuY29uc3QgICAgICAgIG1ha2VTdG9yZVV0aWxzPShWYXREYXRhKT0+e1xuY29uc3R7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIHRoZXNlIGxpdGVyYWxseSBkbyBzaGFkb3cgdGhlIGdsb2JhbHMqL1xubWFrZVNjYWxhckJpZ01hcFN0b3JlLFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXNoYWRvdyAtLSB0aGVzZSBsaXRlcmFsbHkgZG8gc2hhZG93IHRoZSBnbG9iYWxzKi9cbm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUsXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIHRoZXNlIGxpdGVyYWxseSBkbyBzaGFkb3cgdGhlIGdsb2JhbHMqL1xubWFrZVNjYWxhckJpZ1NldFN0b3JlLFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXNoYWRvdyAtLSB0aGVzZSBsaXRlcmFsbHkgZG8gc2hhZG93IHRoZSBnbG9iYWxzKi9cbm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmV9PVxuVmF0RGF0YTtcblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtPbWl0PFN0b3JlT3B0aW9ucywgJ2R1cmFibGUnPn0gb3B0aW9uc1xuICovXG5jb25zdCBwcm92aWRlRHVyYWJsZU1hcFN0b3JlPShiYWdnYWdlLG5hbWUsb3B0aW9ucz17fSk9PlxucHJvdmlkZShiYWdnYWdlLG5hbWUsKCk9PlxubWFrZVNjYWxhckJpZ01hcFN0b3JlKG5hbWUse2R1cmFibGU6dHJ1ZSwuLi5vcHRpb25zfSkpO1xuXG5oYXJkZW4ocHJvdmlkZUR1cmFibGVNYXBTdG9yZSk7XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzJykuQmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtzdHJpbmd9IG5hbWVcbiAqIEBwYXJhbSB7T21pdDxTdG9yZU9wdGlvbnMsICdkdXJhYmxlJz59IG9wdGlvbnNcbiAqL1xuY29uc3QgcHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmU9KGJhZ2dhZ2UsbmFtZSxvcHRpb25zPXt9KT0+XG5wcm92aWRlKGJhZ2dhZ2UsbmFtZSwoKT0+XG5tYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlKG5hbWUse2R1cmFibGU6dHJ1ZSwuLi5vcHRpb25zfSkpO1xuXG5oYXJkZW4ocHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUpO1xuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcycpLkJhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBuYW1lXG4gKiBAcGFyYW0ge09taXQ8U3RvcmVPcHRpb25zLCAnZHVyYWJsZSc+fSBvcHRpb25zXG4gKi9cbmNvbnN0IHByb3ZpZGVEdXJhYmxlU2V0U3RvcmU9KGJhZ2dhZ2UsbmFtZSxvcHRpb25zPXt9KT0+XG5wcm92aWRlKGJhZ2dhZ2UsbmFtZSwoKT0+XG5tYWtlU2NhbGFyQmlnU2V0U3RvcmUobmFtZSx7ZHVyYWJsZTp0cnVlLC4uLm9wdGlvbnN9KSk7XG5cbmhhcmRlbihwcm92aWRlRHVyYWJsZVNldFN0b3JlKTtcblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtPbWl0PFN0b3JlT3B0aW9ucywgJ2R1cmFibGUnPn0gb3B0aW9uc1xuICovXG5jb25zdCBwcm92aWRlRHVyYWJsZVdlYWtTZXRTdG9yZT0oYmFnZ2FnZSxuYW1lLG9wdGlvbnM9e30pPT5cbnByb3ZpZGUoYmFnZ2FnZSxuYW1lLCgpPT5cbm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmUobmFtZSx7ZHVyYWJsZTp0cnVlLC4uLm9wdGlvbnN9KSk7XG5cbmhhcmRlbihwcm92aWRlRHVyYWJsZVdlYWtTZXRTdG9yZSk7XG5cbnJldHVybiBoYXJkZW4oe1xucHJvdmlkZUR1cmFibGVNYXBTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlLFxucHJvdmlkZUR1cmFibGVTZXRTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZVN0b3JlVXRpbHMobWFrZVN0b3JlVXRpbHMpO1xuXG5jb25zdCBnbG9iYWxTdG9yZVV0aWxzPW1ha2VTdG9yZVV0aWxzKFZhdERhdGFHbG9iYWwpO1xuY29uc3QgICAgICAge1xucHJvdmlkZUR1cmFibGVNYXBTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlLFxucHJvdmlkZUR1cmFibGVTZXRTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlfT1cbmdsb2JhbFN0b3JlVXRpbHM7JGjigI1fb25jZS5wcm92aWRlRHVyYWJsZU1hcFN0b3JlKHByb3ZpZGVEdXJhYmxlTWFwU3RvcmUpOyRo4oCNX29uY2UucHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUocHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUpOyRo4oCNX29uY2UucHJvdmlkZUR1cmFibGVTZXRTdG9yZShwcm92aWRlRHVyYWJsZVNldFN0b3JlKTskaOKAjV9vbmNlLnByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlKHByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJWYXREYXRhIjpbIlZhdERhdGFFeHBvcnQiXSwiZGVmaW5lS2luZCI6WyJkZWZpbmVLaW5kIl0sImRlZmluZUtpbmRNdWx0aSI6WyJkZWZpbmVLaW5kTXVsdGkiXSwiZGVmaW5lRHVyYWJsZUtpbmQiOlsiZGVmaW5lRHVyYWJsZUtpbmQiXSwiZGVmaW5lRHVyYWJsZUtpbmRNdWx0aSI6WyJkZWZpbmVEdXJhYmxlS2luZE11bHRpIl0sIm1ha2VLaW5kSGFuZGxlIjpbIm1ha2VLaW5kSGFuZGxlIl0sInByb3ZpZGVQcm9taXNlV2F0Y2hlciI6WyJwcm92aWRlUHJvbWlzZVdhdGNoZXIiXSwid2F0Y2hQcm9taXNlIjpbIndhdGNoUHJvbWlzZSJdLCJtYWtlU2NhbGFyQmlnTWFwU3RvcmUiOlsibWFrZVNjYWxhckJpZ01hcFN0b3JlIl0sIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUiOlsibWFrZVNjYWxhckJpZ1dlYWtNYXBTdG9yZSJdLCJtYWtlU2NhbGFyQmlnU2V0U3RvcmUiOlsibWFrZVNjYWxhckJpZ1NldFN0b3JlIl0sIm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmUiOlsibWFrZVNjYWxhckJpZ1dlYWtTZXRTdG9yZSJdLCJjYW5CZUR1cmFibGUiOlsiY2FuQmVEdXJhYmxlIl0sInBpY2tGYWNldCI6WyJwaWNrRmFjZXQiXSwicGFydGlhbEFzc2lnbiI6WyJwYXJ0aWFsQXNzaWduIl0sInByb3ZpZGUiOlsicHJvdmlkZSJdLCJtYWtlU3RvcmVVdGlscyI6WyJtYWtlU3RvcmVVdGlscyJdLCJwcm92aWRlRHVyYWJsZU1hcFN0b3JlIjpbInByb3ZpZGVEdXJhYmxlTWFwU3RvcmUiXSwicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiOlsicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiXSwicHJvdmlkZUR1cmFibGVTZXRTdG9yZSI6WyJwcm92aWRlRHVyYWJsZVNldFN0b3JlIl0sInByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlIjpbInByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAALLT47GtEgAArRIAADsAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvZHVyYWJpbGl0eS5qc3siaW1wb3J0cyI6WyJAYWdvcmljL2ludGVybmFsIiwiQGFnb3JpYy92YXQtZGF0YSIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiXSwiZXhwb3J0cyI6WyJtYWtlRXBoZW1lcmFQcm92aWRlciIsInByb3ZpZGVBbGwiLCJwcm92aWRlRW1wdHlTZWF0IiwicHJvdmlkZVNpbmdsZXRvbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhbGxWYWx1ZXMsb2JqZWN0TWFwLHByb3ZpZGUsRTskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2ludGVybmFsXCIsIFtbXCJhbGxWYWx1ZXNcIiwgWyRo4oCNX2EgPT4gKGFsbFZhbHVlcyA9ICRo4oCNX2EpXV0sW1wib2JqZWN0TWFwXCIsIFskaOKAjV9hID0+IChvYmplY3RNYXAgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wicHJvdmlkZVwiLCBbJGjigI1fYSA9PiAocHJvdmlkZSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG4vKipcbiAqIFNDQUxFOiBPbmx5IGZvciBsb3cgY2FyZGluYWxpdHkgcHJvdmlzaW9uaW5nLiBFdmVyeSB2YWx1ZSBmcm9tIGluaXQoKSB3aWxsXG4gKiByZW1haW4gaW4gdGhlIG1hcCBmb3IgdGhlIGxpZmV0aW1lIG9mIHRoZSBoZWFwLiBJZiBhIGtleSBvYmplY3QgaXMgR0NlZCwgaXRzXG4gKiByZXByZXNlbnRhdGl2ZSBhbHNvIHJlbWFpbnMuXG4gKlxuICogQHRlbXBsYXRlIHt7fX0gRSBFcGhlbWVyYWwgc3RhdGVcbiAqIEB0ZW1wbGF0ZSB7e319IFtLPWFueV0ga2V5IG9uIHdoaWNoIHRvIHByb3Zpc2lvblxuICogQHBhcmFtIHsoa2V5OiBLKSA9PiBFfSBpbml0XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRXBoZW1lcmFQcm92aWRlcj0oaW5pdCk9Pntcbi8qKiBAdHlwZSB7V2Vha01hcDxLLCBFPn0gKi9cbmNvbnN0IGV4dGFudD1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIFByb3ZpZGUgYW4gb2JqZWN0IHRvIGhvbGQgc3RhdGUgdGhhdCBuZWVkIG5vdCAob3IgY2Fubm90KSBiZSBkdXJhYmxlLlxuICpcbiAqIEB0eXBlIHsoa2V5OiBLKSA9PiBFfVxuICovXG5yZXR1cm4oa2V5KT0+e1xuaWYoZXh0YW50LmhhcyhrZXkpKXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCovXG5yZXR1cm4gZXh0YW50LmdldChrZXkpO1xuIH1cbmNvbnN0IG5ld0VwaD1pbml0KGtleSk7XG5leHRhbnQuc2V0KGtleSxuZXdFcGgpO1xucmV0dXJuIG5ld0VwaDtcbiB9O1xuIH07JGjigI1fb25jZS5tYWtlRXBoZW1lcmFQcm92aWRlcihtYWtlRXBoZW1lcmFQcm92aWRlcik7XG5oYXJkZW4obWFrZUVwaGVtZXJhUHJvdmlkZXIpO1xuXG4vKipcbiAqIFByb3ZpZGUgYW4gZW1wdHkgWkNGIHNlYXQuXG4gKlxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL2VydHAnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge1pDRlNlYXR9XG4gKi9cbmNvbnN0ICAgICAgICBwcm92aWRlRW1wdHlTZWF0PSh6Y2YsYmFnZ2FnZSxuYW1lKT0+e1xucmV0dXJuIHByb3ZpZGUoYmFnZ2FnZSxuYW1lLCgpPT56Y2YubWFrZUVtcHR5U2VhdEtpdCgpLnpjZlNlYXQpO1xuIH07JGjigI1fb25jZS5wcm92aWRlRW1wdHlTZWF0KHByb3ZpZGVFbXB0eVNlYXQpO1xuaGFyZGVuKHByb3ZpZGVFbXB0eVNlYXQpO1xuXG4vKipcbiAqIEZvciB1c2UgaW4gY29udHJhY3QgdXBncmFkZXMgdG8gcHJvdmlkZSB2YWx1ZXMgdGhhdCBjb21lIGZyb20gb3RoZXIgdmF0cy5cbiAqIEFsbCB2YXRzIG11c3QgYmUgYWJsZSB0byBmaW5pc2ggdGhlaXIgdXBncmFkZSB3aXRob3V0IGNvbnRhY3Rpbmcgb3RoZXIgdmF0cyxcbiAqIHNvIHdoYXRldmVyIHZhbHVlcyBhbiBpbnN0YW5jZSBuZWVkcyBmcm9tIG90aGVyIHZhdHMgbXVzdCBiZSBzYXZlZCBpbiB0aGUgZmlyc3RcbiAqIGluY2FybmF0aW9uIGFuZCByZWFkIGZyb20gYmFnZ2FnZSBpbiBlYWNoIHN1YnNlcXVlbnQuXG4gKlxuICogVGhpcyBhYnN0cmFjdHMgdGhhdCBjb25kaXRpb24gc28gdGhhdCB0aGUgY29udHJhY3QgY2FuIGNvbnZlcnQgYSBkaWN0aW9uYXJ5XG4gKiBvZiB0aHVua3MgaW50byBhIGRpY3Rpb25hcnkgb2YgdmFsdWVzIGR1cmluZyBpdHMgZmlyc3QgYHByZXBhcmVgIChzdGFydCkuXG4gKiBFYWNoIHN1YnNlcXVlbnQgYHByZXBhcmVgIGNhbGwgd2lsbCBhdXRvbWF0aWNhbGx5IHJlYWQgZnJvbSB0aGUgYmFnZ2FnZSBhbmRcbiAqIGVzY2hldyByZW1vdGUgY2FsbHMuXG4gKlxuICogVGhlIHZhbHVlcyBhcmUgdGh1bmtzIGluc3RlYWQgb2YgcHJvbWlzZXMgc28gdGhhdCB0aGV5IGRvbid0IHN0YXJ0IGV4ZWN1dGluZ1xuICogdW5uZWNlc3NhcmlseSBvciBpbmR1Y2UgZmFpbHVyZXMuXG4gKlxuICogRm9yIGV4YW1wbGUsXG4gKlxuICogICAgIGNvbnN0IGludml0YXRpb25Jc3N1ZXJQID0gRSh6b2UpLmdldEludml0YXRpb25Jc3N1ZXIoKTtcbiAqICAgICBjb25zdCB7XG4gKiAgICAgICBpbnZpdGF0aW9uSXNzdWVyLFxuICogICAgICAgaW52aXRhdGlvbkJyYW5kLFxuICogICAgIH0gPSBhd2FpdCBwcm92aWRlQWxsKGJhZ2dhZ2UsIHtcbiAqICAgICAgIGludml0YXRpb25Jc3N1ZXI6ICgpID0+IGludml0YXRpb25Jc3N1ZXJQLFxuICogICAgICAgaW52aXRhdGlvbkJyYW5kOiAoKSA9PiBFKGludml0YXRpb25Jc3N1ZXJQKS5nZXRCcmFuZCgpLFxuICogICAgIH0pO1xuICpcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgKCkgPT4gRVJlZjxhbnk+Pn0gVCBkaWN0IG9mIHRodW5rcyAocHJvbWlzZSBtYWtlcnMpXG4gKiBAcGFyYW0ge01hcFN0b3JlPHN0cmluZywgYW55Pn0gYmFnZ2FnZVxuICogQHBhcmFtIHtUfSB0aHVua3NcbiAqIEByZXR1cm5zIHtQcm9taXNlPHsgW0sgaW4ga2V5b2YgVF06IEF3YWl0ZWQ8UmV0dXJuVHlwZTxUW0tdPj4gfT59XG4gKi9cbmNvbnN0ICAgICAgICBwcm92aWRlQWxsPShiYWdnYWdlLHRodW5rcyk9PntcbmNvbnN0IGtleXM9T2JqZWN0LmtleXModGh1bmtzKTtcbi8qIGFzc3VtZSBpZiBhbnkga2V5cyBhcmUgZGVmaW5lZCB0aGV5IGFsbCBhcmUqL1xuY29uc3QgaW5CYWdnYWdlPWJhZ2dhZ2UuaGFzKGtleXNbMF0pO1xuaWYoaW5CYWdnYWdlKXtcbmNvbnN0IG9iaj1vYmplY3RNYXAoXG50aHVua3MsXG4vKiogQHR5cGUgeyh2YWx1ZTogYW55LCBrZXk6IHN0cmluZykgPT4gYW55fSAqL1xuKF8sayk9PmJhZ2dhZ2UuZ2V0KGspKTtcblxucmV0dXJuIFByb21pc2UucmVzb2x2ZShoYXJkZW4ob2JqKSk7XG4gfVxuXG5jb25zdCBrZXllZFByb21pc2VzPW9iamVjdE1hcCh0aHVua3MsKGZuKT0+Zm4oKSk7XG5cbnJldHVybiBhbGxWYWx1ZXMoa2V5ZWRQcm9taXNlcykudGhlbigoa2V5ZWRWYWxzKT0+e1xuZm9yKGNvbnN0W2ssdl1vZiBPYmplY3QuZW50cmllcyhrZXllZFZhbHMpKXtcbmJhZ2dhZ2UuaW5pdChrLHYpO1xuIH1cbnJldHVybiBrZXllZFZhbHM7XG4gfSk7XG4gfTskaOKAjV9vbmNlLnByb3ZpZGVBbGwocHJvdmlkZUFsbCk7XG5oYXJkZW4ocHJvdmlkZUFsbCk7XG5cbi8qKlxuICogTGlrZSBwcm92aWRlQXN5bmMgaW4gQXRvbWljUHJvdmlkZXIgYnV0IGFzc3VtZXMgb25seSBvbmUgY2FsbCBzbyB0aGVyZSBhcmUgbm8gcmFjZSBjb25kaXRpb25zLlxuICogQWRkaXRpb25hbGx5IG9mZmVycyBhIGB3aXRoVmFsdWVgIGhlbHBlciB1c2VmdWwgZm9yIHRyaWdnZXJpbmcgcHJvY2VzZXNzIG9uIGEgcHJvdmlkZWQgb2JqZWN0LlxuICpcbiAqIEBzZWUge21ha2VBdG9taWNQcm92aWRlcn1cbiAqIEBzZWUge0F0b21pY1Byb3ZpZGVyfVxuICogQHRlbXBsYXRlIHsoKSA9PiBFUmVmPGFueT59IFRcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YScpLkJhZ2dhZ2V9IG1hcFN0b3JlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2V5XG4gKiBAcGFyYW0ge1R9IG1ha2VWYWx1ZVxuICogQHBhcmFtIHsodmFsdWU6IEF3YWl0ZWQ8UmV0dXJuVHlwZTxUPj4pID0+IHZvaWR9IFt3aXRoVmFsdWVdXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFJldHVyblR5cGU8VD4+Pn1cbiAqL1xuY29uc3QgICAgICAgIHByb3ZpZGVTaW5nbGV0b249KG1hcFN0b3JlLGtleSxtYWtlVmFsdWUsd2l0aFZhbHVlKT0+e1xuY29uc3Qgc3RvcmVkPVxubWFwU3RvcmUuaGFzKGtleSl8fFxuRS53aGVuKG1ha2VWYWx1ZSgpLCh2KT0+bWFwU3RvcmUuaW5pdChrZXksaGFyZGVuKHYpKSk7XG5cbnJldHVybiBFLndoZW4oc3RvcmVkLCgpPT57XG5jb25zdCB2YWx1ZT1tYXBTdG9yZS5nZXQoa2V5KTtcbmlmKHdpdGhWYWx1ZSl7XG53aXRoVmFsdWUodmFsdWUpO1xuIH1cbnJldHVybiB2YWx1ZTtcbiB9KTtcbiB9OyRo4oCNX29uY2UucHJvdmlkZVNpbmdsZXRvbihwcm92aWRlU2luZ2xldG9uKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlRXBoZW1lcmFQcm92aWRlciI6WyJtYWtlRXBoZW1lcmFQcm92aWRlciJdLCJwcm92aWRlRW1wdHlTZWF0IjpbInByb3ZpZGVFbXB0eVNlYXQiXSwicHJvdmlkZUFsbCI6WyJwcm92aWRlQWxsIl0sInByb3ZpZGVTaW5nbGV0b24iOlsicHJvdmlkZVNpbmdsZXRvbiJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACgpBY1VggAAFYIAAArAAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvbWFrZUhhbmRsZS5qc3siaW1wb3J0cyI6WyIuL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL2Fzc2VydCIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsiZGVmaW5lRHVyYWJsZUhhbmRsZSIsIm1ha2VIYW5kbGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0LGluaXRFbXB0eSxtYWtlRXhvLHByZXBhcmVFeG9DbGFzcyxIYW5kbGVJOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJhc3NlcnRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJpbml0RW1wdHlcIiwgWyRo4oCNX2EgPT4gKGluaXRFbXB0eSA9ICRo4oCNX2EpXV0sW1wibWFrZUV4b1wiLCBbJGjigI1fYSA9PiAobWFrZUV4byA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJwcmVwYXJlRXhvQ2xhc3NcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzcyA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVHdWFyZHMuanNcIiwgW1tcIkhhbmRsZUlcIiwgWyRo4oCNX2EgPT4gKEhhbmRsZUkgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBCYWdnYWdlICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtzdHJpbmd9IEhcbiAqIEBwYXJhbSB7QmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtIfSBoYW5kbGVUeXBlXG4gKiBAcmV0dXJucyB7SCBleHRlbmRzICdJbnN0YW5jZScgPyAoKSA9PiBJbnN0YW5jZSA6ICgpID0+IEhhbmRsZTxIPn1cbiAqL1xuY29uc3QgICAgICAgIGRlZmluZUR1cmFibGVIYW5kbGU9KGJhZ2dhZ2UsaGFuZGxlVHlwZSk9PntcbnR5cGVvZiBoYW5kbGVUeXBlPT09J3N0cmluZyd8fEZhaWwgYGhhbmRsZVR5cGUgbXVzdCBiZSBhIHN0cmluZ2A7XG5jb25zdCBtYWtlSGFuZGxlPXByZXBhcmVFeG9DbGFzcyhcbmJhZ2dhZ2UsXG4gYCR7aGFuZGxlVHlwZX1IYW5kbGVgLFxuSGFuZGxlSSxcbmluaXRFbXB0eSxcbnt9KTtcblxuLyogQHRzLWV4cGVjdC1lcnJvciBCaXQgYnkgb3VyIG93biBvcGFxdWUgdHlwZXMuKi9cbnJldHVybiAoLyoqIEB0eXBlIHsoKSA9PiBIYW5kbGU8SD59ICovbWFrZUhhbmRsZSk7XG4gfTskaOKAjV9vbmNlLmRlZmluZUR1cmFibGVIYW5kbGUoZGVmaW5lRHVyYWJsZUhhbmRsZSk7XG5oYXJkZW4oZGVmaW5lRHVyYWJsZUhhbmRsZSk7XG5cbi8qKlxuICogQ3JlYXRlIGFuIG9wYXF1ZSBoYW5kbGUgb2JqZWN0LlxuICpcbiAqIEB0ZW1wbGF0ZSB7c3RyaW5nfSBIXG4gKiBAcGFyYW0ge0h9IGhhbmRsZVR5cGUgdGhlIHN0cmluZyBsaXRlcmFsIHR5cGUgb2YgdGhlIGhhbmRsZVxuICogQHJldHVybnMge0ggZXh0ZW5kcyAnSW5zdGFuY2UnID8gSW5zdGFuY2UgOiBIYW5kbGU8SD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlSGFuZGxlPShoYW5kbGVUeXBlKT0+e1xudHlwZW9mIGhhbmRsZVR5cGU9PT0nc3RyaW5nJ3x8RmFpbCBgaGFuZGxlVHlwZSBtdXN0IGJlIGEgc3RyaW5nYDtcbi8qIFJldHVybiB0aGUgaW50ZXJzZWN0aW9uIHR5cGUgKHJlYWxseSBqdXN0IGFuIGVtcHR5IG9iamVjdCkuKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgQml0IGJ5IG91ciBvd24gb3BhcXVlIHR5cGVzLiovXG5yZXR1cm4gKC8qKiBAdHlwZSB7SGFuZGxlPEg+fSAqL21ha2VFeG8oYCR7aGFuZGxlVHlwZX1IYW5kbGVgLEhhbmRsZUkse30pKTtcbiB9OyRo4oCNX29uY2UubWFrZUhhbmRsZShtYWtlSGFuZGxlKTtcbmhhcmRlbihtYWtlSGFuZGxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJkZWZpbmVEdXJhYmxlSGFuZGxlIjpbImRlZmluZUR1cmFibGVIYW5kbGUiXSwibWFrZUhhbmRsZSI6WyJtYWtlSGFuZGxlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAOWxCczbQwAA20MAACsAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy90eXBlR3VhcmRzLmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvZXJ0cCIsIkBhZ29yaWMvbm90aWZpZXIiLCJAYWdvcmljL3N0b3JlIiwiQGFnb3JpYy90aW1lIl0sImV4cG9ydHMiOlsiQWRtaW5GYWNldEkiLCJBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUiLCJBbW91bnRQYXR0ZXJuS2V5d29yZFJlY29yZFNoYXBlIiwiQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUiLCJCdW5kbGVDYXBTaGFwZSIsIkJ1bmRsZVNoYXBlIiwiRXhpdE9iamVjdEkiLCJFeGl0T2JqZWN0U2hhcGUiLCJGZWVNaW50QWNjZXNzU2hhcGUiLCJGdWxsUHJvcG9zYWxTaGFwZSIsIkhhbmRsZUkiLCJIYW5kbGVPZmZlckkiLCJJbnN0YWxsYXRpb25TaGFwZSIsIkluc3RhbmNlQWRtaW5JIiwiSW5zdGFuY2VBZG1pblNoYXBlIiwiSW5zdGFuY2VIYW5kbGVTaGFwZSIsIkluc3RhbmNlUmVjb3JkU2hhcGUiLCJJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VySUtpdCIsIkludml0YXRpb25FbGVtZW50U2hhcGUiLCJJbnZpdGF0aW9uSGFuZGxlU2hhcGUiLCJJbnZpdGF0aW9uU2hhcGUiLCJJc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUiLCJJc3N1ZXJQS2V5d29yZFJlY29yZFNoYXBlIiwiSXNzdWVyUmVjb3JkU2hhcGUiLCJLZXl3b3JkU2hhcGUiLCJPZmZlckhhbmRsZXJJIiwiUGF5bWVudFBLZXl3b3JkUmVjb3JkU2hhcGUiLCJQcmljZVF1b3RlU2hhcGUiLCJQcm9wb3NhbFNoYXBlIiwiU2VhdERhdGFTaGFwZSIsIlNlYXRIYW5kbGVBbGxvY2F0aW9uc1NoYXBlIiwiU2VhdFNoYXBlIiwiVGVybXNTaGFwZSIsIlRpbWVyU2hhcGUiLCJVbndyYXBwZWRJbnN0YWxsYXRpb25TaGFwZSIsIlpjZk1pbnRJIiwiWm9lTWludEkiLCJab2VNaW50U2hhcGUiLCJab2VTZXJ2aWNlSSIsIlpvZVN0b3JhZ2VNYW5hZ2VySUtpdCIsImlzQWZ0ZXJEZWFkbGluZUV4aXRSdWxlIiwiaXNPbkRlbWFuZEV4aXRSdWxlIiwiaXNXYWl2ZWRFeGl0UnVsZSIsIm1ha2VIYW5kbGVTaGFwZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBBbW91bnRTaGFwZSxBc3NldEtpbmRTaGFwZSxCcmFuZFNoYXBlLERpc3BsYXlJbmZvU2hhcGUsSXNzdWVyS2l0U2hhcGUsSXNzdWVyU2hhcGUsUGF5bWVudFNoYXBlLFN1YnNjcmliZXJTaGFwZSxNLFRpbWVzdGFtcFNoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvZXJ0cFwiLCBbW1wiQW1vdW50U2hhcGVcIiwgWyRo4oCNX2EgPT4gKEFtb3VudFNoYXBlID0gJGjigI1fYSldXSxbXCJBc3NldEtpbmRTaGFwZVwiLCBbJGjigI1fYSA9PiAoQXNzZXRLaW5kU2hhcGUgPSAkaOKAjV9hKV1dLFtcIkJyYW5kU2hhcGVcIiwgWyRo4oCNX2EgPT4gKEJyYW5kU2hhcGUgPSAkaOKAjV9hKV1dLFtcIkRpc3BsYXlJbmZvU2hhcGVcIiwgWyRo4oCNX2EgPT4gKERpc3BsYXlJbmZvU2hhcGUgPSAkaOKAjV9hKV1dLFtcIklzc3VlcktpdFNoYXBlXCIsIFskaOKAjV9hID0+IChJc3N1ZXJLaXRTaGFwZSA9ICRo4oCNX2EpXV0sW1wiSXNzdWVyU2hhcGVcIiwgWyRo4oCNX2EgPT4gKElzc3VlclNoYXBlID0gJGjigI1fYSldXSxbXCJQYXltZW50U2hhcGVcIiwgWyRo4oCNX2EgPT4gKFBheW1lbnRTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL25vdGlmaWVyXCIsIFtbXCJTdWJzY3JpYmVyU2hhcGVcIiwgWyRo4oCNX2EgPT4gKFN1YnNjcmliZXJTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdGltZVwiLCBbW1wiVGltZXN0YW1wU2hhcGVcIiwgWyRo4oCNX2EgPT4gKFRpbWVzdGFtcFNoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoga2V5d29yZHMgaGF2ZSBhbiBpbml0aWFsIGNhcCovXG5jb25zdCAgICAgICAgS2V5d29yZFNoYXBlPU0uc3RyaW5nKCk7JGjigI1fb25jZS5LZXl3b3JkU2hhcGUoS2V5d29yZFNoYXBlKTtcblxuY29uc3QgICAgICAgIEludml0YXRpb25IYW5kbGVTaGFwZT1NLnJlbW90YWJsZSgnSW52aXRhdGlvbkhhbmRsZScpOyRo4oCNX29uY2UuSW52aXRhdGlvbkhhbmRsZVNoYXBlKEludml0YXRpb25IYW5kbGVTaGFwZSk7XG5jb25zdCAgICAgICAgSW52aXRhdGlvblNoYXBlPU0ucmVtb3RhYmxlKCdJbnZpdGF0aW9uJyk7JGjigI1fb25jZS5JbnZpdGF0aW9uU2hhcGUoSW52aXRhdGlvblNoYXBlKTtcbmNvbnN0ICAgICAgICBJbnN0YW5jZUhhbmRsZVNoYXBlPU0ucmVtb3RhYmxlKCdJbnN0YW5jZUhhbmRsZScpOyRo4oCNX29uY2UuSW5zdGFuY2VIYW5kbGVTaGFwZShJbnN0YW5jZUhhbmRsZVNoYXBlKTtcbmNvbnN0ICAgICAgICBJbnN0YWxsYXRpb25TaGFwZT1NLnJlbW90YWJsZSgnSW5zdGFsbGF0aW9uJyk7JGjigI1fb25jZS5JbnN0YWxsYXRpb25TaGFwZShJbnN0YWxsYXRpb25TaGFwZSk7XG5jb25zdCAgICAgICAgU2VhdFNoYXBlPU0ucmVtb3RhYmxlKCdTZWF0Jyk7JGjigI1fb25jZS5TZWF0U2hhcGUoU2VhdFNoYXBlKTtcblxuY29uc3QgICAgICAgIEFtb3VudEtleXdvcmRSZWNvcmRTaGFwZT1NLnJlY29yZE9mKEtleXdvcmRTaGFwZSxBbW91bnRTaGFwZSk7JGjigI1fb25jZS5BbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUoQW1vdW50S2V5d29yZFJlY29yZFNoYXBlKTtcbmNvbnN0ICAgICAgICBBbW91bnRQYXR0ZXJuS2V5d29yZFJlY29yZFNoYXBlPU0ucmVjb3JkT2YoXG5LZXl3b3JkU2hhcGUsXG5NLnBhdHRlcm4oKSk7JGjigI1fb25jZS5BbW91bnRQYXR0ZXJuS2V5d29yZFJlY29yZFNoYXBlKEFtb3VudFBhdHRlcm5LZXl3b3JkUmVjb3JkU2hhcGUpO1xuXG5jb25zdCAgICAgICAgUGF5bWVudFBLZXl3b3JkUmVjb3JkU2hhcGU9TS5yZWNvcmRPZihcbktleXdvcmRTaGFwZSxcbk0uZXJlZihQYXltZW50U2hhcGUpKTskaOKAjV9vbmNlLlBheW1lbnRQS2V5d29yZFJlY29yZFNoYXBlKFBheW1lbnRQS2V5d29yZFJlY29yZFNoYXBlKTtcblxuY29uc3QgICAgICAgIElzc3VlcktleXdvcmRSZWNvcmRTaGFwZT1NLnJlY29yZE9mKEtleXdvcmRTaGFwZSxJc3N1ZXJTaGFwZSk7JGjigI1fb25jZS5Jc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUoSXNzdWVyS2V5d29yZFJlY29yZFNoYXBlKTtcbmNvbnN0ICAgICAgICBJc3N1ZXJQS2V5d29yZFJlY29yZFNoYXBlPU0ucmVjb3JkT2YoXG5LZXl3b3JkU2hhcGUsXG5NLmVyZWYoSXNzdWVyU2hhcGUpKTskaOKAjV9vbmNlLklzc3VlclBLZXl3b3JkUmVjb3JkU2hhcGUoSXNzdWVyUEtleXdvcmRSZWNvcmRTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBCcmFuZEtleXdvcmRSZWNvcmRTaGFwZT1NLnJlY29yZE9mKEtleXdvcmRTaGFwZSxCcmFuZFNoYXBlKTskaOKAjV9vbmNlLkJyYW5kS2V5d29yZFJlY29yZFNoYXBlKEJyYW5kS2V5d29yZFJlY29yZFNoYXBlKTtcblxuY29uc3QgICAgICAgIElzc3VlclJlY29yZFNoYXBlPU0uc3BsaXRSZWNvcmQoXG57XG5icmFuZDpCcmFuZFNoYXBlLFxuaXNzdWVyOklzc3VlclNoYXBlLFxuYXNzZXRLaW5kOkFzc2V0S2luZFNoYXBlfSxcblxue2Rpc3BsYXlJbmZvOkRpc3BsYXlJbmZvU2hhcGV9KTskaOKAjV9vbmNlLklzc3VlclJlY29yZFNoYXBlKElzc3VlclJlY29yZFNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgVGVybXNTaGFwZT1oYXJkZW4oe1xuaXNzdWVyczpJc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUsXG5icmFuZHM6QnJhbmRLZXl3b3JkUmVjb3JkU2hhcGV9KTskaOKAjV9vbmNlLlRlcm1zU2hhcGUoVGVybXNTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIEluc3RhbmNlUmVjb3JkU2hhcGU9aGFyZGVuKHtcbmluc3RhbGxhdGlvbjpJbnN0YWxsYXRpb25TaGFwZSxcbmluc3RhbmNlOkluc3RhbmNlSGFuZGxlU2hhcGUsXG50ZXJtczpNLnNwbGl0UmVjb3JkKFRlcm1zU2hhcGUpfSk7JGjigI1fb25jZS5JbnN0YW5jZVJlY29yZFNoYXBlKEluc3RhbmNlUmVjb3JkU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBIYW5kbGVJPU0uaW50ZXJmYWNlKCdIYW5kbGUnLHt9KTskaOKAjV9vbmNlLkhhbmRsZUkoSGFuZGxlSSk7XG5cbmNvbnN0ICAgICAgICBtYWtlSGFuZGxlU2hhcGU9KG5hbWUpPT5NLnJlbW90YWJsZSggYCR7bmFtZX1IYW5kbGVgKTskaOKAjV9vbmNlLm1ha2VIYW5kbGVTaGFwZShtYWtlSGFuZGxlU2hhcGUpO1xuY29uc3QgICAgICAgIFRpbWVyU2hhcGU9bWFrZUhhbmRsZVNoYXBlKCd0aW1lcicpO1xuXG4vKipcbiAqIEFmdGVyIGRlZmF1bHRzIGFyZSBmaWxsZWQgaW5cbiAqXG4gKiBAc2VlIHtQcm9wb3NhbFJlY29yZH0gdHlwZVxuICovJGjigI1fb25jZS5UaW1lclNoYXBlKFRpbWVyU2hhcGUpO1xuY29uc3QgICAgICAgIEZ1bGxQcm9wb3NhbFNoYXBlPWhhcmRlbih7XG53YW50OkFtb3VudFBhdHRlcm5LZXl3b3JkUmVjb3JkU2hhcGUsXG5naXZlOkFtb3VudEtleXdvcmRSZWNvcmRTaGFwZSxcbi8qIFRvIGFjY2VwdCBvbmx5IG9uZSwgd2UgY291bGQgdXNlIE0ub3IgcmF0aGVyIHRoYW4gTS5zcGxpdFJlY29yZCwqL1xuLyogYnV0IHRoZSBlcnJvciBtZXNzYWdlcyB3b3VsZCBoYXZlIGJlZW4gd29yc2UuIFJhdGhlciwqL1xuLyogY2xlYW5Qcm9wb3NhbCdzIGFzc2VydEV4aXQgY2hlY2tzIHRoYXQgdGhlcmUncyBleGFjdGx5IG9uZS4qL1xuZXhpdDpNLnNwbGl0UmVjb3JkKFxue30sXG57XG5vbkRlbWFuZDpudWxsLFxud2FpdmVkOm51bGwsXG5hZnRlckRlYWRsaW5lOntcbnRpbWVyOk0uZXJlZihUaW1lclNoYXBlKSxcbmRlYWRsaW5lOlRpbWVzdGFtcFNoYXBlfX0sXG5cblxue30pfSk7XG5cblxuLyoqIEBzZWUge1Byb3Bvc2FsfSB0eXBlICovJGjigI1fb25jZS5GdWxsUHJvcG9zYWxTaGFwZShGdWxsUHJvcG9zYWxTaGFwZSk7XG5jb25zdCAgICAgICAgUHJvcG9zYWxTaGFwZT1NLnNwbGl0UmVjb3JkKHt9LEZ1bGxQcm9wb3NhbFNoYXBlLHt9KTskaOKAjV9vbmNlLlByb3Bvc2FsU2hhcGUoUHJvcG9zYWxTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBpc09uRGVtYW5kRXhpdFJ1bGU9KGV4aXQpPT57XG5jb25zdFtleGl0S2V5XT1PYmplY3Qua2V5cyhleGl0KTtcbnJldHVybiBleGl0S2V5PT09J29uRGVtYW5kJztcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7RXhpdFJ1bGV9IGV4aXRcbiAqIEByZXR1cm5zIHtleGl0IGlzIFdhaXZlZEV4aXRSdWxlfVxuICovJGjigI1fb25jZS5pc09uRGVtYW5kRXhpdFJ1bGUoaXNPbkRlbWFuZEV4aXRSdWxlKTtcbmNvbnN0ICAgICAgICBpc1dhaXZlZEV4aXRSdWxlPShleGl0KT0+e1xuY29uc3RbZXhpdEtleV09T2JqZWN0LmtleXMoZXhpdCk7XG5yZXR1cm4gZXhpdEtleT09PSd3YWl2ZWQnO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtFeGl0UnVsZX0gZXhpdFxuICogQHJldHVybnMge2V4aXQgaXMgQWZ0ZXJEZWFkbGluZUV4aXRSdWxlfVxuICovJGjigI1fb25jZS5pc1dhaXZlZEV4aXRSdWxlKGlzV2FpdmVkRXhpdFJ1bGUpO1xuY29uc3QgICAgICAgIGlzQWZ0ZXJEZWFkbGluZUV4aXRSdWxlPShleGl0KT0+e1xuY29uc3RbZXhpdEtleV09T2JqZWN0LmtleXMoZXhpdCk7XG5yZXR1cm4gZXhpdEtleT09PSdhZnRlckRlYWRsaW5lJztcbiB9OyRo4oCNX29uY2UuaXNBZnRlckRlYWRsaW5lRXhpdFJ1bGUoaXNBZnRlckRlYWRsaW5lRXhpdFJ1bGUpO1xuXG5jb25zdCAgICAgICAgSW52aXRhdGlvbkVsZW1lbnRTaGFwZT1NLnNwbGl0UmVjb3JkKHtcbmRlc2NyaXB0aW9uOk0uc3RyaW5nKCksXG5oYW5kbGU6SW52aXRhdGlvbkhhbmRsZVNoYXBlLFxuaW5zdGFuY2U6SW5zdGFuY2VIYW5kbGVTaGFwZSxcbmluc3RhbGxhdGlvbjpJbnN0YWxsYXRpb25TaGFwZX0pOyRo4oCNX29uY2UuSW52aXRhdGlvbkVsZW1lbnRTaGFwZShJbnZpdGF0aW9uRWxlbWVudFNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgT2ZmZXJIYW5kbGVyST1NLmludGVyZmFjZSgnT2ZmZXJIYW5kbGVyJyx7XG5oYW5kbGU6TS5jYWxsKFNlYXRTaGFwZSkub3B0aW9uYWwoTS5hbnkoKSkucmV0dXJucyhNLnN0cmluZygpKX0pOyRo4oCNX29uY2UuT2ZmZXJIYW5kbGVySShPZmZlckhhbmRsZXJJKTtcblxuXG5jb25zdCAgICAgICAgU2VhdEhhbmRsZUFsbG9jYXRpb25zU2hhcGU9TS5hcnJheU9mKFxuaGFyZGVuKHtcbnNlYXRIYW5kbGU6U2VhdFNoYXBlLFxuYWxsb2NhdGlvbjpBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGV9KSk7JGjigI1fb25jZS5TZWF0SGFuZGxlQWxsb2NhdGlvbnNTaGFwZShTZWF0SGFuZGxlQWxsb2NhdGlvbnNTaGFwZSk7XG5cblxuXG5jb25zdCAgICAgICAgWm9lTWludFNoYXBlPU0ucmVtb3RhYmxlKCdab2VNaW50Jyk7JGjigI1fb25jZS5ab2VNaW50U2hhcGUoWm9lTWludFNoYXBlKTtcbmNvbnN0ICAgICAgICBab2VNaW50ST1NLmludGVyZmFjZSgnWm9lTWludCcse1xuZ2V0SXNzdWVyUmVjb3JkOk0uY2FsbCgpLnJldHVybnMoSXNzdWVyUmVjb3JkU2hhcGUpLFxubWludEFuZEVzY3JvdzpNLmNhbGwoQW1vdW50U2hhcGUpLnJldHVybnMoKSxcbndpdGhkcmF3QW5kQnVybjpNLmNhbGwoQW1vdW50U2hhcGUpLnJldHVybnMoKX0pOyRo4oCNX29uY2UuWm9lTWludEkoWm9lTWludEkpO1xuXG5cbmNvbnN0ICAgICAgICBaY2ZNaW50ST1NLmludGVyZmFjZSgnWmNmTWludCcse1xuZ2V0SXNzdWVyUmVjb3JkOk0uY2FsbCgpLnJldHVybnMoSXNzdWVyUmVjb3JkU2hhcGUpLFxubWludEdhaW5zOk0uY2FsbChBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUpLlxub3B0aW9uYWwoTS5yZW1vdGFibGUoJ3pjZlNlYXQnKSkuXG5yZXR1cm5zKE0ucmVtb3RhYmxlKCd6Y2ZTZWF0JykpLFxuYnVybkxvc3NlczpNLmNhbGwoXG5BbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUsXG5NLnJlbW90YWJsZSgnemNmU2VhdCcpKS5cbnJldHVybnMoKX0pOyRo4oCNX29uY2UuWmNmTWludEkoWmNmTWludEkpO1xuXG5cbmNvbnN0ICAgICAgICBGZWVNaW50QWNjZXNzU2hhcGU9TS5yZW1vdGFibGUoJ0ZlZU1pbnRBY2Nlc3MnKTskaOKAjV9vbmNlLkZlZU1pbnRBY2Nlc3NTaGFwZShGZWVNaW50QWNjZXNzU2hhcGUpO1xuXG5jb25zdCAgICAgICAgRXhpdE9iamVjdEk9TS5pbnRlcmZhY2UoJ0V4aXQgT2JqZWN0Jyx7XG5leGl0Ok0uY2FsbCgpLnJldHVybnMoKX0pOyRo4oCNX29uY2UuRXhpdE9iamVjdEkoRXhpdE9iamVjdEkpO1xuXG5cbmNvbnN0ICAgICAgICBFeGl0T2JqZWN0U2hhcGU9TS5yZW1vdGFibGUoJ0V4aXRPYmonKTskaOKAjV9vbmNlLkV4aXRPYmplY3RTaGFwZShFeGl0T2JqZWN0U2hhcGUpO1xuY29uc3QgICAgICAgIEluc3RhbmNlQWRtaW5TaGFwZT1NLnJlbW90YWJsZSgnSW5zdGFuY2VBZG1pbicpOyRo4oCNX29uY2UuSW5zdGFuY2VBZG1pblNoYXBlKEluc3RhbmNlQWRtaW5TaGFwZSk7XG5jb25zdCAgICAgICAgSW5zdGFuY2VBZG1pbkk9TS5pbnRlcmZhY2UoJ0luc3RhbmNlQWRtaW4nLHtcbm1ha2VJbnZpdGF0aW9uOk0uY2FsbChJbnZpdGF0aW9uSGFuZGxlU2hhcGUsTS5zdHJpbmcoKSkuXG5vcHRpb25hbChNLnJlY29yZCgpLE0ucGF0dGVybigpKS5cbnJldHVybnMoSW52aXRhdGlvblNoYXBlKSxcbnNhdmVJc3N1ZXI6TS5jYWxsV2hlbihNLmF3YWl0KElzc3VlclNoYXBlKSxLZXl3b3JkU2hhcGUpLnJldHVybnMoXG5Jc3N1ZXJSZWNvcmRTaGFwZSksXG5cbm1ha2VOb0VzY3Jvd1NlYXQ6TS5jYWxsKFxuQW1vdW50S2V5d29yZFJlY29yZFNoYXBlLFxuUHJvcG9zYWxTaGFwZSxcbkV4aXRPYmplY3RTaGFwZSxcblNlYXRTaGFwZSkuXG5yZXR1cm5zKFNlYXRTaGFwZSksXG5leGl0QWxsU2VhdHM6TS5jYWxsKE0uYW55KCkpLnJldHVybnMoKSxcbmZhaWxBbGxTZWF0czpNLmNhbGwoTS5hbnkoKSkucmV0dXJucygpLFxuZXhpdFNlYXQ6TS5jYWxsKFNlYXRTaGFwZSxNLmFueSgpKS5yZXR1cm5zKCksXG5mYWlsU2VhdDpNLmNhbGwoU2VhdFNoYXBlLE0uYW55KCkpLnJldHVybnMoKSxcbm1ha2Vab2VNaW50Ok0uY2FsbChLZXl3b3JkU2hhcGUpLlxub3B0aW9uYWwoXG5Bc3NldEtpbmRTaGFwZSxcbkRpc3BsYXlJbmZvU2hhcGUsXG5NLnNwbGl0UmVjb3JkKGhhcmRlbih7fSksaGFyZGVuKHtlbGVtZW50U2hhcGU6TS5wYXR0ZXJuKCl9KSkpLlxuXG5yZXR1cm5zKE0ucmVtb3RhYmxlKCd6b2VNaW50JykpLFxucmVnaXN0ZXJGZWVNaW50Ok0uY2FsbChLZXl3b3JkU2hhcGUsRmVlTWludEFjY2Vzc1NoYXBlKS5yZXR1cm5zKFxuTS5yZW1vdGFibGUoJ2ZlZU1pbnQnKSksXG5cbnJlcGxhY2VBbGxvY2F0aW9uczpNLmNhbGwoU2VhdEhhbmRsZUFsbG9jYXRpb25zU2hhcGUpLnJldHVybnMoKSxcbnN0b3BBY2NlcHRpbmdPZmZlcnM6TS5jYWxsKCkucmV0dXJucygpLFxuc2V0T2ZmZXJGaWx0ZXI6TS5jYWxsKE0uYXJyYXlPZihNLnN0cmluZygpKSkucmV0dXJucygpLFxuZ2V0T2ZmZXJGaWx0ZXI6TS5jYWxsKCkucmV0dXJucyhNLmFycmF5T2YoTS5zdHJpbmcoKSkpLFxuZ2V0RXhpdFN1YnNjcmliZXI6TS5jYWxsKFNlYXRTaGFwZSkucmV0dXJucyhTdWJzY3JpYmVyU2hhcGUpLFxuaXNCbG9ja2VkOk0uY2FsbChNLnN0cmluZygpKS5yZXR1cm5zKE0uYm9vbGVhbigpKX0pOyRo4oCNX29uY2UuSW5zdGFuY2VBZG1pbkkoSW5zdGFuY2VBZG1pbkkpO1xuXG5cbmNvbnN0ICAgICAgICBJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VySUtpdD1oYXJkZW4oe1xuaW5zdGFuY2VTdG9yYWdlTWFuYWdlcjpNLmludGVyZmFjZSgnSW5zdGFuY2VTdG9yYWdlTWFuYWdlcicse1xuZ2V0VGVybXM6TS5jYWxsKCkucmV0dXJucyhNLnNwbGl0UmVjb3JkKFRlcm1zU2hhcGUpKSxcbmdldElzc3VlcnM6TS5jYWxsKCkucmV0dXJucyhJc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUpLFxuZ2V0QnJhbmRzOk0uY2FsbCgpLnJldHVybnMoQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUpLFxuZ2V0SW5zdGFsbGF0aW9uOk0uY2FsbCgpLnJldHVybnMoSW5zdGFsbGF0aW9uU2hhcGUpLFxuZ2V0SW52aXRhdGlvbklzc3VlcjpNLmNhbGwoKS5yZXR1cm5zKElzc3VlclNoYXBlKSxcblxuc2F2ZUlzc3VlcjpNLmNhbGwoSXNzdWVyU2hhcGUsS2V5d29yZFNoYXBlKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbm1ha2Vab2VNaW50Ok0uY2FsbChLZXl3b3JkU2hhcGUpLlxub3B0aW9uYWwoXG5Bc3NldEtpbmRTaGFwZSxcbkRpc3BsYXlJbmZvU2hhcGUsXG5NLnNwbGl0UmVjb3JkKGhhcmRlbih7fSksaGFyZGVuKHtlbGVtZW50U2hhcGU6TS5wYXR0ZXJuKCl9KSkpLlxuXG5yZXR1cm5zKE0uZXJlZihab2VNaW50U2hhcGUpKSxcbnJlZ2lzdGVyRmVlTWludDpNLmNhbGwoS2V5d29yZFNoYXBlLEZlZU1pbnRBY2Nlc3NTaGFwZSkucmV0dXJucyhcbk0ucmVtb3RhYmxlKCdmZWVNaW50JykpLFxuXG5nZXRJbnN0YW5jZVJlY29yZDpNLmNhbGwoKS5yZXR1cm5zKEluc3RhbmNlUmVjb3JkU2hhcGUpLFxuZ2V0SXNzdWVyUmVjb3JkczpNLmNhbGwoKS5yZXR1cm5zKE0uYXJyYXlPZihJc3N1ZXJSZWNvcmRTaGFwZSkpLFxuZ2V0V2l0aGRyYXdGYWNldDpNLmNhbGwoKS5yZXR1cm5zKE0ucmVtb3RhYmxlKCdXaXRoZHJhd0ZhY2V0JykpLFxuaW5pdEluc3RhbmNlQWRtaW46TS5jYWxsKFxuSW5zdGFuY2VIYW5kbGVTaGFwZSxcbk0ucmVtb3RhYmxlKCdpbnN0YW5jZUFkbWluJykpLlxucmV0dXJucyhNLnByb21pc2UoKSksXG5kZWxldGVJbnN0YW5jZUFkbWluOk0uY2FsbChJbnN0YW5jZUFkbWluSSkucmV0dXJucygpLFxubWFrZUludml0YXRpb246TS5jYWxsKEludml0YXRpb25IYW5kbGVTaGFwZSxNLnN0cmluZygpKS5cbm9wdGlvbmFsKE0ucmVjb3JkKCksTS5wYXR0ZXJuKCkpLlxucmV0dXJucyhQYXltZW50U2hhcGUpLFxuZ2V0Um9vdDpNLmNhbGwoKS5yZXR1cm5zKE0uYW55KCkpLFxuZ2V0QWRtaW5Ob2RlOk0uY2FsbCgpLnJldHVybnMoTS5yZW1vdGFibGUoJ2FkbWluTm9kZScpKX0pLFxuXG53aXRoZHJhd0ZhY2V0Ok0uaW50ZXJmYWNlKCdXaXRoZHJhd0ZhY2V0Jyx7XG53aXRoZHJhd1BheW1lbnRzOk0uY2FsbChBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUpLnJldHVybnMoXG5QYXltZW50UEtleXdvcmRSZWNvcmRTaGFwZSl9KSxcblxuXG5oZWxwZXJzOk0uaW50ZXJmYWNlKCdJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VyIGhlbHBlcicse1xud3JhcElzc3VlcktpdFdpdGhab2VNaW50Ok0uY2FsbChcbktleXdvcmRTaGFwZSxcbklzc3VlcktpdFNoYXBlLFxuTS5yZW1vdGFibGUoJ2FkbWluTm9kZScpKS5cbnJldHVybnMoWm9lTWludFNoYXBlKX0pfSk7JGjigI1fb25jZS5JbnN0YW5jZVN0b3JhZ2VNYW5hZ2VySUtpdChJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VySUtpdCk7XG5cblxuXG5jb25zdCAgICAgICAgQnVuZGxlQ2FwU2hhcGU9TS5yZW1vdGFibGUoJ2J1bmRsZUNhcCcpOyRo4oCNX29uY2UuQnVuZGxlQ2FwU2hhcGUoQnVuZGxlQ2FwU2hhcGUpO1xuY29uc3QgICAgICAgIEJ1bmRsZVNoYXBlPU0uYW5kKFxuTS5zcGxpdFJlY29yZCh7bW9kdWxlRm9ybWF0Ok0uYW55KCl9KSxcbk0ucmVjb3JkT2YoTS5zdHJpbmcoKSxNLnN0cmluZyh7c3RyaW5nTGVuZ3RoTGltaXQ6SW5maW5pdHl9KSkpOyRo4oCNX29uY2UuQnVuZGxlU2hhcGUoQnVuZGxlU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBVbndyYXBwZWRJbnN0YWxsYXRpb25TaGFwZT1NLnNwbGl0UmVjb3JkKFxuaGFyZGVuKHtcbmluc3RhbGxhdGlvbjpJbnN0YWxsYXRpb25TaGFwZX0pLFxuXG5oYXJkZW4oe1xuYnVuZGxlOk0ucmVjb3JkT2YoTS5zdHJpbmcoKSxNLnN0cmluZyh7c3RyaW5nTGVuZ3RoTGltaXQ6SW5maW5pdHl9KSksXG5idW5kbGVDYXA6QnVuZGxlQ2FwU2hhcGUsXG5idW5kbGVJRDpNLnN0cmluZygpfSksXG5cbmhhcmRlbih7fSkpOyRo4oCNX29uY2UuVW53cmFwcGVkSW5zdGFsbGF0aW9uU2hhcGUoVW53cmFwcGVkSW5zdGFsbGF0aW9uU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBab2VTdG9yYWdlTWFuYWdlcklLaXQ9aGFyZGVuKHtcbnpvZVNlcnZpY2VEYXRhQWNjZXNzOk0uaW50ZXJmYWNlKCdab2VTZXJ2aWNlIGRhdGFBY2Nlc3MnLHtcbmdldFRlcm1zOk0uY2FsbChJbnN0YW5jZUhhbmRsZVNoYXBlKS5yZXR1cm5zKE0uc3BsaXRSZWNvcmQoVGVybXNTaGFwZSkpLFxuZ2V0SXNzdWVyczpNLmNhbGwoSW5zdGFuY2VIYW5kbGVTaGFwZSkucmV0dXJucyhJc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUpLFxuZ2V0QnJhbmRzOk0uY2FsbChJbnN0YW5jZUhhbmRsZVNoYXBlKS5yZXR1cm5zKEJyYW5kS2V5d29yZFJlY29yZFNoYXBlKSxcbmdldEluc3RhbGxhdGlvbjpNLmNhbGwoSW5zdGFuY2VIYW5kbGVTaGFwZSkucmV0dXJucyhcbk0uZXJlZihNLnJlbW90YWJsZSgnSW5zdGFsbGF0aW9uJykpKSxcblxuZ2V0SW52aXRhdGlvbklzc3VlcjpNLmNhbGwoKS5yZXR1cm5zKElzc3VlclNoYXBlKSxcblxuZ2V0QnVuZGxlSURGcm9tSW5zdGFsbGF0aW9uOk0uY2FsbChJbnN0YWxsYXRpb25TaGFwZSkucmV0dXJucyhcbk0uZXJlZihNLnN0cmluZygpKSksXG5cbmluc3RhbGxCdW5kbGU6TS5jYWxsKE0ub3IoSW5zdGFuY2VIYW5kbGVTaGFwZSxCdW5kbGVTaGFwZSkpLnJldHVybnMoXG5NLnByb21pc2UoKSksXG5cbmluc3RhbGxCdW5kbGVJRDpNLmNhbGwoTS5zdHJpbmcoKSkucmV0dXJucyhNLnByb21pc2UoKSksXG5cbmdldFB1YmxpY0ZhY2V0Ok0uY2FsbChJbnN0YW5jZUhhbmRsZVNoYXBlKS5yZXR1cm5zKFxuTS5lcmVmKE0ucmVtb3RhYmxlKCdQdWJsaWNGYWNldCcpKSksXG5cbmdldE9mZmVyRmlsdGVyOk0uY2FsbChJbnN0YW5jZUhhbmRsZVNoYXBlKS5yZXR1cm5zKE0uYXJyYXlPZihNLnN0cmluZygpKSksXG5nZXRQcm9wb3NhbFNoYXBlRm9ySW52aXRhdGlvbjpNLmNhbGwoSW52aXRhdGlvbkhhbmRsZVNoYXBlKS5yZXR1cm5zKFxuTS5vcHQoTS5wYXR0ZXJuKCkpKX0pLFxuXG5cbm1ha2VPZmZlckFjY2VzczpNLmludGVyZmFjZSgnWm9lU3RvcmFnZSBtYWtlT2ZmZXIgYWNjZXNzJyx7XG5nZXRBc3NldEtpbmRCeUJyYW5kOk0uY2FsbChCcmFuZFNoYXBlKS5yZXR1cm5zKEFzc2V0S2luZFNoYXBlKSxcbmdldEluc3RhbmNlQWRtaW46TS5jYWxsKEluc3RhbmNlSGFuZGxlU2hhcGUpLnJldHVybnMoXG5NLnJlbW90YWJsZSgnaW5zdGFuY2VBZG1pbicpKSxcblxuZ2V0UHJvcG9zYWxTaGFwZUZvckludml0YXRpb246TS5jYWxsKEludml0YXRpb25IYW5kbGVTaGFwZSkucmV0dXJucyhcbk0ub3B0KE0ucGF0dGVybigpKSksXG5cbmdldEludml0YXRpb25Jc3N1ZXI6TS5jYWxsKCkucmV0dXJucyhJc3N1ZXJTaGFwZSksXG5kZXBvc2l0UGF5bWVudHM6TS5jYWxsKFByb3Bvc2FsU2hhcGUsUGF5bWVudFBLZXl3b3JkUmVjb3JkU2hhcGUpLnJldHVybnMoXG5NLnByb21pc2UoKSl9KSxcblxuXG5zdGFydEluc3RhbmNlQWNjZXNzOk0uaW50ZXJmYWNlKCdab2VTdG9yYWdlIHN0YXJ0SW5zdGFuY2UgYWNjZXNzJyx7XG5tYWtlWm9lSW5zdGFuY2VTdG9yYWdlTWFuYWdlcjpNLmNhbGwoXG5NLmFueSgpLFxuSW5zdGFsbGF0aW9uU2hhcGUsXG5NLmFueSgpLFxuSXNzdWVyUEtleXdvcmRSZWNvcmRTaGFwZSxcbk0ub3IoSW5zdGFuY2VIYW5kbGVTaGFwZSxCdW5kbGVTaGFwZSksXG5NLm9yKEJ1bmRsZUNhcFNoYXBlLEJ1bmRsZVNoYXBlKSkuXG5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbnVud3JhcEluc3RhbGxhdGlvbjpNLmNhbGxXaGVuKE0uZXJlZihJbnN0YWxsYXRpb25TaGFwZSkpLnJldHVybnMoXG5VbndyYXBwZWRJbnN0YWxsYXRpb25TaGFwZSl9KSxcblxuXG5pbnZpdGF0aW9uSXNzdWVyQWNjZXNzOk0uaW50ZXJmYWNlKCdab2VTdG9yYWdlIGludml0YXRpb25Jc3N1ZXInLHtcbmdldEludml0YXRpb25Jc3N1ZXI6TS5jYWxsKCkucmV0dXJucyhJc3N1ZXJTaGFwZSl9KX0pOyRo4oCNX29uY2UuWm9lU3RvcmFnZU1hbmFnZXJJS2l0KFpvZVN0b3JhZ2VNYW5hZ2VySUtpdCk7XG5cblxuXG5jb25zdCAgICAgICAgWm9lU2VydmljZUk9TS5pbnRlcmZhY2UoJ1pvZVNlcnZpY2UnLHtcbmluc3RhbGw6TS5jYWxsKE0uYW55KCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuaW5zdGFsbEJ1bmRsZUlEOk0uY2FsbChNLnN0cmluZygpKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbnN0YXJ0SW5zdGFuY2U6TS5jYWxsKE0uZXJlZihJbnN0YWxsYXRpb25TaGFwZSkpLlxub3B0aW9uYWwoSXNzdWVyUEtleXdvcmRSZWNvcmRTaGFwZSxNLmFueSgpLE0uYW55KCkpLlxucmV0dXJucyhNLnByb21pc2UoKSksXG5vZmZlcjpNLmNhbGwoTS5lcmVmKEludml0YXRpb25TaGFwZSkpLlxub3B0aW9uYWwoUHJvcG9zYWxTaGFwZSxQYXltZW50UEtleXdvcmRSZWNvcmRTaGFwZSxNLmFueSgpKS5cbnJldHVybnMoTS5wcm9taXNlKCkpLFxuXG5nZXRPZmZlckZpbHRlcjpNLmNhbGxXaGVuKE0uYXdhaXQoSW5zdGFuY2VIYW5kbGVTaGFwZSkpLnJldHVybnMoXG5NLmFycmF5T2YoTS5zdHJpbmcoKSkpLFxuXG5nZXRJbnZpdGF0aW9uSXNzdWVyOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0RmVlSXNzdWVyOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0QnJhbmRzOk0uY2FsbFdoZW4oTS5hd2FpdChJbnN0YW5jZUhhbmRsZVNoYXBlKSkucmV0dXJucyhcbkJyYW5kS2V5d29yZFJlY29yZFNoYXBlKSxcblxuZ2V0SXNzdWVyczpNLmNhbGxXaGVuKE0uYXdhaXQoSW5zdGFuY2VIYW5kbGVTaGFwZSkpLnJldHVybnMoXG5Jc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUpLFxuXG5nZXRQdWJsaWNGYWNldDpNLmNhbGxXaGVuKE0uYXdhaXQoSW5zdGFuY2VIYW5kbGVTaGFwZSkpLnJldHVybnMoXG5NLnJlbW90YWJsZSgnUHVibGljRmFjZXQnKSksXG5cbmdldFRlcm1zOk0uY2FsbFdoZW4oTS5hd2FpdChJbnN0YW5jZUhhbmRsZVNoYXBlKSkucmV0dXJucyhNLmFueSgpKSxcbmdldEluc3RhbGxhdGlvbkZvckluc3RhbmNlOk0uY2FsbFdoZW4oTS5hd2FpdChJbnN0YW5jZUhhbmRsZVNoYXBlKSkucmV0dXJucyhcbk0uZXJlZihNLnJlbW90YWJsZSgnSW5zdGFsbGF0aW9uJykpKSxcblxuZ2V0QnVuZGxlSURGcm9tSW5zdGFsbGF0aW9uOk0uY2FsbChJbnN0YWxsYXRpb25TaGFwZSkucmV0dXJucyhcbk0uZXJlZihNLnN0cmluZygpKSksXG5cblxuZ2V0SW5zdGFsbGF0aW9uOk0uY2FsbChNLmVyZWYoSW52aXRhdGlvblNoYXBlKSkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRJbnN0YW5jZTpNLmNhbGwoTS5lcmVmKEludml0YXRpb25TaGFwZSkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0Q29uZmlndXJhdGlvbjpNLmNhbGwoKS5yZXR1cm5zKHtcbmZlZUlzc3VlckNvbmZpZzp7XG5uYW1lOk0uc3RyaW5nKCksXG5hc3NldEtpbmQ6J25hdCcsXG5kaXNwbGF5SW5mbzpEaXNwbGF5SW5mb1NoYXBlfX0pLFxuXG5cbmdldEludml0YXRpb25EZXRhaWxzOk0uY2FsbChNLmVyZWYoSW52aXRhdGlvblNoYXBlKSkucmV0dXJucyhNLmFueSgpKSxcbmdldFByb3Bvc2FsU2hhcGVGb3JJbnZpdGF0aW9uOk0uY2FsbChJbnZpdGF0aW9uSGFuZGxlU2hhcGUpLnJldHVybnMoXG5NLm9wdChQcm9wb3NhbFNoYXBlKSl9KTskaOKAjV9vbmNlLlpvZVNlcnZpY2VJKFpvZVNlcnZpY2VJKTtcblxuXG5cbmNvbnN0ICAgICAgICBBZG1pbkZhY2V0ST1NLmludGVyZmFjZSgnWmNmQWRtaW5GYWNldCcse1xuZ2V0VmF0U2h1dGRvd25Qcm9taXNlOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxucmVzdGFydENvbnRyYWN0Ok0uY2FsbCgpLm9wdGlvbmFsKE0uYW55KCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxudXBncmFkZUNvbnRyYWN0Ok0uY2FsbChNLnN0cmluZygpKS5vcHRpb25hbChNLmFueSgpKS5yZXR1cm5zKE0ucHJvbWlzZSgpKX0pOyRo4oCNX29uY2UuQWRtaW5GYWNldEkoQWRtaW5GYWNldEkpO1xuXG5cbmNvbnN0ICAgICAgICBTZWF0RGF0YVNoYXBlPU0uc3BsaXRSZWNvcmQoXG57XG5wcm9wb3NhbDpQcm9wb3NhbFNoYXBlLFxuaW5pdGlhbEFsbG9jYXRpb246QW1vdW50S2V5d29yZFJlY29yZFNoYXBlLFxuc2VhdEhhbmRsZTpTZWF0U2hhcGV9LFxuXG57XG5vZmZlckFyZ3M6TS5hbnkoKX0pOyRo4oCNX29uY2UuU2VhdERhdGFTaGFwZShTZWF0RGF0YVNoYXBlKTtcblxuXG5cbmNvbnN0ICAgICAgICBIYW5kbGVPZmZlckk9TS5pbnRlcmZhY2UoJ0hhbmRsZU9mZmVyJyx7XG5oYW5kbGVPZmZlcjpNLmNhbGwoSW52aXRhdGlvbkhhbmRsZVNoYXBlLFNlYXREYXRhU2hhcGUpLnJldHVybnMoe1xub2ZmZXJSZXN1bHRQcm9taXNlOk0ucHJvbWlzZSgpLFxuZXhpdE9iajpFeGl0T2JqZWN0U2hhcGV9KX0pOyRo4oCNX29uY2UuSGFuZGxlT2ZmZXJJKEhhbmRsZU9mZmVySSk7XG5cblxuXG5jb25zdCAgICAgICAgUHJpY2VRdW90ZVNoYXBlPWhhcmRlbih7XG5xdW90ZUFtb3VudDpBbW91bnRTaGFwZSxcbnF1b3RlUGF5bWVudDpNLmVyZWYoUGF5bWVudFNoYXBlKX0pOyRo4oCNX29uY2UuUHJpY2VRdW90ZVNoYXBlKFByaWNlUXVvdGVTaGFwZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiS2V5d29yZFNoYXBlIjpbIktleXdvcmRTaGFwZSJdLCJJbnZpdGF0aW9uSGFuZGxlU2hhcGUiOlsiSW52aXRhdGlvbkhhbmRsZVNoYXBlIl0sIkludml0YXRpb25TaGFwZSI6WyJJbnZpdGF0aW9uU2hhcGUiXSwiSW5zdGFuY2VIYW5kbGVTaGFwZSI6WyJJbnN0YW5jZUhhbmRsZVNoYXBlIl0sIkluc3RhbGxhdGlvblNoYXBlIjpbIkluc3RhbGxhdGlvblNoYXBlIl0sIlNlYXRTaGFwZSI6WyJTZWF0U2hhcGUiXSwiQW1vdW50S2V5d29yZFJlY29yZFNoYXBlIjpbIkFtb3VudEtleXdvcmRSZWNvcmRTaGFwZSJdLCJBbW91bnRQYXR0ZXJuS2V5d29yZFJlY29yZFNoYXBlIjpbIkFtb3VudFBhdHRlcm5LZXl3b3JkUmVjb3JkU2hhcGUiXSwiUGF5bWVudFBLZXl3b3JkUmVjb3JkU2hhcGUiOlsiUGF5bWVudFBLZXl3b3JkUmVjb3JkU2hhcGUiXSwiSXNzdWVyS2V5d29yZFJlY29yZFNoYXBlIjpbIklzc3VlcktleXdvcmRSZWNvcmRTaGFwZSJdLCJJc3N1ZXJQS2V5d29yZFJlY29yZFNoYXBlIjpbIklzc3VlclBLZXl3b3JkUmVjb3JkU2hhcGUiXSwiQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUiOlsiQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUiXSwiSXNzdWVyUmVjb3JkU2hhcGUiOlsiSXNzdWVyUmVjb3JkU2hhcGUiXSwiVGVybXNTaGFwZSI6WyJUZXJtc1NoYXBlIl0sIkluc3RhbmNlUmVjb3JkU2hhcGUiOlsiSW5zdGFuY2VSZWNvcmRTaGFwZSJdLCJIYW5kbGVJIjpbIkhhbmRsZUkiXSwibWFrZUhhbmRsZVNoYXBlIjpbIm1ha2VIYW5kbGVTaGFwZSJdLCJUaW1lclNoYXBlIjpbIlRpbWVyU2hhcGUiXSwiRnVsbFByb3Bvc2FsU2hhcGUiOlsiRnVsbFByb3Bvc2FsU2hhcGUiXSwiUHJvcG9zYWxTaGFwZSI6WyJQcm9wb3NhbFNoYXBlIl0sImlzT25EZW1hbmRFeGl0UnVsZSI6WyJpc09uRGVtYW5kRXhpdFJ1bGUiXSwiaXNXYWl2ZWRFeGl0UnVsZSI6WyJpc1dhaXZlZEV4aXRSdWxlIl0sImlzQWZ0ZXJEZWFkbGluZUV4aXRSdWxlIjpbImlzQWZ0ZXJEZWFkbGluZUV4aXRSdWxlIl0sIkludml0YXRpb25FbGVtZW50U2hhcGUiOlsiSW52aXRhdGlvbkVsZW1lbnRTaGFwZSJdLCJPZmZlckhhbmRsZXJJIjpbIk9mZmVySGFuZGxlckkiXSwiU2VhdEhhbmRsZUFsbG9jYXRpb25zU2hhcGUiOlsiU2VhdEhhbmRsZUFsbG9jYXRpb25zU2hhcGUiXSwiWm9lTWludFNoYXBlIjpbIlpvZU1pbnRTaGFwZSJdLCJab2VNaW50SSI6WyJab2VNaW50SSJdLCJaY2ZNaW50SSI6WyJaY2ZNaW50SSJdLCJGZWVNaW50QWNjZXNzU2hhcGUiOlsiRmVlTWludEFjY2Vzc1NoYXBlIl0sIkV4aXRPYmplY3RJIjpbIkV4aXRPYmplY3RJIl0sIkV4aXRPYmplY3RTaGFwZSI6WyJFeGl0T2JqZWN0U2hhcGUiXSwiSW5zdGFuY2VBZG1pblNoYXBlIjpbIkluc3RhbmNlQWRtaW5TaGFwZSJdLCJJbnN0YW5jZUFkbWluSSI6WyJJbnN0YW5jZUFkbWluSSJdLCJJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VySUtpdCI6WyJJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VySUtpdCJdLCJCdW5kbGVDYXBTaGFwZSI6WyJCdW5kbGVDYXBTaGFwZSJdLCJCdW5kbGVTaGFwZSI6WyJCdW5kbGVTaGFwZSJdLCJVbndyYXBwZWRJbnN0YWxsYXRpb25TaGFwZSI6WyJVbndyYXBwZWRJbnN0YWxsYXRpb25TaGFwZSJdLCJab2VTdG9yYWdlTWFuYWdlcklLaXQiOlsiWm9lU3RvcmFnZU1hbmFnZXJJS2l0Il0sIlpvZVNlcnZpY2VJIjpbIlpvZVNlcnZpY2VJIl0sIkFkbWluRmFjZXRJIjpbIkFkbWluRmFjZXRJIl0sIlNlYXREYXRhU2hhcGUiOlsiU2VhdERhdGFTaGFwZSJdLCJIYW5kbGVPZmZlckkiOlsiSGFuZGxlT2ZmZXJJIl0sIlByaWNlUXVvdGVTaGFwZSI6WyJQcmljZVF1b3RlU2hhcGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAt8K8e+IGAADiBgAAJQAAAEBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAvc3JjL2hlYXAuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9zdG9yZSIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbIk0iLCJoZWFwWm9uZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlRXhvLGRlZmluZUV4b0NsYXNzLGRlZmluZUV4b0NsYXNzS2l0LG1ha2VTY2FsYXJNYXBTdG9yZSxtYWtlU2NhbGFyU2V0U3RvcmUsbWFrZVNjYWxhcldlYWtNYXBTdG9yZSxtYWtlU2NhbGFyV2Vha1NldFN0b3JlLE0sRmFyOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm1ha2VFeG9cIiwgWyRo4oCNX2EgPT4gKG1ha2VFeG8gPSAkaOKAjV9hKV1dLFtcImRlZmluZUV4b0NsYXNzXCIsIFskaOKAjV9hID0+IChkZWZpbmVFeG9DbGFzcyA9ICRo4oCNX2EpXV0sW1wiZGVmaW5lRXhvQ2xhc3NLaXRcIiwgWyRo4oCNX2EgPT4gKGRlZmluZUV4b0NsYXNzS2l0ID0gJGjigI1fYSldXSxbXCJtYWtlU2NhbGFyTWFwU3RvcmVcIiwgWyRo4oCNX2EgPT4gKG1ha2VTY2FsYXJNYXBTdG9yZSA9ICRo4oCNX2EpXV0sW1wibWFrZVNjYWxhclNldFN0b3JlXCIsIFskaOKAjV9hID0+IChtYWtlU2NhbGFyU2V0U3RvcmUgPSAkaOKAjV9hKV1dLFtcIm1ha2VTY2FsYXJXZWFrTWFwU3RvcmVcIiwgWyRo4oCNX2EgPT4gKG1ha2VTY2FsYXJXZWFrTWFwU3RvcmUgPSAkaOKAjV9hKV1dLFtcIm1ha2VTY2FsYXJXZWFrU2V0U3RvcmVcIiwgWyRo4oCNX2EgPT4gKG1ha2VTY2FsYXJXZWFrU2V0U3RvcmUgPSAkaOKAjV9hKV1dLFtcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKSwkaOKAjV9saXZlW1wiTVwiXV1dXV0sW1wiQGVuZG8vZmFyXCIsIFtbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKlxuICogQHR5cGUge1hpbXBvcnQoJy4nKS5TdG9yZXN9XG4gKi9cbmNvbnN0IGhlYXBTdG9yZXM9RmFyKCdoZWFwU3RvcmVzJyx7XG5kZXRhY2hlZDooKT0+aGVhcFN0b3JlcyxcbmlzU3RvcmFibGU6KF9zcGVjaW1lbik9PnRydWUsXG5cbnNldFN0b3JlOm1ha2VTY2FsYXJTZXRTdG9yZSxcbm1hcFN0b3JlOm1ha2VTY2FsYXJNYXBTdG9yZSxcbndlYWtNYXBTdG9yZTptYWtlU2NhbGFyV2Vha01hcFN0b3JlLFxud2Vha1NldFN0b3JlOm1ha2VTY2FsYXJXZWFrU2V0U3RvcmV9KTtcblxuXG4vKipcbiAqIEEgaGVhcCAoaW4tbWVtb3J5KSB6b25lIHRoYXQgdXNlcyB0aGUgZGVmYXVsdCBleG8gYW5kIHN0b3JlIGltcGxlbWVudGF0aW9ucy5cbiAqXG4gKiBAdHlwZSB7WGltcG9ydCgnLicpLlpvbmV9XG4gKi9cbmNvbnN0ICAgICAgICBoZWFwWm9uZT1GYXIoJ2hlYXBab25lJyx7XG5leG9DbGFzczpkZWZpbmVFeG9DbGFzcyxcbmV4b0NsYXNzS2l0OmRlZmluZUV4b0NsYXNzS2l0LFxuZXhvOm1ha2VFeG8sXG5zdWJab25lOihfbGFiZWwsX29wdGlvbnMpPT5oZWFwWm9uZSxcbi4uLmhlYXBTdG9yZXN9KTskaOKAjV9vbmNlLmhlYXBab25lKGhlYXBab25lKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6eyJNIjpbIk0iLGZhbHNlXX0sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJoZWFwWm9uZSI6WyJoZWFwWm9uZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADY9BkwjwkAAI8JAAAmAAAAQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiLi9oZWFwLmpzIiwiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbIi4vaGVhcC5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlRXhvLGRlZmluZUV4b0NsYXNzLGRlZmluZUV4b0NsYXNzS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm1ha2VFeG9cIiwgWyRo4oCNX2EgPT4gKG1ha2VFeG8gPSAkaOKAjV9hKV1dLFtcImRlZmluZUV4b0NsYXNzXCIsIFskaOKAjV9hID0+IChkZWZpbmVFeG9DbGFzcyA9ICRo4oCNX2EpXV0sW1wiZGVmaW5lRXhvQ2xhc3NLaXRcIiwgWyRo4oCNX2EgPT4gKGRlZmluZUV4b0NsYXNzS2l0ID0gJGjigI1fYSldXV1dLFtcIi4vaGVhcC5qc1wiLCBbXV1dKTsgICBcblxuXG5cblxuXG4vKiBSZWZlcmVuY2VzIHRvIGFsbG93IHRoZSBiZWxvdyB0eXBlb2ZzIHRvIHN1Y2NlZWQuKi9cbm1ha2VFeG87XG5kZWZpbmVFeG9DbGFzcztcbmRlZmluZUV4b0NsYXNzS2l0O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtFeG9ab25lICYgU3RvcmVzfSBab25lIEEgYmFnIG9mIG1ldGhvZHMgZm9yIGNyZWF0aW5nIGRlZmVuc2libGUgb2JqZWN0cyBhbmRcbiAqIGNvbGxlY3Rpb25zIHdpdGggdGhlIHNhbWUgYWxsb2NhdGlvbiBzZW1hbnRpY3MgKGVwaGVtZXJhbCwgcGVyc2lzdGVudCwgZXRjKVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRXhvWm9uZVxuICogQHByb3BlcnR5IHt0eXBlb2YgbWFrZUV4b30gZXhvIGNyZWF0ZSBhIHNpbmdsZXRvbiBleG8tb2JqZWN0IGluc3RhbmNlIGJvdW5kIHRvIHRoaXMgem9uZVxuICogQHByb3BlcnR5IHt0eXBlb2YgZGVmaW5lRXhvQ2xhc3N9IGV4b0NsYXNzIGNyZWF0ZSBhIG1ha2VyIGZ1bmN0aW9uIHRoYXQgY2FuIGJlIHVzZWQgdG8gY3JlYXRlIGV4by1vYmplY3RzIGJvdW5kIHRvIHRoaXMgem9uZVxuICogQHByb3BlcnR5IHt0eXBlb2YgZGVmaW5lRXhvQ2xhc3NLaXR9IGV4b0NsYXNzS2l0IGNyZWF0ZSBhIFwia2l0XCIgbWFrZXIgZnVuY3Rpb24gdGhhdCBjYW4gYmUgdXNlZCB0byBjcmVhdGUgYSByZWNvcmQgb2YgZXhvLW9iamVjdHMgc2hhcmluZyB0aGUgc2FtZSBzdGF0ZVxuICogQHByb3BlcnR5IHsobGFiZWw6IHN0cmluZywgb3B0aW9ucz86IFN0b3JlT3B0aW9ucykgPT4gWm9uZX0gc3ViWm9uZSBjcmVhdGUgYSBuZXcgWm9uZSB0aGF0IGNhbiBiZSBwYXNzZWQgdG8gdW50cnVzdGVkIGNvbnN1bWVycyB3aXRob3V0IGV4cG9zaW5nIHRoZSBzdG9yYWdlIG9mIHRoZSBwYXJlbnQgem9uZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gU3RvcmVzXG4gKiBAcHJvcGVydHkgeygpID0+IFN0b3Jlc30gZGV0YWNoZWQgb2J0YWluIHN0b3JlIHByb3ZpZGVycyB3aGljaCBhcmUgZGV0YWNoZWQgKHRoZSBzdG9yZXMgYXJlIGFub255bW91cyByYXRoZXIgdGhhbiBib3VuZCB0byBgbGFiZWxgIGluIHRoZSB6b25lKVxuICogQHByb3BlcnR5IHsoc3BlY2ltZW46IHVua25vd24pID0+IGJvb2xlYW59IGlzU3RvcmFibGUgcmV0dXJuIHRydWUgaWYgdGhlIHNwZWNpbWVuIGNhbiBiZSBzdG9yZWQgaW4gdGhlIHpvbmUsIHdoZXRoZXIgYXMgZXhvLW9iamVjdCBzdGF0ZSBvciBpbiBhIHN0b3JlXG4gKiBAcHJvcGVydHkgezxLLFY+KGxhYmVsOiBzdHJpbmcsIG9wdGlvbnM/OiBTdG9yZU9wdGlvbnMpID0+IE1hcFN0b3JlPEssIFY+fSBtYXBTdG9yZSBwcm92aWRlIGEgTWFwLWxpa2Ugc3RvcmUgbmFtZWQgYGxhYmVsYCBpbiB0aGUgem9uZVxuICogQHByb3BlcnR5IHs8Sz4obGFiZWw6IHN0cmluZywgb3B0aW9ucz86IFN0b3JlT3B0aW9ucykgPT4gU2V0U3RvcmU8Sz59IHNldFN0b3JlIHByb3ZpZGUgYSBTZXQtbGlrZSBzdG9yZSBuYW1lZCBgbGFiZWxgIGluIHRoZSB6b25lXG4gKiBAcHJvcGVydHkgezxLLFY+KFxuICogICBsYWJlbDogc3RyaW5nLCBvcHRpb25zPzogU3RvcmVPcHRpb25zKSA9PiBXZWFrTWFwU3RvcmU8SywgVj5cbiAqIH0gd2Vha01hcFN0b3JlIHByb3ZpZGUgYSBXZWFrTWFwLWxpa2Ugc3RvcmUgbmFtZWQgYGxhYmVsYCBpbiB0aGUgem9uZVxuICogQHByb3BlcnR5IHs8Sz4oXG4gKiAgIGxhYmVsOiBzdHJpbmcsIG9wdGlvbnM/OiBTdG9yZU9wdGlvbnMpID0+IFdlYWtTZXRTdG9yZTxLPlxuICogfSB3ZWFrU2V0U3RvcmUgcHJvdmlkZSBhIFdlYWtTZXQtbGlrZSBzdG9yZSBuYW1lZCBgbGFiZWxgIGluIHRoZSB6b25lXG4gKi9cbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAzt2xPpALAACQCwAAJAAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTQuOC9zcmMvRS5qc3siaW1wb3J0cyI6WyIuL3RyYWNrLXR1cm5zLmpzIl0sImV4cG9ydHMiOlsiZGVmYXVsdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCB0cmFja1R1cm5zOyRo4oCNX2ltcG9ydHMoW1tcIi4vdHJhY2stdHVybnMuanNcIiwgW1tcInRyYWNrVHVybnNcIiwgWyRo4oCNX2EgPT4gKHRyYWNrVHVybnMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG4vKi8gPHJlZmVyZW5jZSBwYXRoPVwiaW5kZXguZC50c1wiIC8+Ki9cblxuLyoqIEB0eXBlIHtQcm94eUhhbmRsZXI8YW55Pn0gKi9cbmNvbnN0IGJhc2VGcmVlemFibGVQcm94eUhhbmRsZXI9e1xuc2V0KF90YXJnZXQsX3Byb3AsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuaXNFeHRlbnNpYmxlKF90YXJnZXQpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5zZXRQcm90b3R5cGVPZihfdGFyZ2V0LF92YWx1ZSl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbmRlbGV0ZVByb3BlcnR5KF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIGZhbHNlO1xuIH19O1xuXG5cbi8qKlxuICogQSBQcm94eSBoYW5kbGVyIGZvciBFKHgpLlxuICpcbiAqIEBwYXJhbSB7Kn0geCBBbnkgdmFsdWUgcGFzc2VkIHRvIEUoeClcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi9pbmRleCcpLkhhbmRsZWRQcm9taXNlQ29uc3RydWN0b3J9IEhhbmRsZWRQcm9taXNlXG4gKiBAcmV0dXJucyB7UHJveHlIYW5kbGVyfSB0aGUgUHJveHkgaGFuZGxlclxuICovXG5mdW5jdGlvbiBFUHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2Upe1xucmV0dXJuIGhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0KF90YXJnZXQscCxfcmVjZWl2ZXIpe1xucmV0dXJuIGhhcmRlbigoLi4uYXJncyk9PkhhbmRsZWRQcm9taXNlLmFwcGx5TWV0aG9kKHgscCxhcmdzKSk7XG4gfSxcbmFwcGx5KF90YXJnZXQsX3RoaXNBcmcsYXJnQXJyYXk9W10pe1xucmV0dXJuIEhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb24oeCxhcmdBcnJheSk7XG4gfSxcbmhhcyhfdGFyZ2V0LF9wKXtcbi8qIFdlIGp1c3QgcHJldGVuZCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG4gfVxuXG4vKipcbiAqIEEgUHJveHkgaGFuZGxlciBmb3IgRS5zZW5kT25seSh4KVxuICogSXQgaXMgYSB2YXJpYW50IG9uIHRoZSBFKHgpIFByb3h5IGhhbmRsZXIuXG4gKlxuICogQHBhcmFtIHsqfSB4IEFueSB2YWx1ZSBwYXNzZWQgdG8gRS5zZW5kT25seSh4KVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2luZGV4JykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXJ9IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmZ1bmN0aW9uIEVzZW5kT25seVByb3h5SGFuZGxlcih4LEhhbmRsZWRQcm9taXNlKXtcbnJldHVybiBoYXJkZW4oe1xuLi4uYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcixcbmdldChfdGFyZ2V0LHAsX3JlY2VpdmVyKXtcbnJldHVybiguLi5hcmdzKT0+e1xuSGFuZGxlZFByb21pc2UuYXBwbHlNZXRob2RTZW5kT25seSh4LHAsYXJncyk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH07XG4gfSxcbmFwcGx5KF90YXJnZXQsX3RoaXNBcmcsYXJnc0FycmF5PVtdKXtcbkhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb25TZW5kT25seSh4LGFyZ3NBcnJheSk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH0sXG5oYXMoX3RhcmdldCxfcCl7XG4vKiBXZSBqdXN0IHByZXRlbmQgdGhhdCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG4gfVxuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi9pbmRleCcpLkhhbmRsZWRQcm9taXNlQ29uc3RydWN0b3J9IEhhbmRsZWRQcm9taXNlXG4gKiBAcmV0dXJucyB7WGltcG9ydCgnLi9pbmRleCcpLkVQcm94eX1cbiAqL1xuZnVuY3Rpb24gICAgICAgICAgICAgICAgbWFrZUUoSGFuZGxlZFByb21pc2Upe1xuZnVuY3Rpb24gRSh4KXtcbmNvbnN0IGhhbmRsZXI9RVByb3h5SGFuZGxlcih4LEhhbmRsZWRQcm9taXNlKTtcbnJldHVybiBoYXJkZW4obmV3IFByb3h5KCgpPT57IH0saGFuZGxlcikpO1xuIH1cblxuY29uc3QgbWFrZUVHZXR0ZXJQcm94eT0oeCk9PlxubmV3IFByb3h5KE9iamVjdC5jcmVhdGUobnVsbCkse1xuLi4uYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcixcbmhhcyhfdGFyZ2V0LF9wcm9wKXtcbnJldHVybiB0cnVlO1xuIH0sXG5nZXQoX3RhcmdldCxwcm9wKXtcbnJldHVybiBIYW5kbGVkUHJvbWlzZS5nZXQoeCxwcm9wKTtcbiB9fSk7XG5cblxuRS5nZXQ9bWFrZUVHZXR0ZXJQcm94eTtcbkUucmVzb2x2ZT1IYW5kbGVkUHJvbWlzZS5yZXNvbHZlO1xuRS5zZW5kT25seT0oeCk9PntcbmNvbnN0IGhhbmRsZXI9RXNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpO1xucmV0dXJuIGhhcmRlbihuZXcgUHJveHkoKCk9PnsgfSxoYW5kbGVyKSk7XG4gfTtcblxuRS53aGVuPSh4LG9uZnVsZmlsbGVkPXVuZGVmaW5lZCxvbnJlamVjdGVkPXVuZGVmaW5lZCk9PntcbmNvbnN0W29uc3VjY2VzcyxvbmZhaWx1cmVdPXRyYWNrVHVybnMoW29uZnVsZmlsbGVkLG9ucmVqZWN0ZWRdKTtcbnJldHVybiBIYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpLnRoZW4ob25zdWNjZXNzLG9uZmFpbHVyZSk7XG4gfTtcblxucmV0dXJuIGhhcmRlbihFKTtcbiB9JGjigI1fb25jZS5kZWZhdWx0KCAgICAgbWFrZUUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHQiOlsiZGVmYXVsdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABpSisBHQIAAB0CAAAqAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44L3NyYy9uby1zaGltLmpzeyJpbXBvcnRzIjpbIi4vRS5qcyJdLCJleHBvcnRzIjpbIkUiLCJIYW5kbGVkUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlRTskaOKAjV9pbXBvcnRzKFtbXCIuL0UuanNcIiwgW1tcImRlZmF1bHRcIiwgWyRo4oCNX2EgPT4gKG1ha2VFID0gJGjigI1fYSldXV1dXSk7ICAgXG5cbmNvbnN0IGhwPUhhbmRsZWRQcm9taXNlOyRo4oCNX29uY2UuaHAoaHApO1xuY29uc3QgICAgICAgIEU9bWFrZUUoSGFuZGxlZFByb21pc2UpOyRo4oCNX29uY2UuRShFKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJIYW5kbGVkUHJvbWlzZSI6WyJocCJdLCJFIjpbIkUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA6330t3sMAAB7DAAALgAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTQuOC9zcmMvdHJhY2stdHVybnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbInRyYWNrVHVybnMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBnbG9iYWwgZ2xvYmFsVGhpcyAqL1xuLyogQHRzLW5vY2hlY2sqL1xuXG4vKiBOT1RFOiBXZSBjYW4ndCBpbXBvcnQgdGhlc2UgYmVjYXVzZSB0aGV5J3JlIG5vdCBpbiBzY29wZSBiZWZvcmUgbG9ja2Rvd24uKi9cbi8qIGltcG9ydCB7IGFzc2VydCwgZGV0YWlscyBhcyBYIH0gZnJvbSAnQGFnb3JpYy9hc3NlcnQnOyovXG5cbi8qIFdBUk5JTkc6IEdsb2JhbCBNdXRhYmxlIFN0YXRlISovXG4vKiBUaGlzIHN0YXRlIGlzIGNvbW11bmljYXRlZCB0byBgYXNzZXJ0YCB0aGF0IG1ha2VzIGl0IGF2YWlsYWJsZSB0byB0aGUqL1xuLyogY2F1c2FsIGNvbnNvbGUsIHdoaWNoIGFmZmVjdHMgdGhlIGNvbnNvbGUgbG9nIG91dHB1dC4gTm9ybWFsbHkgd2UqL1xuLyogcmVnYXJkIHRoZSBhYmlsaXR5IHRvIHNlZSBjb25zb2xlIGxvZyBvdXRwdXQgYXMgYSBtZXRhLWxldmVsIHByaXZpbGVnZSovXG4vKiBhbmFsb2dvdXMgdG8gdGhlIGFiaWxpdHkgdG8gZGVidWcuIEFzaWRlIGZyb20gdGhhdCwgdGhpcyBtb2R1bGUgc2hvdWxkKi9cbi8qIG5vdCBoYXZlIGFueSBvYnNlcnZhYmx5IG11dGFibGUgc3RhdGUuKi9cblxubGV0IGhpZGRlblByaW9yRXJyb3I7XG5sZXQgaGlkZGVuQ3VycmVudFR1cm49MDtcbmxldCBoaWRkZW5DdXJyZW50RXZlbnQ9MDtcblxuLyogVHVybiBvbiBpZiB5b3Ugc2VlbSB0byBiZSBsb3NpbmcgZXJyb3IgbG9nZ2luZyBhdCB0aGUgdG9wIG9mIHRoZSBldmVudCBsb29wKi9cbmNvbnN0IFZFUkJPU0U9ZmFsc2U7XG5cbi8qKlxuICogQHR5cGVkZWYgeygoLi4uYXJnczogYW55W10pID0+IGFueSkgfCB1bmRlZmluZWR9IFR1cm5TdGFydGVyRm5cbiAqIEFuIG9wdGlvbmFsIGZ1bmN0aW9uIHRoYXQgaXMgbm90IHRoaXMtc2Vuc2l0aXZlLCBleHBlY3RlZCB0byBiZSBjYWxsZWQgYXRcbiAqIGJvdHRvbSBvZiBzdGFjayB0byBzdGFydCBhIG5ldyB0dXJuLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtUdXJuU3RhcnRlckZuW119IFRcbiAqIEdpdmVuIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzLCByZXR1cm5zIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzIHdob3NlXG4gKiBgdGhpc2AtZnJlZSBjYWxsIGJlaGF2aW9ycyBhcmUgbm90IG9ic2VydmFibHkgZGlmZmVyZW50IHRvIHRob3NlIHRoYXRcbiAqIGNhbm5vdCBzZWUgY29uc29sZSBvdXRwdXQuIFRoZSBvbmx5IHB1cnBvc2UgaXMgdG8gY2F1c2UgYWRkaXRpb25hbFxuICogaW5mb3JtYXRpb24gdG8gYXBwZWFyIG9uIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBjYWxsIHRvIGB0cmFja1R1cm5zYCBpcyBpdHNlbGYgYSBzZW5kaW5nIGV2ZW50LCB0aGF0IG9jY3VycyBpbiBzb21lIGNhbGxcbiAqIHN0YWNrIGluIHNvbWUgdHVybiBudW1iZXIgYXQgc29tZSBldmVudCBudW1iZXIgd2l0aGluIHRoYXQgdHVybi4gRWFjaCBjYWxsXG4gKiB0byBhbnkgb2YgdGhlIHJldHVybmVkIGBUdXJuU3RhcnRGbmBzIGlzIGEgcmVjZWl2aW5nIGV2ZW50IHRoYXQgYmVnaW5zIGEgbmV3XG4gKiB0dXJuLiBUaGlzIHNlbmRpbmcgZXZlbnQgY2F1c2VkIGVhY2ggb2YgdGhvc2UgcmVjZWl2aW5nIGV2ZW50cy5cbiAqXG4gKiBAcGFyYW0ge1R9IGZ1bmNzXG4gKiBAcmV0dXJucyB7VH1cbiAqL1xuY29uc3QgICAgICAgIHRyYWNrVHVybnM9KGZ1bmNzKT0+e1xuaWYodHlwZW9mIGdsb2JhbFRoaXM9PT0ndW5kZWZpbmVkJ3x8IWdsb2JhbFRoaXMuYXNzZXJ0KXtcbnJldHVybiBmdW5jcztcbiB9XG5jb25zdHtkZXRhaWxzOlh9PWFzc2VydDtcblxuaGlkZGVuQ3VycmVudEV2ZW50Kz0xO1xuY29uc3Qgc2VuZGluZ0Vycm9yPW5ldyBFcnJvcihcbiBgRXZlbnQ6ICR7aGlkZGVuQ3VycmVudFR1cm59LiR7aGlkZGVuQ3VycmVudEV2ZW50fWApO1xuXG5pZihoaWRkZW5QcmlvckVycm9yIT09dW5kZWZpbmVkKXtcbmFzc2VydC5ub3RlKHNlbmRpbmdFcnJvcixYIGBDYXVzZWQgYnk6ICR7aGlkZGVuUHJpb3JFcnJvcn1gKTtcbiB9XG5cbnJldHVybiBmdW5jcy5tYXAoXG4oZnVuYyk9PlxuZnVuYyYmKFxuKC4uLmFyZ3MpPT57XG5oaWRkZW5QcmlvckVycm9yPXNlbmRpbmdFcnJvcjtcbmhpZGRlbkN1cnJlbnRUdXJuKz0xO1xuaGlkZGVuQ3VycmVudEV2ZW50PTA7XG50cnl7XG5sZXQgcmVzdWx0O1xudHJ5e1xucmVzdWx0PWZ1bmMoLi4uYXJncyk7XG4gfWNhdGNoKGVycil7XG5pZihlcnIgaW5zdGFuY2VvZiBFcnJvcil7XG5hc3NlcnQubm90ZShcbmVycixcblggYFRocm93biBmcm9tOiAke2hpZGRlblByaW9yRXJyb3J9OiR7aGlkZGVuQ3VycmVudFR1cm59LiR7aGlkZGVuQ3VycmVudEV2ZW50fWApO1xuXG4gfVxuaWYoVkVSQk9TRSl7XG5jb25zb2xlLmxvZygnVEhST1dOIHRvIHRvcCBvZiBldmVudCBsb29wJyxlcnIpO1xuIH1cbnRocm93IGVycjtcbiB9XG4vKiBNdXN0IGNhcHR1cmUgdGhpcyBub3csIG5vdCB3aGVuIHRoZSBjYXRjaCB0cmlnZ2Vycy4qL1xuY29uc3QgZGV0YWlsc05vdGU9WCBgUmVqZWN0aW9uIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YDtcblByb21pc2UucmVzb2x2ZShyZXN1bHQpLmNhdGNoKChyZWFzb24pPT57XG5pZihyZWFzb24gaW5zdGFuY2VvZiBFcnJvcil7XG5hc3NlcnQubm90ZShyZWFzb24sZGV0YWlsc05vdGUpO1xuIH1cbmlmKFZFUkJPU0Upe1xuY29uc29sZS5sb2coJ1JFSkVDVEVEIGF0IHRvcCBvZiBldmVudCBsb29wJyxyZWFzb24pO1xuIH1cbiB9KTtcbnJldHVybiByZXN1bHQ7XG4gfWZpbmFsbHl7XG5oaWRkZW5QcmlvckVycm9yPXVuZGVmaW5lZDtcbiB9XG4gfSkpO1xuXG4gfTskaOKAjV9vbmNlLnRyYWNrVHVybnModHJhY2tUdXJucyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsidHJhY2tUdXJucyI6WyJ0cmFja1R1cm5zIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAH4kbi3SEQAA0hEAACQAAABAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIvc3JjL0UuanN7ImltcG9ydHMiOlsiLi90cmFjay10dXJucy5qcyJdLCJleHBvcnRzIjpbImRlZmF1bHQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgdHJhY2tUdXJuczskaOKAjV9pbXBvcnRzKFtbXCIuL3RyYWNrLXR1cm5zLmpzXCIsIFtbXCJ0cmFja1R1cm5zXCIsIFskaOKAjV9hID0+ICh0cmFja1R1cm5zID0gJGjigI1fYSldXV1dXSk7ICAgXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuLyoqIEB0eXBlIHtQcm94eUhhbmRsZXI8YW55Pn0gKi9cbmNvbnN0IGJhc2VGcmVlemFibGVQcm94eUhhbmRsZXI9e1xuc2V0KF90YXJnZXQsX3Byb3AsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuaXNFeHRlbnNpYmxlKF90YXJnZXQpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5zZXRQcm90b3R5cGVPZihfdGFyZ2V0LF92YWx1ZSl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbmRlbGV0ZVByb3BlcnR5KF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIGZhbHNlO1xuIH19O1xuXG5cbi8qIEUgUHJveHkgaGFuZGxlcnMgcHJldGVuZCB0aGF0IGFueSBwcm9wZXJ0eSBleGlzdHMgb24gdGhlIHRhcmdldCBhbmQgcmV0dXJucyovXG4vKiBhIGZ1bmN0aW9uIGZvciB0aGVpciB2YWx1ZS4gV2hpbGUgdGhpcyBmdW5jdGlvbiBpcyBcImJvdW5kXCIgYnkgY29udGV4dCwgaXQgaXMqL1xuLyogbWVhbnQgdG8gYmUgY2FsbGVkIGFzIGEgbWV0aG9kLiBGb3IgdGhhdCByZWFzb24sIHRoZSByZXR1cm5lZCBmdW5jdGlvbiovXG4vKiBpbmNsdWRlcyBhIGNoZWNrIHRoYXQgdGhlIGB0aGlzYCBhcmd1bWVudCBjb3JyZXNwb25kcyB0byB0aGUgaW5pdGlhbCovXG4vKiByZWNlaXZlciB3aGVuIHRoZSBmdW5jdGlvbiB3YXMgcmV0cmlldmVkLiovXG4vKiBFIFByb3h5IGhhbmRsZXJzIGFsc28gZm9yd2FyZCBkaXJlY3QgY2FsbHMgdG8gdGhlIHRhcmdldCBpbiBjYXNlIHRoZSByZW1vdGUqL1xuLyogaXMgYSBmdW5jdGlvbiBpbnN0ZWFkIG9mIGFuIG9iamVjdC4gTm8gc3VjaCByZWNlaXZlciBjaGVja3MgYXJlIG5lY2Vzc2FyeSBpbiovXG4vKiB0aGF0IGNhc2UuKi9cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUoeCkuXG4gKlxuICogQHBhcmFtIHsqfSB4IEFueSB2YWx1ZSBwYXNzZWQgdG8gRSh4KVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2luZGV4JykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXJ9IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmZ1bmN0aW9uIEVQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSl7XG5yZXR1cm4gaGFyZGVuKHtcbi4uLmJhc2VGcmVlemFibGVQcm94eUhhbmRsZXIsXG5nZXQoX3RhcmdldCxwLHJlY2VpdmVyKXtcbnJldHVybiBoYXJkZW4oXG57XG4vKiBUaGlzIGZ1bmN0aW9uIHB1cnBvc2VseSBjaGVja3MgdGhlIGB0aGlzYCB2YWx1ZSAoc2VlIGFib3ZlKSovXG4vKiBJbiBvcmRlciB0byBiZSBgdGhpc2Agc2Vuc2l0aXZlIGl0IGlzIGRlZmluZWQgdXNpbmcgY29uY2lzZSBtZXRob2QqL1xuLyogc3ludGF4IHJhdGhlciB0aGFuIGFzIGFuIGFycm93IGZ1bmN0aW9uLiBUbyBlbnN1cmUgdGhlIGZ1bmN0aW9uKi9cbi8qIGlzIG5vdCBjb25zdHJ1Y3RhYmxlLCBpdCBhbHNvIGF2b2lkcyB0aGUgYGZ1bmN0aW9uYCBzeW50YXguKi9cbltwXSguLi5hcmdzKXtcbmlmKHRoaXMhPT1yZWNlaXZlcil7XG4vKiBSZWplY3QgdGhlIGFzeW5jIGZ1bmN0aW9uIGNhbGwqL1xucmV0dXJuIEhhbmRsZWRQcm9taXNlLnJlamVjdChcbmFzc2VydC5lcnJvcihcblggYFVuZXhwZWN0ZWQgcmVjZWl2ZXIgZm9yIFwiJHtwfVwiIG1ldGhvZCBvZiBFKCR7cSh4KX0pYCkpO1xuXG5cbiB9XG5cbnJldHVybiBIYW5kbGVkUHJvbWlzZS5hcHBseU1ldGhvZCh4LHAsYXJncyk7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUwMzE5Ki99W1xucF0pO1xuXG4gfSxcbmFwcGx5KF90YXJnZXQsX3RoaXNBcmcsYXJnQXJyYXk9W10pe1xucmV0dXJuIEhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb24oeCxhcmdBcnJheSk7XG4gfSxcbmhhcyhfdGFyZ2V0LF9wKXtcbi8qIFdlIGp1c3QgcHJldGVuZCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG4gfVxuXG4vKipcbiAqIEEgUHJveHkgaGFuZGxlciBmb3IgRS5zZW5kT25seSh4KVxuICogSXQgaXMgYSB2YXJpYW50IG9uIHRoZSBFKHgpIFByb3h5IGhhbmRsZXIuXG4gKlxuICogQHBhcmFtIHsqfSB4IEFueSB2YWx1ZSBwYXNzZWQgdG8gRS5zZW5kT25seSh4KVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2luZGV4JykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXJ9IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmZ1bmN0aW9uIEVzZW5kT25seVByb3h5SGFuZGxlcih4LEhhbmRsZWRQcm9taXNlKXtcbnJldHVybiBoYXJkZW4oe1xuLi4uYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcixcbmdldChfdGFyZ2V0LHAscmVjZWl2ZXIpe1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuW3BdKC4uLmFyZ3Mpe1xuLyogVGhyb3cgc2luY2UgdGhlIGZ1bmN0aW9uIHJldHVybnMgbm90aGluZyovXG50aGlzPT09cmVjZWl2ZXJ8fFxuRmFpbCBgVW5leHBlY3RlZCByZWNlaXZlciBmb3IgXCIke3EocCl9XCIgbWV0aG9kIG9mIEUuc2VuZE9ubHkoJHtxKFxueClcbiB9KWA7XG5IYW5kbGVkUHJvbWlzZS5hcHBseU1ldGhvZFNlbmRPbmx5KHgscCxhcmdzKTtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUwMzE5Ki99W1xucF0pO1xuXG4gfSxcbmFwcGx5KF90YXJnZXQsX3RoaXNBcmcsYXJnc0FycmF5PVtdKXtcbkhhbmRsZWRQcm9taXNlLmFwcGx5RnVuY3Rpb25TZW5kT25seSh4LGFyZ3NBcnJheSk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH0sXG5oYXMoX3RhcmdldCxfcCl7XG4vKiBXZSBqdXN0IHByZXRlbmQgdGhhdCBldmVyeXRoaW5nIGV4aXN0cy4qL1xucmV0dXJuIHRydWU7XG4gfX0pO1xuXG4gfVxuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi9pbmRleCcpLkhhbmRsZWRQcm9taXNlQ29uc3RydWN0b3J9IEhhbmRsZWRQcm9taXNlXG4gKiBAcmV0dXJucyB7WGltcG9ydCgnLi9pbmRleCcpLkVQcm94eX1cbiAqL1xuZnVuY3Rpb24gICAgICAgICAgICAgICAgbWFrZUUoSGFuZGxlZFByb21pc2Upe1xuZnVuY3Rpb24gRSh4KXtcbmNvbnN0IGhhbmRsZXI9RVByb3h5SGFuZGxlcih4LEhhbmRsZWRQcm9taXNlKTtcbnJldHVybiBoYXJkZW4obmV3IFByb3h5KCgpPT57IH0saGFuZGxlcikpO1xuIH1cblxuY29uc3QgbWFrZUVHZXR0ZXJQcm94eT0oeCk9PlxubmV3IFByb3h5KE9iamVjdC5jcmVhdGUobnVsbCkse1xuLi4uYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcixcbmhhcyhfdGFyZ2V0LF9wcm9wKXtcbnJldHVybiB0cnVlO1xuIH0sXG5nZXQoX3RhcmdldCxwcm9wKXtcbnJldHVybiBIYW5kbGVkUHJvbWlzZS5nZXQoeCxwcm9wKTtcbiB9fSk7XG5cblxuRS5nZXQ9bWFrZUVHZXR0ZXJQcm94eTtcbkUucmVzb2x2ZT1IYW5kbGVkUHJvbWlzZS5yZXNvbHZlO1xuRS5zZW5kT25seT0oeCk9PntcbmNvbnN0IGhhbmRsZXI9RXNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpO1xucmV0dXJuIGhhcmRlbihuZXcgUHJveHkoKCk9PnsgfSxoYW5kbGVyKSk7XG4gfTtcblxuRS53aGVuPSh4LG9uZnVsZmlsbGVkLG9ucmVqZWN0ZWQpPT57XG5jb25zdFtvbnN1Y2Nlc3Msb25mYWlsdXJlXT10cmFja1R1cm5zKFtvbmZ1bGZpbGxlZCxvbnJlamVjdGVkXSk7XG5yZXR1cm4gSGFuZGxlZFByb21pc2UucmVzb2x2ZSh4KS50aGVuKG9uc3VjY2VzcyxvbmZhaWx1cmUpO1xuIH07XG5cbnJldHVybiBoYXJkZW4oRSk7XG4gfSRo4oCNX29uY2UuZGVmYXVsdCggICAgIG1ha2VFKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJkZWZhdWx0IjpbImRlZmF1bHQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAANwvtTx8CAAAfAgAAKgAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMi9zcmMvbm8tc2hpbS5qc3siaW1wb3J0cyI6WyIuL0UuanMiXSwiZXhwb3J0cyI6WyJFIiwiSGFuZGxlZFByb21pc2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbWFrZUU7JGjigI1faW1wb3J0cyhbW1wiLi9FLmpzXCIsIFtbXCJkZWZhdWx0XCIsIFskaOKAjV9hID0+IChtYWtlRSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cbmNvbnN0IGhwPUhhbmRsZWRQcm9taXNlOyRo4oCNX29uY2UuaHAoaHApO1xuY29uc3QgICAgICAgIEU9bWFrZUUoSGFuZGxlZFByb21pc2UpOyRo4oCNX29uY2UuRShFKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJIYW5kbGVkUHJvbWlzZSI6WyJocCJdLCJFIjpbIkUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAoVgjP48QAACPEAAALgAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMi9zcmMvdHJhY2stdHVybnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbInRyYWNrVHVybnMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBnbG9iYWwgZ2xvYmFsVGhpcyAqL1xuLyogQHRzLW5vY2hlY2sqL1xuXG5jb25zdHtmcmVlemV9PU9iamVjdDtcblxuLyogTk9URTogV2UgY2FuJ3QgaW1wb3J0IHRoZXNlIGJlY2F1c2UgdGhleSdyZSBub3QgaW4gc2NvcGUgYmVmb3JlIGxvY2tkb3duLiovXG4vKiBpbXBvcnQgeyBhc3NlcnQsIGRldGFpbHMgYXMgWCwgRmFpbCB9IGZyb20gJ0BhZ29yaWMvYXNzZXJ0JzsqL1xuXG4vKiBXQVJOSU5HOiBHbG9iYWwgTXV0YWJsZSBTdGF0ZSEqL1xuLyogVGhpcyBzdGF0ZSBpcyBjb21tdW5pY2F0ZWQgdG8gYGFzc2VydGAgdGhhdCBtYWtlcyBpdCBhdmFpbGFibGUgdG8gdGhlKi9cbi8qIGNhdXNhbCBjb25zb2xlLCB3aGljaCBhZmZlY3RzIHRoZSBjb25zb2xlIGxvZyBvdXRwdXQuIE5vcm1hbGx5IHdlKi9cbi8qIHJlZ2FyZCB0aGUgYWJpbGl0eSB0byBzZWUgY29uc29sZSBsb2cgb3V0cHV0IGFzIGEgbWV0YS1sZXZlbCBwcml2aWxlZ2UqL1xuLyogYW5hbG9nb3VzIHRvIHRoZSBhYmlsaXR5IHRvIGRlYnVnLiBBc2lkZSBmcm9tIHRoYXQsIHRoaXMgbW9kdWxlIHNob3VsZCovXG4vKiBub3QgaGF2ZSBhbnkgb2JzZXJ2YWJseSBtdXRhYmxlIHN0YXRlLiovXG5cbmxldCBoaWRkZW5QcmlvckVycm9yO1xubGV0IGhpZGRlbkN1cnJlbnRUdXJuPTA7XG5sZXQgaGlkZGVuQ3VycmVudEV2ZW50PTA7XG5cbi8qIFRPRE8gVXNlIGVudmlyb25tZW50LW9wdGlvbnMuanMgY3VycmVudGx5IGluIHNlcy9zcmMgYWZ0ZXIgZmFjdG9yaW5nIGl0IG91dCovXG4vKiB0byBhIG5ldyBwYWNrYWdlLiovXG5jb25zdCBlbnY9KGdsb2JhbFRoaXMucHJvY2Vzc3x8e30pLmVudnx8e307XG5cbi8qIFR1cm4gb24gaWYgeW91IHNlZW0gdG8gYmUgbG9zaW5nIGVycm9yIGxvZ2dpbmcgYXQgdGhlIHRvcCBvZiB0aGUgZXZlbnQgbG9vcCovXG5jb25zdCBWRVJCT1NFPShlbnYuREVCVUd8fCcnKS5zcGxpdCgnOicpLmluY2x1ZGVzKCd0cmFjay10dXJucycpO1xuXG5jb25zdCB2YWxpZE9wdGlvblZhbHVlcz1mcmVlemUoW3VuZGVmaW5lZCwnZW5hYmxlZCcsJ2Rpc2FibGVkJ10pO1xuXG4vKiBUcmFjay10dXJucyBpcyBlbmFibGVkIGJ5IGRlZmF1bHQgYW5kIGNhbiBiZSBkaXNhYmxlZCBieSBhbiBlbnZpcm9ubWVudCovXG4vKiBvcHRpb24uKi9cbmNvbnN0IGVudk9wdGlvblZhbHVlPWVudi5UUkFDS19UVVJOUztcbmlmKCF2YWxpZE9wdGlvblZhbHVlcy5pbmNsdWRlcyhlbnZPcHRpb25WYWx1ZSkpe1xudGhyb3cgbmV3IFR5cGVFcnJvcihcbiBgdW5yZWNvZ25pemVkIFRSQUNLX1RVUk5TICR7SlNPTi5zdHJpbmdpZnkoZW52T3B0aW9uVmFsdWUpfWApO1xuXG4gfVxuY29uc3QgRU5BQkxFRD0oZW52T3B0aW9uVmFsdWV8fCdkaXNhYmxlZCcpPT09J2VuYWJsZWQnO1xuXG4vKiBXZSBob2lzdCB0aGUgZm9sbG93aW5nIGZ1bmN0aW9ucyBvdXQgb2YgdHJhY2tUdXJucygpIHRvIGRpc2NvdXJhZ2UgdGhlKi9cbi8qIGNsb3N1cmVzIGZyb20gaG9sZGluZyBvbnRvICdhcmdzJyBvciAnZnVuYycgbG9uZ2VyIHRoYW4gbmVjZXNzYXJ5LCovXG4vKiB3aGljaCB3ZSd2ZSBzZWVuIGNhdXNlIEhhbmRsZWRQcm9taXNlIGFyZ3VtZW50cyB0byBiZSByZXRhaW5lZCBmb3IqL1xuLyogYSBzdXJwcmlzaW5nbHkgbG9uZyB0aW1lLiovXG5cbmNvbnN0IGFkZFJlamVjdGlvbk5vdGU9KGRldGFpbHNOb3RlKT0+KHJlYXNvbik9PntcbmlmKHJlYXNvbiBpbnN0YW5jZW9mIEVycm9yKXtcbmFzc2VydC5ub3RlKHJlYXNvbixkZXRhaWxzTm90ZSk7XG4gfVxuaWYoVkVSQk9TRSl7XG5jb25zb2xlLmxvZygnUkVKRUNURUQgYXQgdG9wIG9mIGV2ZW50IGxvb3AnLHJlYXNvbik7XG4gfVxuIH07XG5cbmNvbnN0IHdyYXBGdW5jdGlvbj1cbihmdW5jLHNlbmRpbmdFcnJvcixYKT0+XG4oLi4uYXJncyk9PntcbmhpZGRlblByaW9yRXJyb3I9c2VuZGluZ0Vycm9yO1xuaGlkZGVuQ3VycmVudFR1cm4rPTE7XG5oaWRkZW5DdXJyZW50RXZlbnQ9MDtcbnRyeXtcbmxldCByZXN1bHQ7XG50cnl7XG5yZXN1bHQ9ZnVuYyguLi5hcmdzKTtcbiB9Y2F0Y2goZXJyKXtcbmlmKGVyciBpbnN0YW5jZW9mIEVycm9yKXtcbmFzc2VydC5ub3RlKFxuZXJyLFxuWCBgVGhyb3duIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbiB9XG5pZihWRVJCT1NFKXtcbmNvbnNvbGUubG9nKCdUSFJPV04gdG8gdG9wIG9mIGV2ZW50IGxvb3AnLGVycik7XG4gfVxudGhyb3cgZXJyO1xuIH1cbi8qIE11c3QgY2FwdHVyZSB0aGlzIG5vdywgbm90IHdoZW4gdGhlIGNhdGNoIHRyaWdnZXJzLiovXG5jb25zdCBkZXRhaWxzTm90ZT1YIGBSZWplY3Rpb24gZnJvbTogJHtoaWRkZW5QcmlvckVycm9yfToke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gO1xuUHJvbWlzZS5yZXNvbHZlKHJlc3VsdCkuY2F0Y2goYWRkUmVqZWN0aW9uTm90ZShkZXRhaWxzTm90ZSkpO1xucmV0dXJuIHJlc3VsdDtcbiB9ZmluYWxseXtcbmhpZGRlblByaW9yRXJyb3I9dW5kZWZpbmVkO1xuIH1cbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHsoKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHwgdW5kZWZpbmVkfSBUdXJuU3RhcnRlckZuXG4gKiBBbiBvcHRpb25hbCBmdW5jdGlvbiB0aGF0IGlzIG5vdCB0aGlzLXNlbnNpdGl2ZSwgZXhwZWN0ZWQgdG8gYmUgY2FsbGVkIGF0XG4gKiBib3R0b20gb2Ygc3RhY2sgdG8gc3RhcnQgYSBuZXcgdHVybi5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7VHVyblN0YXJ0ZXJGbltdfSBUXG4gKiBHaXZlbiBhIGxpc3Qgb2YgYFR1cm5TdGFydGVyRm5gcywgcmV0dXJucyBhIGxpc3Qgb2YgYFR1cm5TdGFydGVyRm5gcyB3aG9zZVxuICogYHRoaXNgLWZyZWUgY2FsbCBiZWhhdmlvcnMgYXJlIG5vdCBvYnNlcnZhYmx5IGRpZmZlcmVudCB0byB0aG9zZSB0aGF0XG4gKiBjYW5ub3Qgc2VlIGNvbnNvbGUgb3V0cHV0LiBUaGUgb25seSBwdXJwb3NlIGlzIHRvIGNhdXNlIGFkZGl0aW9uYWxcbiAqIGluZm9ybWF0aW9uIHRvIGFwcGVhciBvbiB0aGUgY29uc29sZS5cbiAqXG4gKiBUaGUgY2FsbCB0byBgdHJhY2tUdXJuc2AgaXMgaXRzZWxmIGEgc2VuZGluZyBldmVudCwgdGhhdCBvY2N1cnMgaW4gc29tZSBjYWxsXG4gKiBzdGFjayBpbiBzb21lIHR1cm4gbnVtYmVyIGF0IHNvbWUgZXZlbnQgbnVtYmVyIHdpdGhpbiB0aGF0IHR1cm4uIEVhY2ggY2FsbFxuICogdG8gYW55IG9mIHRoZSByZXR1cm5lZCBgVHVyblN0YXJ0Rm5gcyBpcyBhIHJlY2VpdmluZyBldmVudCB0aGF0IGJlZ2lucyBhIG5ld1xuICogdHVybi4gVGhpcyBzZW5kaW5nIGV2ZW50IGNhdXNlZCBlYWNoIG9mIHRob3NlIHJlY2VpdmluZyBldmVudHMuXG4gKlxuICogQHBhcmFtIHtUfSBmdW5jc1xuICogQHJldHVybnMge1R9XG4gKi9cbmNvbnN0ICAgICAgICB0cmFja1R1cm5zPShmdW5jcyk9PntcbmlmKCFFTkFCTEVEfHx0eXBlb2YgZ2xvYmFsVGhpcz09PSd1bmRlZmluZWQnfHwhZ2xvYmFsVGhpcy5hc3NlcnQpe1xucmV0dXJuIGZ1bmNzO1xuIH1cbmNvbnN0e2RldGFpbHM6WH09YXNzZXJ0O1xuXG5oaWRkZW5DdXJyZW50RXZlbnQrPTE7XG5jb25zdCBzZW5kaW5nRXJyb3I9bmV3IEVycm9yKFxuIGBFdmVudDogJHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbmlmKGhpZGRlblByaW9yRXJyb3IhPT11bmRlZmluZWQpe1xuYXNzZXJ0Lm5vdGUoc2VuZGluZ0Vycm9yLFggYENhdXNlZCBieTogJHtoaWRkZW5QcmlvckVycm9yfWApO1xuIH1cblxucmV0dXJuIGZ1bmNzLm1hcCgoZnVuYyk9PmZ1bmMmJndyYXBGdW5jdGlvbihmdW5jLHNlbmRpbmdFcnJvcixYKSk7XG4gfTskaOKAjV9vbmNlLnRyYWNrVHVybnModHJhY2tUdXJucyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsidHJhY2tUdXJucyI6WyJ0cmFja1R1cm5zIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAADpSrU0cAgAAHAIAABkAAABAZW5kby9leG8tdjAuMi4yL2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2V4by1tYWtlcnMuanMiXSwiZXhwb3J0cyI6WyJkZWZpbmVFeG9DbGFzcyIsImRlZmluZUV4b0NsYXNzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9zcmMvZXhvLW1ha2Vycy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3NyYy9leG8tbWFrZXJzLmpzIjpbWyJpbml0RW1wdHkiLCJpbml0RW1wdHkiXSxbImRlZmluZUV4b0NsYXNzIiwiZGVmaW5lRXhvQ2xhc3MiXSxbImRlZmluZUV4b0NsYXNzS2l0IiwiZGVmaW5lRXhvQ2xhc3NLaXQiXSxbIm1ha2VFeG8iLCJtYWtlRXhvIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADGt+tWYxgAAGMYAAAiAAAAQGVuZG8vZXhvLXYwLjIuMi9zcmMvZXhvLW1ha2Vycy5qc3siaW1wb3J0cyI6WyIuL2V4by10b29scy5qcyIsIkBlbmRvL3BhdHRlcm5zIl0sImV4cG9ydHMiOlsiZGVmaW5lRXhvQ2xhc3MiLCJkZWZpbmVFeG9DbGFzc0tpdCIsImluaXRFbXB0eSIsIm1ha2VFeG8iXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgb2JqZWN0TWFwLGRlZmVuZFByb3RvdHlwZSxkZWZlbmRQcm90b3R5cGVLaXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGF0dGVybnNcIiwgW1tcIm9iamVjdE1hcFwiLCBbJGjigI1fYSA9PiAob2JqZWN0TWFwID0gJGjigI1fYSldXV1dLFtcIi4vZXhvLXRvb2xzLmpzXCIsIFtbXCJkZWZlbmRQcm90b3R5cGVcIiwgWyRo4oCNX2EgPT4gKGRlZmVuZFByb3RvdHlwZSA9ICRo4oCNX2EpXV0sW1wiZGVmZW5kUHJvdG90eXBlS2l0XCIsIFskaOKAjV9hID0+IChkZWZlbmRQcm90b3R5cGVLaXQgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5jb25zdHtjcmVhdGUsc2VhbCxmcmVlemUsZGVmaW5lUHJvcGVydHl9PU9iamVjdDtcblxuLyogVE9ETyBVc2UgZW52aXJvbm1lbnQtb3B0aW9ucy5qcyBjdXJyZW50bHkgaW4gc2VzL3NyYyBhZnRlciBmYWN0b3JpbmcgaXQgb3V0Ki9cbi8qIHRvIGEgbmV3IHBhY2thZ2UuKi9cbmNvbnN0IGVudj0oZ2xvYmFsVGhpcy5wcm9jZXNzfHx7fSkuZW52fHx7fTtcblxuLyogVHVybiBvbiB0byBnaXZlIGVhY2ggZXhvIGluc3RhbmNlIGl0cyBvd24gdG9TdHJpbmdUYWcgdmFsdWUuKi9cbmNvbnN0IExBQkVMX0lOU1RBTkNFUz0oZW52LkRFQlVHfHwnJykuXG5zcGxpdCgnLCcpLlxuaW5jbHVkZXMoJ2xhYmVsLWluc3RhbmNlcycpO1xuXG5jb25zdCBtYWtlU2VsZj0ocHJvdG8saW5zdGFuY2VDb3VudCk9PntcbmNvbnN0IHNlbGY9Y3JlYXRlKHByb3RvKTtcbmlmKExBQkVMX0lOU1RBTkNFUyl7XG5kZWZpbmVQcm9wZXJ0eShzZWxmLFN5bWJvbC50b1N0cmluZ1RhZyx7XG52YWx1ZTogYCR7cHJvdG9bU3ltYm9sLnRvU3RyaW5nVGFnXX0jJHtpbnN0YW5jZUNvdW50fWAsXG53cml0YWJsZTpmYWxzZSxcbmVudW1lcmFibGU6ZmFsc2UsXG5jb25maWd1cmFibGU6ZmFsc2V9KTtcblxuIH1cbnJldHVybiBoYXJkZW4oc2VsZik7XG4gfTtcblxuY29uc3QgZW1wdHlSZWNvcmQ9aGFyZGVuKHt9KTtcblxuLyoqXG4gKiBXaGVuIGNhbGxpbmcgYGRlZmluZUR1cmFibGVLaW5kYCBhbmRcbiAqIGl0cyBzaWJsaW5ncywgdXNlZCBhcyB0aGUgYGluaXRgIGZ1bmN0aW9uIGFyZ3VtZW50IHRvIGluZGljYXRlIHRoYXQgdGhlXG4gKiBzdGF0ZSByZWNvcmQgb2YgdGhlICh2aXJ0dWFsL2R1cmFibGUpIGluc3RhbmNlcyBvZiB0aGUga2luZC9leG9DbGFzc1xuICogc2hvdWxkIGJlIGVtcHR5LCBhbmQgdGhhdCB0aGUgcmV0dXJuZWQgbWFrZXIgZnVuY3Rpb24gc2hvdWxkIGhhdmUgemVyb1xuICogcGFyYW1ldGVycy5cbiAqXG4gKiBAcmV0dXJucyB7e319XG4gKi9cbmNvbnN0ICAgICAgICBpbml0RW1wdHk9KCk9PmVtcHR5UmVjb3JkO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL2V4by10b29scy5qcycpLkZhY2V0TmFtZX0gRmFjZXROYW1lXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9leG8tdG9vbHMuanMnKS5NZXRob2RzfSBNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1MgPSBhbnldXG4gKiBAdGVtcGxhdGUge01ldGhvZHN9IFtNID0gYW55XVxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vZXhvLXRvb2xzLmpzJykuQ2xhc3NDb250ZXh0fSBDbGFzc0NvbnRleHRcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBbUyA9IGFueV1cbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPEZhY2V0TmFtZSwgTWV0aG9kcz59IFtGID0gYW55XVxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vZXhvLXRvb2xzLmpzJykuS2l0Q29udGV4dH0gS2l0Q29udGV4dFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge3tbbmFtZTogc3RyaW5nXTogWGltcG9ydCgnQGVuZG8vcGF0dGVybnMnKS5QYXR0ZXJufX0gU3RhdGVTaGFwZVxuICogSXQgbG9va3MgbGlrZSBhIGNvcHlSZWNvcmQgcGF0dGVybiwgYnV0IHRoZSBpbnRlcnByZXRhdGlvbiBpcyBkaWZmZXJlbnQuXG4gKiBFYWNoIHByb3BlcnR5IGlzIGRpc3RpbmN0LCBpcyBjaGVja2VkIGFuZCBjaGFuZ2VkIHNlcGFyYXRlbHkuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgQ1xuICogQHR5cGVkZWYge29iamVjdH0gRmFyQ2xhc3NPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhjb250ZXh0OiBDKSA9PiB2b2lkfSBbZmluaXNoXVxuICogQHByb3BlcnR5IHtTdGF0ZVNoYXBlfSBbc3RhdGVTaGFwZV1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IEkgaW5pdCBmdW5jdGlvblxuICogQHRlbXBsYXRlIHtNZXRob2RzfSBNIG1ldGhvZHNcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZFxuICogQHBhcmFtIHtJfSBpbml0XG4gKiBAcGFyYW0ge00gJiBUaGlzVHlwZTx7IHNlbGY6IE0sIHN0YXRlOiBSZXR1cm5UeXBlPEk+IH0+fSBtZXRob2RzXG4gKiBAcGFyYW0ge0ZhckNsYXNzT3B0aW9uczxDbGFzc0NvbnRleHQ8UmV0dXJuVHlwZTxJPiwgTT4+fSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHsoLi4uYXJnczogUGFyYW1ldGVyczxJPikgPT4gKE0gJiBYaW1wb3J0KCdAZW5kby9ldmVudHVhbC1zZW5kJykuUmVtb3RhYmxlQnJhbmQ8e30sIE0+KX1cbiAqLyRo4oCNX29uY2UuaW5pdEVtcHR5KGluaXRFbXB0eSk7XG5jb25zdCAgICAgICAgZGVmaW5lRXhvQ2xhc3M9KHRhZyxpbnRlcmZhY2VHdWFyZCxpbml0LG1ldGhvZHMsb3B0aW9ucyk9PntcbmNvbnN0e2ZpbmlzaD11bmRlZmluZWR9PW9wdGlvbnN8fHt9O1xuLyoqIEB0eXBlIHtXZWFrTWFwPE0sQ2xhc3NDb250ZXh0PFJldHVyblR5cGU8ST4sIE0+Pn0gKi9cbmNvbnN0IGNvbnRleHRNYXA9bmV3IFdlYWtNYXAoKTtcbmNvbnN0IHByb3RvPWRlZmVuZFByb3RvdHlwZShcbnRhZyxcbihzZWxmKT0+LyoqIEB0eXBlIHthbnl9ICovY29udGV4dE1hcC5nZXQoc2VsZiksXG5tZXRob2RzLFxudHJ1ZSxcbmludGVyZmFjZUd1YXJkKTtcblxubGV0IGluc3RhbmNlQ291bnQ9MDtcbi8qKlxuICogQHBhcmFtICB7UGFyYW1ldGVyczxJPn0gYXJnc1xuICovXG5jb25zdCBtYWtlSW5zdGFuY2U9KC4uLmFyZ3MpPT57XG4vKiBCZSBjYXJlZnVsIG5vdCB0byBmcmVlemUgdGhlIHN0YXRlIHJlY29yZCovXG5jb25zdCBzdGF0ZT1zZWFsKGluaXQoLi4uYXJncykpO1xuaW5zdGFuY2VDb3VudCs9MTtcbi8qKiBAdHlwZSB7TX0gKi9cbmNvbnN0IHNlbGY9bWFrZVNlbGYocHJvdG8saW5zdGFuY2VDb3VudCk7XG5cbi8qIEJlIGNhcmVmdWwgbm90IHRvIGZyZWV6ZSB0aGUgc3RhdGUgcmVjb3JkKi9cbi8qKiBAdHlwZSB7Q2xhc3NDb250ZXh0PFJldHVyblR5cGU8ST4sTT59ICovXG5jb25zdCBjb250ZXh0PWZyZWV6ZSh7c3RhdGUsc2VsZn0pO1xuY29udGV4dE1hcC5zZXQoc2VsZixjb250ZXh0KTtcbmlmKGZpbmlzaCl7XG5maW5pc2goY29udGV4dCk7XG4gfVxucmV0dXJuICgvKiogQHR5cGUge00gJiBYaW1wb3J0KCdAZW5kby9ldmVudHVhbC1zZW5kJykuUmVtb3RhYmxlQnJhbmQ8e30sIE0+fSAqL1xuc2VsZik7XG5cbiB9O1xucmV0dXJuIGhhcmRlbihtYWtlSW5zdGFuY2UpO1xuIH07JGjigI1fb25jZS5kZWZpbmVFeG9DbGFzcyhkZWZpbmVFeG9DbGFzcyk7XG5oYXJkZW4oZGVmaW5lRXhvQ2xhc3MpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IEkgaW5pdCBmdW5jdGlvblxuICogQHRlbXBsYXRlIHtSZWNvcmQ8RmFjZXROYW1lLCBNZXRob2RzPn0gRiBmYWNldCBtZXRob2RzXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcGFyYW0ge2FueX0gaW50ZXJmYWNlR3VhcmRLaXRcbiAqIEBwYXJhbSB7SX0gaW5pdFxuICogQHBhcmFtIHtGICYgVGhpc1R5cGU8eyBmYWNldHM6IEYsIHN0YXRlOiBSZXR1cm5UeXBlPEk+IH0+IH0gbWV0aG9kc0tpdFxuICogQHBhcmFtIHtGYXJDbGFzc09wdGlvbnM8S2l0Q29udGV4dDxSZXR1cm5UeXBlPEk+LEY+Pn0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7KC4uLmFyZ3M6IFBhcmFtZXRlcnM8ST4pID0+IEZ9XG4gKi9cbmNvbnN0ICAgICAgICBkZWZpbmVFeG9DbGFzc0tpdD0oXG50YWcsXG5pbnRlcmZhY2VHdWFyZEtpdCxcbmluaXQsXG5tZXRob2RzS2l0LFxub3B0aW9ucyk9Plxue1xuY29uc3R7ZmluaXNoPXVuZGVmaW5lZH09b3B0aW9uc3x8e307XG5jb25zdCBjb250ZXh0TWFwS2l0PW9iamVjdE1hcChtZXRob2RzS2l0LCgpPT5uZXcgV2Vha01hcCgpKTtcbmNvbnN0IGdldENvbnRleHRLaXQ9b2JqZWN0TWFwKFxubWV0aG9kc0tpdCxcbihfdixuYW1lKT0+KGZhY2V0KT0+Y29udGV4dE1hcEtpdFtuYW1lXS5nZXQoZmFjZXQpKTtcblxuY29uc3QgcHJvdG90eXBlS2l0PWRlZmVuZFByb3RvdHlwZUtpdChcbnRhZyxcbmdldENvbnRleHRLaXQsXG5tZXRob2RzS2l0LFxudHJ1ZSxcbmludGVyZmFjZUd1YXJkS2l0KTtcblxubGV0IGluc3RhbmNlQ291bnQ9MDtcbi8qKlxuICogQHBhcmFtIHtQYXJhbWV0ZXJzPEk+fSBhcmdzXG4gKi9cbmNvbnN0IG1ha2VJbnN0YW5jZUtpdD0oLi4uYXJncyk9Pntcbi8qIEJlIGNhcmVmdWwgbm90IHRvIGZyZWV6ZSB0aGUgc3RhdGUgcmVjb3JkKi9cbmNvbnN0IHN0YXRlPXNlYWwoaW5pdCguLi5hcmdzKSk7XG4vKiBEb24ndCBmcmVlemUgY29udGV4dCB1bnRpbCB3ZSBhZGQgZmFjZXRzKi9cbi8qKiBAdHlwZSB7S2l0Q29udGV4dDxSZXR1cm5UeXBlPEk+LEY+fSAqL1xuY29uc3QgY29udGV4dD17c3RhdGUsZmFjZXRzOnt9fTtcbmluc3RhbmNlQ291bnQrPTE7XG5jb25zdCBmYWNldHM9b2JqZWN0TWFwKHByb3RvdHlwZUtpdCwocHJvdG8sZmFjZXROYW1lKT0+e1xuY29uc3Qgc2VsZj1tYWtlU2VsZihwcm90byxpbnN0YW5jZUNvdW50KTtcbmNvbnRleHRNYXBLaXRbZmFjZXROYW1lXS5zZXQoc2VsZixjb250ZXh0KTtcbnJldHVybiBzZWxmO1xuIH0pO1xuY29udGV4dC5mYWNldHM9ZmFjZXRzO1xuLyogQmUgY2FyZWZ1bCBub3QgdG8gZnJlZXplIHRoZSBzdGF0ZSByZWNvcmQqL1xuZnJlZXplKGNvbnRleHQpO1xuaWYoZmluaXNoKXtcbmZpbmlzaChjb250ZXh0KTtcbiB9XG5yZXR1cm4gY29udGV4dC5mYWNldHM7XG4gfTtcbnJldHVybiBoYXJkZW4obWFrZUluc3RhbmNlS2l0KTtcbiB9OyRo4oCNX29uY2UuZGVmaW5lRXhvQ2xhc3NLaXQoZGVmaW5lRXhvQ2xhc3NLaXQpO1xuaGFyZGVuKGRlZmluZUV4b0NsYXNzS2l0KTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge01ldGhvZHN9IFRcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGVuZG8vcGF0dGVybnMnKS5JbnRlcmZhY2VHdWFyZCB8IHVuZGVmaW5lZH0gaW50ZXJmYWNlR3VhcmQgQ0FWRUFUOiBzdGF0aWMgdHlwaW5nIGRvZXMgbm90IHlldCBzdXBwb3J0IGBjYWxsV2hlbmAgdHJhbnNmb3JtYXRpb25cbiAqIEBwYXJhbSB7VH0gbWV0aG9kc1xuICogQHBhcmFtIHtGYXJDbGFzc09wdGlvbnM8Q2xhc3NDb250ZXh0PHt9LFQ+Pn0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7VCAmIFhpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDx7fSwgVD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRXhvPSh0YWcsaW50ZXJmYWNlR3VhcmQsbWV0aG9kcyxvcHRpb25zPXVuZGVmaW5lZCk9PntcbmNvbnN0IG1ha2VJbnN0YW5jZT1kZWZpbmVFeG9DbGFzcyhcbnRhZyxcbmludGVyZmFjZUd1YXJkLFxuaW5pdEVtcHR5LFxubWV0aG9kcyxcbm9wdGlvbnMpO1xuXG5yZXR1cm4gbWFrZUluc3RhbmNlKCk7XG4gfTskaOKAjV9vbmNlLm1ha2VFeG8obWFrZUV4byk7XG5oYXJkZW4obWFrZUV4byk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaW5pdEVtcHR5IjpbImluaXRFbXB0eSJdLCJkZWZpbmVFeG9DbGFzcyI6WyJkZWZpbmVFeG9DbGFzcyJdLCJkZWZpbmVFeG9DbGFzc0tpdCI6WyJkZWZpbmVFeG9DbGFzc0tpdCJdLCJtYWtlRXhvIjpbIm1ha2VFeG8iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAMbCt8nEmAABxJgAAIQAAAEBlbmRvL2V4by12MC4yLjIvc3JjL2V4by10b29scy5qc3siaW1wb3J0cyI6WyJAZW5kby9mYXIiLCJAZW5kby9wYXR0ZXJucyJdLCJleHBvcnRzIjpbImRlZmVuZFByb3RvdHlwZSIsImRlZmVuZFByb3RvdHlwZUtpdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixsaXN0RGlmZmVyZW5jZSxvYmplY3RNYXAsbXVzdE1hdGNoLE07JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wYXR0ZXJuc1wiLCBbW1wibGlzdERpZmZlcmVuY2VcIiwgWyRo4oCNX2EgPT4gKGxpc3REaWZmZXJlbmNlID0gJGjigI1fYSldXSxbXCJvYmplY3RNYXBcIiwgWyRo4oCNX2EgPT4gKG9iamVjdE1hcCA9ICRo4oCNX2EpXV0sW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dLFtcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3BhdHRlcm5zJykuTWV0aG9kfSBNZXRob2QgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGF0dGVybnMnKS5NZXRob2RHdWFyZH0gTWV0aG9kR3VhcmQgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGF0dGVybnMnKS5JbnRlcmZhY2VHdWFyZH0gSW50ZXJmYWNlR3VhcmQgKi9cblxuY29uc3R7cXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5jb25zdHthcHBseSxvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7ZGVmaW5lUHJvcGVydGllc309T2JqZWN0O1xuXG4vKipcbiAqIEEgbWV0aG9kIGd1YXJkLCBmb3IgaW5jbHVzaW9uIGluIGFuIGludGVyZmFjZSBndWFyZCwgdGhhdCBlbmZvcmNlcyBvbmx5IHRoYXRcbiAqIGFsbCBhcmd1bWVudHMgYXJlIHBhc3NhYmxlIGFuZCB0aGF0IHRoZSByZXN1bHQgaXMgcGFzc2FibGUuIChJbiBmYXIgY2xhc3NlcyxcbiAqIFwiYW55XCIgbWVhbnMgYW55ICpwYXNzYWJsZSouKSBUaGlzIGlzIHRoZSBsZWFzdCBwb3NzaWJsZSBlbmZvcmNlbWVudCBmb3IgYVxuICogbWV0aG9kIGd1YXJkLCBhbmQgaXMgaW1wbGllZCBieSBhbGwgb3RoZXIgbWV0aG9kIGd1YXJkcy5cbiAqL1xuY29uc3QgTWluTWV0aG9kR3VhcmQ9TS5jYWxsKCkucmVzdChNLmFueSgpKS5yZXR1cm5zKE0uYW55KCkpO1xuXG5jb25zdCBkZWZlbmRTeW5jQXJncz0oYXJncyxtZXRob2RHdWFyZCxsYWJlbCk9PntcbmNvbnN0e2FyZ0d1YXJkcyxvcHRpb25hbEFyZ0d1YXJkcyxyZXN0QXJnR3VhcmR9PW1ldGhvZEd1YXJkO1xuY29uc3QgcGFyYW1zUGF0dGVybj1NLnNwbGl0QXJyYXkoXG5hcmdHdWFyZHMsXG5vcHRpb25hbEFyZ0d1YXJkcyxcbnJlc3RBcmdHdWFyZCk7XG5cbm11c3RNYXRjaChoYXJkZW4oYXJncykscGFyYW1zUGF0dGVybixsYWJlbCk7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge01ldGhvZH0gbWV0aG9kXG4gKiBAcGFyYW0ge01ldGhvZEd1YXJkfSBtZXRob2RHdWFyZFxuICogQHBhcmFtIHtzdHJpbmd9IGxhYmVsXG4gKiBAcmV0dXJucyB7TWV0aG9kfVxuICovXG5jb25zdCBkZWZlbmRTeW5jTWV0aG9kPShtZXRob2QsbWV0aG9kR3VhcmQsbGFiZWwpPT57XG5jb25zdHtyZXR1cm5HdWFyZH09bWV0aG9kR3VhcmQ7XG5jb25zdHtzeW5jTWV0aG9kfT17XG4vKiBOb3RlIHB1cnBvc2VmdWwgdXNlIG9mIGB0aGlzYCBhbmQgY29uY2lzZSBtZXRob2Qgc3ludGF4Ki9cbnN5bmNNZXRob2QoLi4uYXJncyl7XG5kZWZlbmRTeW5jQXJncyhoYXJkZW4oYXJncyksbWV0aG9kR3VhcmQsbGFiZWwpO1xuY29uc3QgcmVzdWx0PWFwcGx5KG1ldGhvZCx0aGlzLGFyZ3MpO1xubXVzdE1hdGNoKGhhcmRlbihyZXN1bHQpLHJldHVybkd1YXJkLCBgJHtsYWJlbH06IHJlc3VsdGApO1xucmV0dXJuIHJlc3VsdDtcbiB9fTtcblxucmV0dXJuIHN5bmNNZXRob2Q7XG4gfTtcblxuY29uc3QgaXNBd2FpdEFyZ0d1YXJkPShhcmdHdWFyZCk9PlxuYXJnR3VhcmQmJnR5cGVvZiBhcmdHdWFyZD09PSdvYmplY3QnJiZhcmdHdWFyZC5rbGFzcz09PSdhd2FpdEFyZyc7XG5cbmNvbnN0IGRlc3luYz0obWV0aG9kR3VhcmQpPT57XG5jb25zdHthcmdHdWFyZHMsb3B0aW9uYWxBcmdHdWFyZHM9W10scmVzdEFyZ0d1YXJkfT1tZXRob2RHdWFyZDtcbiFpc0F3YWl0QXJnR3VhcmQocmVzdEFyZ0d1YXJkKXx8XG5GYWlsIGBSZXN0IGFyZ3MgbWF5IG5vdCBiZSBhd2FpdGVkOiAke3Jlc3RBcmdHdWFyZH1gO1xuY29uc3QgcmF3QXJnR3VhcmRzPVsuLi5hcmdHdWFyZHMsLi4ub3B0aW9uYWxBcmdHdWFyZHNdO1xuXG5jb25zdCBhd2FpdEluZGV4ZXM9W107XG5mb3IobGV0IGk9MDtpPHJhd0FyZ0d1YXJkcy5sZW5ndGg7aSs9MSl7XG5jb25zdCBhcmdHdWFyZD1yYXdBcmdHdWFyZHNbaV07XG5pZihpc0F3YWl0QXJnR3VhcmQoYXJnR3VhcmQpKXtcbnJhd0FyZ0d1YXJkc1tpXT1hcmdHdWFyZC5hcmdHdWFyZDtcbmF3YWl0SW5kZXhlcy5wdXNoKGkpO1xuIH1cbiB9XG5yZXR1cm57XG5hd2FpdEluZGV4ZXMsXG5yYXdNZXRob2RHdWFyZDp7XG5hcmdHdWFyZHM6cmF3QXJnR3VhcmRzLnNsaWNlKDAsYXJnR3VhcmRzLmxlbmd0aCksXG5vcHRpb25hbEFyZ0d1YXJkczpyYXdBcmdHdWFyZHMuc2xpY2UoYXJnR3VhcmRzLmxlbmd0aCksXG5yZXN0QXJnR3VhcmR9fTtcblxuXG4gfTtcblxuY29uc3QgZGVmZW5kQXN5bmNNZXRob2Q9KG1ldGhvZCxtZXRob2RHdWFyZCxsYWJlbCk9PntcbmNvbnN0e3JldHVybkd1YXJkfT1tZXRob2RHdWFyZDtcbmNvbnN0e2F3YWl0SW5kZXhlcyxyYXdNZXRob2RHdWFyZH09ZGVzeW5jKG1ldGhvZEd1YXJkKTtcbmNvbnN0e2FzeW5jTWV0aG9kfT17XG4vKiBOb3RlIHB1cnBvc2VmdWwgdXNlIG9mIGB0aGlzYCBhbmQgY29uY2lzZSBtZXRob2Qgc3ludGF4Ki9cbmFzeW5jTWV0aG9kKC4uLmFyZ3Mpe1xuY29uc3QgYXdhaXRMaXN0PWF3YWl0SW5kZXhlcy5tYXAoKGkpPT5hcmdzW2ldKTtcbmNvbnN0IHA9UHJvbWlzZS5hbGwoYXdhaXRMaXN0KTtcbmNvbnN0IHJhd0FyZ3M9Wy4uLmFyZ3NdO1xuY29uc3QgcmVzdWx0UD1FLndoZW4ocCwoYXdhaXRlZEFyZ3MpPT57XG5mb3IobGV0IGo9MDtqPGF3YWl0SW5kZXhlcy5sZW5ndGg7ais9MSl7XG5yYXdBcmdzW2F3YWl0SW5kZXhlc1tqXV09YXdhaXRlZEFyZ3Nbal07XG4gfVxuZGVmZW5kU3luY0FyZ3MocmF3QXJncyxyYXdNZXRob2RHdWFyZCxsYWJlbCk7XG5yZXR1cm4gYXBwbHkobWV0aG9kLHRoaXMscmF3QXJncyk7XG4gfSk7XG5yZXR1cm4gRS53aGVuKHJlc3VsdFAsKHJlc3VsdCk9Pntcbm11c3RNYXRjaChoYXJkZW4ocmVzdWx0KSxyZXR1cm5HdWFyZCwgYCR7bGFiZWx9OiByZXN1bHRgKTtcbnJldHVybiByZXN1bHQ7XG4gfSk7XG4gfX07XG5cbnJldHVybiBhc3luY01ldGhvZDtcbiB9O1xuXG4vKipcbiAqXG4gKiBAcGFyYW0ge01ldGhvZH0gbWV0aG9kXG4gKiBAcGFyYW0ge01ldGhvZEd1YXJkfSBtZXRob2RHdWFyZFxuICogQHBhcmFtIHtzdHJpbmd9IGxhYmVsXG4gKi9cbmNvbnN0IGRlZmVuZE1ldGhvZD0obWV0aG9kLG1ldGhvZEd1YXJkLGxhYmVsKT0+e1xuY29uc3R7a2xhc3MsY2FsbEtpbmR9PW1ldGhvZEd1YXJkO1xuYXNzZXJ0KGtsYXNzPT09J21ldGhvZEd1YXJkJyk7XG5pZihjYWxsS2luZD09PSdzeW5jJyl7XG5yZXR1cm4gZGVmZW5kU3luY01ldGhvZChtZXRob2QsbWV0aG9kR3VhcmQsbGFiZWwpO1xuIH1lbHNle1xuYXNzZXJ0KGNhbGxLaW5kPT09J2FzeW5jJyk7XG5yZXR1cm4gZGVmZW5kQXN5bmNNZXRob2QobWV0aG9kLG1ldGhvZEd1YXJkLGxhYmVsKTtcbiB9XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nfSBGYWNldE5hbWVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8c3RyaW5nIHwgc3ltYm9sLCBDYWxsYWJsZUZ1bmN0aW9uPn0gTWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFtTID0gYW55XVxuICogQHRlbXBsYXRlIHtNZXRob2RzfSBbTSA9IGFueV1cbiAqIEB0eXBlZGVmIHt7IHN0YXRlOiBTLCBzZWxmOiBNIH19IENsYXNzQ29udGV4dFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFtTID0gYW55XVxuICogQHRlbXBsYXRlIHtSZWNvcmQ8RmFjZXROYW1lLCBNZXRob2RzPn0gW0YgPSBhbnldXG4gKiBAdHlwZWRlZiB7eyBzdGF0ZTogUywgZmFjZXRzOiBGIH19IEtpdENvbnRleHRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsoZmFjZXQ6IGFueSkgPT4gS2l0Q29udGV4dH0gS2l0Q29udGV4dFByb3ZpZGVyXG4gKiBAdHlwZWRlZiB7KChyZXByZXNlbnRhdGl2ZTogYW55KSA9PiBDbGFzc0NvbnRleHQpIHwgS2l0Q29udGV4dFByb3ZpZGVyfSBDb250ZXh0UHJvdmlkZXJcbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBtZXRob2RUYWdcbiAqIEBwYXJhbSB7Q29udGV4dFByb3ZpZGVyfSBjb250ZXh0UHJvdmlkZXJcbiAqIEBwYXJhbSB7Q2FsbGFibGVGdW5jdGlvbn0gYmVoYXZpb3JNZXRob2RcbiAqIEBwYXJhbSB7Ym9vbGVhbn0gW3RoaXNmdWxNZXRob2RzXVxuICogQHBhcmFtIHtNZXRob2RHdWFyZH0gW21ldGhvZEd1YXJkXVxuICovXG5jb25zdCBiaW5kTWV0aG9kPShcbm1ldGhvZFRhZyxcbmNvbnRleHRQcm92aWRlcixcbmJlaGF2aW9yTWV0aG9kLFxudGhpc2Z1bE1ldGhvZHM9ZmFsc2UsXG5tZXRob2RHdWFyZD11bmRlZmluZWQpPT5cbntcbmFzc2VydC50eXBlb2YoYmVoYXZpb3JNZXRob2QsJ2Z1bmN0aW9uJyk7XG5cbmNvbnN0IGdldENvbnRleHQ9KHNlbGYpPT57XG5jb25zdCBjb250ZXh0PWNvbnRleHRQcm92aWRlcihzZWxmKTtcbmNvbnRleHR8fFxuRmFpbCBgJHtxKG1ldGhvZFRhZyl9IG1heSBvbmx5IGJlIGFwcGxpZWQgdG8gYSB2YWxpZCBpbnN0YW5jZTogJHtzZWxmfWA7XG5yZXR1cm4gY29udGV4dDtcbiB9O1xuXG4vKiBWaW9sYXRpbmcgYWxsIEplc3NpZSBydWxlcyB0byBjcmVhdGUgcmVwcmVzZW50YXRpdmVzIHRoYXQgaW5oZXJpdCovXG4vKiBtZXRob2RzIGZyb20gYSBzaGFyZWQgcHJvdG90eXBlLiBUaGUgYm91bmQgbWV0aG9kIHRoZXJlZm9yZSBuZWVkcyovXG4vKiB0byBtZW50aW9uIGB0aGlzYC4gV2UgZGVmaW5lIGl0IHVzaW5nIGNvbmNpc2UgbWV0aG9kIHN5bnRheCovXG4vKiBzbyB0aGF0IGl0IHdpbGwgYmUgYHRoaXNgIHNlbnNpdGl2ZSBidXQgbm90IGNvbnN0cnVjdGFibGUuKi9cbi8qKi9cbi8qIFdlIG5vcm1hbGx5IGNvbnNpZGVyIGB0aGlzYCB1bnNhZmUgYmVjYXVzZSBvZiB0aGUgaGF6YXJkIG9mIGEqL1xuLyogbWV0aG9kIG9mIG9uZSBhYnN0cmFjdGlvbiBiZWluZyBhcHBsaWVkIHRvIGFuIGluc3RhbmNlIG9mKi9cbi8qIGFub3RoZXIgYWJzdHJhY3Rpb24uIFRvIHByZXZlbnQgdGhhdCBhdHRhY2ssIHRoZSBib3VuZCBtZXRob2QqL1xuLyogY2hlY2tzIHRoYXQgaXRzIGB0aGlzYCBpcyBpbiB0aGUgbWFwIGluIHdoaWNoIGl0cyByZXByZXNlbnRhdGl2ZXMqL1xuLyogYXJlIHJlZ2lzdGVyZWQuKi9cbmxldHttZXRob2R9PXRoaXNmdWxNZXRob2RzP1xue1xubWV0aG9kKC4uLmFyZ3Mpe1xudGhpc3x8XG5GYWlsIGB0aGlzZnVsIG1ldGhvZCAke21ldGhvZFRhZ30gY2FsbGVkIHdpdGhvdXQgJ3RoaXMnIG9iamVjdGA7XG5jb25zdCBjb250ZXh0PWdldENvbnRleHQodGhpcyk7XG5yZXR1cm4gYXBwbHkoYmVoYXZpb3JNZXRob2QsY29udGV4dCxhcmdzKTtcbiB9fTpcblxue1xubWV0aG9kKC4uLmFyZ3Mpe1xuY29uc3QgY29udGV4dD1nZXRDb250ZXh0KHRoaXMpO1xucmV0dXJuIGFwcGx5KGJlaGF2aW9yTWV0aG9kLG51bGwsW2NvbnRleHQsLi4uYXJnc10pO1xuIH19O1xuXG5pZihtZXRob2RHdWFyZCl7XG5tZXRob2Q9ZGVmZW5kTWV0aG9kKG1ldGhvZCxtZXRob2RHdWFyZCxtZXRob2RUYWcpO1xuIH1lbHNlIGlmKHRoaXNmdWxNZXRob2RzKXtcbi8qIEZvciBmYXIgY2xhc3NlcyBlbnN1cmUgdGhhdCBpbnB1dHMgYW5kIG91dHB1dHMgYXJlIHBhc3NhYmxlLiovXG5tZXRob2Q9ZGVmZW5kTWV0aG9kKG1ldGhvZCxNaW5NZXRob2RHdWFyZCxtZXRob2RUYWcpO1xuIH1cbmRlZmluZVByb3BlcnRpZXMobWV0aG9kLHtcbm5hbWU6e3ZhbHVlOm1ldGhvZFRhZ30sXG5sZW5ndGg6e1xudmFsdWU6dGhpc2Z1bE1ldGhvZHM/YmVoYXZpb3JNZXRob2QubGVuZ3RoOmJlaGF2aW9yTWV0aG9kLmxlbmd0aC0xfX0pO1xuXG5cbnJldHVybiBtZXRob2Q7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge1JlY29yZDxzdHJpbmcgfCBzeW1ib2wsIENhbGxhYmxlRnVuY3Rpb24+fSBUXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcGFyYW0ge0NvbnRleHRQcm92aWRlcn0gY29udGV4dFByb3ZpZGVyXG4gKiBAcGFyYW0ge1R9IGJlaGF2aW9yTWV0aG9kc1xuICogQHBhcmFtIHtib29sZWFufSBbdGhpc2Z1bE1ldGhvZHNdXG4gKiBAcGFyYW0ge0ludGVyZmFjZUd1YXJkfSBbaW50ZXJmYWNlR3VhcmRdXG4gKiBAcmV0dXJucyB7VCAmIFhpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDx7fSwgVD59XG4gKi9cbmNvbnN0ICAgICAgICBkZWZlbmRQcm90b3R5cGU9KFxudGFnLFxuY29udGV4dFByb3ZpZGVyLFxuYmVoYXZpb3JNZXRob2RzLFxudGhpc2Z1bE1ldGhvZHM9ZmFsc2UsXG5pbnRlcmZhY2VHdWFyZD11bmRlZmluZWQpPT5cbntcbmNvbnN0IHByb3RvdHlwZT17fTtcbmNvbnN0IG1ldGhvZE5hbWVzPW93bktleXMoYmVoYXZpb3JNZXRob2RzKS5maWx0ZXIoXG4vKiBCeSBpZ25vcmluZyBhbnkgbWV0aG9kIG5hbWVkIFwiY29uc3RydWN0b3JcIiwgd2UgY2FuIHVzZSBhKi9cbi8qIGNsYXNzLnByb3RvdHlwZSBhcyBhIGJlaGF2aW9yTWV0aG9kcy4qL1xuKG5hbWUpPT5uYW1lIT09J2NvbnN0cnVjdG9yJyk7XG5cbmxldCBtZXRob2RHdWFyZHM7XG5pZihpbnRlcmZhY2VHdWFyZCl7XG5jb25zdHtcbmtsYXNzLFxuaW50ZXJmYWNlTmFtZSxcbm1ldGhvZEd1YXJkczptZyxcbnNsb3BweT1mYWxzZX09XG5pbnRlcmZhY2VHdWFyZDtcbm1ldGhvZEd1YXJkcz1tZztcbmFzc2VydC5lcXVhbChrbGFzcywnSW50ZXJmYWNlJyk7XG5hc3NlcnQudHlwZW9mKGludGVyZmFjZU5hbWUsJ3N0cmluZycpO1xue1xuY29uc3QgbWV0aG9kR3VhcmROYW1lcz1vd25LZXlzKG1ldGhvZEd1YXJkcyk7XG5jb25zdCB1bmltcGxlbWVudGVkPWxpc3REaWZmZXJlbmNlKG1ldGhvZEd1YXJkTmFtZXMsbWV0aG9kTmFtZXMpO1xudW5pbXBsZW1lbnRlZC5sZW5ndGg9PT0wfHxcbkZhaWwgYG1ldGhvZHMgJHtxKHVuaW1wbGVtZW50ZWQpfSBub3QgaW1wbGVtZW50ZWQgYnkgJHtxKHRhZyl9YDtcbmlmKCFzbG9wcHkpe1xuY29uc3QgdW5ndWFyZGVkPWxpc3REaWZmZXJlbmNlKG1ldGhvZE5hbWVzLG1ldGhvZEd1YXJkTmFtZXMpO1xudW5ndWFyZGVkLmxlbmd0aD09PTB8fFxuRmFpbCBgbWV0aG9kcyAke3EodW5ndWFyZGVkKX0gbm90IGd1YXJkZWQgYnkgJHtxKGludGVyZmFjZU5hbWUpfWA7XG4gfVxuIH1cbiB9XG5mb3IoY29uc3QgcHJvcCBvZiBtZXRob2ROYW1lcyl7XG5wcm90b3R5cGVbcHJvcF09YmluZE1ldGhvZChcbiBgSW4gJHtxKHByb3ApfSBtZXRob2Qgb2YgKCR7dGFnfSlgLFxuY29udGV4dFByb3ZpZGVyLFxuYmVoYXZpb3JNZXRob2RzW3Byb3BdLFxudGhpc2Z1bE1ldGhvZHMsXG4vKiBUT0RPIHNvbWUgdG9vbCBkb2VzIG5vdCB5ZXQgdW5kZXJzdGFuZCB0aGUgYD8uW2Agc3ludGF4Ki9cbm1ldGhvZEd1YXJkcyYmbWV0aG9kR3VhcmRzW3Byb3BdKTtcblxuIH1cblxucmV0dXJuIEZhcih0YWcsLyoqIEB0eXBlIHtUfSAqL3Byb3RvdHlwZSk7XG4gfTskaOKAjV9vbmNlLmRlZmVuZFByb3RvdHlwZShkZWZlbmRQcm90b3R5cGUpO1xuaGFyZGVuKGRlZmVuZFByb3RvdHlwZSk7XG5cbi8qKlxuICogQHBhcmFtIHtzdHJpbmd9IHRhZ1xuICogQHBhcmFtIHtSZWNvcmQ8RmFjZXROYW1lLCBLaXRDb250ZXh0UHJvdmlkZXI+fSBjb250ZXh0UHJvdmlkZXJLaXRcbiAqIEBwYXJhbSB7UmVjb3JkPEZhY2V0TmFtZSwgUmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj4+fSBiZWhhdmlvck1ldGhvZHNLaXRcbiAqIEBwYXJhbSB7Ym9vbGVhbn0gW3RoaXNmdWxNZXRob2RzXVxuICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCBJbnRlcmZhY2VHdWFyZD59IFtpbnRlcmZhY2VHdWFyZEtpdF1cbiAqL1xuY29uc3QgICAgICAgIGRlZmVuZFByb3RvdHlwZUtpdD0oXG50YWcsXG5jb250ZXh0UHJvdmlkZXJLaXQsXG5iZWhhdmlvck1ldGhvZHNLaXQsXG50aGlzZnVsTWV0aG9kcz1mYWxzZSxcbmludGVyZmFjZUd1YXJkS2l0PXVuZGVmaW5lZCk9Plxue1xuY29uc3QgZmFjZXROYW1lcz1vd25LZXlzKGJlaGF2aW9yTWV0aG9kc0tpdCkuc29ydCgpO1xuZmFjZXROYW1lcy5sZW5ndGg+MXx8RmFpbCBgQSBtdWx0aS1mYWNldCBvYmplY3QgbXVzdCBoYXZlIG11bHRpcGxlIGZhY2V0c2A7XG5pZihpbnRlcmZhY2VHdWFyZEtpdCl7XG5jb25zdCBpbnRlcmZhY2VOYW1lcz1vd25LZXlzKGludGVyZmFjZUd1YXJkS2l0KTtcbmNvbnN0IGV4dHJhSW50ZXJmYWNlTmFtZXM9bGlzdERpZmZlcmVuY2UoZmFjZXROYW1lcyxpbnRlcmZhY2VOYW1lcyk7XG5leHRyYUludGVyZmFjZU5hbWVzLmxlbmd0aD09PTB8fFxuRmFpbCBgSW50ZXJmYWNlcyAke3EoZXh0cmFJbnRlcmZhY2VOYW1lcyl9IG5vdCBpbXBsZW1lbnRlZCBieSAke3EodGFnKX1gO1xuY29uc3QgZXh0cmFGYWNldE5hbWVzPWxpc3REaWZmZXJlbmNlKGludGVyZmFjZU5hbWVzLGZhY2V0TmFtZXMpO1xuZXh0cmFGYWNldE5hbWVzLmxlbmd0aD09PTB8fFxuRmFpbCBgRmFjZXRzICR7cShleHRyYUZhY2V0TmFtZXMpfSBvZiAke3EodGFnKX0gbm90IGd1YXJkZWQgYnkgaW50ZXJmYWNlc2A7XG4gfVxuY29uc3QgY29udGV4dE1hcE5hbWVzPW93bktleXMoY29udGV4dFByb3ZpZGVyS2l0KTtcbmNvbnN0IGV4dHJhQ29udGV4dE5hbWVzPWxpc3REaWZmZXJlbmNlKGZhY2V0TmFtZXMsY29udGV4dE1hcE5hbWVzKTtcbmV4dHJhQ29udGV4dE5hbWVzLmxlbmd0aD09PTB8fFxuRmFpbCBgQ29udGV4dHMgJHtxKGV4dHJhQ29udGV4dE5hbWVzKX0gbm90IGltcGxlbWVudGVkIGJ5ICR7cSh0YWcpfWA7XG5jb25zdCBleHRyYUZhY2V0TmFtZXM9bGlzdERpZmZlcmVuY2UoY29udGV4dE1hcE5hbWVzLGZhY2V0TmFtZXMpO1xuZXh0cmFGYWNldE5hbWVzLmxlbmd0aD09PTB8fFxuRmFpbCBgRmFjZXRzICR7cShleHRyYUZhY2V0TmFtZXMpfSBvZiAke3EodGFnKX0gbWlzc2luZyBjb250ZXh0c2A7XG5yZXR1cm4gb2JqZWN0TWFwKGJlaGF2aW9yTWV0aG9kc0tpdCwoYmVoYXZpb3JNZXRob2RzLGZhY2V0TmFtZSk9PlxuZGVmZW5kUHJvdG90eXBlKFxuIGAke3RhZ30gJHtmYWNldE5hbWV9YCxcbmNvbnRleHRQcm92aWRlcktpdFtmYWNldE5hbWVdLFxuYmVoYXZpb3JNZXRob2RzLFxudGhpc2Z1bE1ldGhvZHMsXG5pbnRlcmZhY2VHdWFyZEtpdCYmaW50ZXJmYWNlR3VhcmRLaXRbZmFjZXROYW1lXSkpO1xuXG5cbiB9OyRo4oCNX29uY2UuZGVmZW5kUHJvdG90eXBlS2l0KGRlZmVuZFByb3RvdHlwZUtpdCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVmZW5kUHJvdG90eXBlIjpbImRlZmVuZFByb3RvdHlwZSJdLCJkZWZlbmRQcm90b3R5cGVLaXQiOlsiZGVmZW5kUHJvdG90eXBlS2l0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEEMM5RAAgAAQAIAAB4AAABAZW5kby9mYXItdjAuMi4xOC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiZXhwb3J0cyI6WyJnZXRJbnRlcmZhY2VPZiIsImdldEludGVyZmFjZU9mIixudWxsXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtdXSxbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7IkBlbmRvL2V2ZW50dWFsLXNlbmQiOltbIkUiLCJFIl1dLCJAZW5kby9wYXNzLXN0eWxlIjpbWyJGYXIiLCJGYXIiXSxbImdldEludGVyZmFjZU9mIiwiZ2V0SW50ZXJmYWNlT2YiXSxbInBhc3NTdHlsZU9mIiwicGFzc1N0eWxlT2YiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAKWPOvdKBwAASgcAAB0AAABAZW5kby9tYXJzaGFsLXYwLjguNS9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanMiLCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qcyIsIi4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qcyIsIi4vc3JjL21hcnNoYWwtanVzdGluLmpzIiwiLi9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanMiLCIuL3NyYy9tYXJzaGFsLmpzIiwiLi9zcmMvcmFua09yZGVyLmpzIiwiLi9zcmMvdHlwZXMuanMiLCJAZW5kby9wYXNzLXN0eWxlIl0sImV4cG9ydHMiOlsiY29tcGFyZVJhbmsiLCJjb21wYXJlUmFuayIsIm1ha2VEZWNvZGVQYXNzYWJsZSIsIm1ha2VEZWNvZGVQYXNzYWJsZSIsInBhcnNlIiwicGFyc2UiLG51bGwsbnVsbCxudWxsLG51bGxdLCJyZWV4cG9ydHMiOlsiLi9zcmMvdHlwZXMuanMiLCJAZW5kby9wYXNzLXN0eWxlIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzXCIsIFtdXSxbXCIuL3NyYy9lbmNvZGVUb0NhcERhdGEuanNcIiwgW11dLFtcIi4vc3JjL21hcnNoYWwuanNcIiwgW11dLFtcIi4vc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzXCIsIFtdXSxbXCIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qc1wiLCBbXV0sW1wiLi9zcmMvZW5jb2RlUGFzc2FibGUuanNcIiwgW11dLFtcIi4vc3JjL3JhbmtPcmRlci5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dLFtcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9zcmMvZGVlcGx5RnVsZmlsbGVkLmpzIjpbWyJkZWVwbHlGdWxmaWxsZWQiLCJkZWVwbHlGdWxmaWxsZWQiXV0sIi4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qcyI6W1siUUNMQVNTIiwiUUNMQVNTIl1dLCIuL3NyYy9tYXJzaGFsLmpzIjpbWyJtYWtlTWFyc2hhbCIsIm1ha2VNYXJzaGFsIl1dLCIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6W1sic3RyaW5naWZ5Iiwic3RyaW5naWZ5Il0sWyJwYXJzZSIsInBhcnNlIl1dLCIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6W1siZGVjb2RlVG9KdXN0aW4iLCJkZWNvZGVUb0p1c3RpbiJdXSwiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOltbIm1ha2VFbmNvZGVQYXNzYWJsZSIsIm1ha2VFbmNvZGVQYXNzYWJsZSJdLFsibWFrZURlY29kZVBhc3NhYmxlIiwibWFrZURlY29kZVBhc3NhYmxlIl0sWyJpc0VuY29kZWRSZW1vdGFibGUiLCJpc0VuY29kZWRSZW1vdGFibGUiXSxbInplcm9QYWQiLCJ6ZXJvUGFkIl0sWyJyZWNvcmROYW1lcyIsInJlY29yZE5hbWVzIl0sWyJyZWNvcmRWYWx1ZXMiLCJyZWNvcmRWYWx1ZXMiXV0sIi4vc3JjL3JhbmtPcmRlci5qcyI6W1siYXNzZXJ0UmFua1NvcnRlZCIsImFzc2VydFJhbmtTb3J0ZWQiXSxbImNvbXBhcmVSYW5rIiwiY29tcGFyZVJhbmsiXSxbImlzUmFua1NvcnRlZCIsImlzUmFua1NvcnRlZCJdLFsic29ydEJ5UmFuayIsInNvcnRCeVJhbmsiXSxbImNvbXBhcmVBbnRpUmFuayIsImNvbXBhcmVBbnRpUmFuayJdLFsibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiLCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCJdLFsiZ2V0UGFzc1N0eWxlQ292ZXIiLCJnZXRQYXNzU3R5bGVDb3ZlciJdLFsiaW50ZXJzZWN0UmFua0NvdmVycyIsImludGVyc2VjdFJhbmtDb3ZlcnMiXSxbInVuaW9uUmFua0NvdmVycyIsInVuaW9uUmFua0NvdmVycyJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAADQgme5QNAACUDQAAKwAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9kZWVwbHlGdWxmaWxsZWQuanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL3Bhc3Mtc3R5bGUiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbImRlZXBseUZ1bGZpbGxlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLGlzUHJvbWlzZSxnZXRUYWcsaXNPYmplY3QsbWFrZVRhZ2dlZCxwYXNzU3R5bGVPZjskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRo4oCNX2EgPT4gKGlzUHJvbWlzZSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRo4oCNX2EgPT4gKGlzT2JqZWN0ID0gJGjigI1fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaOKAjV9hID0+IChtYWtlVGFnZ2VkID0gJGjigI1fYSldXSxbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vZXZlbnR1YWwtc2VuZCcpLkVSZWY8VD59IEVSZWYgKi9cblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnF9PWFzc2VydDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtmcm9tRW50cmllc309T2JqZWN0O1xuXG4vKipcbiAqIEdpdmVuIGEgUGFzc2FibGUgYHZhbGAgd2hvc2UgcGFzcy1ieS1jb3B5IHN0cnVjdHVyZSBtYXkgY29udGFpbiBsZWFmXG4gKiBwcm9taXNlcywgcmV0dXJuIGEgcHJvbWlzZSBmb3IgYSByZXBsYWNlbWVudCBQYXNzYWJsZSxcbiAqIHdoZXJlIHRoYXQgcmVwbGFjZW1lbnQgaXMgKmRlZXBseSBmdWxmaWxsZWQqLCBpLmUuLCBpdHNcbiAqIHBhc3MtYnktY29weSBzdHJ1Y3R1cmUgZG9lcyBub3QgY29udGFpbiBhbnkgcHJvbWlzZXMuXG4gKlxuICogVGhpcyBpcyBhIGRlZXAgZm9ybSBvZiBgUHJvbWlzZS5hbGxgIHNwZWNpYWxpemVkIGZvciBQYXNzYWJsZXMuIEZvciBlYWNoXG4gKiBlbmNvdW50ZXJlZCBwcm9taXNlLCByZXBsYWNlIGl0IHdpdGggdGhlIGRlZXBseSBmdWxmaWxsZWQgZm9ybSBvZlxuICogaXRzIGZ1bGZpbGxtZW50LlxuICogSWYgYW55IG9mIHRoZSBwcm9taXNlcyByZWplY3QsIHRoZW4gdGhlIHByb21pc2UgZm9yIHRoZSByZXBsYWNlbWVudFxuICogcmVqZWN0cy4gSWYgYW55IG9mIHRoZSBwcm9taXNlcyBuZXZlciBzZXR0bGUsIHRoZW4gdGhlIHByb21pc2UgZm9yXG4gKiB0aGUgcmVwbGFjZW1lbnQgbmV2ZXIgc2V0dGxlcy5cbiAqXG4gKiBJZiB0aGUgcmVwbGFjZW1lbnQgd291bGQgbm90IGJlIFBhc3NhYmxlLCBpLmUuLCBpZiBgdmFsYCBpcyBub3RcbiAqIFBhc3NhYmxlLCBvciBpZiBhbnkgb2YgdGhlIHRyYW5zaXRpdmUgcHJvbWlzZXMgZnVsZmlsbCB0byBzb21ldGhpbmdcbiAqIHRoYXQgaXMgbm90IFBhc3NhYmxlLCB0aGVuIHRoZSByZXR1cm5lZCBwcm9taXNlIHJlamVjdHMuXG4gKlxuICogSWYgYHZhbGAgb3IgaXRzIHBhcnRzIGFyZSBub24ta2V5IFBhc3NhYmxlcyBvbmx5ICpiZWNhdXNlKiB0aGV5IGNvbnRhaW5zXG4gKiBwcm9taXNlcywgdGhlIGRlZXBseSBmdWxmaWxsZWQgZm9ybXMgb2YgdmFsIG9yIGl0cyBwYXJ0cyBtYXkgYmUga2V5cy4gVGhpc1xuICogaXMgZm9yIHRoZSBoaWdoZXIgXCJzdG9yZVwiIGxldmVsIG9mIGFic3RyYWN0aW9uIHRvIGRldGVybWluZSwgYmVjYXVzZSBpdFxuICogZGVmaW5lcyB0aGUgXCJrZXlcIiBub3Rpb24gaW4gcXVlc3Rpb24uXG4gKlxuICogLy8gVE9ETzogVGhhdCBoaWdoZXIgbGV2ZWwgaXMgaW4gdGhlIHByb2Nlc3Mgb2YgYmVpbmcgbWlncmF0ZWQgZnJvbVxuICogLy8gYEBhZ29yaWMvc3RvcmVgIHRvIGBAZW5kby9wYXR0ZXJuc2AuIE9uY2UgdGhhdCBpcyBmYXIgZW5vdWdoIGFsb25nLFxuICogLy8gcmV2aXNlIHRoZSBhYm92ZSBjb21tZW50IHRvIG1hdGNoLlxuICogLy8gU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzE0NTFcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB2YWxcbiAqIEByZXR1cm5zIHtQcm9taXNlPFBhc3NhYmxlPn1cbiAqL1xuY29uc3QgICAgICAgIGRlZXBseUZ1bGZpbGxlZD1hc3luYyh2YWwpPT57XG5pZighaXNPYmplY3QodmFsKSl7XG5yZXR1cm4gdmFsO1xuIH1cbmlmKGlzUHJvbWlzZSh2YWwpKXtcbnJldHVybiBFLndoZW4odmFsLChub25wKT0+ZGVlcGx5RnVsZmlsbGVkKG5vbnApKTtcbiB9XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YodmFsKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdjb3B5UmVjb3JkJzp7XG5jb25zdCBuYW1lcz1vd25LZXlzKHZhbCk7XG5jb25zdCB2YWxQcz1uYW1lcy5tYXAoKG5hbWUpPT5kZWVwbHlGdWxmaWxsZWQodmFsW25hbWVdKSk7XG5yZXR1cm4gRS53aGVuKFByb21pc2UuYWxsKHZhbFBzKSwodmFscyk9PlxuaGFyZGVuKGZyb21FbnRyaWVzKHZhbHMubWFwKChjLGkpPT5bbmFtZXNbaV0sY10pKSkpO1xuXG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbmNvbnN0IHZhbFBzPXZhbC5tYXAoKHApPT5kZWVwbHlGdWxmaWxsZWQocCkpO1xucmV0dXJuIEUud2hlbihQcm9taXNlLmFsbCh2YWxQcyksKHZhbHMpPT5oYXJkZW4odmFscykpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5jb25zdCB0YWc9Z2V0VGFnKHZhbCk7XG5yZXR1cm4gRS53aGVuKGRlZXBseUZ1bGZpbGxlZCh2YWwucGF5bG9hZCksKHBheWxvYWQpPT5cbm1ha2VUYWdnZWQodGFnLHBheWxvYWQpKTtcblxuIH1cbmNhc2UncmVtb3RhYmxlJzp7XG5yZXR1cm4gdmFsO1xuIH1cbmNhc2UnZXJyb3InOntcbnJldHVybiB2YWw7XG4gfVxuY2FzZSdwcm9taXNlJzp7XG5yZXR1cm4gRS53aGVuKHZhbCwobm9ucCk9PmRlZXBseUZ1bGZpbGxlZChub25wKSk7XG4gfVxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGBVbmV4cGVjdGVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX1gLFR5cGVFcnJvcik7XG4gfX1cblxuIH07JGjigI1fb25jZS5kZWVwbHlGdWxmaWxsZWQoZGVlcGx5RnVsZmlsbGVkKTtcbmhhcmRlbihkZWVwbHlGdWxmaWxsZWQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZXBseUZ1bGZpbGxlZCI6WyJkZWVwbHlGdWxmaWxsZWQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAO3LPgOQ/AADkPwAAKgAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9lbmNvZGVQYXNzYWJsZS5qc3siaW1wb3J0cyI6WyJAZW5kby9wYXNzLXN0eWxlIl0sImV4cG9ydHMiOlsiaXNFbmNvZGVkUmVtb3RhYmxlIiwibWFrZURlY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIiwicGFzc1N0eWxlUHJlZml4ZXMiLCJyZWNvcmROYW1lcyIsInJlY29yZFZhbHVlcyIsInplcm9QYWQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgZ2V0VGFnLG1ha2VUYWdnZWQscGFzc1N0eWxlT2YsYXNzZXJ0UmVjb3JkLGlzRXJyb3JMaWtlLG5hbWVGb3JQYXNzYWJsZVN5bWJvbCxwYXNzYWJsZVN5bWJvbEZvck5hbWU7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0VGFnXCIsIFskaOKAjV9hID0+IChnZXRUYWcgPSAkaOKAjV9hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRo4oCNX2EgPT4gKG1ha2VUYWdnZWQgPSAkaOKAjV9hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UmVjb3JkXCIsIFskaOKAjV9hID0+IChhc3NlcnRSZWNvcmQgPSAkaOKAjV9hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaOKAjV9hID0+IChpc0Vycm9yTGlrZSA9ICRo4oCNX2EpXV0sW1wibmFtZUZvclBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaOKAjV9hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjigI1fYSA9PiAocGFzc2FibGVTeW1ib2xGb3JOYW1lID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlJlbW90YWJsZU9iamVjdH0gUmVtb3RhYmxlICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5Db3B5UmVjb3JkPFQ+fSBDb3B5UmVjb3JkICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SYW5rQ292ZXJ9IFJhbmtDb3ZlciAqL1xuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcbmNvbnN0e2Zyb21FbnRyaWVzLGlzfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIEFzc3VtaW5nIHRoYXQgYHJlY29yZGAgaXMgYSBDb3B5UmVjb3JkLCB3ZSBoYXZlIG9ubHlcbiAqIHN0cmluZy1uYW1lZCBvd24gcHJvcGVydGllcy4gYHJlY29yZE5hbWVzYCByZXR1cm5zIHRob3NlIG5hbWUgKnJldmVyc2UqXG4gKiBzb3J0ZWQsIGJlY2F1c2UgdGhhdCdzIGhvdyByZWNvcmRzIGFyZSBjb21wYXJlZCwgZW5jb2RlZCwgYW5kIHNvcnRlZC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFQ+fSByZWNvcmRcbiAqIEByZXR1cm5zIHtzdHJpbmdbXX1cbiAqL1xuY29uc3QgICAgICAgIHJlY29yZE5hbWVzPShyZWNvcmQpPT5cbi8qIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzEyNjAjZGlzY3Vzc2lvbl9yMTAwMzY1NzI0NCovXG4vKiBjb21wYXJlcyB0d28gd2F5cyBvZiByZXZlcnNlIHNvcnRpbmcsIGFuZCBzaG93cyB0aGF0IGAuc29ydCgpLnJldmVyc2UoKWAqL1xuLyogaXMgY3VycmVudGx5IGZhc3RlciBvbiBNb2RkYWJsZSBYUywgd2hpbGUgdGhlIG90aGVyIHdheSwqL1xuLyogYC5zb3J0KHJldmVyc2VDb21wYXJhdG9yKWAsIGlzIGZhc3RlciBvbiB2OC4gV2UgY3VycmVudGx5IGNhcmUgbW9yZSBhYm91dCovXG4vKiBYUyBwZXJmb3JtYW5jZSwgc28gd2UgcmV2ZXJzZSBzb3J0IHVzaW5nIGAuc29ydCgpLnJldmVyc2UoKWAuKi9cbmhhcmRlbigvKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmVjb3JkKS5zb3J0KCkucmV2ZXJzZSgpKTskaOKAjV9vbmNlLnJlY29yZE5hbWVzKHJlY29yZE5hbWVzKTtcbmhhcmRlbihyZWNvcmROYW1lcyk7XG5cbi8qKlxuICogQXNzdW1pbmcgdGhhdCBgcmVjb3JkYCBpcyBhIENvcHlSZWNvcmQgYW5kIGBuYW1lc2AgaXMgYHJlY29yZE5hbWVzKHJlY29yZClgLFxuICogcmV0dXJuIHRoZSBjb3JyZXNwb25kaW5nIGFycmF5IG9mIHByb3BlcnR5IHZhbHVlcy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFQ+fSByZWNvcmRcbiAqIEBwYXJhbSB7c3RyaW5nW119IG5hbWVzXG4gKiBAcmV0dXJucyB7VFtdfVxuICovXG5jb25zdCAgICAgICAgcmVjb3JkVmFsdWVzPShyZWNvcmQsbmFtZXMpPT5cbmhhcmRlbihuYW1lcy5tYXAoKG5hbWUpPT5yZWNvcmRbbmFtZV0pKTskaOKAjV9vbmNlLnJlY29yZFZhbHVlcyhyZWNvcmRWYWx1ZXMpO1xuaGFyZGVuKHJlY29yZFZhbHVlcyk7XG5cbi8qKlxuICogQHBhcmFtIHt1bmtub3dufSBuXG4gKiBAcGFyYW0ge251bWJlcn0gc2l6ZVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgICAgICAgIHplcm9QYWQ9KG4sc2l6ZSk9PntcbmNvbnN0IG5TdHI9IGAke259YDtcbmFzc2VydChuU3RyLmxlbmd0aDw9c2l6ZSk7XG5jb25zdCBzdHI9IGAwMDAwMDAwMDAwMDAwMDAwMDAwMCR7blN0cn1gO1xuY29uc3QgcmVzdWx0PXN0ci5zdWJzdHJpbmcoc3RyLmxlbmd0aC1zaXplKTtcbmFzc2VydChyZXN1bHQubGVuZ3RoPT09c2l6ZSk7XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjigI1fb25jZS56ZXJvUGFkKHplcm9QYWQpO1xuaGFyZGVuKHplcm9QYWQpO1xuXG4vKiBUaGlzIGlzIHRoZSBKYXZhU2NyaXB0IGFuYWxvZyB0byBhIEMgdW5pb246IGEgd2F5IHRvIG1hcCBiZXR3ZWVuIGEgZmxvYXQgYXMgYSovXG4vKiBudW1iZXIgYW5kIHRoZSBiaXRzIHRoYXQgcmVwcmVzZW50IHRoZSBmbG9hdCBhcyBhIGJ1ZmZlciBmdWxsIG9mIGJ5dGVzLiAgTm90ZSovXG4vKiB0aGF0IHRoZSBtdXRhdGlvbiBvZiBzdGF0aWMgc3RhdGUgaGVyZSBtYWtlcyB0aGlzIGludmFsaWQgSmVzc2llIGNvZGUsIGJ1dCovXG4vKiBkb2luZyBpdCB0aGlzIHdheSBzYXZlcyB0aGUgbnVnYXRvcnkgYW5kIGdyYXR1aXRvdXMgYWxsb2NhdGlvbnMgdGhhdCB3b3VsZCovXG4vKiBoYXBwZW4gZXZlcnkgdGltZSB5b3UgZG8gYSBjb252ZXJzaW9uIC0tIGFuZCBpbiBwcmFjdGljYWwgdGVybXMgaXQncyBzYWZlKi9cbi8qIGJlY2F1c2Ugd2UgcHV0IHRoZSB2YWx1ZSBpbiBvbmUgc2lkZSBhbmQgdGhlbiBpbW1lZGlhdGVseSB0YWtlIGl0IG91dCB0aGUqL1xuLyogb3RoZXI7IHRoZXJlIGlzIG5vIGFjdHVhbCBzdGF0ZSByZXRhaW5lZCBpbiB0aGUgY2xhc3NpYyBzZW5zZSBhbmQgdGh1cyBubyovXG4vKiByZS1lbnRyYW5jeSBpc3N1ZS4qL1xuY29uc3QgYXNOdW1iZXI9bmV3IEZsb2F0NjRBcnJheSgxKTtcbmNvbnN0IGFzQml0cz1uZXcgQmlnVWludDY0QXJyYXkoYXNOdW1iZXIuYnVmZmVyKTtcblxuLyogSmF2YVNjcmlwdCBudW1iZXJzIGFyZSBlbmNvZGVkIGJ5IG91dHB1dHRpbmcgdGhlIGJhc2UtMTYqL1xuLyogcmVwcmVzZW50YXRpb24gb2YgdGhlIGJpbmFyeSB2YWx1ZSBvZiB0aGUgdW5kZXJseWluZyBJRUVFIGZsb2F0aW5nIHBvaW50Ki9cbi8qIHJlcHJlc2VudGF0aW9uLiAgRm9yIG5lZ2F0aXZlIHZhbHVlcywgYWxsIGJpdHMgb2YgdGhpcyByZXByZXNlbnRhdGlvbiBhcmUqL1xuLyogY29tcGxlbWVudGVkIHByaW9yIHRvIHRoZSBiYXNlLTE2IGNvbnZlcnNpb24sIHdoaWxlIGZvciBwb3NpdGl2ZSB2YWx1ZXMsIHRoZSovXG4vKiBzaWduIGJpdCBpcyBjb21wbGVtZW50ZWQuICBUaGlzIGVuc3VyZXMgYm90aCB0aGF0IG5lZ2F0aXZlIHZhbHVlcyBzb3J0IGJlZm9yZSovXG4vKiBwb3NpdGl2ZSB2YWx1ZXMgYW5kIHRoYXQgbmVnYXRpdmUgdmFsdWVzIHNvcnQgYWNjb3JkaW5nIHRvIHRoZWlyIG5lZ2F0aXZlKi9cbi8qIG1hZ25pdHVkZSByYXRoZXIgdGhhbiB0aGVpciBwb3NpdGl2ZSBtYWduaXR1ZGUuICBUaGlzIHJlc3VsdHMgaW4gYW4gQVNDSUkqL1xuLyogZW5jb2Rpbmcgd2hvc2UgbGV4aWNvZ3JhcGhpYyBzb3J0IG9yZGVyIGlzIHRoZSBzYW1lIGFzIHRoZSBudW1lcmljIHNvcnQgb3JkZXIqL1xuLyogb2YgdGhlIGNvcnJlc3BvbmRpbmcgbnVtYmVycy4qL1xuXG4vKiBUT0RPIENob29zZSB0aGUgc2FtZSBjYW5vbmljYWwgTmFOIGVuY29kaW5nIHRoYXQgY29zbVdhc20gYW5kIGV3YXNtIGNob3NlLiovXG5jb25zdCBDYW5vbmljYWxOYU5CaXRzPSdmZmY4MDAwMDAwMDAwMDAwJztcblxuLyoqXG4gKiBAcGFyYW0ge251bWJlcn0gblxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlQmluYXJ5NjQ9KG4pPT57XG4vKiBOb3JtYWxpemUgLTAgdG8gMCBhbmQgTmFOIHRvIGEgY2Fub25pY2FsIGVuY29kaW5nKi9cbmlmKGlzKG4sLTApKXtcbm49MDtcbiB9ZWxzZSBpZihpcyhuLE5hTikpe1xucmV0dXJuIGBmJHtDYW5vbmljYWxOYU5CaXRzfWA7XG4gfVxuYXNOdW1iZXJbMF09bjtcbmxldCBiaXRzPWFzQml0c1swXTtcbmlmKG48MCl7XG5iaXRzXj0weGZmZmZmZmZmZmZmZmZmZmZuO1xuIH1lbHNle1xuYml0c149MHg4MDAwMDAwMDAwMDAwMDAwbjtcbiB9XG5yZXR1cm4gYGYke3plcm9QYWQoYml0cy50b1N0cmluZygxNiksMTYpfWA7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFxuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgZGVjb2RlQmluYXJ5NjQ9KGVuY29kZWQpPT57XG5lbmNvZGVkLnN0YXJ0c1dpdGgoJ2YnKXx8RmFpbCBgRW5jb2RlZCBudW1iZXIgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xubGV0IGJpdHM9QmlnSW50KCBgMHgke2VuY29kZWQuc3Vic3RyaW5nKDEpfWApO1xuaWYoZW5jb2RlZFsxXTwnOCcpe1xuYml0c149MHhmZmZmZmZmZmZmZmZmZmZmbjtcbiB9ZWxzZXtcbmJpdHNePTB4ODAwMDAwMDAwMDAwMDAwMG47XG4gfVxuYXNCaXRzWzBdPWJpdHM7XG5jb25zdCByZXN1bHQ9YXNOdW1iZXJbMF07XG4haXMocmVzdWx0LC0wKXx8RmFpbCBgVW5leHBlY3RlZCBuZWdhdGl2ZSB6ZXJvOiAke2VuY29kZWR9YDtcbnJldHVybiByZXN1bHQ7XG4gfTtcblxuLyoqXG4gKiBFbmNvZGUgYSBKYXZhU2NyaXB0IGJpZ2ludCB1c2luZyBhIHZhcmlhbnQgb2YgRWxpYXMgZGVsdGEgY29kaW5nLCB3aXRoIGFuXG4gKiBpbml0aWFsIGNvbXBvbmVudCBmb3IgdGhlIGxlbmd0aCBvZiB0aGUgZGlnaXQgY291bnQgYXMgYSB1bmFyeSBzdHJpbmcsIGFcbiAqIHNlY29uZCBjb21wb25lbnQgZm9yIHRoZSBkZWNpbWFsIGRpZ2l0IGNvdW50LCBhbmQgYSB0aGlyZCBjb21wb25lbnQgZm9yIHRoZVxuICogZGVjaW1hbCBkaWdpdHMgcHJlY2VkZWQgYnkgYSBncmF0dWl0b3VzIHNlcGFyYXRpbmcgY29sb24uXG4gKiBUbyBlbnN1cmUgdGhhdCB0aGUgbGV4aWNvZ3JhcGhpYyBzb3J0IG9yZGVyIG9mIGVuY29kZWQgdmFsdWVzIG1hdGNoZXMgdGhlXG4gKiBudW1lcmljIHNvcnQgb3JkZXIgb2YgdGhlIGNvcnJlc3BvbmRpbmcgbnVtYmVycywgdGhlIGNoYXJhY3RlcnMgb2YgdGhlIHVuYXJ5XG4gKiBwcmVmaXggYXJlIGRpZmZlcmVudCBmb3IgbmVnYXRpdmUgdmFsdWVzICh0eXBlIFwiblwiIGZvbGxvd2VkIGJ5IGFueSBudW1iZXIgb2ZcbiAqIFwiI1wicyBbd2hpY2ggc29ydCBiZWZvcmUgZGVjaW1hbCBkaWdpdHNdKSB2cy4gcG9zaXRpdmUgYW5kIHplcm8gdmFsdWVzICh0eXBlXG4gKiBcInBcIiBmb2xsb3dlZCBieSBhbnkgbnVtYmVyIG9mIFwiflwicyBbd2hpY2ggc29ydCBhZnRlciBkZWNpbWFsIGRpZ2l0c10pIGFuZFxuICogZWFjaCBkZWNpbWFsIGRpZ2l0IG9mIHRoZSBlbmNvZGluZyBmb3IgYSBuZWdhdGl2ZSB2YWx1ZSBpcyByZXBsYWNlZCB3aXRoIGl0c1xuICogdGVuJ3MgY29tcGxlbWVudCAoc28gdGhhdCBuZWdhdGl2ZSB2YWx1ZXMgb2YgdGhlIHNhbWUgc2NhbGUgc29ydCBieVxuICogKmRlc2NlbmRpbmcqIGFic29sdXRlIHZhbHVlKS5cbiAqXG4gKiBAcGFyYW0ge2JpZ2ludH0gblxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZW5jb2RlQmlnSW50PShuKT0+e1xuY29uc3QgYWJzPW48MG4/LW46bjtcbmNvbnN0IG5EaWdpdHM9YWJzLnRvU3RyaW5nKCkubGVuZ3RoO1xuY29uc3QgbERpZ2l0cz1uRGlnaXRzLnRvU3RyaW5nKCkubGVuZ3RoO1xuaWYobjwwbil7XG5yZXR1cm4gYG4ke1xuLyogQSBcIiNcIiBmb3IgZWFjaCBkaWdpdCBiZXlvbmQgdGhlIGZpcnN0Ki9cbi8qIGluIHRoZSBkZWNpbWFsICpjb3VudCogb2YgZGVjaW1hbCBkaWdpdHMuKi9cbicjJy5yZXBlYXQobERpZ2l0cy0xKVxuIH0ke1xuLyogVGhlIHRlbidzIGNvbXBsZW1lbnQgb2YgdGhlIGNvdW50IG9mIGRpZ2l0cy4qL1xuKDEwKipsRGlnaXRzLW5EaWdpdHMpLnRvU3RyaW5nKCkucGFkU3RhcnQobERpZ2l0cywnMCcpXG4gfToke1xuLyogVGhlIHRlbidzIGNvbXBsZW1lbnQgb2YgdGhlIGRpZ2l0cy4qL1xuKDEwbioqQmlnSW50KG5EaWdpdHMpK24pLnRvU3RyaW5nKCkucGFkU3RhcnQobkRpZ2l0cywnMCcpXG4gfWA7XG4gfWVsc2V7XG5yZXR1cm4gYHAke1xuLyogQSBcIn5cIiBmb3IgZWFjaCBkaWdpdCBiZXlvbmQgdGhlIGZpcnN0Ki9cbi8qIGluIHRoZSBkZWNpbWFsICpjb3VudCogb2YgZGVjaW1hbCBkaWdpdHMuKi9cbid+Jy5yZXBlYXQobERpZ2l0cy0xKVxuIH0ke1xuLyogVGhlIGNvdW50IG9mIGRpZ2l0cy4qL1xubkRpZ2l0c1xuIH06JHtcbi8qIFRoZSBkaWdpdHMuKi9cbm5cbiB9YDtcbiB9XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFxuICogQHJldHVybnMge2JpZ2ludH1cbiAqL1xuY29uc3QgZGVjb2RlQmlnSW50PShlbmNvZGVkKT0+e1xuY29uc3QgdHlwZVByZWZpeD1lbmNvZGVkLmNoYXJBdCgwKTsvKiBmYXN0ZXIgdGhhbiBlbmNvZGVkWzBdKi9cbmxldCByZW09ZW5jb2RlZC5zbGljZSgxKTtcbnR5cGVQcmVmaXg9PT0ncCd8fFxudHlwZVByZWZpeD09PSduJ3x8XG5GYWlsIGBFbmNvZGVkIGJpZ2ludCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5cbmNvbnN0IGxEaWdpdHM9cmVtLnNlYXJjaCgvWzAtOV0vKSsxO1xubERpZ2l0cz49MXx8RmFpbCBgRGlnaXQgY291bnQgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xucmVtPXJlbS5zbGljZShsRGlnaXRzLTEpO1xuXG5yZW0ubGVuZ3RoPj1sRGlnaXRzfHxGYWlsIGBDb21wbGV0ZSBkaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5jb25zdCBzbkRpZ2l0cz1yZW0uc2xpY2UoMCxsRGlnaXRzKTtcbnJlbT1yZW0uc2xpY2UobERpZ2l0cyk7XG4vXlswLTldKyQvLnRlc3Qoc25EaWdpdHMpfHxGYWlsIGBEZWNpbWFsIGRpZ2l0IGNvdW50IGV4cGVjdGVkOiAke2VuY29kZWR9YDtcbmxldCBuRGlnaXRzPXBhcnNlSW50KHNuRGlnaXRzLDEwKTtcbmlmKHR5cGVQcmVmaXg9PT0nbicpe1xuLyogVE9ETyBBc3NlcnQgdG8gcmVqZWN0IGZvcmJpZGRlbiBlbmNvZGluZ3MqL1xuLyogbGlrZSBcIm4wOlwiIGFuZCBcIm4wMDrigKZcIiBhbmQgXCJuOTE64oCmXCIgdGhyb3VnaCBcIm45OTrigKZcIj8qL1xubkRpZ2l0cz0xMCoqbERpZ2l0cy1uRGlnaXRzO1xuIH1cblxucmVtLnN0YXJ0c1dpdGgoJzonKXx8RmFpbCBgU2VwYXJhdG9yIGV4cGVjdGVkOiAke2VuY29kZWR9YDtcbnJlbT1yZW0uc2xpY2UoMSk7XG5yZW0ubGVuZ3RoPT09bkRpZ2l0c3x8XG5GYWlsIGBGaXhlZC1sZW5ndGggZGlnaXQgc2VxdWVuY2UgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xubGV0IG49QmlnSW50KHJlbSk7XG5pZih0eXBlUHJlZml4PT09J24nKXtcbi8qIFRPRE8gQXNzZXJ0IHRvIHJlamVjdCBmb3JiaWRkZW4gZW5jb2RpbmdzKi9cbi8qIGxpa2UgXCJuOTowXCIgYW5kIFwibjg6MDBcIiBhbmQgXCJuODo5MVwiIHRocm91Z2ggXCJuODo5OVwiPyovXG5uPS0oMTBuKipCaWdJbnQobkRpZ2l0cyktbik7XG4gfVxuXG5yZXR1cm4gbjtcbiB9O1xuXG4vKiBgJ1xcdTAwMDAnYCBpcyB0aGUgdGVybWluYXRvciBhZnRlciBlbGVtZW50cy4qL1xuLyogYCdcXHUwMDAxJ2AgaXMgdGhlIGJhY2tzbGFzaC1saWtlIGVzY2FwZSBjaGFyYWN0ZXIsIGZvciovXG4vKiBlc2NhcGluZyBib3RoIG9mIHRoZXNlIGNoYXJhY3RlcnMuKi9cblxuY29uc3QgZW5jb2RlQXJyYXk9KGFycmF5LGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgY2hhcnM9WydbJ107XG5mb3IoY29uc3QgZWxlbWVudCBvZiBhcnJheSl7XG5jb25zdCBlbmM9ZW5jb2RlUGFzc2FibGUoZWxlbWVudCk7XG5mb3IoY29uc3QgYyBvZiBlbmMpe1xuaWYoYz09PSdcXHUwMDAwJ3x8Yz09PSdcXHUwMDAxJyl7XG5jaGFycy5wdXNoKCdcXHUwMDAxJyk7XG4gfVxuY2hhcnMucHVzaChjKTtcbiB9XG5jaGFycy5wdXNoKCdcXHUwMDAwJyk7XG4gfVxucmV0dXJuIGNoYXJzLmpvaW4oJycpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtzdHJpbmd9IGVuY29kZWRcbiAqIEBwYXJhbSB7KGVuY29kZWQ6IHN0cmluZykgPT4gUGFzc2FibGV9IGRlY29kZVBhc3NhYmxlXG4gKiBAcmV0dXJucyB7QXJyYXl9XG4gKi9cbmNvbnN0IGRlY29kZUFycmF5PShlbmNvZGVkLGRlY29kZVBhc3NhYmxlKT0+e1xuZW5jb2RlZC5zdGFydHNXaXRoKCdbJyl8fEZhaWwgYEVuY29kZWQgYXJyYXkgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xuY29uc3QgZWxlbWVudHM9W107XG5jb25zdCBlbGVtQ2hhcnM9W107XG5mb3IobGV0IGk9MTtpPGVuY29kZWQubGVuZ3RoO2krPTEpe1xuY29uc3QgYz1lbmNvZGVkW2ldO1xuaWYoYz09PSdcXHUwMDAwJyl7XG5jb25zdCBlbmNvZGVkRWxlbWVudD1lbGVtQ2hhcnMuam9pbignJyk7XG5lbGVtQ2hhcnMubGVuZ3RoPTA7XG5jb25zdCBlbGVtZW50PWRlY29kZVBhc3NhYmxlKGVuY29kZWRFbGVtZW50KTtcbmVsZW1lbnRzLnB1c2goZWxlbWVudCk7XG4gfWVsc2UgaWYoYz09PSdcXHUwMDAxJyl7XG5pKz0xO1xuaTxlbmNvZGVkLmxlbmd0aHx8RmFpbCBgdW5leHBlY3RlZCBlbmQgb2YgZW5jb2RpbmcgJHtlbmNvZGVkfWA7XG5jb25zdCBjMj1lbmNvZGVkW2ldO1xuYzI9PT0nXFx1MDAwMCd8fFxuYzI9PT0nXFx1MDAwMSd8fFxuRmFpbCBgVW5leHBlY3RlZCBjaGFyYWN0ZXIgYWZ0ZXIgdTAwMDEgZXNjYXBlOiAke2MyfWA7XG5lbGVtQ2hhcnMucHVzaChjMik7XG4gfWVsc2V7XG5lbGVtQ2hhcnMucHVzaChjKTtcbiB9XG4gfVxuZWxlbUNoYXJzLmxlbmd0aD09PTB8fEZhaWwgYGVuY29kaW5nIHRlcm1pbmF0ZWQgZWFybHk6ICR7ZW5jb2RlZH1gO1xucmV0dXJuIGhhcmRlbihlbGVtZW50cyk7XG4gfTtcblxuY29uc3QgZW5jb2RlUmVjb3JkPShyZWNvcmQsZW5jb2RlUGFzc2FibGUpPT57XG5jb25zdCBuYW1lcz1yZWNvcmROYW1lcyhyZWNvcmQpO1xuY29uc3QgdmFsdWVzPXJlY29yZFZhbHVlcyhyZWNvcmQsbmFtZXMpO1xucmV0dXJuIGAoJHtlbmNvZGVBcnJheShoYXJkZW4oW25hbWVzLHZhbHVlc10pLGVuY29kZVBhc3NhYmxlKX1gO1xuIH07XG5cbmNvbnN0IGRlY29kZVJlY29yZD0oZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSk9PntcbmFzc2VydChlbmNvZGVkLnN0YXJ0c1dpdGgoJygnKSk7XG5jb25zdCBrZXlzdmFscz1kZWNvZGVBcnJheShlbmNvZGVkLnN1YnN0cmluZygxKSxkZWNvZGVQYXNzYWJsZSk7XG5rZXlzdmFscy5sZW5ndGg9PT0yfHxGYWlsIGBleHBlY3RlZCBrZXlzLHZhbHVlcyBwYWlyOiAke2VuY29kZWR9YDtcbmNvbnN0W2tleXMsdmFsc109a2V5c3ZhbHM7XG5cbnBhc3NTdHlsZU9mKGtleXMpPT09J2NvcHlBcnJheScmJlxucGFzc1N0eWxlT2YodmFscyk9PT0nY29weUFycmF5JyYmXG5rZXlzLmxlbmd0aD09PXZhbHMubGVuZ3RoJiZcbmtleXMuZXZlcnkoKGtleSk9PnR5cGVvZiBrZXk9PT0nc3RyaW5nJyl8fFxuRmFpbCBgbm90IGEgdmFsaWQgcmVjb3JkIGVuY29kaW5nOiAke2VuY29kZWR9YDtcbmNvbnN0IG1hcEVudHJpZXM9a2V5cy5tYXAoKGtleSxpKT0+W2tleSx2YWxzW2ldXSk7XG5jb25zdCByZWNvcmQ9aGFyZGVuKGZyb21FbnRyaWVzKG1hcEVudHJpZXMpKTtcbmFzc2VydFJlY29yZChyZWNvcmQsJ2RlY29kZWQgcmVjb3JkJyk7XG5yZXR1cm4gcmVjb3JkO1xuIH07XG5cbmNvbnN0IGVuY29kZVRhZ2dlZD0odGFnZ2VkLGVuY29kZVBhc3NhYmxlKT0+XG4gYDoke2VuY29kZUFycmF5KGhhcmRlbihbZ2V0VGFnKHRhZ2dlZCksdGFnZ2VkLnBheWxvYWRdKSxlbmNvZGVQYXNzYWJsZSl9YDtcblxuY29uc3QgZGVjb2RlVGFnZ2VkPShlbmNvZGVkLGRlY29kZVBhc3NhYmxlKT0+e1xuYXNzZXJ0KGVuY29kZWQuc3RhcnRzV2l0aCgnOicpKTtcbmNvbnN0IHRhZ3BheWxvYWQ9ZGVjb2RlQXJyYXkoZW5jb2RlZC5zdWJzdHJpbmcoMSksZGVjb2RlUGFzc2FibGUpO1xudGFncGF5bG9hZC5sZW5ndGg9PT0yfHxGYWlsIGBleHBlY3RlZCB0YWcscGF5bG9hZCBwYWlyOiAke2VuY29kZWR9YDtcbmNvbnN0W3RhZyxwYXlsb2FkXT10YWdwYXlsb2FkO1xucGFzc1N0eWxlT2YodGFnKT09PSdzdHJpbmcnfHxcbkZhaWwgYG5vdCBhIHZhbGlkIHRhZ2dlZCBlbmNvZGluZzogJHtlbmNvZGVkfWA7XG5yZXR1cm4gbWFrZVRhZ2dlZCh0YWcscGF5bG9hZCk7XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFbmNvZGVPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVtb3RhYmxlOiBSZW1vdGFibGUsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IHN0cmluZyxcbiAqICkgPT4gc3RyaW5nfSBbZW5jb2RlUmVtb3RhYmxlXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIHByb21pc2U6IFByb21pc2UsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IHN0cmluZyxcbiAqICkgPT4gc3RyaW5nfSBbZW5jb2RlUHJvbWlzZV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlcnJvcjogRXJyb3IsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IHN0cmluZyxcbiAqICkgPT4gc3RyaW5nfSBbZW5jb2RlRXJyb3JdXG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZU9wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhwYXNzYWJsZTogUGFzc2FibGUpID0+IHN0cmluZ31cbiAqL1xuY29uc3QgICAgICAgIG1ha2VFbmNvZGVQYXNzYWJsZT0oZW5jb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZW5jb2RlUmVtb3RhYmxlPShyZW0sXyk9PkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3JlbX1gLFxuZW5jb2RlUHJvbWlzZT0ocHJvbSxfKT0+RmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Byb219YCxcbmVuY29kZUVycm9yPShlcnIsXyk9PkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7ZXJyfWB9PVxuZW5jb2RlT3B0aW9ucztcblxuY29uc3QgZW5jb2RlUGFzc2FibGU9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbnJldHVybiBlbmNvZGVFcnJvcihwYXNzYWJsZSxlbmNvZGVQYXNzYWJsZSk7XG4gfVxuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhc3NhYmxlKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdudWxsJzp7XG5yZXR1cm4ndic7XG4gfVxuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybid6JztcbiB9XG5jYXNlJ251bWJlcic6e1xucmV0dXJuIGVuY29kZUJpbmFyeTY0KHBhc3NhYmxlKTtcbiB9XG5jYXNlJ3N0cmluZyc6e1xucmV0dXJuIGBzJHtwYXNzYWJsZX1gO1xuIH1cbmNhc2UnYm9vbGVhbic6e1xucmV0dXJuIGBiJHtwYXNzYWJsZX1gO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5yZXR1cm4gZW5jb2RlQmlnSW50KHBhc3NhYmxlKTtcbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVJlbW90YWJsZShwYXNzYWJsZSxlbmNvZGVQYXNzYWJsZSk7XG5yZXN1bHQuc3RhcnRzV2l0aCgncicpfHxcbkZhaWwgYGludGVybmFsOiBSZW1vdGFibGUgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiclwiOiAke3Jlc3VsdH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5jYXNlJ2Vycm9yJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlRXJyb3IocGFzc2FibGUsZW5jb2RlUGFzc2FibGUpO1xucmVzdWx0LnN0YXJ0c1dpdGgoJyEnKXx8XG5GYWlsIGBpbnRlcm5hbDogRXJyb3IgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiIVwiOiAke3Jlc3VsdH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5jYXNlJ3Byb21pc2UnOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVQcm9taXNlKHBhc3NhYmxlLGVuY29kZVBhc3NhYmxlKTtcbnJlc3VsdC5zdGFydHNXaXRoKCc/Jyl8fFxuRmFpbCBgaW50ZXJuYWw6IFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiP1wiOiAke3Jlc3VsdH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xucmV0dXJuIGB5JHtuYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpfWA7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbnJldHVybiBlbmNvZGVBcnJheShwYXNzYWJsZSxlbmNvZGVQYXNzYWJsZSk7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG5yZXR1cm4gZW5jb2RlUmVjb3JkKHBhc3NhYmxlLGVuY29kZVBhc3NhYmxlKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJuIGVuY29kZVRhZ2dlZChwYXNzYWJsZSxlbmNvZGVQYXNzYWJsZSk7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBhICR7cShwYXNzU3R5bGUpfSBjYW5ub3QgYmUgdXNlZCBhcyBhIGNvbGxlY3Rpb24gcGFzc2FibGVgO1xuIH19XG5cbiB9O1xucmV0dXJuIGhhcmRlbihlbmNvZGVQYXNzYWJsZSk7XG4gfTskaOKAjV9vbmNlLm1ha2VFbmNvZGVQYXNzYWJsZShtYWtlRW5jb2RlUGFzc2FibGUpO1xuaGFyZGVuKG1ha2VFbmNvZGVQYXNzYWJsZSk7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVjb2RlT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IHN0cmluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IFJlbW90YWJsZX0gW2RlY29kZVJlbW90YWJsZV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogc3RyaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IHN0cmluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUHJvbWlzZX0gW2RlY29kZVByb21pc2VdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBzdHJpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogc3RyaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBFcnJvcn0gW2RlY29kZUVycm9yXVxuICovXG5cbi8qKlxuICogQHBhcmFtIHtEZWNvZGVPcHRpb25zfSBbZGVjb2RlT3B0aW9uc11cbiAqIEByZXR1cm5zIHsoZW5jb2RlZDogc3RyaW5nKSA9PiBQYXNzYWJsZX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VEZWNvZGVQYXNzYWJsZT0oZGVjb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZGVjb2RlUmVtb3RhYmxlPShyZW0sXyk9PkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3JlbX1gLFxuZGVjb2RlUHJvbWlzZT0ocHJvbSxfKT0+RmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Byb219YCxcbmRlY29kZUVycm9yPShlcnIsXyk9PkZhaWwgYGVycm9yIHVuZXhwZWN0ZWQ6ICR7ZXJyfWB9PVxuZGVjb2RlT3B0aW9ucztcblxuY29uc3QgZGVjb2RlUGFzc2FibGU9KGVuY29kZWQpPT57XG5zd2l0Y2goZW5jb2RlZC5jaGFyQXQoMCkpe1xuY2FzZSd2Jzp7XG5yZXR1cm4gbnVsbDtcbiB9XG5jYXNlJ3onOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZSdmJzp7XG5yZXR1cm4gZGVjb2RlQmluYXJ5NjQoZW5jb2RlZCk7XG4gfVxuY2FzZSdzJzp7XG5yZXR1cm4gZW5jb2RlZC5zdWJzdHJpbmcoMSk7XG4gfVxuY2FzZSdiJzp7XG5yZXR1cm4gZW5jb2RlZC5zdWJzdHJpbmcoMSkhPT0nZmFsc2UnO1xuIH1cbmNhc2Unbic6XG5jYXNlJ3AnOntcbnJldHVybiBkZWNvZGVCaWdJbnQoZW5jb2RlZCk7XG4gfVxuY2FzZSdyJzp7XG5yZXR1cm4gZGVjb2RlUmVtb3RhYmxlKGVuY29kZWQsZGVjb2RlUGFzc2FibGUpO1xuIH1cbmNhc2UnPyc6e1xucmV0dXJuIGRlY29kZVByb21pc2UoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSk7XG4gfVxuY2FzZSchJzp7XG5yZXR1cm4gZGVjb2RlRXJyb3IoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSk7XG4gfVxuY2FzZSd5Jzp7XG5yZXR1cm4gcGFzc2FibGVTeW1ib2xGb3JOYW1lKGVuY29kZWQuc3Vic3RyaW5nKDEpKTtcbiB9XG5jYXNlJ1snOntcbnJldHVybiBkZWNvZGVBcnJheShlbmNvZGVkLGRlY29kZVBhc3NhYmxlKTtcbiB9XG5jYXNlJygnOntcbnJldHVybiBkZWNvZGVSZWNvcmQoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSk7XG4gfVxuY2FzZSc6Jzp7XG5yZXR1cm4gZGVjb2RlVGFnZ2VkKGVuY29kZWQsZGVjb2RlUGFzc2FibGUpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgRmFpbCBgaW52YWxpZCBkYXRhYmFzZSBrZXk6ICR7ZW5jb2RlZH1gO1xuIH19XG5cbiB9O1xucmV0dXJuIGhhcmRlbihkZWNvZGVQYXNzYWJsZSk7XG4gfTskaOKAjV9vbmNlLm1ha2VEZWNvZGVQYXNzYWJsZShtYWtlRGVjb2RlUGFzc2FibGUpO1xuaGFyZGVuKG1ha2VEZWNvZGVQYXNzYWJsZSk7XG5cbmNvbnN0ICAgICAgICBpc0VuY29kZWRSZW1vdGFibGU9KGVuY29kZWQpPT5lbmNvZGVkLmNoYXJBdCgwKT09PSdyJzskaOKAjV9vbmNlLmlzRW5jb2RlZFJlbW90YWJsZShpc0VuY29kZWRSZW1vdGFibGUpO1xuaGFyZGVuKGlzRW5jb2RlZFJlbW90YWJsZSk7XG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBAdHlwZSB7UmVjb3JkPFBhc3NTdHlsZSwgc3RyaW5nPn1cbiAqIFRoZSBzaW5nbGUgcHJlZml4IGNoYXJhY3RlcnMgdG8gYmUgdXNlZCBmb3IgZWFjaCBQYXNzU3R5bGUgY2F0ZWdvcnkuXG4gKiBgYmlnaW50YCBpcyBhIHR3byBjaGFyYWN0ZXIgc3RyaW5nIGJlY2F1c2UgZWFjaCBvZiB0aG9zZSBjaGFyYWN0ZXJzXG4gKiBpbmRpdmlkdWFsbHkgaXMgYSB2YWxpZCBiaWdpbnQgcHJlZml4LiBgbmAgZm9yIFwibmVnYXRpdmVcIiBhbmQgYHBgIGZvclxuICogXCJwb3NpdGl2ZVwiLiBUaGUgb3JkZXJpbmcgb2YgdGhlc2UgcHJlZml4ZXMgaXMgdGhlIHNhbWUgYXMgdGhlXG4gKiByYW5rT3JkZXJpbmcgb2YgdGhlaXIgcmVzcGVjdGl2ZSBQYXNzU3R5bGVzLiBUaGlzIHRhYmxlIGlzIGltcG9ydGVkIGJ5XG4gKiByYW5rT3JkZXIuanMgZm9yIHRoaXMgcHVycG9zZS5cbiAqXG4gKiBJbiBhZGRpdGlvbiwgYHxgIGlzIHRoZSByZW1vdGFibGUtPm9yZGluYWwgbWFwcGluZyBwcmVmaXg6XG4gKiBUaGlzIGlzIG5vdCB1c2VkIGluIGNvdmVycyBidXQgaXQgaXNcbiAqIHJlc2VydmVkIGZyb20gdGhlIHNhbWUgc2V0IG9mIHN0cmluZ3MuIE5vdGUgdGhhdCB0aGUgcHJlZml4IGlzID4gYW55XG4gKiBwcmVmaXggdXNlZCBieSBhbnkgY292ZXIgc28gdGhhdCBvcmRpbmFsIG1hcHBpbmcga2V5cyBhcmUgYWx3YXlzIG91dHNpZGVcbiAqIHRoZSByYW5nZSBvZiB2YWxpZCBjb2xsZWN0aW9uIGVudHJ5IGtleXMuXG4gKi9cbmNvbnN0ICAgICAgICBwYXNzU3R5bGVQcmVmaXhlcz17XG5lcnJvcjonIScsXG5jb3B5UmVjb3JkOicoJyxcbnRhZ2dlZDonOicsXG5wcm9taXNlOic/JyxcbmNvcHlBcnJheTonWycsXG5ib29sZWFuOidiJyxcbm51bWJlcjonZicsXG5iaWdpbnQ6J25wJyxcbnJlbW90YWJsZToncicsXG5zdHJpbmc6J3MnLFxubnVsbDondicsXG5zeW1ib2w6J3knLFxudW5kZWZpbmVkOid6J307JGjigI1fb25jZS5wYXNzU3R5bGVQcmVmaXhlcyhwYXNzU3R5bGVQcmVmaXhlcyk7XG5cbk9iamVjdC5zZXRQcm90b3R5cGVPZihwYXNzU3R5bGVQcmVmaXhlcyxudWxsKTtcbmhhcmRlbihwYXNzU3R5bGVQcmVmaXhlcyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicmVjb3JkTmFtZXMiOlsicmVjb3JkTmFtZXMiXSwicmVjb3JkVmFsdWVzIjpbInJlY29yZFZhbHVlcyJdLCJ6ZXJvUGFkIjpbInplcm9QYWQiXSwibWFrZUVuY29kZVBhc3NhYmxlIjpbIm1ha2VFbmNvZGVQYXNzYWJsZSJdLCJtYWtlRGVjb2RlUGFzc2FibGUiOlsibWFrZURlY29kZVBhc3NhYmxlIl0sImlzRW5jb2RlZFJlbW90YWJsZSI6WyJpc0VuY29kZWRSZW1vdGFibGUiXSwicGFzc1N0eWxlUHJlZml4ZXMiOlsicGFzc1N0eWxlUHJlZml4ZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAxFOn8Pw/AAD8PwAAKwAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9lbmNvZGVUb0NhcERhdGEuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbIlFDTEFTUyIsIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YSIsIm1ha2VFbmNvZGVUb0NhcERhdGEiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcGFzc1N0eWxlT2YsaXNFcnJvckxpa2UsbWFrZVRhZ2dlZCxpc09iamVjdCxnZXRUYWcsaGFzT3duUHJvcGVydHlPZixhc3NlcnRQYXNzYWJsZVN5bWJvbCxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV0sW1wiaXNFcnJvckxpa2VcIiwgWyRo4oCNX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjigI1fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaOKAjV9hID0+IChtYWtlVGFnZ2VkID0gJGjigI1fYSldXSxbXCJpc09iamVjdFwiLCBbJGjigI1fYSA9PiAoaXNPYmplY3QgPSAkaOKAjV9hKV1dLFtcImdldFRhZ1wiLCBbJGjigI1fYSA9PiAoZ2V0VGFnID0gJGjigI1fYSldXSxbXCJoYXNPd25Qcm9wZXJ0eU9mXCIsIFskaOKAjV9hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjigI1fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVN5bWJvbFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGFzc2FibGVTeW1ib2wgPSAkaOKAjV9hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjigI1fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjigI1fYSldXSxbXCJwYXNzYWJsZVN5bWJvbEZvck5hbWVcIiwgWyRo4oCNX2EgPT4gKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkVuY29kaW5nfSBFbmNvZGluZyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUmVtb3RhYmxlfSBSZW1vdGFibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkVuY29kaW5nVW5pb259IEVuY29kaW5nVW5pb24gKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzLFxuZGVmaW5lUHJvcGVydGllcyxcbmlzLFxuZW50cmllcyxcbmZyb21FbnRyaWVzLFxuZnJlZXplfT1cbk9iamVjdDtcbmNvbnN0e2RldGFpbHM6WCxGYWlsLHF1b3RlOnF9PWFzc2VydDtcblxuLyoqXG4gKiBTcGVjaWFsIHByb3BlcnR5IG5hbWUgdGhhdCBpbmRpY2F0ZXMgYW4gZW5jb2RpbmcgdGhhdCBuZWVkcyBzcGVjaWFsXG4gKiBkZWNvZGluZy5cbiAqL1xuY29uc3QgUUNMQVNTPSdAcWNsYXNzJzskaOKAjV9vbmNlLlFDTEFTUyhRQ0xBU1MpO1xuXG5cbi8qKlxuICogQHBhcmFtIHtFbmNvZGluZ30gZW5jb2RlZFxuICogQHJldHVybnMge2VuY29kZWQgaXMgRW5jb2RpbmdVbmlvbn1cbiAqL1xuY29uc3QgaGFzUUNsYXNzPShlbmNvZGVkKT0+aGFzT3duUHJvcGVydHlPZihlbmNvZGVkLFFDTEFTUyk7XG5cbi8qKlxuICogQHBhcmFtIHtFbmNvZGluZ30gZW5jb2RlZFxuICogQHBhcmFtIHtzdHJpbmd9IHFjbGFzc1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IHFjbGFzc01hdGNoZXM9KGVuY29kZWQscWNsYXNzKT0+XG5pc09iamVjdChlbmNvZGVkKSYmXG4haXNBcnJheShlbmNvZGVkKSYmXG5oYXNRQ2xhc3MoZW5jb2RlZCkmJlxuZW5jb2RlZFtRQ0xBU1NdPT09cWNsYXNzO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZVRvQ2FwRGF0YU9wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICByZW1vdGFibGU6IFJlbW90YWJsZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gRW5jb2RpbmdcbiAqICkgPT4gRW5jb2Rpbmd9IFtlbmNvZGVSZW1vdGFibGVUb0NhcERhdGFdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcHJvbWlzZTogUHJvbWlzZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gRW5jb2RpbmdcbiAqICkgPT4gRW5jb2Rpbmd9IFtlbmNvZGVQcm9taXNlVG9DYXBEYXRhXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gRW5jb2RpbmdcbiAqICkgPT4gRW5jb2Rpbmd9IFtlbmNvZGVFcnJvclRvQ2FwRGF0YV1cbiAqL1xuXG5jb25zdCBkb250RW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhPShyZW0pPT5GYWlsIGByZW1vdGFibGUgdW5leHBlY3RlZDogJHtyZW19YDtcblxuY29uc3QgZG9udEVuY29kZVByb21pc2VUb0NhcERhdGE9KHByb20pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7cHJvbX1gO1xuXG5jb25zdCBkb250RW5jb2RlRXJyb3JUb0NhcERhdGE9KGVycik9PkZhaWwgYGVycm9yIG9iamVjdCB1bmV4cGVjdGVkOiAke2Vycn1gO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlVG9DYXBEYXRhT3B0aW9uc30gW2VuY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7KHBhc3NhYmxlOiBQYXNzYWJsZSkgPT4gRW5jb2Rpbmd9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW5jb2RlVG9DYXBEYXRhPShlbmNvZGVPcHRpb25zPXt9KT0+e1xuY29uc3R7XG5lbmNvZGVSZW1vdGFibGVUb0NhcERhdGE9ZG9udEVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YSxcbmVuY29kZVByb21pc2VUb0NhcERhdGE9ZG9udEVuY29kZVByb21pc2VUb0NhcERhdGEsXG5lbmNvZGVFcnJvclRvQ2FwRGF0YT1kb250RW5jb2RlRXJyb3JUb0NhcERhdGF9PVxuZW5jb2RlT3B0aW9ucztcblxuLyoqXG4gKiBNdXN0IGVuY29kZSBgdmFsYCBpbnRvIHBsYWluIEpTT04gZGF0YSAqY2Fub25pY2FsbHkqLCBzdWNoIHRoYXRcbiAqIGBKU09OLnN0cmluZ2lmeShlbmNvZGUodjEpKSA9PT0gSlNPTi5zdHJpbmdpZnkoZW5jb2RlKHYxKSlgLiBGb3IgbW9zdFxuICogZW5jb2RpbmdzLCB0aGUgb3JkZXIgb2YgcHJvcGVydGllcyBvZiBlYWNoIG5vZGUgb2YgdGhlIG91dHB1dFxuICogc3RydWN0dXJlIGlzIGRldGVybWluZWQgYnkgdGhlIGFsZ29yaXRobSBiZWxvdyB3aXRob3V0IHNwZWNpYWxcbiAqIGFycmFuZ2VtZW50LCB1c3VhbGx5IGJ5IGJlaW5nIGV4cHJlc3NlZCBkaXJlY3RseSBhcyBhbiBvYmplY3QgbGl0ZXJhbC5cbiAqIFRoZSBleGNlcHRpb24gaXMgY29weVJlY29yZHMsIHdob3NlIG5hdHVyYWwgZW51bWVyYXRpb24gb3JkZXJcbiAqIGNhbiBkaWZmZXIgYmV0d2VlbiBjb3B5UmVjb3JkcyB0aGF0IG91ciBkaXN0cmlidXRlZCBvYmplY3Qgc2VtYW50aWNzXG4gKiBjb25zaWRlcnMgdG8gYmUgZXF1aXZhbGVudC5cbiAqIFNpbmNlLCBmb3IgZWFjaCBjb3B5UmVjb3JkLCB3ZSBvbmx5IGFjY2VwdCBzdHJpbmcgcHJvcGVydHkgbmFtZXMsXG4gKiBub3Qgc3ltYm9scywgd2UgY2FuIGNhbm9uaWNhbGx5IHNvcnQgdGhlIG5hbWVzIGZpcnN0LlxuICogSlNPTi5zdHJpbmdpZnkgd2lsbCB0aGVuIHZpc2l0IHRoZXNlIGluIHRoYXQgc29ydGVkIG9yZGVyLlxuICpcbiAqIEVuY29kaW5nIHdpdGggYSBjYW5vbmljYWwtSlNPTiBlbmNvZGVyIHdvdWxkIGFsc28gc29sdmUgdGhpcyBjYW5vbmljYWxuZXNzXG4gKiBwcm9ibGVtIGluIGEgbW9yZSBtb2R1bGFyIGFuZCBlbmNhcHN1bGF0ZWQgbWFubmVyLiBOb3RlIHRoYXQgdGhlXG4gKiBhY3R1YWwgb3JkZXIgcHJvZHVjZWQgaGVyZSwgdGhvdWdoIGl0IGFncmVlcyB3aXRoIGNhbm9uaWNhbC1KU09OIG9uXG4gKiBjb3B5UmVjb3JkIHByb3BlcnR5IG9yZGVyaW5nLCBkaWZmZXJzIGZyb20gY2Fub25pY2FsLUpTT04gYXMgYSB3aG9sZVxuICogaW4gdGhhdCB0aGUgb3RoZXIgcmVjb3JkIHByb3BlcnRpZXMgYXJlIHZpc2l0ZWQgaW4gdGhlIG9yZGVyIGluIHdoaWNoXG4gKiB0aGV5IGFyZSBsaXRlcmFsbHkgd3JpdHRlbiBiZWxvdy4gVE9ETyBwZXJoYXBzIHdlIHNob3VsZCBpbmRlZWQgc3dpdGNoXG4gKiB0byBhIGNhbm9uaWNhbCBKU09OIGVuY29kZXIsIGFuZCBub3QgZGVsaWNhdGVseSBkZXBlbmQgb24gdGhlIG9yZGVyXG4gKiBpbiB3aGljaCB0aGVzZSBvYmplY3QgbGl0ZXJhbHMgYXJlIHdyaXR0ZW4uXG4gKlxuICogUmVhZGVycyBtdXN0IG5vdCBjYXJlIGFib3V0IHRoaXMgb3JkZXIgYW55d2F5LiBXZSBpbXBvc2UgdGhpcyByZXF1aXJlbWVudFxuICogbWFpbmx5IHRvIHJlZHVjZSBub24tZGV0ZXJtaW5pc20gZXhwb3NlZCBvdXRzaWRlIGEgdmF0LlxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHBhc3NhYmxlXG4gKiBAcmV0dXJucyB7RW5jb2Rpbmd9IGV4Y2VwdCB0aGF0IGBlbmNvZGVUb0NhcERhdGFgIGRvZXMgbm90IGdlbmVyYWxseVxuICogYGhhcmRlbmAgdGhpcyByZXN1bHQgYmVmb3JlIHJldHVybmluZy4gUmF0aGVyLCBgZW5jb2RlVG9DYXBEYXRhYCBpcyBub3RcbiAqIGRpcmVjdGx5IGV4cG9zZWQuXG4gKiBXaGF0J3MgZXhwb3NlZCBpbnN0ZWFkIGlzIGEgd3JhcHBlciB0aGF0IGZyZWV6ZXMgdGhlIG91dHB1dCBiZWZvcmVcbiAqIHJldHVybmluZy4gSWYgdGhpcyB0dXJucyBvdXQgdG8gaW1wZWRlIHN0YXRpYyBhbmFseXNpcyBmb3IgYGhhcmRlbmAgc2FmZXR5LFxuICogd2UgY2FuIGFsd2F5cyBwdXQgdGhlIChub3cgcmVkdW5kYW50KSBoYXJkZW5zIGJhY2sgaW4uIFRoZXkgZG9uJ3QgaHVydC5cbiAqL1xuY29uc3QgZW5jb2RlVG9DYXBEYXRhUmVjdXI9KHBhc3NhYmxlKT0+e1xuLyogRmlyc3Qgd2UgaGFuZGxlIGFsbCBwcmltaXRpdmVzLiBTb21lIGNhbiBiZSByZXByZXNlbnRlZCBkaXJlY3RseSBhcyovXG4vKiBKU09OLCBhbmQgc29tZSBtdXN0IGJlIGVuY29kZWQgYXMgW1FDTEFTU10gY29tcG9zaXRlcy4qL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhc3NhYmxlKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdudWxsJzpcbmNhc2UnYm9vbGVhbic6XG5jYXNlJ3N0cmluZyc6e1xuLyogcGFzcyB0aHJvdWdoIHRvIEpTT04qL1xucmV0dXJuIHBhc3NhYmxlO1xuIH1cbmNhc2UndW5kZWZpbmVkJzp7XG5yZXR1cm57W1FDTEFTU106J3VuZGVmaW5lZCd9O1xuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBTcGVjaWFsLWNhc2UgbnVtYmVycyB3aXRoIG5vIGRpZ2l0LWJhc2VkIHJlcHJlc2VudGF0aW9uLiovXG5pZihOdW1iZXIuaXNOYU4ocGFzc2FibGUpKXtcbnJldHVybntbUUNMQVNTXTonTmFOJ307XG4gfWVsc2UgaWYocGFzc2FibGU9PT1JbmZpbml0eSl7XG5yZXR1cm57W1FDTEFTU106J0luZmluaXR5J307XG4gfWVsc2UgaWYocGFzc2FibGU9PT0tSW5maW5pdHkpe1xucmV0dXJue1tRQ0xBU1NdOictSW5maW5pdHknfTtcbiB9XG4vKiBQYXNzIHRocm91Z2ggZXZlcnl0aGluZyBlbHNlLCByZXBsYWNpbmcgLTAgd2l0aCAwLiovXG5yZXR1cm4gaXMocGFzc2FibGUsLTApPzA6cGFzc2FibGU7XG4gfVxuY2FzZSdiaWdpbnQnOntcbnJldHVybntcbltRQ0xBU1NdOidiaWdpbnQnLFxuZGlnaXRzOlN0cmluZyhwYXNzYWJsZSl9O1xuXG4gfVxuY2FzZSdzeW1ib2wnOntcbmFzc2VydFBhc3NhYmxlU3ltYm9sKHBhc3NhYmxlKTtcbmNvbnN0IG5hbWU9LyoqIEB0eXBlIHtzdHJpbmd9ICovbmFtZUZvclBhc3NhYmxlU3ltYm9sKHBhc3NhYmxlKTtcbnJldHVybntcbltRQ0xBU1NdOidzeW1ib2wnLFxubmFtZX07XG5cbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbmlmKGhhc093blByb3BlcnR5T2YocGFzc2FibGUsUUNMQVNTKSl7XG4vKiBIaWxiZXJ0IGhvdGVsKi9cbmNvbnN0e1tRQ0xBU1NdOnFjbGFzc1ZhbHVlLC4uLnJlc3R9PXBhc3NhYmxlO1xuLyoqIEB0eXBlIHtFbmNvZGluZ30gKi9cbmNvbnN0IHJlc3VsdD17XG5bUUNMQVNTXTonaGlsYmVydCcsXG5vcmlnaW5hbDplbmNvZGVUb0NhcERhdGFSZWN1cihxY2xhc3NWYWx1ZSl9O1xuXG5pZihvd25LZXlzKHJlc3QpLmxlbmd0aD49MSl7XG4vKiBXZSBoYXJkZW4gdGhlIGVudGlyZSBjYXBEYXRhIGVuY29kaW5nIGJlZm9yZSB3ZSByZXR1cm4gaXQuKi9cbi8qIGBlbmNvZGVUb0NhcERhdGFgIHJlcXVpcmVzIHRoYXQgaXRzIGlucHV0IGJlIFBhc3NhYmxlLCBhbmQqL1xuLyogdGhlcmVmb3JlIGhhcmRlbmVkLiovXG4vKiBUaGUgYGZyZWV6ZWAgaGVyZSBpcyBuZWVkZWQgYW55d2F5LCBiZWNhdXNlIHRoZSBgcmVzdGAgaXMqL1xuLyogZnJlc2hseSBjb25zdHJ1Y3RlZCBieSB0aGUgYC4uLmAgYWJvdmUsIGFuZCB3ZSdyZSB1c2luZyBpdCovXG4vKiBhcyBpbXB1dCBpbiBhbm90aGVyIGNhbGwgdG8gYGVuY29kZVRvQ2FwRGF0YWAuKi9cbnJlc3VsdC5yZXN0PWVuY29kZVRvQ2FwRGF0YVJlY3VyKGZyZWV6ZShyZXN0KSk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9XG4vKiBDdXJyZW50bHkgY29weVJlY29yZCBhbGxvd3Mgb25seSBzdHJpbmcga2V5cyBzbyB0aGlzIHdpbGwqL1xuLyogd29yay4gSWYgd2UgYWxsb3cgc29ydGFibGUgc3ltYm9sIGtleXMsIHRoaXMgd2lsbCBuZWVkIHRvKi9cbi8qIGJlY29tZSBtb3JlIGludGVyZXN0aW5nLiovXG5jb25zdCBuYW1lcz1vd25LZXlzKHBhc3NhYmxlKS5zb3J0KCk7XG5yZXR1cm4gZnJvbUVudHJpZXMoXG5uYW1lcy5tYXAoKG5hbWUpPT5bbmFtZSxlbmNvZGVUb0NhcERhdGFSZWN1cihwYXNzYWJsZVtuYW1lXSldKSk7XG5cbiB9XG5jYXNlJ2NvcHlBcnJheSc6e1xucmV0dXJuIHBhc3NhYmxlLm1hcChlbmNvZGVUb0NhcERhdGFSZWN1cik7XG4gfVxuY2FzZSd0YWdnZWQnOntcbnJldHVybntcbltRQ0xBU1NdOid0YWdnZWQnLFxudGFnOmdldFRhZyhwYXNzYWJsZSksXG5wYXlsb2FkOmVuY29kZVRvQ2FwRGF0YVJlY3VyKHBhc3NhYmxlLnBheWxvYWQpfTtcblxuIH1cbmNhc2UncmVtb3RhYmxlJzp7XG5jb25zdCBlbmNvZGVkPWVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YShcbnBhc3NhYmxlLFxuZW5jb2RlVG9DYXBEYXRhUmVjdXIpO1xuXG5pZihxY2xhc3NNYXRjaGVzKGVuY29kZWQsJ3Nsb3QnKSl7XG5yZXR1cm4gZW5jb2RlZDtcbiB9XG4vKiBgdGhyb3dgIGlzIG5vb3Agc2luY2UgYEZhaWxgIHRocm93cy4gQnV0IGxpbnRlciBjb25mdXNlZCovXG50aHJvdyBGYWlsIGBpbnRlcm5hbDogUmVtb3RhYmxlIGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0IHdpdGggJHtxKFxuUUNMQVNTKVxuIH0gJHtxKCdzbG90Jyl9OiAke2VuY29kZWR9YDtcbiB9XG5jYXNlJ3Byb21pc2UnOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlUHJvbWlzZVRvQ2FwRGF0YShwYXNzYWJsZSxlbmNvZGVUb0NhcERhdGFSZWN1cik7XG5pZihxY2xhc3NNYXRjaGVzKGVuY29kZWQsJ3Nsb3QnKSl7XG5yZXR1cm4gZW5jb2RlZDtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogUHJvbWlzZSBlbmNvZGluZyBtdXN0IGJlIGFuIG9iamVjdCB3aXRoICR7cShcblFDTEFTUyxcbidzbG90JylcbiB9OiAke2VuY29kZWR9YDtcbiB9XG5jYXNlJ2Vycm9yJzp7XG5jb25zdCBlbmNvZGVkPWVuY29kZUVycm9yVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnZXJyb3InKSl7XG5yZXR1cm4gZW5jb2RlZDtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogRXJyb3IgZW5jb2RpbmcgbXVzdCBiZSBhbiBvYmplY3Qgd2l0aCAke3EoXG5RQ0xBU1MsXG4nZXJyb3InKVxuIH06ICR7ZW5jb2RlZH1gO1xuIH1cbmRlZmF1bHQ6e1xuYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogVW5yZWNvZ25pemVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX1gLFxuVHlwZUVycm9yKTtcblxuIH19XG5cbiB9O1xuY29uc3QgZW5jb2RlVG9DYXBEYXRhPShwYXNzYWJsZSk9PntcbmlmKGlzRXJyb3JMaWtlKHBhc3NhYmxlKSl7XG4vKiBXZSBwdWxsIG91dCB0aGlzIHNwZWNpYWwgY2FzZSB0byBhY2NvbW1vZGF0ZSBlcnJvcnMgdGhhdCBhcmUgbm90Ki9cbi8qIHZhbGlkIFBhc3NhYmxlcy4gRm9yIGV4YW1wbGUsIGJlY2F1c2UgdGhleSdyZSBub3QgZnJvemVuLiovXG4vKiBUaGUgc3BlY2lhbCBjYXNlIGNhbiBvbmx5IGV2ZXIgYXBwbHkgYXQgdGhlIHJvb3QsIGFuZCB0aGVyZWZvcmUqL1xuLyogb3V0c2lkZSB0aGUgcmVjdXJzaW9uLCBzaW5jZSBhbiBlcnJvciBjb3VsZCBvbmx5IGJlIGRlZXBlciBpbiovXG4vKiBhIHBhc3NhYmxlIHN0cnVjdHVyZSBpZiBpdCB3ZXJlIHBhc3NhYmxlLiovXG4vKiovXG4vKiBXZSBwdWxsIG91dCB0aGlzIHNwZWNpYWwgY2FzZSBiZWNhdXNlLCBmb3IgdGhlc2UgZXJyb3JzLCB3ZSdyZSBtdWNoKi9cbi8qIG1vcmUgaW50ZXJlc3RlZCBpbiByZXBvcnRpbmcgd2hhdGV2ZXIgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiB0aGV5Ki9cbi8qIGNhcnJ5IHRoYW4gd2UgYXJlIGFib3V0IHJlcG9ydGluZyBwcm9ibGVtcyBlbmNvdW50ZXJlZCBpbiByZXBvcnRpbmcqL1xuLyogdGhpcyBpbmZvcm1hdGlvbi4qL1xucmV0dXJuIGhhcmRlbihlbmNvZGVFcnJvclRvQ2FwRGF0YShwYXNzYWJsZSxlbmNvZGVUb0NhcERhdGFSZWN1cikpO1xuIH1cbnJldHVybiBoYXJkZW4oZW5jb2RlVG9DYXBEYXRhUmVjdXIocGFzc2FibGUpKTtcbiB9O1xucmV0dXJuIGhhcmRlbihlbmNvZGVUb0NhcERhdGEpO1xuIH07JGjigI1fb25jZS5tYWtlRW5jb2RlVG9DYXBEYXRhKG1ha2VFbmNvZGVUb0NhcERhdGEpO1xuaGFyZGVuKG1ha2VFbmNvZGVUb0NhcERhdGEpO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IERlY29kZU9wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUmVtb3RhYmxlOiBFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gKFByb21pc2V8UmVtb3RhYmxlKX0gW2RlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRQcm9taXNlOiBFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gKFByb21pc2V8UmVtb3RhYmxlKX0gW2RlY29kZVByb21pc2VGcm9tQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkRXJyb3I6IEVuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IEVuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBFcnJvcn0gW2RlY29kZUVycm9yRnJvbUNhcERhdGFdXG4gKi9cblxuY29uc3QgZG9udERlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhPShzbG90RW5jb2RpbmcpPT5cbkZhaWwgYHJlbW90YWJsZSBvciBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7c2xvdEVuY29kaW5nfWA7XG5jb25zdCBkb250RGVjb2RlRXJyb3JGcm9tQ2FwRGF0YT0oZXJyb3JFbmNvZGluZyk9PlxuRmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtlcnJvckVuY29kaW5nfWA7XG5cbi8qKlxuICogVGhlIGN1cnJlbnQgZW5jb2RpbmcgZG9lcyBub3QgZ2l2ZSB0aGUgZGVjb2RlciBlbm91Z2ggaW50byB0byBkaXN0aW5ndWlzaFxuICogd2hldGhlciBhIHNsb3QgcmVwcmVzZW50cyBhIHByb21pc2Ugb3IgYSByZW1vdGFibGUuIEFzIGFuIGltcGxlbWVudGF0aW9uXG4gKiByZXN0cmljdGlvbiB1bnRpbCB0aGlzIGlzIGZpeGVkLCBpZiBlaXRoZXIgaXMgcHJvdmlkZWQsIGJvdGggbXVzdCBiZVxuICogcHJvdmlkZWQgYW5kIHRoZXkgbXVzdCBiZSB0aGUgc2FtZS5cbiAqXG4gKiBUaGlzIHNlZW1zIGxpa2UgdGhlIGJlc3Qgc3RhcnRpbmcgcG9pbnQgdG8gaW5jcmVtZW50YWxseSBldm9sdmUgdG8gYW5cbiAqIEFQSSB3aGVyZSB0aGVzZSBjYW4gcmVsaWFibHkgZGlmZmVyLlxuICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDMzNFxuICpcbiAqIEBwYXJhbSB7RGVjb2RlT3B0aW9uc30gW2RlY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7KGVuY29kZWQ6IEVuY29kaW5nKSA9PiBQYXNzYWJsZX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VEZWNvZGVGcm9tQ2FwRGF0YT0oZGVjb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZGVjb2RlUmVtb3RhYmxlRnJvbUNhcERhdGE9ZG9udERlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhPWRvbnREZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YSxcbmRlY29kZUVycm9yRnJvbUNhcERhdGE9ZG9udERlY29kZUVycm9yRnJvbUNhcERhdGF9PVxuZGVjb2RlT3B0aW9ucztcblxuZGVjb2RlUmVtb3RhYmxlRnJvbUNhcERhdGE9PT1kZWNvZGVQcm9taXNlRnJvbUNhcERhdGF8fFxuRmFpbCBgQW4gaW1wbGVtZW50YXRpb24gcmVzdHJpY3Rpb24gZm9yIG5vdzogSWYgZWl0aGVyIGRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhIG9yIGRlY29kZVByb21pc2VGcm9tQ2FwRGF0YSBpcyBwcm92aWRlZCwgYm90aCBtdXN0IGJlIHByb3ZpZGVkIGFuZCB0aGV5IG11c3QgYmUgdGhlIHNhbWU6ICR7cShcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhKVxuIH0gdnMgJHtxKGRlY29kZVByb21pc2VGcm9tQ2FwRGF0YSl9YDtcblxuLyoqXG4gKiBgZGVjb2RlRnJvbUNhcERhdGFgIG1heSByZWx5IG9uIGBqc29uRW5jb2RlZGAgYmVpbmcgdGhlIHJlc3VsdCBvZiBhXG4gKiBwbGFpbiBjYWxsIHRvIEpTT04ucGFyc2UuIEhvd2V2ZXIsIGl0ICpjYW5ub3QqIHJlbHkgb24gYGpzb25FbmNvZGVkYFxuICogaGF2aW5nIGJlZW4gcHJvZHVjZWQgYnkgSlNPTi5zdHJpbmdpZnkgb24gdGhlIG91dHB1dCBvZiBgZW5jb2RlVG9DYXBEYXRhYFxuICogYWJvdmUsIGkuZS4sIGBkZWNvZGVGcm9tQ2FwRGF0YWAgY2Fubm90IHJlbHkgb24gYGpzb25FbmNvZGVkYCBiZWluZyBhXG4gKiB2YWxpZCBtYXJzaGFsbGVkIHJlcHJlc2VudGF0aW9uLiBSYXRoZXIsIGBkZWNvZGVGcm9tQ2FwRGF0YWAgbXVzdFxuICogdmFsaWRhdGUgdGhhdC5cbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSBqc29uRW5jb2RlZCBtdXN0IGJlIGhhcmRlbmVkXG4gKi9cbmNvbnN0IGRlY29kZUZyb21DYXBEYXRhPShqc29uRW5jb2RlZCk9PntcbmlmKCFpc09iamVjdChqc29uRW5jb2RlZCkpe1xuLyogcHJpbWl0aXZlcyBwYXNzIHRocm91Z2gqL1xucmV0dXJuIGpzb25FbmNvZGVkO1xuIH1cbmlmKGlzQXJyYXkoanNvbkVuY29kZWQpKXtcbnJldHVybiBqc29uRW5jb2RlZC5tYXAoKGVuY29kZWRWYWwpPT5kZWNvZGVGcm9tQ2FwRGF0YShlbmNvZGVkVmFsKSk7XG4gfWVsc2UgaWYoaGFzUUNsYXNzKGpzb25FbmNvZGVkKSl7XG5jb25zdCBxY2xhc3M9anNvbkVuY29kZWRbUUNMQVNTXTtcbnR5cGVvZiBxY2xhc3M9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkICR7cShRQ0xBU1MpfSB0eXBlb2YgJHtxKHR5cGVvZiBxY2xhc3MpfWA7XG5zd2l0Y2gocWNsYXNzKXtcbi8qIEVuY29kaW5nIG9mIHByaW1pdGl2ZXMgbm90IGhhbmRsZWQgYnkgSlNPTiovXG5jYXNlJ3VuZGVmaW5lZCc6e1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG5jYXNlJ05hTic6e1xucmV0dXJuIE5hTjtcbiB9XG5jYXNlJ0luZmluaXR5Jzp7XG5yZXR1cm4gSW5maW5pdHk7XG4gfVxuY2FzZSctSW5maW5pdHknOntcbnJldHVybi1JbmZpbml0eTtcbiB9XG5jYXNlJ2JpZ2ludCc6e1xuLyogVXNpbmcgQHRzLWlnbm9yZSByYXRoZXIgdGhhbiBAdHMtZXhwZWN0LWVycm9yIGJlbG93IGJlY2F1c2UqL1xuLyogd2l0aCBAdHMtZXhwZWN0LWVycm9yIEkgZ2V0IGEgcmVkIHVuZGVybGluZSBpbiB2c2NvZGUsIGJ1dCovXG4vKiB3aXRob3V0IGl0IEkgZ2V0IGVycm9ycyBmcm9tIGB5YXJuIGxpbnRgLiovXG4vKiBAdHMtaWdub3JlIGluYWRlcXVhdGUgdHlwZSBpbmZlcmVuY2UqL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzEyNTkjZGlzY3Vzc2lvbl9yOTU0NTYxOTAxKi9cbmNvbnN0e2RpZ2l0c309anNvbkVuY29kZWQ7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuIEJpZ0ludChkaWdpdHMpO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG4vKiBEZXByZWNhdGVkIHFjbGFzcy4gVE9ETyBtYWtlIGNvbmRpdGlvbmFsKi9cbi8qIG9uIGVudmlyb25tZW50IHZhcmlhYmxlLiBFdmVudHVhbGx5IHJlbW92ZSwgYnV0IGFmdGVyIGNvbmZpZGVudCovXG4vKiB0aGF0IHRoZXJlIGFyZSBubyBtb3JlIHN1cHBvcnRlZCBzZW5kZXJzLiovXG4vKiovXG4vKiBVc2luZyBAdHMtaWdub3JlIHJhdGhlciB0aGFuIEB0cy1leHBlY3QtZXJyb3IgYmVsb3cgYmVjYXVzZSovXG4vKiB3aXRoIEB0cy1leHBlY3QtZXJyb3IgSSBnZXQgYSByZWQgdW5kZXJsaW5lIGluIHZzY29kZSwgYnV0Ki9cbi8qIHdpdGhvdXQgaXQgSSBnZXQgZXJyb3JzIGZyb20gYHlhcm4gbGludGAuKi9cbi8qIEB0cy1pZ25vcmUgaW5hZGVxdWF0ZSB0eXBlIGluZmVyZW5jZSovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI1OSNkaXNjdXNzaW9uX3I5NTQ1NjE5MDEqL1xucmV0dXJuIFN5bWJvbC5hc3luY0l0ZXJhdG9yO1xuIH1cbmNhc2Unc3ltYm9sJzp7XG4vKiBVc2luZyBAdHMtaWdub3JlIHJhdGhlciB0aGFuIEB0cy1leHBlY3QtZXJyb3IgYmVsb3cgYmVjYXVzZSovXG4vKiB3aXRoIEB0cy1leHBlY3QtZXJyb3IgSSBnZXQgYSByZWQgdW5kZXJsaW5lIGluIHZzY29kZSwgYnV0Ki9cbi8qIHdpdGhvdXQgaXQgSSBnZXQgZXJyb3JzIGZyb20gYHlhcm4gbGludGAuKi9cbi8qIEB0cy1pZ25vcmUgaW5hZGVxdWF0ZSB0eXBlIGluZmVyZW5jZSovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI1OSNkaXNjdXNzaW9uX3I5NTQ1NjE5MDEqL1xuY29uc3R7bmFtZX09anNvbkVuY29kZWQ7XG5yZXR1cm4gcGFzc2FibGVTeW1ib2xGb3JOYW1lKG5hbWUpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG4vKiBVc2luZyBAdHMtaWdub3JlIHJhdGhlciB0aGFuIEB0cy1leHBlY3QtZXJyb3IgYmVsb3cgYmVjYXVzZSovXG4vKiB3aXRoIEB0cy1leHBlY3QtZXJyb3IgSSBnZXQgYSByZWQgdW5kZXJsaW5lIGluIHZzY29kZSwgYnV0Ki9cbi8qIHdpdGhvdXQgaXQgSSBnZXQgZXJyb3JzIGZyb20gYHlhcm4gbGludGAuKi9cbi8qIEB0cy1pZ25vcmUgaW5hZGVxdWF0ZSB0eXBlIGluZmVyZW5jZSovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI1OSNkaXNjdXNzaW9uX3I5NTQ1NjE5MDEqL1xuY29uc3R7dGFnLHBheWxvYWR9PWpzb25FbmNvZGVkO1xucmV0dXJuIG1ha2VUYWdnZWQodGFnLGRlY29kZUZyb21DYXBEYXRhKHBheWxvYWQpKTtcbiB9XG5jYXNlJ3Nsb3QnOntcbi8qIFNlZSBub3RlIGFib3ZlIGFib3V0IGhvdyB0aGUgY3VycmVudCBlbmNvZGluZyBjYW5ub3QgcmVsaWFibHkqL1xuLyogZGlzdGluZ3Vpc2ggd2hpY2ggd2Ugc2hvdWxkIGNhbGwsIHNvIGluIHRoZSBub24tZGVmYXVsdCBjYXNlKi9cbi8qIGJvdGggbXVzdCBiZSB0aGUgc2FtZSBhbmQgaXQgZG9lc24ndCBtYXR0ZXIgd2hpY2ggd2UgY2FsbC4qL1xuY29uc3QgZGVjb2RlZD1kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YShcbmpzb25FbmNvZGVkLFxuZGVjb2RlRnJvbUNhcERhdGEpO1xuXG4vKiBCRVdBUkU6IGNhcGRhdGEgZG9lcyBub3QgY2hlY2sgdGhhdCBgZGVjb2RlZGAgaXMqL1xuLyogYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLCBzaW5jZSB0aGF0IHdvdWxkIGJyZWFrIHNvbWUqL1xuLyogY2FwZGF0YSBjbGllbnRzLiBXZSBhcmUgZGVwcmVjYXRpbmcgY2FwZGF0YSwgYW5kIHRoZXNlIGNsaWVudHMqL1xuLyogd2lsbCBuZWVkIHRvIHVwZGF0ZSBiZWZvcmUgc3dpdGNoaW5nIHRvIHNtYWxsY2Fwcy4qL1xucmV0dXJuIGRlY29kZWQ7XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3QgZGVjb2RlZD1kZWNvZGVFcnJvckZyb21DYXBEYXRhKFxuanNvbkVuY29kZWQsXG5kZWNvZGVGcm9tQ2FwRGF0YSk7XG5cbmlmKHBhc3NTdHlsZU9mKGRlY29kZWQpPT09J2Vycm9yJyl7XG5yZXR1cm4gZGVjb2RlZDtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YSBvcHRpb24gbXVzdCByZXR1cm4gYW4gZXJyb3I6ICR7ZGVjb2RlZH1gO1xuIH1cbmNhc2UnaGlsYmVydCc6e1xuLyogVXNpbmcgQHRzLWlnbm9yZSByYXRoZXIgdGhhbiBAdHMtZXhwZWN0LWVycm9yIGJlbG93IGJlY2F1c2UqL1xuLyogd2l0aCBAdHMtZXhwZWN0LWVycm9yIEkgZ2V0IGEgcmVkIHVuZGVybGluZSBpbiB2c2NvZGUsIGJ1dCovXG4vKiB3aXRob3V0IGl0IEkgZ2V0IGVycm9ycyBmcm9tIGB5YXJuIGxpbnRgLiovXG4vKiBAdHMtaWdub3JlIGluYWRlcXVhdGUgdHlwZSBpbmZlcmVuY2UqL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9wdWxsLzEyNTkjZGlzY3Vzc2lvbl9yOTU0NTYxOTAxKi9cbmNvbnN0e29yaWdpbmFsLHJlc3R9PWpzb25FbmNvZGVkO1xuaGFzT3duUHJvcGVydHlPZihqc29uRW5jb2RlZCwnb3JpZ2luYWwnKXx8XG5GYWlsIGBJbnZhbGlkIEhpbGJlcnQgSG90ZWwgZW5jb2RpbmcgJHtqc29uRW5jb2RlZH1gO1xuLyogRG9uJ3QgaGFyZGVuIHNpbmNlIHdlJ3JlIG5vdCBkb25lIG11dGF0aW5nIGl0Ki9cbmNvbnN0IHJlc3VsdD17W1FDTEFTU106ZGVjb2RlRnJvbUNhcERhdGEob3JpZ2luYWwpfTtcbmlmKGhhc093blByb3BlcnR5T2YoanNvbkVuY29kZWQsJ3Jlc3QnKSl7XG5jb25zdCBpc05vbkVtcHR5T2JqZWN0PVxudHlwZW9mIHJlc3Q9PT0nb2JqZWN0JyYmXG5yZXN0IT09bnVsbCYmXG5vd25LZXlzKHJlc3QpLmxlbmd0aD49MTtcbmlmKCFpc05vbkVtcHR5T2JqZWN0KXtcbnRocm93IEZhaWwgYFJlc3QgZW5jb2RpbmcgbXVzdCBiZSBhIG5vbi1lbXB0eSBvYmplY3Q6ICR7cmVzdH1gO1xuIH1cbmNvbnN0IHJlc3RPYmo9ZGVjb2RlRnJvbUNhcERhdGEocmVzdCk7XG4vKiBUT0RPIHJlYWxseSBzaG91bGQgYXNzZXJ0IHRoYXQgYHBhc3NTdHlsZU9mKHJlc3QpYCBpcyovXG4vKiBgJ2NvcHlSZWNvcmQnYCBidXQgd2UnZCBoYXZlIHRvIGhhcmRlbiBpdCBhbmQgaXQgaXMgdG9vKi9cbi8qIGVhcmx5IHRvIGRvIHRoYXQuKi9cbiFoYXNPd25Qcm9wZXJ0eU9mKHJlc3RPYmosUUNMQVNTKXx8XG5GYWlsIGBSZXN0IG11c3Qgbm90IGNvbnRhaW4gaXRzIG93biBkZWZpbml0aW9uIG9mICR7cShRQ0xBU1MpfWA7XG5kZWZpbmVQcm9wZXJ0aWVzKHJlc3VsdCxnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKHJlc3RPYmopKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbi8qIEB0cy1leHBlY3QtZXJyb3IgVGhpcyBpcyB0aGUgZXJyb3IgY2FzZSB3ZSdyZSB0ZXN0aW5nIGZvciovXG5jYXNlJ2liaWQnOntcbnRocm93IEZhaWwgYFRoZSBjYXBEYXRhIHByb3RvY29sIG5vIGxvbmdlciBzdXBwb3J0cyAke3EoUUNMQVNTKX0gJHtxKFxucWNsYXNzKVxuIH1gO1xuIH1cbmRlZmF1bHQ6e1xuYXNzZXJ0LmZhaWwoWCBgdW5yZWNvZ25pemVkICR7cShRQ0xBU1MpfSAke3EocWNsYXNzKX1gLFR5cGVFcnJvcik7XG4gfX1cblxuIH1lbHNle1xuYXNzZXJ0KHR5cGVvZiBqc29uRW5jb2RlZD09PSdvYmplY3QnJiZqc29uRW5jb2RlZCE9PW51bGwpO1xuY29uc3QgZGVjb2RlRW50cnk9KFtuYW1lLGVuY29kZWRWYWxdKT0+e1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBQcm9wZXJ0eSAke3EobmFtZSl9IG9mICR7anNvbkVuY29kZWR9IG11c3QgYmUgYSBzdHJpbmdgO1xucmV0dXJuW25hbWUsZGVjb2RlRnJvbUNhcERhdGEoZW5jb2RlZFZhbCldO1xuIH07XG5jb25zdCBkZWNvZGVkRW50cmllcz1lbnRyaWVzKGpzb25FbmNvZGVkKS5tYXAoZGVjb2RlRW50cnkpO1xucmV0dXJuIGZyb21FbnRyaWVzKGRlY29kZWRFbnRyaWVzKTtcbiB9XG4gfTtcbnJldHVybiBoYXJkZW4oZGVjb2RlRnJvbUNhcERhdGEpO1xuIH07JGjigI1fb25jZS5tYWtlRGVjb2RlRnJvbUNhcERhdGEobWFrZURlY29kZUZyb21DYXBEYXRhKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJRQ0xBU1MiOlsiUUNMQVNTIl0sIm1ha2VFbmNvZGVUb0NhcERhdGEiOlsibWFrZUVuY29kZVRvQ2FwRGF0YSJdLCJtYWtlRGVjb2RlRnJvbUNhcERhdGEiOlsibWFrZURlY29kZUZyb21DYXBEYXRhIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAALNe92vFOwAAxTsAAC0AAABAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvZW5jb2RlVG9TbWFsbGNhcHMuanN7ImltcG9ydHMiOlsiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzIiwibWFrZUVuY29kZVRvU21hbGxjYXBzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHBhc3NTdHlsZU9mLGlzRXJyb3JMaWtlLG1ha2VUYWdnZWQsZ2V0VGFnLGhhc093blByb3BlcnR5T2YsYXNzZXJ0UGFzc2FibGVTeW1ib2wsbmFtZUZvclBhc3NhYmxlU3ltYm9sLHBhc3NhYmxlU3ltYm9sRm9yTmFtZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcImlzRXJyb3JMaWtlXCIsIFskaOKAjV9hID0+IChpc0Vycm9yTGlrZSA9ICRo4oCNX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjigI1fYSA9PiAobWFrZVRhZ2dlZCA9ICRo4oCNX2EpXV0sW1wiZ2V0VGFnXCIsIFskaOKAjV9hID0+IChnZXRUYWcgPSAkaOKAjV9hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRo4oCNX2EgPT4gKGhhc093blByb3BlcnR5T2YgPSAkaOKAjV9hKV1dLFtcImFzc2VydFBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV0sW1wibmFtZUZvclBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaOKAjV9hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjigI1fYSA9PiAocGFzc2FibGVTeW1ib2xGb3JOYW1lID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlJlbW90YWJsZX0gUmVtb3RhYmxlICovXG4vKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlNtYWxsY2Fwc0VuY29kaW5nfSBTbWFsbGNhcHNFbmNvZGluZyAqWC8qL1xuLyogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5TbWFsbGNhcHNFbmNvZGluZ1VuaW9ufSBTbWFsbGNhcHNFbmNvZGluZ1VuaW9uICpYLyovXG4vKiogQHR5cGVkZWYge2FueX0gU21hbGxjYXBzRW5jb2RpbmcgKi9cbi8qKiBAdHlwZWRlZiB7YW55fSBTbWFsbGNhcHNFbmNvZGluZ1VuaW9uICovXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e2lzLGVudHJpZXMsZnJvbUVudHJpZXN9PU9iamVjdDtcbmNvbnN0e2RldGFpbHM6WCxGYWlsLHF1b3RlOnF9PWFzc2VydDtcblxuY29uc3QgQkFORz0nIScuY2hhckNvZGVBdCgwKTtcbmNvbnN0IERBU0g9Jy0nLmNoYXJDb2RlQXQoMCk7XG5cbi8qKlxuICogQW4gYGVuY29kZVRvU21hbGxjYXBzYCBmdW5jdGlvbiB0YWtlcyBhIHBhc3NhYmxlIGFuZCByZXR1cm5zIGFcbiAqIEpTT04tcmVwcmVzZW50YWJsZSBvYmplY3QgKGkuZS4sIHJvdW5kLXRyaXBwaW5nIGl0IHRocm91Z2hcbiAqIGBKU09OLnN0cmluZ2lmeWAgYW5kIGBKU09OLnBhcnNlYCB3aXRoIG5vIHJlcGxhY2VycyBvciByZXZpdmVyc1xuICogcmV0dXJucyBhbiBlcXVpdmFsZW50IHN0cnVjdHVyZSBleGNlcHQgZm9yIG9iamVjdCBpZGVudGl0eSkuXG4gKiBXZSBjYWxsIHRoaXMgcmVwcmVzZW50YXRpb24gYSBTbWFsbGNhcHMgRW5jb2RpbmcuXG4gKlxuICogQSBgZGVjb2RlRnJvbVNtYWxsY2Fwc2AgZnVuY3Rpb24gdGFrZXMgYXMgYXJndW1lbnQgd2hhdCBpdFxuICogKmFzc3VtZXMqIGlzIHRoZSByZXN1bHQgb2YgYSBwbGFpbiBgSlNPTi5wYXJzZWAgd2l0aCBubyByZXNvbHZlci4gSXQgdGhlblxuICogbXVzdCB2YWxpZGF0ZSB0aGF0IGl0IGlzIGEgdmFsaWQgU21hbGxjYXBzIEVuY29kaW5nLCBhbmQgaWYgaXQgaXMsXG4gKiByZXR1cm4gYSBjb3JyZXNwb25kaW5nIHBhc3NhYmxlLlxuICpcbiAqIFNtYWxsY2FwcyBjb25zaWRlcnMgdGhlIGNoYXJhY3RlcnMgYmV0d2VlbiBgIWAgKGFzY2lpIGNvZGUgMzMsIEJBTkcpXG4gKiBhbmQgYC1gIChhc2NpaSBjb2RlIDQ1LCBEQVNIKSB0byBiZSBzcGVjaWFsIHByZWZpeGVzIGFsbG93aW5nXG4gKiByZXByZXNlbnRhdGlvbiBvZiBKU09OLWluY29tcGF0aWJsZSBkYXRhIHVzaW5nIHN0cmluZ3MuXG4gKiBUaGVzZSBjaGFyYWN0ZXJzLCBpbiBvcmRlciwgYXJlIGAhXCIjJCUmJygpKissLWBcbiAqIE9mIHRoZXNlLCBzbWFsbGNhcHMgY3VycmVudGx5IHVzZXMgdGhlIGZvbGxvd2luZzpcbiAqXG4gKiAgKiBgIWAgLSBlc2NhcGVkIHN0cmluZ1xuICogICogYCtgIC0gbm9uLW5lZ2F0aXZlIGJpZ2ludFxuICogICogYC1gIC0gbmVnYXRpdmUgYmlnaW50XG4gKiAgKiBgI2AgLSBtYW5pZmVzdCBjb25zdGFudFxuICogICogYCVgIC0gc3ltYm9sXG4gKiAgKiBgJGAgLSByZW1vdGFibGVcbiAqICAqIGAmYCAtIHByb21pc2VcbiAqXG4gKiBBbGwgb3RoZXIgc3BlY2lhbCBjaGFyYWN0ZXJzIChgXCInKCkqLGApIGFyZSByZXNlcnZlZCBmb3IgZnV0dXJlIHVzZS5cbiAqXG4gKiBUaGUgbWFuaWZlc3QgY29uc3RhbnRzIHRoYXQgc21hbGxjYXBzIGN1cnJlbnRseSB1c2VzIGZvciB2YWx1ZXM6XG4gKiAgKiBgI3VuZGVmaW5lZGBcbiAqICAqIGAjTmFOYFxuICogICogYCNJbmZpbml0eWBcbiAqICAqIGAjLUluZmluaXR5YFxuICpcbiAqIGFuZCBmb3IgcHJvcGVydHkgbmFtZXMgYW5hbG9nb3VzIHRvIGNhcGRhdGEgQHFjbGFzczpcbiAqICAqIGAjdGFnYFxuICogICogYCNlcnJvcmBcbiAqXG4gKiBBbGwgb3RoZXIgZW5jb2RlZCBzdHJpbmdzIGJlZ2lubmluZyB3aXRoIGAjYCBhcmUgcmVzZXJ2ZWQgZm9yXG4gKiBmdXR1cmUgdXNlLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkU3RyXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3Qgc3RhcnRzU3BlY2lhbD0oZW5jb2RlZFN0cik9PntcbmlmKGVuY29kZWRTdHI9PT0nJyl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuLyogY2hhckNvZGVBdCgwKSBhbmQgbnVtYmVyIGNvbXBhcmUgaXMgYSBiaXQgZmFzdGVyLiovXG5jb25zdCBjb2RlPWVuY29kZWRTdHIuY2hhckNvZGVBdCgwKTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSB5b2RhKi9cbnJldHVybiBCQU5HPD1jb2RlJiZjb2RlPD1EQVNIO1xuIH07XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRW5jb2RlVG9TbWFsbGNhcHNPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcmVtb3RhYmxlOiBSZW1vdGFibGUsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IFNtYWxsY2Fwc0VuY29kaW5nXG4gKiApID0+IFNtYWxsY2Fwc0VuY29kaW5nfSBbZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHNdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcHJvbWlzZTogUHJvbWlzZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2RpbmdcbiAqICkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9IFtlbmNvZGVQcm9taXNlVG9TbWFsbGNhcHNdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZXJyb3I6IEVycm9yLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBTbWFsbGNhcHNFbmNvZGluZ1xuICogKSA9PiBTbWFsbGNhcHNFbmNvZGluZ30gW2VuY29kZUVycm9yVG9TbWFsbGNhcHNdXG4gKi9cblxuY29uc3QgZG9udEVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzPShyZW0pPT5cbkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3JlbX1gO1xuXG5jb25zdCBkb250RW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzPShwcm9tKT0+RmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke3Byb219YDtcblxuY29uc3QgZG9udEVuY29kZUVycm9yVG9TbWFsbGNhcHM9KGVycik9PlxuRmFpbCBgZXJyb3Igb2JqZWN0IHVuZXhwZWN0ZWQ6ICR7cShlcnIpfWA7XG5cbi8qKlxuICogQHBhcmFtIHtFbmNvZGVUb1NtYWxsY2Fwc09wdGlvbnN9IFtlbmNvZGVPcHRpb25zXVxuICogZW5jb2RlT3B0aW9ucyBpcyBhY3R1YWxseSBvcHRpb25hbCwgYnV0IG5vdCBtYXJrZWQgYXMgc3VjaCB0byB3b3JrIGFyb3VuZFxuICogaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy81MDI4NlxuICpcbiAqIEByZXR1cm5zIHsocGFzc2FibGU6IFBhc3NhYmxlKSA9PiBTbWFsbGNhcHNFbmNvZGluZ31cbiAqL1xuY29uc3QgICAgICAgIG1ha2VFbmNvZGVUb1NtYWxsY2Fwcz0oZW5jb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHM9ZG9udEVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzLFxuZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzPWRvbnRFbmNvZGVQcm9taXNlVG9TbWFsbGNhcHMsXG5lbmNvZGVFcnJvclRvU21hbGxjYXBzPWRvbnRFbmNvZGVFcnJvclRvU21hbGxjYXBzfT1cbmVuY29kZU9wdGlvbnM7XG5cbmNvbnN0IGFzc2VydEVuY29kZWRFcnJvcj0oZW5jb2RpbmcpPT57XG50eXBlb2YgZW5jb2Rpbmc9PT0nb2JqZWN0JyYmaGFzT3duUHJvcGVydHlPZihlbmNvZGluZywnI2Vycm9yJyl8fFxuRmFpbCBgaW50ZXJuYWw6IEVycm9yIGVuY29kaW5nIG11c3QgaGF2ZSBcIiNlcnJvclwiIHByb3BlcnR5OiAke3EoXG5lbmNvZGluZylcbiB9YDtcbi8qIEFzc2VydCB0aGF0IHRoZSAjZXJyb3IgcHJvcGVydHkgZGVjb2RlcyB0byBhIHN0cmluZy4qL1xuY29uc3QgbWVzc2FnZT1lbmNvZGluZ1snI2Vycm9yJ107XG50eXBlb2YgbWVzc2FnZT09PSdzdHJpbmcnJiYoXG4hc3RhcnRzU3BlY2lhbChtZXNzYWdlKXx8bWVzc2FnZS5zdGFydHNXaXRoKCchJykpfHxcbkZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGhhdmUgc3RyaW5nIG1lc3NhZ2U6ICR7cShtZXNzYWdlKX1gO1xuIH07XG5cbi8qKlxuICogTXVzdCBlbmNvZGUgYHZhbGAgaW50byBwbGFpbiBKU09OIGRhdGEgKmNhbm9uaWNhbGx5Kiwgc3VjaCB0aGF0XG4gKiBgSlNPTi5zdHJpbmdpZnkoZW5jb2RlKHYxKSkgPT09IEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpYC4gRm9yIG1vc3RcbiAqIGVuY29kaW5ncywgdGhlIG9yZGVyIG9mIHByb3BlcnRpZXMgb2YgZWFjaCBub2RlIG9mIHRoZSBvdXRwdXRcbiAqIHN0cnVjdHVyZSBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBhbGdvcml0aG0gYmVsb3cgd2l0aG91dCBzcGVjaWFsXG4gKiBhcnJhbmdlbWVudCwgdXN1YWxseSBieSBiZWluZyBleHByZXNzZWQgZGlyZWN0bHkgYXMgYW4gb2JqZWN0IGxpdGVyYWwuXG4gKiBUaGUgZXhjZXB0aW9uIGlzIGNvcHlSZWNvcmRzLCB3aG9zZSBuYXR1cmFsIGVudW1lcmF0aW9uIG9yZGVyXG4gKiBjYW4gZGlmZmVyIGJldHdlZW4gY29weVJlY29yZHMgdGhhdCBvdXIgZGlzdHJpYnV0ZWQgb2JqZWN0IHNlbWFudGljc1xuICogY29uc2lkZXJzIHRvIGJlIGVxdWl2YWxlbnQuXG4gKiBTaW5jZSwgZm9yIGVhY2ggY29weVJlY29yZCwgd2Ugb25seSBhY2NlcHQgc3RyaW5nIHByb3BlcnR5IG5hbWVzLFxuICogbm90IHN5bWJvbHMsIHdlIGNhbiBjYW5vbmljYWxseSBzb3J0IHRoZSBuYW1lcyBmaXJzdC5cbiAqIEpTT04uc3RyaW5naWZ5IHdpbGwgdGhlbiB2aXNpdCB0aGVzZSBpbiB0aGF0IHNvcnRlZCBvcmRlci5cbiAqXG4gKiBFbmNvZGluZyB3aXRoIGEgY2Fub25pY2FsLUpTT04gZW5jb2RlciB3b3VsZCBhbHNvIHNvbHZlIHRoaXMgY2Fub25pY2FsbmVzc1xuICogcHJvYmxlbSBpbiBhIG1vcmUgbW9kdWxhciBhbmQgZW5jYXBzdWxhdGVkIG1hbm5lci4gTm90ZSB0aGF0IHRoZVxuICogYWN0dWFsIG9yZGVyIHByb2R1Y2VkIGhlcmUsIHRob3VnaCBpdCBhZ3JlZXMgd2l0aCBjYW5vbmljYWwtSlNPTiBvblxuICogY29weVJlY29yZCBwcm9wZXJ0eSBvcmRlcmluZywgZGlmZmVycyBmcm9tIGNhbm9uaWNhbC1KU09OIGFzIGEgd2hvbGVcbiAqIGluIHRoYXQgdGhlIG90aGVyIHJlY29yZCBwcm9wZXJ0aWVzIGFyZSB2aXNpdGVkIGluIHRoZSBvcmRlciBpbiB3aGljaFxuICogdGhleSBhcmUgbGl0ZXJhbGx5IHdyaXR0ZW4gYmVsb3cuIFRPRE8gcGVyaGFwcyB3ZSBzaG91bGQgaW5kZWVkIHN3aXRjaFxuICogdG8gYSBjYW5vbmljYWwgSlNPTiBlbmNvZGVyLCBhbmQgbm90IGRlbGljYXRlbHkgZGVwZW5kIG9uIHRoZSBvcmRlclxuICogaW4gd2hpY2ggdGhlc2Ugb2JqZWN0IGxpdGVyYWxzIGFyZSB3cml0dGVuLlxuICpcbiAqIFJlYWRlcnMgbXVzdCBub3QgY2FyZSBhYm91dCB0aGlzIG9yZGVyIGFueXdheS4gV2UgaW1wb3NlIHRoaXMgcmVxdWlyZW1lbnRcbiAqIG1haW5seSB0byByZWR1Y2Ugbm9uLWRldGVybWluaXNtIGV4cG9zZWQgb3V0c2lkZSBhIHZhdC5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBwYXNzYWJsZVxuICogQHJldHVybnMge1NtYWxsY2Fwc0VuY29kaW5nfSBleGNlcHQgdGhhdCBgZW5jb2RlVG9TbWFsbGNhcHNgIGRvZXMgbm90IGdlbmVyYWxseVxuICogYGhhcmRlbmAgdGhpcyByZXN1bHQgYmVmb3JlIHJldHVybmluZy4gUmF0aGVyLCBgZW5jb2RlVG9TbWFsbGNhcHNgIGlzIG5vdFxuICogZGlyZWN0bHkgZXhwb3NlZC5cbiAqIFdoYXQncyBleHBvc2VkIGluc3RlYWQgaXMgYSB3cmFwcGVyIHRoYXQgZnJlZXplcyB0aGUgb3V0cHV0IGJlZm9yZVxuICogcmV0dXJuaW5nLiBJZiB0aGlzIHR1cm5zIG91dCB0byBpbXBlZGUgc3RhdGljIGFuYWx5c2lzIGZvciBgaGFyZGVuYCBzYWZldHksXG4gKiB3ZSBjYW4gYWx3YXlzIHB1dCB0aGUgKG5vdyByZWR1bmRhbnQpIGhhcmRlbnMgYmFjayBpbi4gVGhleSBkb24ndCBodXJ0LlxuICovXG5jb25zdCBlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyPShwYXNzYWJsZSk9Pntcbi8qIEZpcnN0IHdlIGhhbmRsZSBhbGwgcHJpbWl0aXZlcy4gU29tZSBjYW4gYmUgcmVwcmVzZW50ZWQgZGlyZWN0bHkgYXMqL1xuLyogSlNPTiwgYW5kIHNvbWUgbXVzdCBiZSBlbmNvZGVkIGludG8gc21hbGxjYXBzIHN0cmluZ3MuKi9cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihwYXNzYWJsZSk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnbnVsbCc6XG5jYXNlJ2Jvb2xlYW4nOntcbi8qIHBhc3MgdGhyb3VnaCB0byBKU09OKi9cbnJldHVybiBwYXNzYWJsZTtcbiB9XG5jYXNlJ3N0cmluZyc6e1xuaWYoc3RhcnRzU3BlY2lhbChwYXNzYWJsZSkpe1xuLyogU3RyaW5ncyB0aGF0IHN0YXJ0IHdpdGggYSBzcGVjaWFsIGNoYXIgYXJlIHF1b3RlZCB3aXRoIGAhYC4qL1xuLyogU2luY2UgYCFgIGlzIGl0c2VsZiBhIHNwZWNpYWwgY2hhcmFjdGVyLCB0aGlzIHRyaXZpYWxseSBkb2VzKi9cbi8qIHRoZSBIaWxiZXJ0IGhvdGVsLiBBbHNvLCBzaW5jZSB0aGUgc3BlY2lhbCBjaGFyYWN0ZXJzIGFyZSovXG4vKiBhIGNvbnRpbnVvdXMgc3VicmFuZ2Ugb2YgYXNjaWksIHRoaXMgcXVvdGluZyBpcyBzb3J0LW9yZGVyKi9cbi8qIHByZXNlcnZpbmcuKi9cbnJldHVybiBgISR7cGFzc2FibGV9YDtcbiB9XG4vKiBBbGwgb3RoZXIgc3RyaW5ncyBwYXNzIHRocm91Z2ggdG8gSlNPTiovXG5yZXR1cm4gcGFzc2FibGU7XG4gfVxuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybicjdW5kZWZpbmVkJztcbiB9XG5jYXNlJ251bWJlcic6e1xuLyogU3BlY2lhbC1jYXNlIG51bWJlcnMgd2l0aCBubyBkaWdpdC1iYXNlZCByZXByZXNlbnRhdGlvbi4qL1xuaWYoTnVtYmVyLmlzTmFOKHBhc3NhYmxlKSl7XG5yZXR1cm4nI05hTic7XG4gfWVsc2UgaWYocGFzc2FibGU9PT1JbmZpbml0eSl7XG5yZXR1cm4nI0luZmluaXR5JztcbiB9ZWxzZSBpZihwYXNzYWJsZT09PS1JbmZpbml0eSl7XG5yZXR1cm4nIy1JbmZpbml0eSc7XG4gfVxuLyogUGFzcyB0aHJvdWdoIGV2ZXJ5dGhpbmcgZWxzZSwgcmVwbGFjaW5nIC0wIHdpdGggMC4qL1xucmV0dXJuIGlzKHBhc3NhYmxlLC0wKT8wOnBhc3NhYmxlO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdCBzdHI9U3RyaW5nKHBhc3NhYmxlKTtcbnJldHVybiAoLyoqIEB0eXBlIHtiaWdpbnR9ICovcGFzc2FibGU8MG4/c3RyOmArJHtzdHJ9YCk7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmFzc2VydFBhc3NhYmxlU3ltYm9sKHBhc3NhYmxlKTtcbmNvbnN0IG5hbWU9LyoqIEB0eXBlIHtzdHJpbmd9ICovbmFtZUZvclBhc3NhYmxlU3ltYm9sKHBhc3NhYmxlKTtcbnJldHVybiBgJSR7bmFtZX1gO1xuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuLyogQ3VycmVudGx5IGNvcHlSZWNvcmQgYWxsb3dzIG9ubHkgc3RyaW5nIGtleXMgc28gdGhpcyB3aWxsKi9cbi8qIHdvcmsuIElmIHdlIGFsbG93IHNvcnRhYmxlIHN5bWJvbCBrZXlzLCB0aGlzIHdpbGwgbmVlZCB0byovXG4vKiBiZWNvbWUgbW9yZSBpbnRlcmVzdGluZy4qL1xuY29uc3QgbmFtZXM9b3duS2V5cyhwYXNzYWJsZSkuc29ydCgpO1xucmV0dXJuIGZyb21FbnRyaWVzKFxubmFtZXMubWFwKChuYW1lKT0+W1xuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihuYW1lKSxcbmVuY29kZVRvU21hbGxjYXBzUmVjdXIocGFzc2FibGVbbmFtZV0pXSkpO1xuXG5cbiB9XG5jYXNlJ2NvcHlBcnJheSc6e1xucmV0dXJuIHBhc3NhYmxlLm1hcChlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJue1xuJyN0YWcnOmVuY29kZVRvU21hbGxjYXBzUmVjdXIoZ2V0VGFnKHBhc3NhYmxlKSksXG5wYXlsb2FkOmVuY29kZVRvU21hbGxjYXBzUmVjdXIocGFzc2FibGUucGF5bG9hZCl9O1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVSZW1vdGFibGVUb1NtYWxsY2FwcyhcbnBhc3NhYmxlLFxuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cik7XG5cbmlmKHR5cGVvZiByZXN1bHQ9PT0nc3RyaW5nJyYmcmVzdWx0LnN0YXJ0c1dpdGgoJyQnKSl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbi8qIGB0aHJvd2AgaXMgbm9vcCBzaW5jZSBgRmFpbGAgdGhyb3dzLiBCdXQgbGludGVyIGNvbmZ1c2VkKi9cbnRocm93IEZhaWwgYGludGVybmFsOiBSZW1vdGFibGUgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiJFwiOiAke3Jlc3VsdH1gO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVByb21pc2VUb1NtYWxsY2FwcyhcbnBhc3NhYmxlLFxuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cik7XG5cbmlmKHR5cGVvZiByZXN1bHQ9PT0nc3RyaW5nJyYmcmVzdWx0LnN0YXJ0c1dpdGgoJyYnKSl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBQcm9taXNlIGVuY29kaW5nIG11c3Qgc3RhcnQgd2l0aCBcIiZcIjogJHtyZXN1bHR9YDtcbiB9XG5jYXNlJ2Vycm9yJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlRXJyb3JUb1NtYWxsY2FwcyhwYXNzYWJsZSxlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcbmFzc2VydEVuY29kZWRFcnJvcihyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5kZWZhdWx0OntcbmFzc2VydC5mYWlsKFxuWCBgaW50ZXJuYWw6IFVucmVjb2duaXplZCBwYXNzU3R5bGUgJHtxKHBhc3NTdHlsZSl9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfTtcbmNvbnN0IGVuY29kZVRvU21hbGxjYXBzPShwYXNzYWJsZSk9PntcbmlmKGlzRXJyb3JMaWtlKHBhc3NhYmxlKSl7XG4vKiBXZSBwdWxsIG91dCB0aGlzIHNwZWNpYWwgY2FzZSB0byBhY2NvbW1vZGF0ZSBlcnJvcnMgdGhhdCBhcmUgbm90Ki9cbi8qIHZhbGlkIFBhc3NhYmxlcy4gRm9yIGV4YW1wbGUsIGJlY2F1c2UgdGhleSdyZSBub3QgZnJvemVuLiovXG4vKiBUaGUgc3BlY2lhbCBjYXNlIGNhbiBvbmx5IGV2ZXIgYXBwbHkgYXQgdGhlIHJvb3QsIGFuZCB0aGVyZWZvcmUqL1xuLyogb3V0c2lkZSB0aGUgcmVjdXJzaW9uLCBzaW5jZSBhbiBlcnJvciBjb3VsZCBvbmx5IGJlIGRlZXBlciBpbiovXG4vKiBhIHBhc3NhYmxlIHN0cnVjdHVyZSBpZiBpdCB3ZXJlIHBhc3NhYmxlLiovXG4vKiovXG4vKiBXZSBwdWxsIG91dCB0aGlzIHNwZWNpYWwgY2FzZSBiZWNhdXNlLCBmb3IgdGhlc2UgZXJyb3JzLCB3ZSdyZSBtdWNoKi9cbi8qIG1vcmUgaW50ZXJlc3RlZCBpbiByZXBvcnRpbmcgd2hhdGV2ZXIgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiB0aGV5Ki9cbi8qIGNhcnJ5IHRoYW4gd2UgYXJlIGFib3V0IHJlcG9ydGluZyBwcm9ibGVtcyBlbmNvdW50ZXJlZCBpbiByZXBvcnRpbmcqL1xuLyogdGhpcyBpbmZvcm1hdGlvbi4qL1xuY29uc3QgcmVzdWx0PWhhcmRlbihcbmVuY29kZUVycm9yVG9TbWFsbGNhcHMocGFzc2FibGUsZW5jb2RlVG9TbWFsbGNhcHNSZWN1cikpO1xuXG5hc3NlcnRFbmNvZGVkRXJyb3IocmVzdWx0KTtcbnJldHVybiByZXN1bHQ7XG4gfVxucmV0dXJuIGhhcmRlbihlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKHBhc3NhYmxlKSk7XG4gfTtcbnJldHVybiBoYXJkZW4oZW5jb2RlVG9TbWFsbGNhcHMpO1xuIH07JGjigI1fb25jZS5tYWtlRW5jb2RlVG9TbWFsbGNhcHMobWFrZUVuY29kZVRvU21hbGxjYXBzKTtcbmhhcmRlbihtYWtlRW5jb2RlVG9TbWFsbGNhcHMpO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IERlY29kZUZyb21TbWFsbGNhcHNPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFJlbW90YWJsZTogU21hbGxjYXBzRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZSA6U21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IFJlbW90YWJsZX0gW2RlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHNdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFByb21pc2U6IFNtYWxsY2Fwc0VuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGUgOlNtYWxsY2Fwc0VuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBQcm9taXNlfSBbZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHNdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZEVycm9yOiBTbWFsbGNhcHNFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlIDpTbWFsbGNhcHNFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gRXJyb3J9IFtkZWNvZGVFcnJvckZyb21TbWFsbGNhcHNdXG4gKi9cblxuY29uc3QgZG9udERlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9KGVuY29kaW5nKT0+XG5GYWlsIGByZW1vdGFibGUgdW5leHBlY3RlZDogJHtlbmNvZGluZ31gO1xuY29uc3QgZG9udERlY29kZVByb21pc2VGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PlxuRmFpbCBgcHJvbWlzZSB1bmV4cGVjdGVkOiAke2VuY29kaW5nfWA7XG5jb25zdCBkb250RGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzPShlbmNvZGluZyk9PlxuRmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtxKGVuY29kaW5nKX1gO1xuXG4vKipcbiAqIEBwYXJhbSB7RGVjb2RlRnJvbVNtYWxsY2Fwc09wdGlvbnN9IFtkZWNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhlbmNvZGVkOiBTbWFsbGNhcHNFbmNvZGluZykgPT4gUGFzc2FibGV9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRGVjb2RlRnJvbVNtYWxsY2Fwcz0oZGVjb2RlT3B0aW9ucz17fSk9PntcbmNvbnN0e1xuZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwcz1kb250RGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2FwcyxcbmRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzPWRvbnREZWNvZGVQcm9taXNlRnJvbVNtYWxsY2FwcyxcbmRlY29kZUVycm9yRnJvbVNtYWxsY2Fwcz1kb250RGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzfT1cbmRlY29kZU9wdGlvbnM7XG5cbi8qKlxuICogYGRlY29kZUZyb21TbWFsbGNhcHNgIG1heSByZWx5IG9uIGBlbmNvZGluZ2AgYmVpbmcgdGhlIHJlc3VsdCBvZiBhXG4gKiBwbGFpbiBjYWxsIHRvIEpTT04ucGFyc2UuIEhvd2V2ZXIsIGl0ICpjYW5ub3QqIHJlbHkgb24gYGVuY29kaW5nYFxuICogaGF2aW5nIGJlZW4gcHJvZHVjZWQgYnkgSlNPTi5zdHJpbmdpZnkgb24gdGhlIG91dHB1dCBvZiBgZW5jb2RlVG9TbWFsbGNhcHNgXG4gKiBhYm92ZSwgaS5lLiwgYGRlY29kZUZyb21TbWFsbGNhcHNgIGNhbm5vdCByZWx5IG9uIGBlbmNvZGluZ2AgYmVpbmcgYVxuICogdmFsaWQgbWFyc2hhbGxlZCByZXByZXNlbnRhdGlvbi4gUmF0aGVyLCBgZGVjb2RlRnJvbVNtYWxsY2Fwc2AgbXVzdFxuICogdmFsaWRhdGUgdGhhdC5cbiAqXG4gKiBAcGFyYW0ge1NtYWxsY2Fwc0VuY29kaW5nfSBlbmNvZGluZyBtdXN0IGJlIGhhcmRlbmVkXG4gKi9cbmNvbnN0IGRlY29kZUZyb21TbWFsbGNhcHM9KGVuY29kaW5nKT0+e1xuc3dpdGNoKHR5cGVvZiBlbmNvZGluZyl7XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdudW1iZXInOntcbnJldHVybiBlbmNvZGluZztcbiB9XG5jYXNlJ3N0cmluZyc6e1xuaWYoIXN0YXJ0c1NwZWNpYWwoZW5jb2RpbmcpKXtcbnJldHVybiBlbmNvZGluZztcbiB9XG5jb25zdCBjPWVuY29kaW5nLmNoYXJBdCgwKTtcbnN3aXRjaChjKXtcbmNhc2UnISc6e1xuLyogdW4taGlsYmVydC1pZnkgdGhlIHN0cmluZyovXG5yZXR1cm4gZW5jb2Rpbmcuc2xpY2UoMSk7XG4gfVxuY2FzZSclJzp7XG5yZXR1cm4gcGFzc2FibGVTeW1ib2xGb3JOYW1lKGVuY29kaW5nLnNsaWNlKDEpKTtcbiB9XG5jYXNlJyMnOntcbnN3aXRjaChlbmNvZGluZyl7XG5jYXNlJyN1bmRlZmluZWQnOntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY2FzZScjTmFOJzp7XG5yZXR1cm4gTmFOO1xuIH1cbmNhc2UnI0luZmluaXR5Jzp7XG5yZXR1cm4gSW5maW5pdHk7XG4gfVxuY2FzZScjLUluZmluaXR5Jzp7XG5yZXR1cm4tSW5maW5pdHk7XG4gfVxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGB1bmtub3duIGNvbnN0YW50IFwiJHtxKGVuY29kaW5nKX1cImAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfVxuY2FzZScrJzpcbmNhc2UnLSc6e1xucmV0dXJuIEJpZ0ludChlbmNvZGluZyk7XG4gfVxuY2FzZSckJzp7XG5jb25zdCByZXN1bHQ9ZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2FwcyhcbmVuY29kaW5nLFxuZGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG5cbmlmKHBhc3NTdHlsZU9mKHJlc3VsdCkhPT0ncmVtb3RhYmxlJyl7XG5GYWlsIGBpbnRlcm5hbDogZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2FwcyBvcHRpb24gbXVzdCByZXR1cm4gYSByZW1vdGFibGU6ICR7cmVzdWx0fWA7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9XG5jYXNlJyYnOntcbmNvbnN0IHJlc3VsdD1kZWNvZGVQcm9taXNlRnJvbVNtYWxsY2FwcyhcbmVuY29kaW5nLFxuZGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG5cbmlmKHBhc3NTdHlsZU9mKHJlc3VsdCkhPT0ncHJvbWlzZScpe1xuRmFpbCBgaW50ZXJuYWw6IGRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzIG9wdGlvbiBtdXN0IHJldHVybiBhIHByb21pc2U6ICR7cmVzdWx0fWA7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYFNwZWNpYWwgY2hhciAke3EoXG5jKVxuIH0gcmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2U6ICR7ZW5jb2Rpbmd9YDtcbiB9fVxuXG4gfVxuY2FzZSdvYmplY3QnOntcbmlmKGVuY29kaW5nPT09bnVsbCl7XG5yZXR1cm4gZW5jb2Rpbmc7XG4gfVxuXG5pZihpc0FycmF5KGVuY29kaW5nKSl7XG5yZXR1cm4gZW5jb2RpbmcubWFwKCh2YWwpPT5kZWNvZGVGcm9tU21hbGxjYXBzKHZhbCkpO1xuIH1cblxuaWYoaGFzT3duUHJvcGVydHlPZihlbmNvZGluZywnI3RhZycpKXtcbmNvbnN0eycjdGFnJzp0YWcscGF5bG9hZCwuLi5yZXN0fT1lbmNvZGluZztcbnR5cGVvZiB0YWc9PT0nc3RyaW5nJ3x8XG5GYWlsIGBWYWx1ZSBvZiBcIiN0YWdcIiwgdGhlIHRhZywgbXVzdCBiZSBhIHN0cmluZzogJHtlbmNvZGluZ31gO1xub3duS2V5cyhyZXN0KS5sZW5ndGg9PT0wfHxcbkZhaWwgYCN0YWcgcmVjb3JkIHVuZXhwZWN0ZWQgcHJvcGVydGllczogJHtxKG93bktleXMocmVzdCkpfWA7XG5yZXR1cm4gbWFrZVRhZ2dlZChcbmRlY29kZUZyb21TbWFsbGNhcHModGFnKSxcbmRlY29kZUZyb21TbWFsbGNhcHMocGF5bG9hZCkpO1xuXG4gfVxuXG5pZihoYXNPd25Qcm9wZXJ0eU9mKGVuY29kaW5nLCcjZXJyb3InKSl7XG5jb25zdCByZXN1bHQ9ZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzKFxuZW5jb2RpbmcsXG5kZWNvZGVGcm9tU21hbGxjYXBzKTtcblxucGFzc1N0eWxlT2YocmVzdWx0KT09PSdlcnJvcid8fFxuRmFpbCBgaW50ZXJuYWw6IGRlY29kZUVycm9yRnJvbVNtYWxsY2FwcyBvcHRpb24gbXVzdCByZXR1cm4gYW4gZXJyb3I6ICR7cmVzdWx0fWA7XG5yZXR1cm4gcmVzdWx0O1xuIH1cblxuY29uc3QgZGVjb2RlRW50cnk9KFtlbmNvZGVkTmFtZSxlbmNvZGVkVmFsXSk9PntcbnR5cGVvZiBlbmNvZGVkTmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYFByb3BlcnR5IG5hbWUgJHtxKFxuZW5jb2RlZE5hbWUpXG4gfSBvZiAke2VuY29kaW5nfSBtdXN0IGJlIGEgc3RyaW5nYDtcbiFlbmNvZGVkTmFtZS5zdGFydHNXaXRoKCcjJyl8fFxuRmFpbCBgVW5yZWNvZ25pemVkIHJlY29yZCB0eXBlICR7cShlbmNvZGVkTmFtZSl9OiAke2VuY29kaW5nfWA7XG5jb25zdCBuYW1lPWRlY29kZUZyb21TbWFsbGNhcHMoZW5jb2RlZE5hbWUpO1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBEZWNvZGVkIHByb3BlcnR5IG5hbWUgJHtuYW1lfSBmcm9tICR7ZW5jb2Rpbmd9IG11c3QgYmUgYSBzdHJpbmdgO1xucmV0dXJuW25hbWUsZGVjb2RlRnJvbVNtYWxsY2FwcyhlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoZW5jb2RpbmcpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbmRlZmF1bHQ6e1xuYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogdW5yZWNvZ25pemVkIEpTT04gdHlwZW9mICR7cShcbnR5cGVvZiBlbmNvZGluZylcbiB9OiAke2VuY29kaW5nfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5yZXR1cm4gaGFyZGVuKGRlY29kZUZyb21TbWFsbGNhcHMpO1xuIH07JGjigI1fb25jZS5tYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyhtYWtlRGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZUVuY29kZVRvU21hbGxjYXBzIjpbIm1ha2VFbmNvZGVUb1NtYWxsY2FwcyJdLCJtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyI6WyJtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAIQpL9rCoAAKwqAAAqAAAAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL21hcnNoYWwtanVzdGluLmpzeyJpbXBvcnRzIjpbIi4vZW5jb2RlVG9DYXBEYXRhLmpzIiwiQGVuZG8vbmF0IiwiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbImRlY29kZVRvSnVzdGluIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IE5hdCxnZXRFcnJvckNvbnN0cnVjdG9yLGlzT2JqZWN0LHBhc3NhYmxlU3ltYm9sRm9yTmFtZSxRQ0xBU1M7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRo4oCNX2EgPT4gKE5hdCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJnZXRFcnJvckNvbnN0cnVjdG9yXCIsIFskaOKAjV9hID0+IChnZXRFcnJvckNvbnN0cnVjdG9yID0gJGjigI1fYSldXSxbXCJpc09iamVjdFwiLCBbJGjigI1fYSA9PiAoaXNPYmplY3QgPSAkaOKAjV9hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjigI1fYSA9PiAocGFzc2FibGVTeW1ib2xGb3JOYW1lID0gJGjigI1fYSldXV1dLFtcIi4vZW5jb2RlVG9DYXBEYXRhLmpzXCIsIFtbXCJRQ0xBU1NcIiwgWyRo4oCNX2EgPT4gKFFDTEFTUyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRW5jb2Rpbmd9IEVuY29kaW5nICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5DYXBEYXRhPFQ+fSBDYXBEYXRhICovXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e3N0cmluZ2lmeTpxdW90ZX09SlNPTjtcbmNvbnN0e3F1b3RlOnEsZGV0YWlsczpYLEZhaWx9PWFzc2VydDtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJbmRlbnRlclxuICogQHByb3BlcnR5IHsob3BlbkJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBvcGVuXG4gKiBAcHJvcGVydHkgeygpID0+IG51bWJlcn0gbGluZVxuICogQHByb3BlcnR5IHsodG9rZW46IHN0cmluZykgPT4gbnVtYmVyfSBuZXh0XG4gKiBAcHJvcGVydHkgeyhjbG9zZUJyYWNrZXQ6IHN0cmluZykgPT4gbnVtYmVyfSBjbG9zZVxuICogQHByb3BlcnR5IHsoKSA9PiBzdHJpbmd9IGRvbmVcbiAqL1xuXG4vKipcbiAqIEdlbmVyb3VzIHdoaXRlc3BhY2UgZm9yIHJlYWRhYmlsaXR5XG4gKlxuICogQHJldHVybnMge0luZGVudGVyfVxuICovXG5jb25zdCBtYWtlWWVzSW5kZW50ZXI9KCk9PntcbmNvbnN0IHN0cmluZ3M9W107XG5sZXQgbGV2ZWw9MDtcbmxldCBuZWVkU3BhY2U9ZmFsc2U7XG5jb25zdCBsaW5lPSgpPT57XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKCdcXG4nLCcgICcucmVwZWF0KGxldmVsKSk7XG4gfTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT57XG5sZXZlbCs9MTtcbmlmKG5lZWRTcGFjZSl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9ZmFsc2U7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKG9wZW5CcmFja2V0KTtcbiB9LFxubGluZSxcbm5leHQ6KHRva2VuKT0+e1xuaWYobmVlZFNwYWNlJiZ0b2tlbiE9PScsJyl7XG5zdHJpbmdzLnB1c2goJyAnKTtcbiB9XG5uZWVkU3BhY2U9dHJ1ZTtcbnJldHVybiBzdHJpbmdzLnB1c2godG9rZW4pO1xuIH0sXG5jbG9zZTooY2xvc2VCcmFja2V0KT0+e1xuYXNzZXJ0KGxldmVsPj0xKTtcbmxldmVsLT0xO1xubGluZSgpO1xucmV0dXJuIHN0cmluZ3MucHVzaChjbG9zZUJyYWNrZXQpO1xuIH0sXG5kb25lOigpPT57XG5hc3NlcnQuZXF1YWwobGV2ZWwsMCk7XG5yZXR1cm4gc3RyaW5ncy5qb2luKCcnKTtcbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIElmIHRoZSBsYXN0IGNoYXJhY3RlciBvZiBvbmUgdG9rZW4gdG9nZXRoZXIgd2l0aCB0aGUgZmlyc3QgY2hhcmFjdGVyXG4gKiBvZiB0aGUgbmV4dCB0b2tlbiBtYXRjaGVzIHRoaXMgcGF0dGVybiwgdGhlbiB0aGUgdHdvIHRva2VucyBtdXN0IGJlXG4gKiBzZXBhcmF0ZWQgYnkgd2hpdGVzcGFjZSB0byBwcmVzZXJ2ZSB0aGVpciBtZWFuaW5nLiBPdGhlcndpc2UgdGhlXG4gKiB3aGl0ZXNwYWNlIGluIHVubmVjZXNzYXJ5LlxuICpcbiAqIFRoZSBgPCFgIGFuZCBgLT5gIGNhc2VzIHByZXZlbnQgdGhlIGFjY2lkZW50YWwgZm9ybWF0aW9uIG9mIGFuXG4gKiBodG1sLWxpa2UgY29tbWVudC4gSSBkb24ndCB0aGluayB0aGUgZG91YmxlIGFuZ2xlIGJyYWNrZXRzIGFyZSBhY3R1YWxseVxuICogbmVlZGVkIGJ1dCBJIGhhdmVuJ3QgdGhvdWdodCBhYm91dCBpdCBlbm91Z2ggdG8gcmVtb3ZlIHRoZW0uXG4gKi9cbmNvbnN0IGJhZFBhaXJQYXR0ZXJuPS9eKD86XFx3XFx3fDw8fD4+fFxcK1xcK3wtLXw8IXwtPikkLztcblxuLyoqXG4gKiBNaW5pbXVtIHdoaXRlc3BhY2UgbmVlZGVkIHRvIHByZXNldmUgbWVhbmluZy5cbiAqXG4gKiBAcmV0dXJucyB7SW5kZW50ZXJ9XG4gKi9cbmNvbnN0IG1ha2VOb0luZGVudGVyPSgpPT57XG4vKiogQHR5cGUge3N0cmluZ1tdfSAqL1xuY29uc3Qgc3RyaW5ncz1bXTtcbnJldHVybiBoYXJkZW4oe1xub3Blbjoob3BlbkJyYWNrZXQpPT5zdHJpbmdzLnB1c2gob3BlbkJyYWNrZXQpLFxubGluZTooKT0+c3RyaW5ncy5sZW5ndGgsXG5uZXh0Oih0b2tlbik9PntcbmlmKHN0cmluZ3MubGVuZ3RoPj0xKXtcbmNvbnN0IGxhc3Q9c3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXTtcbmlmKGxhc3QubGVuZ3RoPj0xJiZ0b2tlbi5sZW5ndGg+PTEpe1xuY29uc3QgcGFpcj0gYCR7bGFzdFtsYXN0Lmxlbmd0aC0xXX0ke3Rva2VuWzBdfWA7XG5pZihiYWRQYWlyUGF0dGVybi50ZXN0KHBhaXIpKXtcbnN0cmluZ3MucHVzaCgnICcpO1xuIH1cbiB9XG4gfVxucmV0dXJuIHN0cmluZ3MucHVzaCh0b2tlbik7XG4gfSxcbmNsb3NlOihjbG9zZUJyYWNrZXQpPT57XG5pZihzdHJpbmdzLmxlbmd0aD49MSYmc3RyaW5nc1tzdHJpbmdzLmxlbmd0aC0xXT09PScsJyl7XG5zdHJpbmdzLnBvcCgpO1xuIH1cbnJldHVybiBzdHJpbmdzLnB1c2goY2xvc2VCcmFja2V0KTtcbiB9LFxuZG9uZTooKT0+c3RyaW5ncy5qb2luKCcnKX0pO1xuXG4gfTtcblxuY29uc3QgaWRlbnRQYXR0ZXJuPS9eW2EtekEtWl1cXHcqJC87XG5oYXJkZW4oaWRlbnRQYXR0ZXJuKTtcbmNvbnN0IEF0QXRQcmVmaXhQYXR0ZXJuPS9eQEAoLiopJC87XG5oYXJkZW4oQXRBdFByZWZpeFBhdHRlcm4pO1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGVuY29kaW5nXG4gKiBAcGFyYW0ge2Jvb2xlYW49fSBzaG91bGRJbmRlbnRcbiAqIEBwYXJhbSB7YW55W119IFtzbG90c11cbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGRlY29kZVRvSnVzdGluPShlbmNvZGluZyxzaG91bGRJbmRlbnQ9ZmFsc2Usc2xvdHM9W10pPT57XG4vKipcbiAqIFRoZSBmaXJzdCBwYXNzIGRvZXMgc29tZSBpbnB1dCB2YWxpZGF0aW9uLlxuICogSXRzIGNvbnRyb2wgZmxvdyBzaG91bGQgbWlycm9yIGByZWN1cmAgYXMgY2xvc2VseSBhcyBwb3NzaWJsZVxuICogYW5kIHRoZSB0d28gc2hvdWxkIGJlIG1haW50YWluZWQgdG9nZXRoZXIuIFRoZXkgbXVzdCB2aXNpdCBldmVyeXRoaW5nXG4gKiBpbiB0aGUgc2FtZSBvcmRlci5cbiAqXG4gKiBUT0RPIG5vdyB0aGF0IGliaWRzIGFyZSBnb25lLCB3ZSBzaG91bGQgZm9sZCB0aGlzIGJhY2sgdG9nZXRoZXIgaW50b1xuICogb25lIHZhbGlkYXRpbmcgcGFzcy5cbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgcHJlcGFyZT0ocmF3VHJlZSk9PntcbmlmKCFpc09iamVjdChyYXdUcmVlKSl7XG5yZXR1cm47XG4gfVxuLyogQXNzZXJ0aW9ucyBvZiB0aGUgYWJvdmUgdG8gbmFycm93IHRoZSB0eXBlLiovXG5hc3NlcnQudHlwZW9mKHJhd1RyZWUsJ29iamVjdCcpO1xuYXNzZXJ0KHJhd1RyZWUhPT1udWxsKTtcbmlmKFFDTEFTUyBpbiByYXdUcmVlKXtcbmNvbnN0IHFjbGFzcz1yYXdUcmVlW1FDTEFTU107XG50eXBlb2YgcWNsYXNzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBxY2xhc3MgdHlwZW9mICR7cSh0eXBlb2YgcWNsYXNzKX1gO1xuYXNzZXJ0KCFpc0FycmF5KHJhd1RyZWUpKTtcbnN3aXRjaChyYXdUcmVlWydAcWNsYXNzJ10pe1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdOYU4nOlxuY2FzZSdJbmZpbml0eSc6XG5jYXNlJy1JbmZpbml0eSc6e1xucmV0dXJuO1xuIH1cbmNhc2UnYmlnaW50Jzp7XG5jb25zdHtkaWdpdHN9PXJhd1RyZWU7XG50eXBlb2YgZGlnaXRzPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBkaWdpdHMgdHlwZW9mICR7cSh0eXBlb2YgZGlnaXRzKX1gO1xucmV0dXJuO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG5yZXR1cm47XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuY29uc3Qgc3ltPXBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbmFzc2VydC50eXBlb2Yoc3ltLCdzeW1ib2wnKTtcbnJldHVybjtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKHRhZywnc3RyaW5nJyk7XG5wcmVwYXJlKHBheWxvYWQpO1xucmV0dXJuO1xuIH1cbmNhc2Unc2xvdCc6e1xuY29uc3R7aW5kZXgsaWZhY2V9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKGluZGV4LCdudW1iZXInKTtcbk5hdChpbmRleCk7XG5pZihpZmFjZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKGlmYWNlLCdzdHJpbmcnKTtcbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdoaWxiZXJ0Jzp7XG5jb25zdHtvcmlnaW5hbCxyZXN0fT1yYXdUcmVlO1xuJ29yaWdpbmFsJ2luIHJhd1RyZWV8fFxuRmFpbCBgSW52YWxpZCBIaWxiZXJ0IEhvdGVsIGVuY29kaW5nICR7cmF3VHJlZX1gO1xucHJlcGFyZShvcmlnaW5hbCk7XG5pZigncmVzdCdpbiByYXdUcmVlKXtcbmlmKHR5cGVvZiByZXN0IT09J29iamVjdCcpe1xudGhyb3cgRmFpbCBgUmVzdCAke3Jlc3R9IGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0YDtcbiB9XG5pZihyZXN0PT09bnVsbCl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgbnVsbGA7XG4gfVxuaWYoaXNBcnJheShyZXN0KSl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBub3QgYmUgYW4gYXJyYXlgO1xuIH1cbmlmKFFDTEFTUyBpbiByZXN0KXtcbnRocm93IEZhaWwgYFJlc3QgZW5jb2RpbmcgJHtyZXN0fSBtdXN0IG5vdCBjb250YWluICR7cShRQ0xBU1MpfWA7XG4gfVxuY29uc3QgbmFtZXM9b3duS2V5cyhyZXN0KTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbnR5cGVvZiBuYW1lPT09J3N0cmluZyd8fFxuRmFpbCBgUHJvcGVydHkgbmFtZSAke25hbWV9IG9mICR7cmF3VHJlZX0gbXVzdCBiZSBhIHN0cmluZ2A7XG5wcmVwYXJlKHJlc3RbbmFtZV0pO1xuIH1cbiB9XG5yZXR1cm47XG4gfVxuY2FzZSdlcnJvcic6e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1yYXdUcmVlO1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkIGVycm9yIG5hbWUgdHlwZW9mICR7cSh0eXBlb2YgbmFtZSl9YDtcbmdldEVycm9yQ29uc3RydWN0b3IobmFtZSkhPT11bmRlZmluZWR8fFxuRmFpbCBgTXVzdCBiZSB0aGUgbmFtZSBvZiBhbiBFcnJvciBjb25zdHJ1Y3RvciAke25hbWV9YDtcbnR5cGVvZiBtZXNzYWdlPT09J3N0cmluZyd8fFxuRmFpbCBgaW52YWxpZCBlcnJvciBtZXNzYWdlIHR5cGVvZiAke3EodHlwZW9mIG1lc3NhZ2UpfWA7XG5yZXR1cm47XG4gfVxuXG5kZWZhdWx0OntcbmFzc2VydC5mYWlsKFggYHVucmVjb2duaXplZCAke3EoUUNMQVNTKX0gJHtxKHFjbGFzcyl9YCxUeXBlRXJyb3IpO1xuIH19XG5cbiB9ZWxzZSBpZihpc0FycmF5KHJhd1RyZWUpKXtcbmNvbnN0e2xlbmd0aH09cmF3VHJlZTtcbmZvcihsZXQgaT0wO2k8bGVuZ3RoO2krPTEpe1xucHJlcGFyZShyYXdUcmVlW2ldKTtcbiB9XG4gfWVsc2V7XG5jb25zdCBuYW1lcz1vd25LZXlzKHJhd1RyZWUpO1xuZm9yKGNvbnN0IG5hbWUgb2YgbmFtZXMpe1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBQcm9wZXJ0eSBuYW1lICR7bmFtZX0gb2YgJHtyYXdUcmVlfSBtdXN0IGJlIGEgc3RyaW5nYDtcbiB9XG5wcmVwYXJlKHJhd1RyZWVbbmFtZV0pO1xuIH1cbiB9XG4gfTtcblxuY29uc3QgbWFrZUluZGVudGVyPXNob3VsZEluZGVudD9tYWtlWWVzSW5kZW50ZXI6bWFrZU5vSW5kZW50ZXI7XG5sZXQgb3V0PW1ha2VJbmRlbnRlcigpO1xuXG4vKipcbiAqIFRoaXMgaXMgdGhlIHNlY29uZCBwYXNzIHJlY3Vyc2lvbiBhZnRlciB0aGUgZmlyc3QgcGFzcyBgcHJlcGFyZWAuXG4gKiBUaGUgZmlyc3QgcGFzcyBkaWQgc29tZSBpbnB1dCB2YWxpZGF0aW9uIHNvXG4gKiBoZXJlIHdlIGNhbiBzYWZlbHkgYXNzdW1lIGV2ZXJ5dGhpbmcgdGhvc2UgdGhpbmdzIGFyZSB2YWxpZGF0ZWQuXG4gKlxuICogQHBhcmFtIHtFbmNvZGluZ30gcmF3VHJlZVxuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgZGVjb2RlPShyYXdUcmVlKT0+e1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbnJldHVybiByZWN1cihyYXdUcmVlKTtcbiB9O1xuXG5jb25zdCBkZWNvZGVQcm9wZXJ0eT0obmFtZSx2YWx1ZSk9Pntcbm91dC5saW5lKCk7XG5pZihuYW1lPT09J19fcHJvdG9fXycpe1xuLyogSmF2YVNjcmlwdCBpbnRlcnByZXRzIGB7X19wcm90b19fOiB4LCAuLi59YCovXG4vKiBhcyBtYWtpbmcgYW4gb2JqZWN0IGluaGVyaXRpbmcgZnJvbSBgeGAsIHdoZXJlYXMqL1xuLyogaW4gSlNPTiBpdCBpcyBzaW1wbHkgYSBwcm9wZXJ0eSBuYW1lLiBQcmVzZXJ2ZSB0aGUqL1xuLyogSlNPTiBtZWFuaW5nLiovXG5vdXQubmV4dCggYFtcIl9fcHJvdG9fX1wiXTpgKTtcbiB9ZWxzZSBpZihpZGVudFBhdHRlcm4udGVzdChuYW1lKSl7XG5vdXQubmV4dCggYCR7bmFtZX06YCk7XG4gfWVsc2V7XG5vdXQubmV4dCggYCR7cXVvdGUobmFtZSl9OmApO1xuIH1cbmRlY29kZSh2YWx1ZSk7XG5vdXQubmV4dCgnLCcpO1xuIH07XG5cbi8qKlxuICogTW9kZWxlZCBhZnRlciBgZnVsbFJldml2ZWAgaW4gbWFyc2hhbC5qc1xuICpcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IHJhd1RyZWVcbiAqIEByZXR1cm5zIHtudW1iZXJ9XG4gKi9cbmNvbnN0IHJlY3VyPShyYXdUcmVlKT0+e1xuaWYoIWlzT2JqZWN0KHJhd1RyZWUpKXtcbi8qIHByaW1pdGl2ZXMgZ2V0IHF1b3RlZCovXG5yZXR1cm4gb3V0Lm5leHQocXVvdGUocmF3VHJlZSkpO1xuIH1cbi8qIEFzc2VydGlvbnMgb2YgdGhlIGFib3ZlIHRvIG5hcnJvdyB0aGUgdHlwZS4qL1xuYXNzZXJ0LnR5cGVvZihyYXdUcmVlLCdvYmplY3QnKTtcbmFzc2VydChyYXdUcmVlIT09bnVsbCk7XG5pZihRQ0xBU1MgaW4gcmF3VHJlZSl7XG5jb25zdCBxY2xhc3M9cmF3VHJlZVtRQ0xBU1NdO1xuYXNzZXJ0LnR5cGVvZihxY2xhc3MsJ3N0cmluZycpO1xuYXNzZXJ0KCFpc0FycmF5KHJhd1RyZWUpKTtcbi8qIFN3aXRjaGluZyBvbiBgZW5jb2RlZFtRQ0xBU1NdYCAob3IgYW55dGhpbmcgbGVzcyBkaXJlY3QsIGxpa2UqL1xuLyogYHFjbGFzc2ApIGRvZXMgbm90IGRpc2NyaW1pbmF0ZSByYXdUcmVlIGluIHR5cGVzY3JpcHRANC4yLjMgYW5kKi9cbi8qIGVhcmxpZXIuKi9cbnN3aXRjaChyYXdUcmVlWydAcWNsYXNzJ10pe1xuLyogRW5jb2Rpbmcgb2YgcHJpbWl0aXZlcyBub3QgaGFuZGxlZCBieSBKU09OKi9cbmNhc2UndW5kZWZpbmVkJzpcbmNhc2UnTmFOJzpcbmNhc2UnSW5maW5pdHknOlxuY2FzZSctSW5maW5pdHknOntcbi8qIFRoZWlyIHFjbGFzcyBpcyB0aGVpciBleHByZXNzaW9uIHNvdXJjZS4qL1xucmV0dXJuIG91dC5uZXh0KHFjbGFzcyk7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0e2RpZ2l0c309cmF3VHJlZTtcbmFzc2VydC50eXBlb2YoZGlnaXRzLCdzdHJpbmcnKTtcbnJldHVybiBvdXQubmV4dCggYCR7QmlnSW50KGRpZ2l0cyl9bmApO1xuIH1cbmNhc2UnQEBhc3luY0l0ZXJhdG9yJzp7XG4vKiBUT0RPIGRlcHJlY2F0ZWQuIEV2ZW50dWFsbHkgcmVtb3ZlLiovXG5yZXR1cm4gb3V0Lm5leHQoJ1N5bWJvbC5hc3luY0l0ZXJhdG9yJyk7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmNvbnN0e25hbWV9PXJhd1RyZWU7XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuY29uc3Qgc3ltPXBhc3NhYmxlU3ltYm9sRm9yTmFtZShuYW1lKTtcbmFzc2VydC50eXBlb2Yoc3ltLCdzeW1ib2wnKTtcbmNvbnN0IHJlZ2lzdGVyZWROYW1lPVN5bWJvbC5rZXlGb3Ioc3ltKTtcbmlmKHJlZ2lzdGVyZWROYW1lPT09dW5kZWZpbmVkKXtcbmNvbnN0IG1hdGNoPUF0QXRQcmVmaXhQYXR0ZXJuLmV4ZWMobmFtZSk7XG5hc3NlcnQobWF0Y2ghPT1udWxsKTtcbmNvbnN0IHN1ZmZpeD1tYXRjaFsxXTtcbmFzc2VydChTeW1ib2xbc3VmZml4XT09PXN5bSk7XG5hc3NlcnQoaWRlbnRQYXR0ZXJuLnRlc3Qoc3VmZml4KSk7XG5yZXR1cm4gb3V0Lm5leHQoIGBTeW1ib2wuJHtzdWZmaXh9YCk7XG4gfVxucmV0dXJuIG91dC5uZXh0KCBgU3ltYm9sLmZvcigke3F1b3RlKHJlZ2lzdGVyZWROYW1lKX0pYCk7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0e3RhZyxwYXlsb2FkfT1yYXdUcmVlO1xub3V0Lm5leHQoIGBtYWtlVGFnZ2VkKCR7cXVvdGUodGFnKX0sYCk7XG5kZWNvZGUocGF5bG9hZCk7XG5yZXR1cm4gb3V0Lm5leHQoJyknKTtcbiB9XG5cbmNhc2Unc2xvdCc6e1xubGV0e2lmYWNlfT1yYXdUcmVlO1xuY29uc3QgaW5kZXg9TnVtYmVyKE5hdChyYXdUcmVlLmluZGV4KSk7XG5jb25zdCBuZXN0ZWRSZW5kZXI9KGFyZyk9PntcbmNvbnN0IG9sZE91dD1vdXQ7XG50cnl7XG5vdXQ9bWFrZU5vSW5kZW50ZXIoKTtcbmRlY29kZShhcmcpO1xucmV0dXJuIG91dC5kb25lKCk7XG4gfWZpbmFsbHl7XG5vdXQ9b2xkT3V0O1xuIH1cbiB9O1xuaWYoaW5kZXg8c2xvdHMubGVuZ3RoKXtcbmNvbnN0IHNsb3Q9bmVzdGVkUmVuZGVyKHNsb3RzW2luZGV4XSk7XG5pZihpZmFjZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gb3V0Lm5leHQoIGBzbG90VG9WYWwoJHtzbG90fSlgKTtcbiB9XG5pZmFjZT1uZXN0ZWRSZW5kZXIoaWZhY2UpO1xucmV0dXJuIG91dC5uZXh0KCBgc2xvdFRvVmFsKCR7c2xvdH0sJHtpZmFjZX0pYCk7XG4gfWVsc2UgaWYoaWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIG91dC5uZXh0KCBgc2xvdCgke2luZGV4fSlgKTtcbiB9XG5pZmFjZT1uZXN0ZWRSZW5kZXIoaWZhY2UpO1xucmV0dXJuIG91dC5uZXh0KCBgc2xvdCgke2luZGV4fSwke2lmYWNlfSlgKTtcbiB9XG5cbmNhc2UnaGlsYmVydCc6e1xuY29uc3R7b3JpZ2luYWwscmVzdH09cmF3VHJlZTtcbm91dC5vcGVuKCd7Jyk7XG5kZWNvZGVQcm9wZXJ0eShRQ0xBU1Msb3JpZ2luYWwpO1xuaWYoJ3Jlc3QnaW4gcmF3VHJlZSl7XG5hc3NlcnQudHlwZW9mKHJlc3QsJ29iamVjdCcpO1xuYXNzZXJ0KHJlc3QhPT1udWxsKTtcbmNvbnN0IG5hbWVzPW93bktleXMocmVzdCk7XG5mb3IoY29uc3QgbmFtZSBvZiBuYW1lcyl7XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnRocm93IEZhaWwgYFByb3BlcnR5IG5hbWUgJHtxKFxubmFtZSlcbiB9IG9mICR7cmVzdH0gbXVzdCBiZSBhIHN0cmluZ2A7XG4gfVxuZGVjb2RlUHJvcGVydHkobmFtZSxyZXN0W25hbWVdKTtcbiB9XG4gfVxucmV0dXJuIG91dC5jbG9zZSgnfScpO1xuIH1cblxuY2FzZSdlcnJvcic6e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1yYXdUcmVlO1xucmV0dXJuIG91dC5uZXh0KCBgJHtuYW1lfSgke3F1b3RlKG1lc3NhZ2UpfSlgKTtcbiB9XG5cbmRlZmF1bHQ6e1xuYXNzZXJ0LmZhaWwoWCBgdW5yZWNvZ25pemVkICR7cShRQ0xBU1MpfSAke3EocWNsYXNzKX1gLFR5cGVFcnJvcik7XG4gfX1cblxuIH1lbHNlIGlmKGlzQXJyYXkocmF3VHJlZSkpe1xuY29uc3R7bGVuZ3RofT1yYXdUcmVlO1xuaWYobGVuZ3RoPT09MCl7XG5yZXR1cm4gb3V0Lm5leHQoJ1tdJyk7XG4gfWVsc2V7XG5vdXQub3BlbignWycpO1xuZm9yKGxldCBpPTA7aTxsZW5ndGg7aSs9MSl7XG5vdXQubGluZSgpO1xuZGVjb2RlKHJhd1RyZWVbaV0pO1xub3V0Lm5leHQoJywnKTtcbiB9XG5yZXR1cm4gb3V0LmNsb3NlKCddJyk7XG4gfVxuIH1lbHNle1xuLyogcmF3VHJlZSBpcyBhbiBgRW5jb2RpbmdSZWNvcmRgIHdoaWNoIG9ubHkgaGFzIHN0cmluZyBrZXlzLCovXG4vKiBidXQgc2luY2Ugb3duS2V5cyBpcyBub3QgZ2VuZXJpYywgaXQgY2FuJ3QgcHJvcGFnYXRlIHRoYXQqL1xuY29uc3QgbmFtZXM9LyoqIEB0eXBlIHtzdHJpbmdbXX0gKi9vd25LZXlzKHJhd1RyZWUpO1xuaWYobmFtZXMubGVuZ3RoPT09MCl7XG5yZXR1cm4gb3V0Lm5leHQoJ3t9Jyk7XG4gfWVsc2V7XG5vdXQub3BlbigneycpO1xuZm9yKGNvbnN0IG5hbWUgb2YgbmFtZXMpe1xuZGVjb2RlUHJvcGVydHkobmFtZSxyYXdUcmVlW25hbWVdKTtcbiB9XG5yZXR1cm4gb3V0LmNsb3NlKCd9Jyk7XG4gfVxuIH1cbiB9O1xucHJlcGFyZShlbmNvZGluZyk7XG5kZWNvZGUoZW5jb2RpbmcpO1xucmV0dXJuIG91dC5kb25lKCk7XG4gfTskaOKAjV9vbmNlLmRlY29kZVRvSnVzdGluKGRlY29kZVRvSnVzdGluKTtcbmhhcmRlbihkZWNvZGVUb0p1c3Rpbik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVjb2RlVG9KdXN0aW4iOlsiZGVjb2RlVG9KdXN0aW4iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAE9PVG9wGAADcBgAALQAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qc3siaW1wb3J0cyI6WyIuL21hcnNoYWwuanMiXSwiZXhwb3J0cyI6WyJwYXJzZSIsInN0cmluZ2lmeSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlTWFyc2hhbDskaOKAjV9pbXBvcnRzKFtbXCIuL21hcnNoYWwuanNcIiwgW1tcIm1ha2VNYXJzaGFsXCIsIFskaOKAjV9hID0+IChtYWtlTWFyc2hhbCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUGFzc2FibGV9IFBhc3NhYmxlICovXG5cbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuLyoqIEB0eXBlIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ29udmVydFZhbFRvU2xvdDxhbnk+fSAqL1xuY29uc3QgZG9Ob3RDb252ZXJ0VmFsVG9TbG90PSh2YWwpPT5cbkZhaWwgYE1hcnNoYWwncyBzdHJpbmdpZnkgcmVqZWN0cyBwcmVzZW5jZXMgYW5kIHByb21pc2VzICR7dmFsfWA7XG5cbi8qKiBAdHlwZSB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRvTm90Q29udmVydFNsb3RUb1ZhbD0oc2xvdCxfaWZhY2UpPT5cbkZhaWwgYE1hcnNoYWwncyBwYXJzZSBtdXN0IG5vdCBlbmNvZGUgYW55IHNsb3RzICR7c2xvdH1gO1xuXG5jb25zdCBiYWRBcnJheUhhbmRsZXI9aGFyZGVuKHtcbmdldDooX3RhcmdldCxuYW1lLF9yZWNlaXZlcik9PntcbmlmKG5hbWU9PT0nbGVuZ3RoJyl7XG5yZXR1cm4gMDtcbiB9XG4vKiBgdGhyb3dgIGlzIG5vb3Agc2luY2UgYEZhaWxgIHRocm93cy4gQnV0IGxpbnRlciBjb25mdXNlZCovXG50aHJvdyBGYWlsIGBNYXJzaGFsJ3MgcGFyc2UgbXVzdCBub3QgZW5jb2RlIGFueSBzbG90IHBvc2l0aW9ucyAke25hbWV9YDtcbiB9fSk7XG5cblxuY29uc3QgYmFkQXJyYXk9aGFyZGVuKG5ldyBQcm94eShoYXJkZW4oW10pLGJhZEFycmF5SGFuZGxlcikpO1xuXG5jb25zdHtzZXJpYWxpemUsdW5zZXJpYWxpemV9PW1ha2VNYXJzaGFsKFxuZG9Ob3RDb252ZXJ0VmFsVG9TbG90LFxuZG9Ob3RDb252ZXJ0U2xvdFRvVmFsLFxue1xuZXJyb3JUYWdnaW5nOidvZmYnLFxuLyogVE9ETyBmaXggdGVzdHMgdG8gd29ya3Mgd2l0aCBzbWFsbGNhcHMuKi9cbnNlcmlhbGl6ZUJvZHlGb3JtYXQ6J2NhcGRhdGEnfSk7XG5cblxuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3Qgc3RyaW5naWZ5PSh2YWwpPT5zZXJpYWxpemUodmFsKS5ib2R5OyRo4oCNX29uY2Uuc3RyaW5naWZ5KHN0cmluZ2lmeSk7XG5oYXJkZW4oc3RyaW5naWZ5KTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyXG4gKiBAcmV0dXJucyB7UGFzc2FibGV9XG4gKi9cbmNvbnN0IHBhcnNlPShzdHIpPT5cbnVuc2VyaWFsaXplKFxuaGFyZGVuKHtcbmJvZHk6c3RyLFxuc2xvdHM6YmFkQXJyYXl9KSk7JGjigI1fb25jZS5wYXJzZShwYXJzZSk7XG5cblxuaGFyZGVuKHBhcnNlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJzdHJpbmdpZnkiOlsic3RyaW5naWZ5Il0sInBhcnNlIjpbInBhcnNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAL6eaUrsMgAA7DIAACMAAABAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvbWFyc2hhbC5qc3siaW1wb3J0cyI6WyIuL2VuY29kZVRvQ2FwRGF0YS5qcyIsIi4vZW5jb2RlVG9TbWFsbGNhcHMuanMiLCJAZW5kby9uYXQiLCJAZW5kby9wYXNzLXN0eWxlIl0sImV4cG9ydHMiOlsibWFrZU1hcnNoYWwiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgTmF0LGFzc2VydFBhc3NhYmxlLGdldEludGVyZmFjZU9mLGdldEVycm9yQ29uc3RydWN0b3IsaGFzT3duUHJvcGVydHlPZixRQ0xBU1MsbWFrZUVuY29kZVRvQ2FwRGF0YSxtYWtlRGVjb2RlRnJvbUNhcERhdGEsbWFrZURlY29kZUZyb21TbWFsbGNhcHMsbWFrZUVuY29kZVRvU21hbGxjYXBzOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL25hdFwiLCBbW1wiTmF0XCIsIFskaOKAjV9hID0+IChOYXQgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiYXNzZXJ0UGFzc2FibGVcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFBhc3NhYmxlID0gJGjigI1fYSldXSxbXCJnZXRJbnRlcmZhY2VPZlwiLCBbJGjigI1fYSA9PiAoZ2V0SW50ZXJmYWNlT2YgPSAkaOKAjV9hKV1dLFtcImdldEVycm9yQ29uc3RydWN0b3JcIiwgWyRo4oCNX2EgPT4gKGdldEVycm9yQ29uc3RydWN0b3IgPSAkaOKAjV9hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRo4oCNX2EgPT4gKGhhc093blByb3BlcnR5T2YgPSAkaOKAjV9hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjigI1fYSA9PiAoUUNMQVNTID0gJGjigI1fYSldXSxbXCJtYWtlRW5jb2RlVG9DYXBEYXRhXCIsIFskaOKAjV9hID0+IChtYWtlRW5jb2RlVG9DYXBEYXRhID0gJGjigI1fYSldXSxbXCJtYWtlRGVjb2RlRnJvbUNhcERhdGFcIiwgWyRo4oCNX2EgPT4gKG1ha2VEZWNvZGVGcm9tQ2FwRGF0YSA9ICRo4oCNX2EpXV1dXSxbXCIuL2VuY29kZVRvU21hbGxjYXBzLmpzXCIsIFtbXCJtYWtlRGVjb2RlRnJvbVNtYWxsY2Fwc1wiLCBbJGjigI1fYSA9PiAobWFrZURlY29kZUZyb21TbWFsbGNhcHMgPSAkaOKAjV9hKV1dLFtcIm1ha2VFbmNvZGVUb1NtYWxsY2Fwc1wiLCBbJGjigI1fYSA9PiAobWFrZUVuY29kZVRvU21hbGxjYXBzID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLk1ha2VNYXJzaGFsT3B0aW9uc30gTWFrZU1hcnNoYWxPcHRpb25zICovXG4vKiogQHRlbXBsYXRlIFNsb3QgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Db252ZXJ0U2xvdFRvVmFsPFNsb3Q+fSBDb252ZXJ0U2xvdFRvVmFsICovXG4vKiogQHRlbXBsYXRlIFNsb3QgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Db252ZXJ0VmFsVG9TbG90PFNsb3Q+fSBDb252ZXJ0VmFsVG9TbG90ICovXG4vKiogQHRlbXBsYXRlIFNsb3QgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Ub0NhcERhdGE8U2xvdD59IFRvQ2FwRGF0YSAqL1xuLyoqIEB0ZW1wbGF0ZSBTbG90IEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRnJvbUNhcERhdGE8U2xvdD59IEZyb21DYXBEYXRhICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLkludGVyZmFjZVNwZWN9IEludGVyZmFjZVNwZWMgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkVuY29kaW5nfSBFbmNvZGluZyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUmVtb3RhYmxlT2JqZWN0fSBSZW1vdGFibGUgKi9cblxuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtkZXRhaWxzOlgsRmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiogQHR5cGUge0NvbnZlcnRWYWxUb1Nsb3Q8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRWYWxUb1Nsb3RGbj0oeCk9Png7XG4vKiogQHR5cGUge0NvbnZlcnRTbG90VG9WYWw8YW55Pn0gKi9cbmNvbnN0IGRlZmF1bHRTbG90VG9WYWxGbj0oeCxfKT0+eDtcblxuLyoqXG4gKiBAdGVtcGxhdGUgU2xvdFxuICogQHBhcmFtIHtDb252ZXJ0VmFsVG9TbG90PFNsb3Q+fSBbY29udmVydFZhbFRvU2xvdF1cbiAqIEBwYXJhbSB7Q29udmVydFNsb3RUb1ZhbDxTbG90Pn0gW2NvbnZlcnRTbG90VG9WYWxdXG4gKiBAcGFyYW0ge01ha2VNYXJzaGFsT3B0aW9uc30gb3B0aW9uc1xuICovXG5jb25zdCAgICAgICAgbWFrZU1hcnNoYWw9KFxuY29udmVydFZhbFRvU2xvdD1kZWZhdWx0VmFsVG9TbG90Rm4sXG5jb252ZXJ0U2xvdFRvVmFsPWRlZmF1bHRTbG90VG9WYWxGbixcbntcbmVycm9yVGFnZ2luZz0nb24nLFxubWFyc2hhbE5hbWU9J2Fub24tbWFyc2hhbCcsXG4vKiBUT0RPIFRlbXBvcmFyeSBoYWNrLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8yNzgwKi9cbmVycm9ySWROdW09MTAwMDAsXG4vKiBXZSBwcmVmZXIgdGhhdCB0aGUgY2FsbGVyIGluc3RlYWQgbG9nIHRvIHNvbWV3aGVyZSBoaWRkZW4qL1xuLyogdG8gYmUgcmV2ZWFsZWQgd2hlbiBjb3JyZWxhdGluZyB3aXRoIHRoZSByZWNlaXZlZCBlcnJvci4qL1xubWFyc2hhbFNhdmVFcnJvcj0oZXJyKT0+XG5jb25zb2xlLmxvZygnVGVtcG9yYXJ5IGxvZ2dpbmcgb2Ygc2VudCBlcnJvcicsZXJyKSxcbi8qIERlZmF1bHQgdG8gJ2NhcGRhdGEnIGJlY2F1c2UgaXQgd2FzIGltcGxlbWVudGVkIGZpcnN0LiovXG4vKiBTb21ldGltZXMsIG9udG9nZW55IGRvZXMgcmVjYXBpdHVsYXRlIHBoeWxvZ2VueSA7KSovXG5zZXJpYWxpemVCb2R5Rm9ybWF0PSdjYXBkYXRhJ309XG57fSk9Plxue1xuYXNzZXJ0LnR5cGVvZihtYXJzaGFsTmFtZSwnc3RyaW5nJyk7XG5lcnJvclRhZ2dpbmc9PT0nb24nfHxcbmVycm9yVGFnZ2luZz09PSdvZmYnfHxcbkZhaWwgYFRoZSBlcnJvclRhZ2dpbmcgb3B0aW9uIGNhbiBvbmx5IGJlIFwib25cIiBvciBcIm9mZlwiICR7ZXJyb3JUYWdnaW5nfWA7XG5jb25zdCBuZXh0RXJyb3JJZD0oKT0+e1xuZXJyb3JJZE51bSs9MTtcbnJldHVybiBgZXJyb3I6JHttYXJzaGFsTmFtZX0jJHtlcnJvcklkTnVtfWA7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7VG9DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCB0b0NhcERhdGE9KHJvb3QpPT57XG5jb25zdCBzbG90cz1bXTtcbi8qIG1hcHMgdmFsIChwcm9taXNlIG9yIHJlbW90YWJsZSkgdG8gaW5kZXggb2Ygc2xvdHNbXSovXG5jb25zdCBzbG90TWFwPW5ldyBNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JlbW90YWJsZSB8IFByb21pc2V9IHBhc3NhYmxlXG4gKiBAcmV0dXJucyB7e2luZGV4OiBudW1iZXIsIHJlcGVhdDogYm9vbGVhbn19XG4gKi9cbmNvbnN0IGVuY29kZVNsb3RDb21tb249KHBhc3NhYmxlKT0+e1xubGV0IGluZGV4PXNsb3RNYXAuZ2V0KHBhc3NhYmxlKTtcbmlmKGluZGV4IT09dW5kZWZpbmVkKXtcbi8qIFRPRE8gYXNzZXJ0IHRoYXQgaXQncyB0aGUgc2FtZSBpZmFjZSBhcyBiZWZvcmUqL1xuYXNzZXJ0LnR5cGVvZihpbmRleCwnbnVtYmVyJyk7XG5yZXR1cm4gaGFyZGVuKHtpbmRleCxyZXBlYXQ6dHJ1ZX0pO1xuIH1cblxuaW5kZXg9c2xvdHMubGVuZ3RoO1xuY29uc3Qgc2xvdD1jb252ZXJ0VmFsVG9TbG90KHBhc3NhYmxlKTtcbnNsb3RzLnB1c2goc2xvdCk7XG5zbG90TWFwLnNldChwYXNzYWJsZSxpbmRleCk7XG5yZXR1cm4gaGFyZGVuKHtpbmRleCxyZXBlYXQ6ZmFsc2V9KTtcbiB9O1xuXG4vKipcbiAqIEV2ZW4gaWYgYW4gRXJyb3IgaXMgbm90IGFjdHVhbGx5IHBhc3NhYmxlLCB3ZSdkIHJhdGhlciBzZW5kXG4gKiBpdCBhbnl3YXkgYmVjYXVzZSB0aGUgZGlhZ25vc3RpYyBpbmZvIGNhcnJpZWQgYnkgdGhlIGVycm9yXG4gKiBpcyBtb3JlIHZhbHVhYmxlIHRoYW4gZGlhZ25vc2luZyB3aHkgdGhlIGVycm9yIGlzbid0XG4gKiBwYXNzYWJsZS4gU2VlIGNvbW1lbnRzIGluIGlzRXJyb3JMaWtlLlxuICpcbiAqIEBwYXJhbSB7RXJyb3J9IGVyclxuICogQHBhcmFtIHsocDogUGFzc2FibGUpID0+IHVua25vd259IGVuY29kZVJlY3VyXG4gKiBAcmV0dXJucyB7e2Vycm9ySWQ/OiBzdHJpbmcsIG1lc3NhZ2U6IHN0cmluZywgbmFtZTogc3RyaW5nfX1cbiAqL1xuY29uc3QgZW5jb2RlRXJyb3JDb21tb249KGVycixlbmNvZGVSZWN1cik9PntcbmNvbnN0IG1lc3NhZ2U9ZW5jb2RlUmVjdXIoIGAke2Vyci5tZXNzYWdlfWApO1xuYXNzZXJ0LnR5cGVvZihtZXNzYWdlLCdzdHJpbmcnKTtcbmNvbnN0IG5hbWU9ZW5jb2RlUmVjdXIoIGAke2Vyci5uYW1lfWApO1xuYXNzZXJ0LnR5cGVvZihuYW1lLCdzdHJpbmcnKTtcbi8qIE11c3QgZW5jb2RlIGBjYXVzZWAsIGBlcnJvcnNgLiovXG4vKiBuZXN0ZWQgbm9uLXBhc3NhYmxlIGVycm9ycyBtdXN0IGJlIG9rIGZyb20gaGVyZS4qL1xuaWYoZXJyb3JUYWdnaW5nPT09J29uJyl7XG4vKiBXZSBkZWxpYmVyYXRlbHkgZG8gbm90IHNoYXJlIHRoZSBzdGFjaywgYnV0IGl0IHdvdWxkKi9cbi8qIGJlIHVzZWZ1bCB0byBsb2cgdGhlIHN0YWNrIGxvY2FsbHkgc28gc29tZW9uZSB3aG8gaGFzKi9cbi8qIHByaXZpbGVnZWQgYWNjZXNzIHRvIHRoZSB0aHJvd2luZyBWYXQgY2FuIGNvcnJlbGF0ZSovXG4vKiB0aGUgcHJvYmxlbSB3aXRoIHRoZSByZW1vdGUgVmF0IHRoYXQgZ2V0cyB0aGlzKi9cbi8qIHN1bW1hcnkuIElmIHdlIGRvIHRoYXQsIHdlIGNvdWxkIGFsbG9jYXRlIHNvbWUgcmFuZG9tKi9cbi8qIGlkZW50aWZpZXIgYW5kIGluY2x1ZGUgaXQgaW4gdGhlIG1lc3NhZ2UsIHRvIGhlbHAqL1xuLyogd2l0aCB0aGUgY29ycmVsYXRpb24uKi9cbmNvbnN0IGVycm9ySWQ9ZW5jb2RlUmVjdXIobmV4dEVycm9ySWQoKSk7XG5hc3NlcnQudHlwZW9mKGVycm9ySWQsJ3N0cmluZycpO1xuYXNzZXJ0Lm5vdGUoZXJyLFggYFNlbnQgYXMgJHtlcnJvcklkfWApO1xubWFyc2hhbFNhdmVFcnJvcihlcnIpO1xucmV0dXJuIGhhcmRlbih7ZXJyb3JJZCxtZXNzYWdlLG5hbWV9KTtcbiB9ZWxzZXtcbnJldHVybiBoYXJkZW4oe21lc3NhZ2UsbmFtZX0pO1xuIH1cbiB9O1xuXG5pZihzZXJpYWxpemVCb2R5Rm9ybWF0PT09J2NhcGRhdGEnKXtcbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcGFzc2FibGVcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gW2lmYWNlXVxuICogQHJldHVybnMge0VuY29kaW5nfVxuICovXG5jb25zdCBlbmNvZGVTbG90VG9DYXBEYXRhPShwYXNzYWJsZSxpZmFjZT11bmRlZmluZWQpPT57XG5jb25zdHtpbmRleCxyZXBlYXR9PWVuY29kZVNsb3RDb21tb24ocGFzc2FibGUpO1xuXG5pZihyZXBlYXQ9PT10cnVlfHxpZmFjZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gaGFyZGVuKHtbUUNMQVNTXTonc2xvdCcsaW5kZXh9KTtcbiB9ZWxzZXtcbnJldHVybiBoYXJkZW4oe1tRQ0xBU1NdOidzbG90JyxpZmFjZSxpbmRleH0pO1xuIH1cbiB9O1xuXG5jb25zdCBlbmNvZGVSZW1vdGFibGVUb0NhcERhdGE9KHZhbCxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb0NhcERhdGEodmFsLGdldEludGVyZmFjZU9mKHZhbCkpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlVG9DYXBEYXRhPShwcm9taXNlLF9lbmNvZGVSZWN1cik9PlxuZW5jb2RlU2xvdFRvQ2FwRGF0YShwcm9taXNlKTtcblxuLyoqXG4gKiBFdmVuIGlmIGFuIEVycm9yIGlzIG5vdCBhY3R1YWxseSBwYXNzYWJsZSwgd2UnZCByYXRoZXIgc2VuZFxuICogaXQgYW55d2F5IGJlY2F1c2UgdGhlIGRpYWdub3N0aWMgaW5mbyBjYXJyaWVkIGJ5IHRoZSBlcnJvclxuICogaXMgbW9yZSB2YWx1YWJsZSB0aGFuIGRpYWdub3Npbmcgd2h5IHRoZSBlcnJvciBpc24ndFxuICogcGFzc2FibGUuIFNlZSBjb21tZW50cyBpbiBpc0Vycm9yTGlrZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEBwYXJhbSB7KHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ30gZW5jb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtFbmNvZGluZ31cbiAqL1xuY29uc3QgZW5jb2RlRXJyb3JUb0NhcERhdGE9KGVycixlbmNvZGVSZWN1cik9PntcbmNvbnN0IGVyckRhdGE9ZW5jb2RlRXJyb3JDb21tb24oZXJyLGVuY29kZVJlY3VyKTtcbnJldHVybiBoYXJkZW4oe1tRQ0xBU1NdOidlcnJvcicsLi4uZXJyRGF0YX0pO1xuIH07XG5cbmNvbnN0IGVuY29kZVRvQ2FwRGF0YT1tYWtlRW5jb2RlVG9DYXBEYXRhKHtcbmVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YSxcbmVuY29kZVByb21pc2VUb0NhcERhdGEsXG5lbmNvZGVFcnJvclRvQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IGVuY29kZWQ9ZW5jb2RlVG9DYXBEYXRhKHJvb3QpO1xuY29uc3QgYm9keT1KU09OLnN0cmluZ2lmeShlbmNvZGVkKTtcbnJldHVybiBoYXJkZW4oe1xuYm9keSxcbnNsb3RzfSk7XG5cbiB9ZWxzZSBpZihzZXJpYWxpemVCb2R5Rm9ybWF0PT09J3NtYWxsY2Fwcycpe1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gcHJlZml4XG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBwYXNzYWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBbaWZhY2VdXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVTbG90VG9TbWFsbGNhcHM9KHByZWZpeCxwYXNzYWJsZSxpZmFjZT11bmRlZmluZWQpPT57XG5jb25zdHtpbmRleCxyZXBlYXR9PWVuY29kZVNsb3RDb21tb24ocGFzc2FibGUpO1xuXG4vKiBUT0RPIGV4cGxvcmUgcmVtb3ZpbmcgdGhpcyBzcGVjaWFsIGNhc2UqL1xuaWYocmVwZWF0PT09dHJ1ZXx8aWZhY2U9PT11bmRlZmluZWQpe1xucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fWA7XG4gfVxucmV0dXJuIGAke3ByZWZpeH0ke2luZGV4fS4ke2lmYWNlfWA7XG4gfTtcblxuY29uc3QgZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHM9KHJlbW90YWJsZSxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb1NtYWxsY2FwcygnJCcscmVtb3RhYmxlLGdldEludGVyZmFjZU9mKHJlbW90YWJsZSkpO1xuXG5jb25zdCBlbmNvZGVQcm9taXNlVG9TbWFsbGNhcHM9KHByb21pc2UsX2VuY29kZVJlY3VyKT0+XG5lbmNvZGVTbG90VG9TbWFsbGNhcHMoJyYnLHByb21pc2UpO1xuXG5jb25zdCBlbmNvZGVFcnJvclRvU21hbGxjYXBzPShlcnIsZW5jb2RlUmVjdXIpPT57XG5jb25zdCBlcnJEYXRhPWVuY29kZUVycm9yQ29tbW9uKGVycixlbmNvZGVSZWN1cik7XG5jb25zdHttZXNzYWdlLC4uLnJlc3R9PWVyckRhdGE7XG5yZXR1cm4gaGFyZGVuKHsnI2Vycm9yJzptZXNzYWdlLC4uLnJlc3R9KTtcbiB9O1xuXG5jb25zdCBlbmNvZGVUb1NtYWxsY2Fwcz1tYWtlRW5jb2RlVG9TbWFsbGNhcHMoe1xuZW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHMsXG5lbmNvZGVQcm9taXNlVG9TbWFsbGNhcHMsXG5lbmNvZGVFcnJvclRvU21hbGxjYXBzfSk7XG5cblxuY29uc3QgZW5jb2RlZD1lbmNvZGVUb1NtYWxsY2Fwcyhyb290KTtcbmNvbnN0IHNtYWxsY2Fwc0JvZHk9SlNPTi5zdHJpbmdpZnkoZW5jb2RlZCk7XG5yZXR1cm4gaGFyZGVuKHtcbi8qIFZhbGlkIEpTT04gY2Fubm90IGJlZ2luIHdpdGggYSAnIycsIHNvIHRoaXMgaXMgYSB2YWxpZCBzaWduYWwqL1xuLyogaW5kaWNhdGluZyBzbWFsbGNhcHMgZm9ybWF0LiovXG5ib2R5OiBgIyR7c21hbGxjYXBzQm9keX1gLFxuc2xvdHN9KTtcblxuIH1lbHNle1xuLyogVGhlIGB0aHJvd2AgaXMgYSBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEFkZGVkIGZvciBjb25mdXNlZCBsaW50ZXJzLiovXG50aHJvdyBGYWlsIGBVbnJlY29nbml6ZWQgc2VyaWFsaXplQm9keUZvcm1hdDogJHtxKHNlcmlhbGl6ZUJvZHlGb3JtYXQpfWA7XG4gfVxuIH07XG5cbmNvbnN0IG1ha2VGdWxsUmV2aXZlPShzbG90cyk9Pntcbi8qKiBAdHlwZSB7TWFwPG51bWJlciwgUGFzc2FibGU+fSAqL1xuY29uc3QgdmFsTWFwPW5ldyBNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge3tpZmFjZT86IHN0cmluZywgaW5kZXg6IG51bWJlcn19IHNsb3REYXRhXG4gKiBAcmV0dXJucyB7UmVtb3RhYmxlIHwgUHJvbWlzZX1cbiAqL1xuY29uc3QgZGVjb2RlU2xvdENvbW1vbj0oc2xvdERhdGEpPT57XG5jb25zdHtpZmFjZT11bmRlZmluZWQsaW5kZXgsLi4ucmVzdH09c2xvdERhdGE7XG5vd25LZXlzKHJlc3QpLmxlbmd0aD09PTB8fFxuRmFpbCBgdW5leHBlY3RlZCBlbmNvZGVkIHNsb3QgcHJvcGVydGllcyAke3Eob3duS2V5cyhyZXN0KSl9YDtcbmlmKHZhbE1hcC5oYXMoaW5kZXgpKXtcbnJldHVybiB2YWxNYXAuZ2V0KGluZGV4KTtcbiB9XG4vKiBUT0RPIFNFQ1VSSVRZIEhBWkFSRDogbXVzdCBlbmZvY2UgdGhhdCByZW1vdGFibGUgdnMgcHJvbWlzZSovXG4vKiBpcyBhY2NvcmRpbmcgdG8gdGhlIGVuY29kZWQgc3RyaW5nLiovXG5jb25zdCBzbG90PXNsb3RzW051bWJlcihOYXQoaW5kZXgpKV07XG5jb25zdCB2YWw9Y29udmVydFNsb3RUb1ZhbChzbG90LGlmYWNlKTtcbnZhbE1hcC5zZXQoaW5kZXgsdmFsKTtcbnJldHVybiB2YWw7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3tlcnJvcklkPzogc3RyaW5nLCBtZXNzYWdlOiBzdHJpbmcsIG5hbWU6IHN0cmluZ319IGVyckRhdGFcbiAqIEBwYXJhbSB7KGU6IHVua25vd24pID0+IFBhc3NhYmxlfSBkZWNvZGVSZWN1clxuICogQHJldHVybnMge0Vycm9yfVxuICovXG5jb25zdCBkZWNvZGVFcnJvckNvbW1vbj0oZXJyRGF0YSxkZWNvZGVSZWN1cik9PntcbmNvbnN0e2Vycm9ySWQ9dW5kZWZpbmVkLG1lc3NhZ2UsbmFtZSwuLi5yZXN0fT1lcnJEYXRhO1xub3duS2V5cyhyZXN0KS5sZW5ndGg9PT0wfHxcbkZhaWwgYHVuZXhwZWN0ZWQgZW5jb2RlZCBlcnJvciBwcm9wZXJ0aWVzICR7cShvd25LZXlzKHJlc3QpKX1gO1xuLyogVE9ETyBNdXN0IGRlY29kZSBgY2F1c2VgIGFuZCBgZXJyb3JzYCBwcm9wZXJ0aWVzKi9cbi8qIGNhcERhdGEgZG9lcyBub3QgdHJhbnNmb3JtIHN0cmluZ3MuIFRoZSBjYWxscyB0byBgZGVjb2RlUmVjdXJgKi9cbi8qIGFyZSBmb3IgcmV1c2UgYnkgb3RoZXIgZW5jb2RpbmdzIHRoYXQgZG8sIHN1Y2ggYXMgc21hbGxjYXBzLiovXG5jb25zdCBkTmFtZT1kZWNvZGVSZWN1cihuYW1lKTtcbmNvbnN0IGRNZXNzYWdlPWRlY29kZVJlY3VyKG1lc3NhZ2UpO1xuY29uc3QgZEVycm9ySWQ9ZXJyb3JJZCYmZGVjb2RlUmVjdXIoZXJyb3JJZCk7XG50eXBlb2YgZE5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkIGVycm9yIG5hbWUgdHlwZW9mICR7cSh0eXBlb2YgZE5hbWUpfWA7XG50eXBlb2YgZE1lc3NhZ2U9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkIGVycm9yIG1lc3NhZ2UgdHlwZW9mICR7cSh0eXBlb2YgZE1lc3NhZ2UpfWA7XG5jb25zdCBFQz1nZXRFcnJvckNvbnN0cnVjdG9yKGROYW1lKXx8RXJyb3I7XG4vKiBlcnJvcklkIGlzIGEgbGF0ZSBhZGRpdGlvbiBzbyBiZSB0b2xlcmFudCBvZiBpdHMgYWJzZW5jZS4qL1xuY29uc3QgZXJyb3JOYW1lPVxuZEVycm9ySWQ9PT11bmRlZmluZWQ/XG4gYFJlbW90ZSR7RUMubmFtZX1gOlxuIGBSZW1vdGUke0VDLm5hbWV9KCR7ZEVycm9ySWR9KWA7XG5jb25zdCBlcnJvcj1hc3NlcnQuZXJyb3IoZE1lc3NhZ2UsRUMse2Vycm9yTmFtZX0pO1xucmV0dXJuIGhhcmRlbihlcnJvcik7XG4gfTtcblxuLyogVGhlIGN1cnJlbnQgZW5jb2RpbmcgZG9lcyBub3QgZ2l2ZSB0aGUgZGVjb2RlciBlbm91Z2ggaW50byB0byBkaXN0aW5ndWlzaCovXG4vKiB3aGV0aGVyIGEgc2xvdCByZXByZXNlbnRzIGEgcHJvbWlzZSBvciBhIHJlbW90YWJsZS4gQXMgYW4gaW1wbGVtZW50YXRpb24qL1xuLyogcmVzdHJpY3Rpb24gdW50aWwgdGhpcyBpcyBmaXhlZCwgaWYgZWl0aGVyIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmUqL1xuLyogcHJvdmlkZWQgYW5kIHRoZXkgbXVzdCBiZSB0aGUgc2FtZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDMzNCovXG5jb25zdCBkZWNvZGVSZW1vdGFibGVPclByb21pc2VGcm9tQ2FwRGF0YT0ocmF3VHJlZSxfZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLnNsb3REYXRhfT1yYXdUcmVlO1xucmV0dXJuIGRlY29kZVNsb3RDb21tb24oc2xvdERhdGEpO1xuIH07XG5cbmNvbnN0IGRlY29kZUVycm9yRnJvbUNhcERhdGE9KHJhd1RyZWUsZGVjb2RlUmVjdXIpPT57XG5jb25zdHtbUUNMQVNTXTpfLC4uLmVyckRhdGF9PXJhd1RyZWU7XG5yZXR1cm4gZGVjb2RlRXJyb3JDb21tb24oZXJyRGF0YSxkZWNvZGVSZWN1cik7XG4gfTtcblxuY29uc3QgcmV2aXZlRnJvbUNhcERhdGE9bWFrZURlY29kZUZyb21DYXBEYXRhKHtcbmRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhOmRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YX0pO1xuXG5cbmNvbnN0IG1ha2VEZWNvZGVTbG90RnJvbVNtYWxsY2Fwcz0ocHJlZml4KT0+e1xuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gc3RyaW5nRW5jb2RpbmdcbiAqIEBwYXJhbSB7KGU6IHVua25vd24pID0+IFBhc3NhYmxlfSBfZGVjb2RlUmVjdXJcbiAqIEByZXR1cm5zIHtSZW1vdGFibGUgfCBQcm9taXNlfVxuICovXG5yZXR1cm4oc3RyaW5nRW5jb2RpbmcsX2RlY29kZVJlY3VyKT0+e1xuYXNzZXJ0KHN0cmluZ0VuY29kaW5nLnN0YXJ0c1dpdGgocHJlZml4KSk7XG4vKiBzbG90czogJHNsb3RJbmRleC5pZmFjZSBvciAkc2xvdEluZGV4Ki9cbmNvbnN0IGk9c3RyaW5nRW5jb2RpbmcuaW5kZXhPZignLicpO1xuY29uc3QgaW5kZXg9TnVtYmVyKHN0cmluZ0VuY29kaW5nLnNsaWNlKDEsaTwwP3VuZGVmaW5lZDppKSk7XG4vKiBpIDwgMCBtZWFucyB0aGVyZSB3YXMgbm8gaWZhY2UgaW5jbHVkZWQuKi9cbmNvbnN0IGlmYWNlPWk8MD91bmRlZmluZWQ6c3RyaW5nRW5jb2Rpbmcuc2xpY2UoaSsxKTtcbnJldHVybiBkZWNvZGVTbG90Q29tbW9uKHtpZmFjZSxpbmRleH0pO1xuIH07XG4gfTtcbmNvbnN0IGRlY29kZVJlbW90YWJsZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZVNsb3RGcm9tU21hbGxjYXBzKCckJyk7XG5jb25zdCBkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwcz1tYWtlRGVjb2RlU2xvdEZyb21TbWFsbGNhcHMoJyYnKTtcblxuY29uc3QgZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzPShlbmNvZGluZyxkZWNvZGVSZWN1cik9PntcbmNvbnN0eycjZXJyb3InOm1lc3NhZ2UsLi4ucmVzdEVyckRhdGF9PWVuY29kaW5nO1xuIWhhc093blByb3BlcnR5T2YocmVzdEVyckRhdGEsJ21lc3NhZ2UnKXx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgZXJyb3IgcHJvcGVydHkgJHtxKCdtZXNzYWdlJyl9YDtcbnJldHVybiBkZWNvZGVFcnJvckNvbW1vbih7bWVzc2FnZSwuLi5yZXN0RXJyRGF0YX0sZGVjb2RlUmVjdXIpO1xuIH07XG5cbmNvbnN0IHJldml2ZUZyb21TbWFsbGNhcHM9bWFrZURlY29kZUZyb21TbWFsbGNhcHMoe1xuZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2FwcyxcbmRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzLFxuZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzfSk7XG5cblxucmV0dXJuIGhhcmRlbih7cmV2aXZlRnJvbUNhcERhdGEscmV2aXZlRnJvbVNtYWxsY2Fwc30pO1xuIH07XG5cbi8qKlxuICogQHR5cGUge0Zyb21DYXBEYXRhPFNsb3Q+fVxuICovXG5jb25zdCBmcm9tQ2FwRGF0YT0oZGF0YSk9PntcbmNvbnN0e2JvZHksc2xvdHN9PWRhdGE7XG50eXBlb2YgYm9keT09PSdzdHJpbmcnfHxcbkZhaWwgYHVuc2VyaWFsaXplKCkgZ2l2ZW4gbm9uLWNhcGRhdGEgKC5ib2R5IGlzICR7Ym9keX0sIG5vdCBzdHJpbmcpYDtcbmlzQXJyYXkoZGF0YS5zbG90cyl8fFxuRmFpbCBgdW5zZXJpYWxpemUoKSBnaXZlbiBub24tY2FwZGF0YSAoLnNsb3RzIGFyZSBub3QgQXJyYXkpYDtcbmNvbnN0e3Jldml2ZUZyb21DYXBEYXRhLHJldml2ZUZyb21TbWFsbGNhcHN9PW1ha2VGdWxsUmV2aXZlKHNsb3RzKTtcbmxldCByZXN1bHQ7XG4vKiBKU09OIGNhbm5vdCBiZWdpbiB3aXRoIGEgJyMnLCBzbyB0aGlzIGlzIGFuIHVuYW1iaWd1b3VzIHNpZ25hbC4qL1xuaWYoYm9keS5zdGFydHNXaXRoKCcjJykpe1xuY29uc3Qgc21hbGxjYXBzQm9keT1ib2R5LnNsaWNlKDEpO1xuY29uc3QgZW5jb2Rpbmc9aGFyZGVuKEpTT04ucGFyc2Uoc21hbGxjYXBzQm9keSkpO1xucmVzdWx0PWhhcmRlbihyZXZpdmVGcm9tU21hbGxjYXBzKGVuY29kaW5nKSk7XG4gfWVsc2V7XG5jb25zdCByYXdUcmVlPWhhcmRlbihKU09OLnBhcnNlKGJvZHkpKTtcbnJlc3VsdD1oYXJkZW4ocmV2aXZlRnJvbUNhcERhdGEocmF3VHJlZSkpO1xuIH1cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzMzcqL1xuLyogd2hpY2ggc2hvdWxkIGJlIGNvbnNpZGVyZWQgZml4ZWQgb25jZSB3ZSd2ZSBjb21wbGV0ZWQgdGhlIHN3aXRjaCovXG4vKiB0byBzbWFsbGNhcHMuKi9cbmFzc2VydFBhc3NhYmxlKHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH07XG5cbnJldHVybiBoYXJkZW4oe1xudG9DYXBEYXRhLFxuZnJvbUNhcERhdGEsXG5cbi8qIGZvciBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSovXG4vKiogQGRlcHJlY2F0ZWQgdXNlIHRvQ2FwRGF0YSAqL1xuc2VyaWFsaXplOnRvQ2FwRGF0YSxcbi8qKiBAZGVwcmVjYXRlZCB1c2UgZnJvbUNhcERhdGEgKi9cbnVuc2VyaWFsaXplOmZyb21DYXBEYXRhfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZU1hcnNoYWwobWFrZU1hcnNoYWwpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VNYXJzaGFsIjpbIm1ha2VNYXJzaGFsIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAFdEZAp+QAAAfkAAACUAAABAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvcmFua09yZGVyLmpzeyJpbXBvcnRzIjpbIi4vZW5jb2RlUGFzc2FibGUuanMiLCJAZW5kby9wYXNzLXN0eWxlIl0sImV4cG9ydHMiOlsiRnVsbFJhbmtDb3ZlciIsImFzc2VydFJhbmtTb3J0ZWQiLCJjb21wYXJhdG9yTWlycm9ySW1hZ2UiLCJjb21wYXJlQW50aVJhbmsiLCJjb21wYXJlUmFuayIsImNvdmVyZWRFbnRyaWVzIiwiZ2V0SW5kZXhDb3ZlciIsImdldFBhc3NTdHlsZUNvdmVyIiwiaW50ZXJzZWN0UmFua0NvdmVycyIsImlzUmFua1NvcnRlZCIsIm1ha2VDb21wYXJhdG9yS2l0IiwibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiLCJzb3J0QnlSYW5rIiwidW5pb25SYW5rQ292ZXJzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGdldFRhZyxwYXNzU3R5bGVPZixuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc1N0eWxlUHJlZml4ZXMscmVjb3JkTmFtZXMscmVjb3JkVmFsdWVzOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcImdldFRhZ1wiLCBbJGjigI1fYSA9PiAoZ2V0VGFnID0gJGjigI1fYSldXSxbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcIm5hbWVGb3JQYXNzYWJsZVN5bWJvbFwiLCBbJGjigI1fYSA9PiAobmFtZUZvclBhc3NhYmxlU3ltYm9sID0gJGjigI1fYSldXV1dLFtcIi4vZW5jb2RlUGFzc2FibGUuanNcIiwgW1tcInBhc3NTdHlsZVByZWZpeGVzXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVQcmVmaXhlcyA9ICRo4oCNX2EpXV0sW1wicmVjb3JkTmFtZXNcIiwgWyRo4oCNX2EgPT4gKHJlY29yZE5hbWVzID0gJGjigI1fYSldXSxbXCJyZWNvcmRWYWx1ZXNcIiwgWyRo4oCNX2EgPT4gKHJlY29yZFZhbHVlcyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUGFzc2FibGV9IFBhc3NhYmxlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzU3R5bGV9IFBhc3NTdHlsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmFua0NvdmVyfSBSYW5rQ292ZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJhbmtDb21wYXJpc29ufSBSYW5rQ29tcGFyaXNvbiAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmFua0NvbXBhcmV9IFJhbmtDb21wYXJlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5GdWxsQ29tcGFyZX0gRnVsbENvbXBhcmUgKi9cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtlbnRyaWVzLGZyb21FbnRyaWVzLHNldFByb3RvdHlwZU9mLGlzfT1PYmplY3Q7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUmFua0NvbXBhcmF0b3JLaXRcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEBwcm9wZXJ0eSB7UmFua0NvbXBhcmV9IGFudGlDb21wYXJhdG9yXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBGdWxsQ29tcGFyYXRvcktpdFxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gY29tcGFyYXRvclxuICogQHByb3BlcnR5IHtGdWxsQ29tcGFyZX0gYW50aUNvbXBhcmF0b3JcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtbbnVtYmVyLCBudW1iZXJdfSBJbmRleENvdmVyXG4gKi9cblxuLyoqXG4gKiBUaGlzIGlzIHRoZSBlcXVhbGl0eSBjb21wYXJpc29uIHVzZWQgYnkgSmF2YVNjcmlwdCdzIE1hcCBhbmQgU2V0XG4gKiBhYnN0cmFjdGlvbnMsIHdoZXJlIE5hTiBpcyB0aGUgc2FtZSBhcyBOYU4gYW5kIC0wIGlzIHRoZSBzYW1lIGFzXG4gKiAwLiBNYXJzaGFsIHNlcmlhbGl6ZXMgLTAgYXMgemVybywgc28gdGhlIHNlbWFudGljcyBvZiBvdXIgZGlzdHJpYnV0ZWRcbiAqIG9iamVjdCBzeXN0ZW0gZG9lcyBub3QgZGlzdGluZ3Vpc2ggMCBmcm9tIC0wLlxuICpcbiAqIGBzYW1lVmFsdWVaZXJvYCBpcyB0aGUgRWNtYVNjcmlwdCBzcGVjIG5hbWUgZm9yIHRoaXMgZXF1YWxpdHkgY29tcGFyaXNvbixcbiAqIGJ1dCBUT0RPIHdlIG5lZWQgYSBiZXR0ZXIgbmFtZSBmb3IgdGhlIEFQSS5cbiAqXG4gKiBAcGFyYW0ge2FueX0geFxuICogQHBhcmFtIHthbnl9IHlcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBzYW1lVmFsdWVaZXJvPSh4LHkpPT54PT09eXx8aXMoeCx5KTtcblxuY29uc3QgdHJpdmlhbENvbXBhcmF0b3I9KGxlZnQscmlnaHQpPT5cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1uZXN0ZWQtdGVybmFyeSwgQGVuZG8vcmVzdHJpY3QtY29tcGFyaXNvbi1vcGVyYW5kcyovXG5sZWZ0PHJpZ2h0Py0xOmxlZnQ9PT1yaWdodD8wOjE7XG5cbi8qKlxuICogQHR5cGVkZWYge1JlY29yZDxQYXNzU3R5bGUsIHsgaW5kZXg6IG51bWJlciwgY292ZXI6IFJhbmtDb3ZlciB9Pn0gUGFzc1N0eWxlUmFua3NSZWNvcmRcbiAqL1xuXG5jb25zdCBwYXNzU3R5bGVSYW5rcz0vKiogQHR5cGUge1Bhc3NTdHlsZVJhbmtzUmVjb3JkfSAqL1xuZnJvbUVudHJpZXMoXG5lbnRyaWVzKHBhc3NTdHlsZVByZWZpeGVzKVxuLyogU29ydCBlbnRyaWVzIGJ5IGFzY2VuZGluZyBwcmVmaXguKi8uXG5zb3J0KChbX2xlZnRTdHlsZSxsZWZ0UHJlZml4ZXNdLFtfcmlnaHRTdHlsZSxyaWdodFByZWZpeGVzXSk9PntcbnJldHVybiB0cml2aWFsQ29tcGFyYXRvcihsZWZ0UHJlZml4ZXMscmlnaHRQcmVmaXhlcyk7XG4gfSkuXG5tYXAoKFtwYXNzU3R5bGUscHJlZml4ZXNdLGluZGV4KT0+e1xuLyogQ292ZXIgYWxsIHN0cmluZ3MgdGhhdCBzdGFydCB3aXRoIGFueSBjaGFyYWN0ZXIgaW4gYHByZWZpeGVzYCwqL1xuLyogdmVyaWZ5aW5nIHRoYXQgaXQgaXMgc29ydGVkIHNvIHRoYXQgaXMqL1xuLyogYWxsIHMgc3VjaCB0aGF0IHByZWZpeGVzLmF0KDApIOKJpCBzIDwgc3VjY2Vzc29yKHByZWZpeGVzLmF0KC0xKSkuKi9cbnByZWZpeGVzPT09Wy4uLnByZWZpeGVzXS5zb3J0KCkuam9pbignJyl8fFxuRmFpbCBgdW5zb3J0ZWQgcHJlZml4ZXMgZm9yIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX06ICR7cShwcmVmaXhlcyl9YDtcbmNvbnN0IGNvdmVyPVtcbnByZWZpeGVzLmNoYXJBdCgwKSxcblN0cmluZy5mcm9tQ2hhckNvZGUocHJlZml4ZXMuY2hhckNvZGVBdChwcmVmaXhlcy5sZW5ndGgtMSkrMSldO1xuXG5yZXR1cm5bcGFzc1N0eWxlLHtpbmRleCxjb3Zlcn1dO1xuIH0pKTtcblxuXG5zZXRQcm90b3R5cGVPZihwYXNzU3R5bGVSYW5rcyxudWxsKTtcbmhhcmRlbihwYXNzU3R5bGVSYW5rcyk7XG5cbi8qKlxuICogQXNzb2NpYXRlIHdpdGggZWFjaCBwYXNzU3R5bGUgYSBSYW5rQ292ZXIgdGhhdCBtYXkgYmUgYW4gb3ZlcmVzdGltYXRlLFxuICogYW5kIHdob3NlIHJlc3VsdHMgdGhlcmVmb3JlIG5lZWQgdG8gYmUgZmlsdGVyZWQgZG93bi4gRm9yIGV4YW1wbGUsIGJlY2F1c2VcbiAqIHRoZXJlIGlzIG5vdCBhIHNtYWxsZXN0IG9yIGJpZ2dlc3QgYmlnaW50LCBib3VuZCBpdCBieSBgTmFOYCAodGhlIGxhc3QgcGxhY2VcbiAqIG51bWJlcikgYW5kIGAnJ2AgKHRoZSBlbXB0eSBzdHJpbmcsIHdoaWNoIGlzIHRoZSBmaXJzdCBwbGFjZSBzdHJpbmcpLiBUaHVzLFxuICogYSByYW5nZSBxdWVyeSB1c2luZyB0aGlzIHJhbmdlIG1heSBpbmNsdWRlIHRoZXNlIHZhbHVlcywgd2hpY2ggd291bGQgdGhlblxuICogbmVlZCB0byBiZSBmaWx0ZXJlZCBvdXQuXG4gKlxuICogQHBhcmFtIHtQYXNzU3R5bGV9IHBhc3NTdHlsZVxuICogQHJldHVybnMge1JhbmtDb3Zlcn1cbiAqL1xuY29uc3QgICAgICAgIGdldFBhc3NTdHlsZUNvdmVyPShwYXNzU3R5bGUpPT5wYXNzU3R5bGVSYW5rc1twYXNzU3R5bGVdLmNvdmVyOyRo4oCNX29uY2UuZ2V0UGFzc1N0eWxlQ292ZXIoZ2V0UGFzc1N0eWxlQ292ZXIpO1xuaGFyZGVuKGdldFBhc3NTdHlsZUNvdmVyKTtcblxuLyoqXG4gKiBAdHlwZSB7V2Vha01hcDxSYW5rQ29tcGFyZSxXZWFrU2V0PFBhc3NhYmxlW10+Pn1cbiAqL1xuY29uc3QgbWVtb09mU29ydGVkPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQHR5cGUge1dlYWtNYXA8UmFua0NvbXBhcmUsUmFua0NvbXBhcmU+fVxuICovXG5jb25zdCBjb21wYXJhdG9yTWlycm9ySW1hZ2VzPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZT19IGNvbXBhcmVSZW1vdGFibGVzXG4gKiBBbiBvcHRpb24gdG8gY3JlYXRlIGEgY29tcGFyYXRvciBpbiB3aGljaCBhbiBpbnRlcm5hbCBvcmRlciBpc1xuICogYXNzaWduZWQgdG8gcmVtb3RhYmxlcy4gVGhpcyBkZWZhdWx0cyB0byBhIGNvbXBhcmF0b3IgdGhhdFxuICogYWx3YXlzIHJldHVybnMgYDBgLCBtZWFuaW5nIHRoYXQgYWxsIHJlbW90YWJsZXMgYXJlIHRpZWRcbiAqIGZvciB0aGUgc2FtZSByYW5rLlxuICogQHJldHVybnMge1JhbmtDb21wYXJhdG9yS2l0fVxuICovXG5jb25zdCAgICAgICAgbWFrZUNvbXBhcmF0b3JLaXQ9KGNvbXBhcmVSZW1vdGFibGVzPShfeCxfeSk9PjApPT57XG4vKiogQHR5cGUge1JhbmtDb21wYXJlfSAqL1xuY29uc3QgY29tcGFyYXRvcj0obGVmdCxyaWdodCk9PntcbmlmKHNhbWVWYWx1ZVplcm8obGVmdCxyaWdodCkpe1xucmV0dXJuIDA7XG4gfVxuY29uc3QgbGVmdFN0eWxlPXBhc3NTdHlsZU9mKGxlZnQpO1xuY29uc3QgcmlnaHRTdHlsZT1wYXNzU3R5bGVPZihyaWdodCk7XG5pZihsZWZ0U3R5bGUhPT1yaWdodFN0eWxlKXtcbnJldHVybiB0cml2aWFsQ29tcGFyYXRvcihcbnBhc3NTdHlsZVJhbmtzW2xlZnRTdHlsZV0uaW5kZXgsXG5wYXNzU3R5bGVSYW5rc1tyaWdodFN0eWxlXS5pbmRleCk7XG5cbiB9XG4vKiBlc2xpbnQtZGlzYWJsZSBAZW5kby9yZXN0cmljdC1jb21wYXJpc29uLW9wZXJhbmRzIC0tXG4gKiBXZSBrbm93IGBsZWZ0YCBhbmQgYHJpZ2h0YCBhcmUgY29tcGFyYWJsZS5cbiAqL1xuc3dpdGNoKGxlZnRTdHlsZSl7XG5jYXNlJ3JlbW90YWJsZSc6e1xucmV0dXJuIGNvbXBhcmVSZW1vdGFibGVzKGxlZnQscmlnaHQpO1xuIH1cbmNhc2UndW5kZWZpbmVkJzpcbmNhc2UnbnVsbCc6XG5jYXNlJ2Vycm9yJzpcbmNhc2UncHJvbWlzZSc6e1xuLyogRm9yIGVhY2ggb2YgdGhlc2UgcGFzc1N0eWxlcywgYWxsIG1lbWJlcnMgb2YgdGhhdCBwYXNzU3R5bGUgYXJlIHRpZWQqL1xuLyogZm9yIHRoZSBzYW1lIHJhbmsuKi9cbnJldHVybiAwO1xuIH1cbmNhc2UnYm9vbGVhbic6XG5jYXNlJ2JpZ2ludCc6XG5jYXNlJ3N0cmluZyc6e1xuLyogV2l0aGluIGVhY2ggb2YgdGhlc2UgcGFzc1N0eWxlcywgdGhlIHJhbmsgb3JkZXJpbmcgYWdyZWVzIHdpdGgqL1xuLyogSmF2YVNjcmlwdCdzIHJlbGF0aW9uYWwgb3BlcmF0b3JzIGA8YCBhbmQgYD5gLiovXG5pZihsZWZ0PHJpZ2h0KXtcbnJldHVybi0xO1xuIH1lbHNle1xuYXNzZXJ0KGxlZnQ+cmlnaHQpO1xucmV0dXJuIDE7XG4gfVxuIH1cbmNhc2Unc3ltYm9sJzp7XG5yZXR1cm4gY29tcGFyYXRvcihcbm5hbWVGb3JQYXNzYWJsZVN5bWJvbChsZWZ0KSxcbm5hbWVGb3JQYXNzYWJsZVN5bWJvbChyaWdodCkpO1xuXG4gfVxuY2FzZSdudW1iZXInOntcbi8qIGBOYU5gJ3MgcmFuayBpcyBhZnRlciBhbGwgb3RoZXIgbnVtYmVycy4qL1xuaWYoTnVtYmVyLmlzTmFOKGxlZnQpKXtcbmFzc2VydCghTnVtYmVyLmlzTmFOKHJpZ2h0KSk7XG5yZXR1cm4gMTtcbiB9ZWxzZSBpZihOdW1iZXIuaXNOYU4ocmlnaHQpKXtcbnJldHVybi0xO1xuIH1cbi8qIFRoZSByYW5rIG9yZGVyaW5nIG9mIG5vbi1OYU4gbnVtYmVycyBhZ3JlZXMgd2l0aCBKYXZhU2NyaXB0J3MqL1xuLyogcmVsYXRpb25hbCBvcGVyYXRvcnMgJzwnIGFuZCAnPicuKi9cbmlmKGxlZnQ8cmlnaHQpe1xucmV0dXJuLTE7XG4gfWVsc2V7XG5hc3NlcnQobGVmdD5yaWdodCk7XG5yZXR1cm4gMTtcbiB9XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBMZXhpY29ncmFwaGljIGJ5IGludmVyc2Ugc29ydGVkIG9yZGVyIG9mIHByb3BlcnR5IG5hbWVzLCB0aGVuKi9cbi8qIGxleGljb2dyYXBoaWMgYnkgY29ycmVzcG9uZGluZyB2YWx1ZXMgaW4gdGhhdCBzYW1lIGludmVyc2UqL1xuLyogb3JkZXIgb2YgdGhlaXIgcHJvcGVydHkgbmFtZXMuIENvbXBhcmluZyBuYW1lcyBieSB0aGVtc2VsdmVzIGZpcnN0LCovXG4vKiBhbGwgcmVjb3JkcyB3aXRoIHRoZSBleGFjdCBzYW1lIHNldCBvZiBwcm9wZXJ0eSBuYW1lcyBzb3J0IG5leHQgdG8qL1xuLyogZWFjaCBvdGhlciBpbiBhIHJhbmstc29ydCBvZiBjb3B5UmVjb3Jkcy4qL1xuXG4vKiBUaGUgY29weVJlY29yZCBpbnZhcmlhbnRzIGVuZm9yY2VkIGJ5IHBhc3NTdHlsZU9mIGVuc3VyZSB0aGF0Ki9cbi8qIGFsbCB0aGUgcHJvcGVydHkgbmFtZXMgYXJlIHN0cmluZ3MuIFdlIG5lZWQgdGhlIHJldmVyc2Ugc29ydGVkIG9yZGVyKi9cbi8qIG9mIHRoZXNlIG5hbWVzLCB3aGljaCB3ZSB0aGVuIGNvbXBhcmUgbGV4aWNvZ3JhcGhpY2FsbHkuIFRoaXMgZW5zdXJlcyovXG4vKiB0aGF0IGlmIHRoZSBuYW1lcyBvZiByZWNvcmQgWCBhcmUgYSBzdWJzZXQgb2YgdGhlIG5hbWVzIG9mIHJlY29yZCBZLCovXG4vKiB0aGVuIHJlY29yZCBYIHdpbGwgaGF2ZSBhbiBlYXJsaWVyIHJhbmsgYW5kIHNvcnQgdG8gdGhlIGxlZnQgb2YgWS4qL1xuY29uc3QgbGVmdE5hbWVzPXJlY29yZE5hbWVzKGxlZnQpO1xuY29uc3QgcmlnaHROYW1lcz1yZWNvcmROYW1lcyhyaWdodCk7XG5cbmNvbnN0IHJlc3VsdD1jb21wYXJhdG9yKGxlZnROYW1lcyxyaWdodE5hbWVzKTtcbmlmKHJlc3VsdCE9PTApe1xucmV0dXJuIHJlc3VsdDtcbiB9XG5yZXR1cm4gY29tcGFyYXRvcihcbnJlY29yZFZhbHVlcyhsZWZ0LGxlZnROYW1lcyksXG5yZWNvcmRWYWx1ZXMocmlnaHQscmlnaHROYW1lcykpO1xuXG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIExleGljb2dyYXBoaWMqL1xuY29uc3QgbGVuPU1hdGgubWluKGxlZnQubGVuZ3RoLHJpZ2h0Lmxlbmd0aCk7XG5mb3IobGV0IGk9MDtpPGxlbjtpKz0xKXtcbmNvbnN0IHJlc3VsdD1jb21wYXJhdG9yKGxlZnRbaV0scmlnaHRbaV0pO1xuaWYocmVzdWx0IT09MCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG4vKiBJZiBhbGwgbWF0Y2hpbmcgZWxlbWVudHMgd2VyZSB0aWVkLCB0aGVuIGFjY29yZGluZyB0byB0aGVpciBsZW5ndGhzLiovXG4vKiBJZiBhcnJheSBYIGlzIGEgcHJlZml4IG9mIGFycmF5IFksIHRoZW4gWCBoYXMgYW4gZWFybGllciByYW5rIHRoYW4gWS4qL1xucmV0dXJuIGNvbXBhcmF0b3IobGVmdC5sZW5ndGgscmlnaHQubGVuZ3RoKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuLyogTGV4aWNvZ3JhcGhpYyBieSBgW1N5bWJvbC50b1N0cmluZ1RhZ11gIHRoZW4gYC5wYXlsb2FkYC4qL1xuY29uc3QgbGFiZWxDb21wPWNvbXBhcmF0b3IoZ2V0VGFnKGxlZnQpLGdldFRhZyhyaWdodCkpO1xuaWYobGFiZWxDb21wIT09MCl7XG5yZXR1cm4gbGFiZWxDb21wO1xuIH1cbnJldHVybiBjb21wYXJhdG9yKGxlZnQucGF5bG9hZCxyaWdodC5wYXlsb2FkKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYFVucmVjb2duaXplZCBwYXNzU3R5bGU6ICR7cShsZWZ0U3R5bGUpfWA7XG4gfX1cblxuLyogZXNsaW50LWVuYWJsZSAqL1xuIH07XG5cbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBhbnRpQ29tcGFyYXRvcj0oeCx5KT0+Y29tcGFyYXRvcih5LHgpO1xuXG5tZW1vT2ZTb3J0ZWQuc2V0KGNvbXBhcmF0b3IsbmV3IFdlYWtTZXQoKSk7XG5tZW1vT2ZTb3J0ZWQuc2V0KGFudGlDb21wYXJhdG9yLG5ldyBXZWFrU2V0KCkpO1xuY29tcGFyYXRvck1pcnJvckltYWdlcy5zZXQoY29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcik7XG5jb21wYXJhdG9yTWlycm9ySW1hZ2VzLnNldChhbnRpQ29tcGFyYXRvcixjb21wYXJhdG9yKTtcblxucmV0dXJuIGhhcmRlbih7Y29tcGFyYXRvcixhbnRpQ29tcGFyYXRvcn0pO1xuIH07XG4vKipcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmF0b3JcbiAqIEByZXR1cm5zIHtSYW5rQ29tcGFyZT19XG4gKi8kaOKAjV9vbmNlLm1ha2VDb21wYXJhdG9yS2l0KG1ha2VDb21wYXJhdG9yS2l0KTtcbmNvbnN0ICAgICAgICBjb21wYXJhdG9yTWlycm9ySW1hZ2U9KGNvbXBhcmF0b3IpPT5cbmNvbXBhcmF0b3JNaXJyb3JJbWFnZXMuZ2V0KGNvbXBhcmF0b3IpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gcGFzc2FibGVzXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqLyRo4oCNX29uY2UuY29tcGFyYXRvck1pcnJvckltYWdlKGNvbXBhcmF0b3JNaXJyb3JJbWFnZSk7XG5jb25zdCAgICAgICAgaXNSYW5rU29ydGVkPShwYXNzYWJsZXMsY29tcGFyZSk9PntcbmNvbnN0IHN1Yk1lbW9PZlNvcnRlZD1tZW1vT2ZTb3J0ZWQuZ2V0KGNvbXBhcmUpO1xuYXNzZXJ0KHN1Yk1lbW9PZlNvcnRlZCE9PXVuZGVmaW5lZCk7XG5pZihzdWJNZW1vT2ZTb3J0ZWQuaGFzKHBhc3NhYmxlcykpe1xucmV0dXJuIHRydWU7XG4gfVxuYXNzZXJ0KHBhc3NTdHlsZU9mKHBhc3NhYmxlcyk9PT0nY29weUFycmF5Jyk7XG5mb3IobGV0IGk9MTtpPHBhc3NhYmxlcy5sZW5ndGg7aSs9MSl7XG5pZihjb21wYXJlKHBhc3NhYmxlc1tpLTFdLHBhc3NhYmxlc1tpXSk+PTEpe1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5zdWJNZW1vT2ZTb3J0ZWQuYWRkKHBhc3NhYmxlcyk7XG5yZXR1cm4gdHJ1ZTtcbiB9OyRo4oCNX29uY2UuaXNSYW5rU29ydGVkKGlzUmFua1NvcnRlZCk7XG5oYXJkZW4oaXNSYW5rU29ydGVkKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UmFua1NvcnRlZD0oc29ydGVkLGNvbXBhcmUpPT5cbmlzUmFua1NvcnRlZChzb3J0ZWQsY29tcGFyZSl8fFxuLyogVE9ETyBhc3NlcnQgb24gYnVnIGNvdWxkIGxlYWQgdG8gaW5maW5pdGUgcmVjdXJzaW9uLiBGaXguKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5GYWlsIGBNdXN0IGJlIHJhbmsgc29ydGVkOiAke3NvcnRlZH0gdnMgJHtzb3J0QnlSYW5rKHNvcnRlZCxjb21wYXJlKX1gOyRo4oCNX29uY2UuYXNzZXJ0UmFua1NvcnRlZChhc3NlcnRSYW5rU29ydGVkKTtcbmhhcmRlbihhc3NlcnRSYW5rU29ydGVkKTtcblxuLyoqXG4gKiBUT0RPIFNFQ1VSSVRZIEJVRzogaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy80MjYwXG4gKiBzb3J0QnlSYW5rIGN1cnJlbnRseSB1c2VzIGBBcnJheS5wcm90b3R5cGUuc29ydGAgZGlyZWN0bHksIGFuZFxuICogc28gb25seSB3b3JrcyBjb3JyZWN0bHkgd2hlbiBnaXZlbiBhIGBjb21wYXJlYCBmdW5jdGlvbiB0aGF0IGNvbnNpZGVyc1xuICogYHVuZGVmaW5lZGAgc3RyaWN0bHkgYmlnZ2VyIChgPmApIHRoYW4gZXZlcnl0aGluZyBlbHNlLiBUaGlzIGlzXG4gKiBiZWNhdXNlIGBBcnJheS5wcm90b3R5cGUuc29ydGAgYml6YXJyZWx5IG1vdmVzIGFsbCBgdW5kZWZpbmVkYHMgdG9cbiAqIHRoZSBlbmQgb2YgdGhlIGFycmF5IHJlZ2FyZGxlc3MsIHdpdGhvdXQgY29uc3VsdGluZyB0aGUgYGNvbXBhcmVgXG4gKiBmdW5jdGlvbi4gVGhpcyBpcyBhIGdlbnVpbmUgYnVnIGZvciB1cyBOT1cgYmVjYXVzZSBzb21ldGltZXMgd2Ugc29ydFxuICogaW4gcmV2ZXJzZSBvcmRlciBieSBwYXNzaW5nIGEgcmV2ZXJzZWQgcmFuayBjb21wYXJpc29uIGZ1bmN0aW9uLlxuICpcbiAqIEBwYXJhbSB7SXRlcmFibGU8UGFzc2FibGU+fSBwYXNzYWJsZXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEByZXR1cm5zIHtQYXNzYWJsZVtdfVxuICovXG5jb25zdCAgICAgICAgc29ydEJ5UmFuaz0ocGFzc2FibGVzLGNvbXBhcmUpPT57XG5pZihBcnJheS5pc0FycmF5KHBhc3NhYmxlcykpe1xuaGFyZGVuKHBhc3NhYmxlcyk7XG4vKiBDYWxsaW5nIGlzUmFua1NvcnRlZCBnaXZlcyBpdCBhIGNoYW5jZSB0byBnZXQgbWVtb2l6ZWQgZm9yKi9cbi8qIHRoaXMgYGNvbXBhcmVgIGZ1bmN0aW9uIGV2ZW4gaWYgaXQgd2FzIGFscmVhZHkgbWVtb2l6ZWQgZm9yIGEgZGlmZmVyZW50Ki9cbi8qIGBjb21wYXJlYCBmdW5jdGlvbi4qL1xuaWYoaXNSYW5rU29ydGVkKHBhc3NhYmxlcyxjb21wYXJlKSl7XG5yZXR1cm4gcGFzc2FibGVzO1xuIH1cbiB9XG5jb25zdCB1bnNvcnRlZD1bLi4ucGFzc2FibGVzXTtcbnVuc29ydGVkLmZvckVhY2goaGFyZGVuKTtcbmNvbnN0IHNvcnRlZD1oYXJkZW4odW5zb3J0ZWQuc29ydChjb21wYXJlKSk7XG5jb25zdCBzdWJNZW1vT2ZTb3J0ZWQ9bWVtb09mU29ydGVkLmdldChjb21wYXJlKTtcbmFzc2VydChzdWJNZW1vT2ZTb3J0ZWQhPT11bmRlZmluZWQpO1xuc3ViTWVtb09mU29ydGVkLmFkZChzb3J0ZWQpO1xucmV0dXJuIHNvcnRlZDtcbiB9OyRo4oCNX29uY2Uuc29ydEJ5UmFuayhzb3J0QnlSYW5rKTtcbmhhcmRlbihzb3J0QnlSYW5rKTtcblxuLyoqXG4gKiBTZWVcbiAqIGh0dHBzOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL0JpbmFyeV9zZWFyY2hfYWxnb3JpdGhtI1Byb2NlZHVyZV9mb3JfZmluZGluZ190aGVfbGVmdG1vc3RfZWxlbWVudFxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBrZXlcbiAqIEBwYXJhbSB7KFwibGVmdE1vc3RcIiB8IFwicmlnaHRNb3N0XCIpPX0gYmlhc1xuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgcmFua1NlYXJjaD0oc29ydGVkLGNvbXBhcmUsa2V5LGJpYXM9J2xlZnRNb3N0Jyk9PntcbmFzc2VydFJhbmtTb3J0ZWQoc29ydGVkLGNvbXBhcmUpO1xubGV0IGxlZnQ9MDtcbmxldCByaWdodD1zb3J0ZWQubGVuZ3RoO1xud2hpbGUobGVmdDxyaWdodCl7XG5jb25zdCBtPU1hdGguZmxvb3IoKGxlZnQrcmlnaHQpLzIpO1xuY29uc3QgY29tcD1jb21wYXJlKHNvcnRlZFttXSxrZXkpO1xuaWYoY29tcDw9LTF8fGNvbXA9PT0wJiZiaWFzPT09J3JpZ2h0TW9zdCcpe1xubGVmdD1tKzE7XG4gfWVsc2V7XG5hc3NlcnQoY29tcD49MXx8Y29tcD09PTAmJmJpYXM9PT0nbGVmdE1vc3QnKTtcbnJpZ2h0PW07XG4gfVxuIH1cbnJldHVybiBiaWFzPT09J2xlZnRNb3N0Jz9sZWZ0OnJpZ2h0LTE7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHNvcnRlZFxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IHJhbmtDb3ZlclxuICogQHJldHVybnMge0luZGV4Q292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBnZXRJbmRleENvdmVyPShzb3J0ZWQsY29tcGFyZSxbbGVmdEtleSxyaWdodEtleV0pPT57XG5hc3NlcnRSYW5rU29ydGVkKHNvcnRlZCxjb21wYXJlKTtcbmNvbnN0IGxlZnRJbmRleD1yYW5rU2VhcmNoKHNvcnRlZCxjb21wYXJlLGxlZnRLZXksJ2xlZnRNb3N0Jyk7XG5jb25zdCByaWdodEluZGV4PXJhbmtTZWFyY2goc29ydGVkLGNvbXBhcmUscmlnaHRLZXksJ3JpZ2h0TW9zdCcpO1xucmV0dXJuW2xlZnRJbmRleCxyaWdodEluZGV4XTtcbiB9OyRo4oCNX29uY2UuZ2V0SW5kZXhDb3ZlcihnZXRJbmRleENvdmVyKTtcbmhhcmRlbihnZXRJbmRleENvdmVyKTtcblxuLyoqIEB0eXBlIHtSYW5rQ292ZXJ9ICovXG5jb25zdCAgICAgICAgRnVsbFJhbmtDb3Zlcj1oYXJkZW4oWycnLCd7J10pO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge0luZGV4Q292ZXJ9IGluZGV4Q292ZXJcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxbbnVtYmVyLCBQYXNzYWJsZV0+fVxuICovJGjigI1fb25jZS5GdWxsUmFua0NvdmVyKEZ1bGxSYW5rQ292ZXIpO1xuY29uc3QgICAgICAgIGNvdmVyZWRFbnRyaWVzPShzb3J0ZWQsW2xlZnRJbmRleCxyaWdodEluZGV4XSk9Pntcbi8qKiBAdHlwZSB7SXRlcmFibGU8W251bWJlciwgUGFzc2FibGVdPn0gKi9cbmNvbnN0IGl0ZXJhYmxlPWhhcmRlbih7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xubGV0IGk9bGVmdEluZGV4O1xucmV0dXJuIGhhcmRlbih7XG5uZXh0OigpPT57XG5pZihpPD1yaWdodEluZGV4KXtcbmNvbnN0IGVsZW1lbnQ9c29ydGVkW2ldO1xuaSs9MTtcbnJldHVybiBoYXJkZW4oe3ZhbHVlOltpLGVsZW1lbnRdLGRvbmU6ZmFsc2V9KTtcbiB9ZWxzZXtcbnJldHVybiBoYXJkZW4oe3ZhbHVlOnVuZGVmaW5lZCxkb25lOnRydWV9KTtcbiB9XG4gfX0pO1xuXG4gfX0pO1xuXG5yZXR1cm4gaXRlcmFibGU7XG4gfTskaOKAjV9vbmNlLmNvdmVyZWRFbnRyaWVzKGNvdmVyZWRFbnRyaWVzKTtcbmhhcmRlbihjb3ZlcmVkRW50cmllcyk7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtQYXNzYWJsZX0gYVxuICogQHBhcmFtIHtQYXNzYWJsZX0gYlxuICogQHJldHVybnMge1Bhc3NhYmxlfVxuICovXG5jb25zdCBtYXhSYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKT49MD9hOmI7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtQYXNzYWJsZX0gYVxuICogQHBhcmFtIHtQYXNzYWJsZX0gYlxuICogQHJldHVybnMge1Bhc3NhYmxlfVxuICovXG5jb25zdCBtaW5SYW5rPShjb21wYXJlLGEsYik9PmNvbXBhcmUoYSxiKTw9MD9hOmI7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJbXX0gY292ZXJzXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCAgICAgICAgdW5pb25SYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCB1bmlvblJhbmtDb3ZlclBhaXI9KFtsZWZ0QSxyaWdodEFdLFtsZWZ0QixyaWdodEJdKT0+W1xubWluUmFuayhjb21wYXJlLGxlZnRBLGxlZnRCKSxcbm1heFJhbmsoY29tcGFyZSxyaWdodEEscmlnaHRCKV07XG5cbnJldHVybiBjb3ZlcnMucmVkdWNlKHVuaW9uUmFua0NvdmVyUGFpcixbJ3snLCcnXSk7XG4gfTskaOKAjV9vbmNlLnVuaW9uUmFua0NvdmVycyh1bmlvblJhbmtDb3ZlcnMpO1xuaGFyZGVuKHVuaW9uUmFua0NvdmVycyk7XG5cbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHBhcmFtIHtSYW5rQ292ZXJbXX0gY292ZXJzXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCAgICAgICAgaW50ZXJzZWN0UmFua0NvdmVycz0oY29tcGFyZSxjb3ZlcnMpPT57XG4vKipcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBhXG4gKiBAcGFyYW0ge1JhbmtDb3Zlcn0gYlxuICogQHJldHVybnMge1JhbmtDb3Zlcn1cbiAqL1xuY29uc3QgaW50ZXJzZWN0UmFua0NvdmVyUGFpcj0oW2xlZnRBLHJpZ2h0QV0sW2xlZnRCLHJpZ2h0Ql0pPT5bXG5tYXhSYW5rKGNvbXBhcmUsbGVmdEEsbGVmdEIpLFxubWluUmFuayhjb21wYXJlLHJpZ2h0QSxyaWdodEIpXTtcblxucmV0dXJuIGNvdmVycy5yZWR1Y2UoaW50ZXJzZWN0UmFua0NvdmVyUGFpcixbJycsJ3snXSk7XG4gfTskaOKAjV9vbmNlLmludGVyc2VjdFJhbmtDb3ZlcnMoaW50ZXJzZWN0UmFua0NvdmVycyk7XG5cbmNvbnN0ICAgICAgIHtjb21wYXJhdG9yOmNvbXBhcmVSYW5rLGFudGlDb21wYXJhdG9yOmNvbXBhcmVBbnRpUmFua309XG5tYWtlQ29tcGFyYXRvcktpdCgpO1xuXG4vKipcbiAqIENyZWF0ZSBhIGNvbXBhcmF0b3Iga2l0IGluIHdoaWNoIHJlbW90YWJsZXMgYXJlIGZ1bGx5IG9yZGVyZWRcbiAqIGJ5IHRoZSBvcmRlciBpbiB3aGljaCB0aGV5IGFyZSBmaXJzdCBzZWVuIGJ5ICp0aGlzKiBjb21wYXJhdG9yIGtpdC5cbiAqIEJFV0FSRTogVGhpcyBpcyBvYnNlcnZhYmxlIG11dGFibGUgc3RhdGUsIHNvIHN1Y2ggYSBjb21wYXJhdG9yIGtpdFxuICogc2hvdWxkIG5ldmVyIGJlIHNoYXJlZCBhbW9uZyBzdWJzeXN0ZW1zIHRoYXQgc2hvdWxkIG5vdCBiZSBhYmxlXG4gKiB0byBjb21tdW5pY2F0ZS5cbiAqXG4gKiBOb3RlIHRoYXQgdGhpcyBvcmRlciBkb2VzIG5vdCBtZWV0IHRoZSByZXF1aXJlbWVudHMgZm9yIHN0b3JlXG4gKiBvcmRlcmluZywgc2luY2UgaXQgaGFzIG5vIG1lbW9yeSBvZiBkZWxldGVkIGtleXMuXG4gKlxuICogVGhlc2UgZnVsbCBvcmRlciBjb21wYXJhdG9yIGtpdCBpcyBzdHJpY3RseSBtb3JlIHByZWNpc2UgdGhhdCB0aGVcbiAqIHJhbmsgb3JkZXIgY29tcGFyYXRvciBraXRzIGFib3ZlLiBBcyBhIHJlc3VsdCwgYW55IGFycmF5IHdoaWNoIGlzXG4gKiBzb3J0ZWQgYnkgc3VjaCBhIGZ1bGwgb3JkZXIgd2lsbCBwYXNzIHRoZSBpc1JhbmtTb3J0ZWQgdGVzdCB3aXRoXG4gKiBhIGNvcnJlc3BvbmRpbmcgcmFuayBvcmRlci5cbiAqXG4gKiBBbiBhcnJheSB3aGljaCBpcyBzb3J0ZWQgYnkgYSAqZnJlc2gqIGZ1bGwgb3JkZXIgY29tcGFyYXRvciwgaS5lLixcbiAqIG9uZSB0aGF0IGhhcyBub3QgeWV0IHNlZW4gYW55IHJlbW90YWJsZXMsIHdpbGwgb2YgY291cnNlIHJlbWFpblxuICogc29ydGVkIGJ5IGFjY29yZGluZyB0byAqdGhhdCogZnVsbCBvcmRlciBjb21wYXJhdG9yLiBBbiBhcnJheSAqb2ZcbiAqIHNjYWxhcnMqIHNvcnRlZCBieSBhIGZyZXNoIGZ1bGwgb3JkZXIgd2lsbCByZW1haW4gc29ydGVkIGV2ZW5cbiAqIGFjY29yZGluZyB0byBhIG5ldyBmcmVzaCBmdWxsIG9yZGVyIGNvbXBhcmF0b3IsIHNpbmNlIGl0IHdpbGwgc2VlXG4gKiB0aGUgcmVtb3RhYmxlcyBpbiB0aGUgc2FtZSBvcmRlciBhZ2Fpbi4gVW5mb3J0dW5hdGVseSwgdGhpcyBpc1xuICogbm90IHRydWUgb2YgYXJyYXlzIG9mIHBhc3NhYmxlcyBpbiBnZW5lcmFsLlxuICpcbiAqIEBwYXJhbSB7Ym9vbGVhbj19IGxvbmdMaXZlZFxuICogQHJldHVybnMge0Z1bGxDb21wYXJhdG9yS2l0fVxuICovJGjigI1fb25jZS5jb21wYXJlUmFuayhjb21wYXJlUmFuayk7JGjigI1fb25jZS5jb21wYXJlQW50aVJhbmsoY29tcGFyZUFudGlSYW5rKTtcbmNvbnN0ICAgICAgICBtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdD0obG9uZ0xpdmVkPWZhbHNlKT0+e1xubGV0IG51bVNlZW49MDtcbi8qIFdoZW4gZHluYW1pY2FsbHkgY3JlYXRlZCB3aXRoIHNob3J0IGxpZmV0aW1lcyAodGhlIGRlZmF1bHQpIGEgV2Vha01hcCovXG4vKiB3b3VsZCBwZXJmb3JtIHBvb3JseSwgYW5kIHRoZSBsZWFrIGNyZWF0ZWQgYnkgYSBNYXAgb25seSBsYXN0cyBhcyBsb25nKi9cbi8qIGFzIHRoZSBNYXAuKi9cbmNvbnN0IE1hcENvbnN0cnVjdG9yPWxvbmdMaXZlZD9XZWFrTWFwOk1hcDtcbmNvbnN0IHNlZW49bmV3IE1hcENvbnN0cnVjdG9yKCk7XG5jb25zdCB0YWc9KHIpPT57XG5pZihzZWVuLmhhcyhyKSl7XG5yZXR1cm4gc2Vlbi5nZXQocik7XG4gfVxubnVtU2Vlbis9MTtcbnNlZW4uc2V0KHIsbnVtU2Vlbik7XG5yZXR1cm4gbnVtU2VlbjtcbiB9O1xuY29uc3QgY29tcGFyZVJlbW90YWJsZXM9KHgseSk9PmNvbXBhcmVSYW5rKHRhZyh4KSx0YWcoeSkpO1xucmV0dXJuIG1ha2VDb21wYXJhdG9yS2l0KGNvbXBhcmVSZW1vdGFibGVzKTtcbiB9OyRo4oCNX29uY2UubWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQobWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQpO1xuaGFyZGVuKG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRQYXNzU3R5bGVDb3ZlciI6WyJnZXRQYXNzU3R5bGVDb3ZlciJdLCJtYWtlQ29tcGFyYXRvcktpdCI6WyJtYWtlQ29tcGFyYXRvcktpdCJdLCJjb21wYXJhdG9yTWlycm9ySW1hZ2UiOlsiY29tcGFyYXRvck1pcnJvckltYWdlIl0sImlzUmFua1NvcnRlZCI6WyJpc1JhbmtTb3J0ZWQiXSwiYXNzZXJ0UmFua1NvcnRlZCI6WyJhc3NlcnRSYW5rU29ydGVkIl0sInNvcnRCeVJhbmsiOlsic29ydEJ5UmFuayJdLCJnZXRJbmRleENvdmVyIjpbImdldEluZGV4Q292ZXIiXSwiRnVsbFJhbmtDb3ZlciI6WyJGdWxsUmFua0NvdmVyIl0sImNvdmVyZWRFbnRyaWVzIjpbImNvdmVyZWRFbnRyaWVzIl0sInVuaW9uUmFua0NvdmVycyI6WyJ1bmlvblJhbmtDb3ZlcnMiXSwiaW50ZXJzZWN0UmFua0NvdmVycyI6WyJpbnRlcnNlY3RSYW5rQ292ZXJzIl0sImNvbXBhcmVSYW5rIjpbImNvbXBhcmVSYW5rIl0sImNvbXBhcmVBbnRpUmFuayI6WyJjb21wYXJlQW50aVJhbmsiXSwibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiOlsibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAmBk7szQBAAA0AQAAIQAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAlHpu9zwsAAM8LAAAeAAAAQGVuZG8vbmF0LXY0LjEuMjcvc3JjL2luZGV4LmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJOYXQiLCJpc05hdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShpc05hdCwgJ25hbWUnLCB7dmFsdWU6IFwiaXNOYXRcIn0pOyRo4oCNX29uY2UuaXNOYXQoaXNOYXQpO09iamVjdC5kZWZpbmVQcm9wZXJ0eShOYXQsICduYW1lJywge3ZhbHVlOiBcIk5hdFwifSk7JGjigI1fb25jZS5OYXQoTmF0KTsgICAvKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4qL1xuLyogQ29weXJpZ2h0IChDKSAyMDE4IEFnb3JpYyovXG4vKiovXG4vKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpOyovXG4vKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuKi9cbi8qIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdCovXG4vKiovXG4vKiBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAqL1xuLyoqL1xuLyogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZSovXG4vKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsKi9cbi8qIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLiovXG4vKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kKi9cbi8qIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLiovXG5cbi8qIEB0cy1jaGVjayovXG5cbi8qKlxuICogSXMgYGFsbGVnZWROdW1gIGEgbnVtYmVyIGluIHRoZSBbY29udGlndW91cyByYW5nZSBvZiBleGFjdGx5IGFuZFxuICogdW5hbWJpZ3VvdXNseVxuICogcmVwcmVzZW50YWJsZV0oaHR0cHM6Ly9lc2Rpc2N1c3Mub3JnL3RvcGljL21vcmUtbnVtZXJpYy1jb25zdGFudHMtcGxlYXNlLWVzcGVjaWFsbHktZXBzaWxvbiNjb250ZW50LTE0KVxuICogIG5hdHVyYWwgbnVtYmVycyAobm9uLW5lZ2F0aXZlIGludGVnZXJzKT9cbiAqXG4gKiBUbyBxdWFsaWZ5IGBhbGxlZ2VkTnVtYCBtdXN0IGVpdGhlciBiZSBhXG4gKiBub24tbmVnYXRpdmUgYGJpZ2ludGAsIG9yIGEgbm9uLW5lZ2F0aXZlIGBudW1iZXJgIHJlcHJlc2VudGluZyBhbiBpbnRlZ2VyXG4gKiB3aXRoaW4gcmFuZ2Ugb2YgW2ludGVnZXJzIHNhZmVseSByZXByZXNlbnRhYmxlIGluXG4gKiBmbG9hdGluZyBwb2ludF0oaHR0cHM6Ly90YzM5LmVzL2VjbWEyNjIvI3NlYy1udW1iZXIuaXNzYWZlaW50ZWdlcikuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBhbGxlZ2VkTnVtXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuZnVuY3Rpb24gaXNOYXQoYWxsZWdlZE51bSl7XG5pZih0eXBlb2YgYWxsZWdlZE51bT09PSdiaWdpbnQnKXtcbnJldHVybiBhbGxlZ2VkTnVtPj0wO1xuIH1cbmlmKHR5cGVvZiBhbGxlZ2VkTnVtIT09J251bWJlcicpe1xucmV0dXJuIGZhbHNlO1xuIH1cblxucmV0dXJuIE51bWJlci5pc1NhZmVJbnRlZ2VyKGFsbGVnZWROdW0pJiZhbGxlZ2VkTnVtPj0wO1xuIH1cblxuLyoqXG4gKiBJZiBgYWxsZWdlZE51bWJlcmAgcGFzc2VzIHRoZSBgaXNOYXRgIHRlc3QsIHRoZW4gcmV0dXJuIGl0IGFzIGEgYmlnaW50LlxuICogT3RoZXJ3aXNlIHRocm93IGFuIGFwcHJvcHJpYXRlIGVycm9yLlxuICpcbiAqIElmIGBhbGxlZ2VkTnVtYCBpcyBuZWl0aGVyIGEgYmlnaW50IG5vciBhIG51bWJlciwgYE5hdGAgdGhyb3dzIGEgYFR5cGVFcnJvcmAuXG4gKiBPdGhlcndpc2UsIGlmIGl0IGlzIG5vdCBhIFtzYWZlbHlcbiAqIHJlcHJlc2VudGFibGVdKGh0dHBzOi8vZXNkaXNjdXNzLm9yZy90b3BpYy9tb3JlLW51bWVyaWMtY29uc3RhbnRzLXBsZWFzZS1lc3BlY2lhbGx5LWVwc2lsb24jY29udGVudC0xNClcbiAqIG5vbi1uZWdhdGl2ZSBpbnRlZ2VyLCBgTmF0YCB0aHJvd3MgYSBgUmFuZ2VFcnJvcmAuXG4gKiBPdGhlcndpc2UsIGl0IGlzIGNvbnZlcnRlZCB0byBhIGJpZ2ludCBpZiBuZWNlc3NhcnkgYW5kIHJldHVybmVkLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gYWxsZWdlZE51bVxuICogQHJldHVybnMge2JpZ2ludH1cbiAqL1xuZnVuY3Rpb24gTmF0KGFsbGVnZWROdW0pe1xuaWYodHlwZW9mIGFsbGVnZWROdW09PT0nYmlnaW50Jyl7XG5pZihhbGxlZ2VkTnVtPDApe1xudGhyb3cgbmV3IFJhbmdlRXJyb3IoIGAke2FsbGVnZWROdW19IGlzIG5lZ2F0aXZlYCk7XG4gfVxucmV0dXJuIGFsbGVnZWROdW07XG4gfVxuXG5pZih0eXBlb2YgYWxsZWdlZE51bT09PSdudW1iZXInKXtcbmlmKCFOdW1iZXIuaXNTYWZlSW50ZWdlcihhbGxlZ2VkTnVtKSl7XG50aHJvdyBuZXcgUmFuZ2VFcnJvciggYCR7YWxsZWdlZE51bX0gbm90IGEgc2FmZSBpbnRlZ2VyYCk7XG4gfVxuaWYoYWxsZWdlZE51bTwwKXtcbnRocm93IG5ldyBSYW5nZUVycm9yKCBgJHthbGxlZ2VkTnVtfSBpcyBuZWdhdGl2ZWApO1xuIH1cbnJldHVybiBCaWdJbnQoYWxsZWdlZE51bSk7XG4gfVxuXG50aHJvdyBuZXcgVHlwZUVycm9yKFxuIGAke2FsbGVnZWROdW19IGlzIGEgJHt0eXBlb2YgYWxsZWdlZE51bX0gYnV0IG11c3QgYmUgYSBiaWdpbnQgb3IgYSBudW1iZXJgKTtcblxuIH1cbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJpc05hdCI6WyJpc05hdCJdLCJOYXQiOlsiTmF0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGXyjBp8CAAAfAgAACAAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9lcnJvci5qcyIsIi4vc3JjL2l0ZXItaGVscGVycy5qcyIsIi4vc3JjL21ha2UtZmFyLmpzIiwiLi9zcmMvbWFrZVRhZ2dlZC5qcyIsIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9zcmMvcGFzc1N0eWxlT2YuanMiLCIuL3NyYy9yZW1vdGFibGUuanMiLCIuL3NyYy9zeW1ib2wuanMiLCIuL3NyYy90eXBlR3VhcmRzLmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiZXhwb3J0cyI6WyJGYXIiLCJGYXIiLCJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIiwiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSIsImlzT2JqZWN0IiwiaXNPYmplY3QiLCJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsInRvUGFzc2FibGVFcnJvciIsInRvUGFzc2FibGVFcnJvciIsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9zcmMvaXRlci1oZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbXV0sW1wiLi9zcmMvZXJyb3IuanNcIiwgW11dLFtcIi4vc3JjL3JlbW90YWJsZS5qc1wiLCBbXV0sW1wiLi9zcmMvc3ltYm9sLmpzXCIsIFtdXSxbXCIuL3NyYy9wYXNzU3R5bGVPZi5qc1wiLCBbXV0sW1wiLi9zcmMvbWFrZVRhZ2dlZC5qc1wiLCBbXV0sW1wiLi9zcmMvbWFrZS1mYXIuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVHdWFyZHMuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2l0ZXItaGVscGVycy5qcyI6W1sibWFwSXRlcmFibGUiLCJtYXBJdGVyYWJsZSJdLFsiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSJdXSwiLi9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanMiOltbIlBBU1NfU1RZTEUiLCJQQVNTX1NUWUxFIl0sWyJpc09iamVjdCIsImlzT2JqZWN0Il0sWyJhc3NlcnRDaGVja2VyIiwiYXNzZXJ0Q2hlY2tlciJdLFsiZ2V0VGFnIiwiZ2V0VGFnIl0sWyJoYXNPd25Qcm9wZXJ0eU9mIiwiaGFzT3duUHJvcGVydHlPZiJdXSwiLi9zcmMvZXJyb3IuanMiOltbImdldEVycm9yQ29uc3RydWN0b3IiLCJnZXRFcnJvckNvbnN0cnVjdG9yIl0sWyJ0b1Bhc3NhYmxlRXJyb3IiLCJ0b1Bhc3NhYmxlRXJyb3IiXSxbImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiXV0sIi4vc3JjL3JlbW90YWJsZS5qcyI6W1siZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdXSwiLi9zcmMvc3ltYm9sLmpzIjpbWyJhc3NlcnRQYXNzYWJsZVN5bWJvbCIsImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sWyJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCJdLFsibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sWyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiLCJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXV0sIi4vc3JjL3Bhc3NTdHlsZU9mLmpzIjpbWyJwYXNzU3R5bGVPZiIsInBhc3NTdHlsZU9mIl0sWyJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIl1dLCIuL3NyYy9tYWtlVGFnZ2VkLmpzIjpbWyJtYWtlVGFnZ2VkIiwibWFrZVRhZ2dlZCJdXSwiLi9zcmMvbWFrZS1mYXIuanMiOltbIlJlbW90YWJsZSIsIlJlbW90YWJsZSJdLFsiRmFyIiwiRmFyIl0sWyJUb0ZhckZ1bmN0aW9uIiwiVG9GYXJGdW5jdGlvbiJdXSwiLi9zcmMvdHlwZUd1YXJkcy5qcyI6W1siYXNzZXJ0UmVjb3JkIiwiYXNzZXJ0UmVjb3JkIl0sWyJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiXSxbImFzc2VydFJlbW90YWJsZSIsImFzc2VydFJlbW90YWJsZSJdLFsiaXNSZW1vdGFibGUiLCJpc1JlbW90YWJsZSJdLFsiaXNSZWNvcmQiLCJpc1JlY29yZCJdLFsiaXNDb3B5QXJyYXkiLCJpc0NvcHlBcnJheSJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA3ka2qpMHAACTBwAAKAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9jb3B5QXJyYXkuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlBcnJheUhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLGNoZWNrTm9ybWFsUHJvcGVydHk7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiY2hlY2tOb3JtYWxQcm9wZXJ0eVwiLCBbJGjigI1fYSA9PiAoY2hlY2tOb3JtYWxQcm9wZXJ0eSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3R7ZGV0YWlsczpYfT1hc3NlcnQ7XG5jb25zdHtnZXRQcm90b3R5cGVPZn09T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXkscHJvdG90eXBlOmFycmF5UHJvdG90eXBlfT1BcnJheTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNhbkJlVmFsaWQ9KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT5cbmlzQXJyYXkoY2FuZGlkYXRlKXx8XG4hIWNoZWNrJiZjaGVjayhmYWxzZSxYIGBBcnJheSBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCk7XG5cbi8qKlxuICpcbiAqIEB0eXBlIHtYaW1wb3J0KCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgQ29weUFycmF5SGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2NvcHlBcnJheScsXG5cbmNhbkJlVmFsaWQsXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKT09PWFycmF5UHJvdG90eXBlfHxcbmFzc2VydC5mYWlsKFggYE1hbGZvcm1lZCBhcnJheTogJHtjYW5kaWRhdGV9YCxUeXBlRXJyb3IpO1xuLyogU2luY2Ugd2UncmUgYWxyZWFkeSBlbnN1cmVkIGNhbmRpZGF0ZSBpcyBhbiBhcnJheSwgaXQgc2hvdWxkIG5vdCBiZSovXG4vKiBwb3NzaWJsZSBmb3IgdGhlIGZvbGxvd2luZyB0ZXN0IHRvIGZhaWwqL1xuY2hlY2tOb3JtYWxQcm9wZXJ0eShjYW5kaWRhdGUsJ2xlbmd0aCcsZmFsc2UsYXNzZXJ0Q2hlY2tlcik7XG5jb25zdCBsZW49LyoqIEB0eXBlIHt1bmtub3duW119ICovY2FuZGlkYXRlLmxlbmd0aDtcbmZvcihsZXQgaT0wO2k8bGVuO2krPTEpe1xuY2hlY2tOb3JtYWxQcm9wZXJ0eShjYW5kaWRhdGUsaSx0cnVlLGFzc2VydENoZWNrZXIpO1xuIH1cbi8qICsxIGZvciB0aGUgJ2xlbmd0aCcgcHJvcGVydHkgaXRzZWxmLiovXG5vd25LZXlzKGNhbmRpZGF0ZSkubGVuZ3RoPT09bGVuKzF8fFxuYXNzZXJ0LmZhaWwoWCBgQXJyYXlzIG11c3Qgbm90IGhhdmUgbm9uLWluZGV4ZXM6ICR7Y2FuZGlkYXRlfWAsVHlwZUVycm9yKTtcbi8qIFJlY3Vyc2l2ZWx5IHZhbGlkYXRlIHRoYXQgZWFjaCBtZW1iZXIgaXMgcGFzc2FibGUuKi9cbmNhbmRpZGF0ZS5ldmVyeSgodik9PiEhcGFzc1N0eWxlT2ZSZWN1cih2KSk7XG4gfX0pOyRo4oCNX29uY2UuQ29weUFycmF5SGVscGVyKENvcHlBcnJheUhlbHBlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ29weUFycmF5SGVscGVyIjpbIkNvcHlBcnJheUhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACD9dsszwcAAM8HAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2NvcHlSZWNvcmQuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlSZWNvcmRIZWxwZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixjYW5CZU1ldGhvZCxjaGVja05vcm1hbFByb3BlcnR5OyRo4oCNX2ltcG9ydHMoW1tcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcImNhbkJlTWV0aG9kXCIsIFskaOKAjV9hID0+IChjYW5CZU1ldGhvZCA9ICRo4oCNX2EpXV0sW1wiY2hlY2tOb3JtYWxQcm9wZXJ0eVwiLCBbJGjigI1fYSA9PiAoY2hlY2tOb3JtYWxQcm9wZXJ0eSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5jb25zdHtkZXRhaWxzOlh9PWFzc2VydDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtnZXRQcm90b3R5cGVPZix2YWx1ZXMscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIENvcHlSZWNvcmRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonY29weVJlY29yZCcsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuaWYoZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKSE9PW9iamVjdFByb3RvdHlwZSl7XG5yZXR1cm4oXG5yZWplY3QmJlxucmVqZWN0KFggYFJlY29yZHMgbXVzdCBpbmhlcml0IGZyb20gT2JqZWN0LnByb3RvdHlwZTogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfVxuXG5yZXR1cm4gb3duS2V5cyhjYW5kaWRhdGUpLmV2ZXJ5KChrZXkpPT57XG5yZXR1cm4oXG4odHlwZW9mIGtleT09PSdzdHJpbmcnfHxcbiEhcmVqZWN0JiZcbnJlamVjdChcblggYFJlY29yZHMgY2FuIG9ubHkgaGF2ZSBzdHJpbmctbmFtZWQgcHJvcGVydGllczogJHtjYW5kaWRhdGV9YCkpJiYoXG5cbiFjYW5CZU1ldGhvZChjYW5kaWRhdGVba2V5XSl8fFxuISFyZWplY3QmJlxucmVqZWN0KFxuLyogVE9ETzogVXBkYXRlIG1lc3NhZ2Ugbm93IHRoYXQgdGhlcmUgaXMgbm8gc3VjaCB0aGluZyBhcyBcImltcGxpY2l0IFJlbW90YWJsZVwiLiovXG5YIGBSZWNvcmRzIGNhbm5vdCBjb250YWluIG5vbi1mYXIgZnVuY3Rpb25zIGJlY2F1c2UgdGhleSBtYXkgYmUgbWV0aG9kcyBvZiBhbiBpbXBsaWNpdCBSZW1vdGFibGU6ICR7Y2FuZGlkYXRlfWApKSk7XG5cblxuIH0pO1xuIH0sXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbkNvcHlSZWNvcmRIZWxwZXIuY2FuQmVWYWxpZChjYW5kaWRhdGUsYXNzZXJ0Q2hlY2tlcik7XG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGNhbmRpZGF0ZSkpe1xuY2hlY2tOb3JtYWxQcm9wZXJ0eShjYW5kaWRhdGUsbmFtZSx0cnVlLGFzc2VydENoZWNrZXIpO1xuIH1cbi8qIFJlY3Vyc2l2ZWx5IHZhbGlkYXRlIHRoYXQgZWFjaCBtZW1iZXIgaXMgcGFzc2FibGUuKi9cbmZvcihjb25zdCB2YWwgb2YgdmFsdWVzKGNhbmRpZGF0ZSkpe1xucGFzc1N0eWxlT2ZSZWN1cih2YWwpO1xuIH1cbiB9fSk7JGjigI1fb25jZS5Db3B5UmVjb3JkSGVscGVyKENvcHlSZWNvcmRIZWxwZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNvcHlSZWNvcmRIZWxwZXIiOlsiQ29weVJlY29yZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADToDhxnREAAJ0RAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2Vycm9yLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJFcnJvckhlbHBlciIsImdldEVycm9yQ29uc3RydWN0b3IiLCJpc0Vycm9yTGlrZSIsInRvUGFzc2FibGVFcnJvciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyOyRo4oCNX2ltcG9ydHMoW1tcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn0gUGFzc1N0eWxlSGVscGVyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5DaGVja2VyfSBDaGVja2VyICovXG5cbmNvbnN0e2RldGFpbHM6WCxGYWlsfT1hc3NlcnQ7XG5jb25zdHtnZXRQcm90b3R5cGVPZixnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiBUT0RPOiBNYWludGVuYW5jZSBoYXphcmQ6IENvb3JkaW5hdGUgd2l0aCB0aGUgbGlzdCBvZiBlcnJvcnMgaW4gdGhlIFNFUyovXG4vKiB3aGlsZWxpc3QuIEN1cnJlbnRseSwgYm90aCBvbWl0IEFnZ3JlZ2F0ZUVycm9yLCB3aGljaCBpcyBub3cgc3RhbmRhcmQuIEJvdGgqL1xuLyogbXVzdCBldmVudHVhbGx5IGluY2x1ZGUgaXQuKi9cbmNvbnN0IGVycm9yQ29uc3RydWN0b3JzPW5ldyBNYXAoW1xuWydFcnJvcicsRXJyb3JdLFxuWydFdmFsRXJyb3InLEV2YWxFcnJvcl0sXG5bJ1JhbmdlRXJyb3InLFJhbmdlRXJyb3JdLFxuWydSZWZlcmVuY2VFcnJvcicsUmVmZXJlbmNlRXJyb3JdLFxuWydTeW50YXhFcnJvcicsU3ludGF4RXJyb3JdLFxuWydUeXBlRXJyb3InLFR5cGVFcnJvcl0sXG5bJ1VSSUVycm9yJyxVUklFcnJvcl1dKTtcblxuXG5jb25zdCAgICAgICAgZ2V0RXJyb3JDb25zdHJ1Y3Rvcj0obmFtZSk9PmVycm9yQ29uc3RydWN0b3JzLmdldChuYW1lKTskaOKAjV9vbmNlLmdldEVycm9yQ29uc3RydWN0b3IoZ2V0RXJyb3JDb25zdHJ1Y3Rvcik7XG5oYXJkZW4oZ2V0RXJyb3JDb25zdHJ1Y3Rvcik7XG5cbi8qKlxuICogQHBhcmFtIHt1bmtub3dufSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrRXJyb3JMaWtlPShjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbi8qIFRPRE86IE5lZWQgYSBiZXR0ZXIgdGVzdCB0aGFuIGluc3RhbmNlb2YqL1xucmV0dXJuKFxuY2FuZGlkYXRlIGluc3RhbmNlb2YgRXJyb3J8fFxucmVqZWN0JiZyZWplY3QoWCBgRXJyb3IgZXhwZWN0ZWQ6ICR7Y2FuZGlkYXRlfWApKTtcblxuIH07XG5oYXJkZW4oY2hlY2tFcnJvckxpa2UpO1xuXG4vKipcbiAqIFZhbGlkYXRpbmcgZXJyb3Igb2JqZWN0cyBhcmUgcGFzc2FibGUgcmFpc2VzIGEgdGVuc2lvbiBiZXR3ZWVuIHNlY3VyaXR5XG4gKiB2cyBwcmVzZXJ2aW5nIGRpYWdub3N0aWMgaW5mb3JtYXRpb24uIEZvciBlcnJvcnMsIHdlIG5lZWQgdG8gcmVtZW1iZXJcbiAqIHRoZSBlcnJvciBpdHNlbGYgZXhpc3RzIHRvIGhlbHAgdXMgZGlhZ25vc2UgYSBidWcgdGhhdCdzIGxpa2VseSBtb3JlXG4gKiBwcmVzc2luZyB0aGFuIGEgdmFsaWRpdHkgYnVnIGluIHRoZSBlcnJvciBpdHNlbGYuIFRodXMsIHdoZW5ldmVyIGl0IGlzIHNhZmVcbiAqIHRvIGRvIHNvLCB3ZSBwcmVmZXIgdG8gbGV0IHRoZSBlcnJvci1saWtlIHRlc3Qgc3VjY2VlZCBhbmQgdG8gY291Y2ggdGhlc2VcbiAqIGNvbXBsYWludHMgYXMgbm90ZXMgb24gdGhlIGVycm9yLlxuICpcbiAqIFRvIHJlc29sdmUgdGhpcywgc3VjaCBhIG1hbGZvcm1lZCBlcnJvciBvYmplY3Qgd2lsbCBzdGlsbCBwYXNzXG4gKiBgaXNFcnJvckxpa2VgIHNvIG1hcnNoYWwgY2FuIHVzZSB0aGlzIGZvciB0b3AgbGV2ZWwgZXJyb3IgdG8gcmVwb3J0IGZyb20sXG4gKiBldmVuIGlmIGl0IHdvdWxkIG5vdCBhY3R1YWxseSB2YWxpZGF0ZS5cbiAqIEluc3RlYWQsIHRoZSBkaWFnbm9zdGljcyB0aGF0IGBhc3NlcnRFcnJvcmAgd291bGQgaGF2ZSByZXBvcnRlZCBhcmVcbiAqIGF0dGFjaGVkIGFzIG5vdGVzIHRvIHRoZSBtYWxmb3JtZWQgZXJyb3IuIFRodXMsIGEgbWFsZm9ybWVkXG4gKiBlcnJvciBpcyBwYXNzYWJsZSBieSBpdHNlbGYsIGJ1dCBub3QgYXMgcGFydCBvZiBhIHBhc3NhYmxlIHN0cnVjdHVyZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc0Vycm9yTGlrZT0oY2FuZGlkYXRlKT0+Y2hlY2tFcnJvckxpa2UoY2FuZGlkYXRlKTskaOKAjV9vbmNlLmlzRXJyb3JMaWtlKGlzRXJyb3JMaWtlKTtcbmhhcmRlbihpc0Vycm9yTGlrZSk7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIEVycm9ySGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2Vycm9yJyxcblxuY2FuQmVWYWxpZDpjaGVja0Vycm9yTGlrZSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSk9PntcbkVycm9ySGVscGVyLmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuY29uc3QgcHJvdG89Z2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKTtcbmNvbnN0e25hbWV9PXByb3RvO1xuY29uc3QgRUM9Z2V0RXJyb3JDb25zdHJ1Y3RvcihuYW1lKTtcbkVDJiZFQy5wcm90b3R5cGU9PT1wcm90b3x8XG5GYWlsIGBFcnJvcnMgbXVzdCBpbmhlcml0IGZyb20gYW4gZXJyb3IgY2xhc3MgLnByb3RvdHlwZSAke2NhbmRpZGF0ZX1gO1xuXG5jb25zdHtcbi8qIE11c3QgYWxsb3cgYGNhdXNlYCwgYGVycm9yc2AqL1xubWVzc2FnZTptRGVzYyxcbi8qIEFsbG93IGJ1dCBpZ25vcmUgb25seSBleHRyYW5lb3VzIG93biBgc3RhY2tgIHByb3BlcnR5LiovXG5zdGFjazpfb3B0U3RhY2tEZXNjLFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoY2FuZGlkYXRlKTtcbm93bktleXMocmVzdERlc2NzKS5sZW5ndGg8MXx8XG5GYWlsIGBQYXNzZWQgRXJyb3IgaGFzIGV4dHJhIHVucGFzc2VkIHByb3BlcnRpZXMgJHtyZXN0RGVzY3N9YDtcbmlmKG1EZXNjKXtcbnR5cGVvZiBtRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbkZhaWwgYFBhc3NlZCBFcnJvciBcIm1lc3NhZ2VcIiAke21EZXNjfSBtdXN0IGJlIGEgc3RyaW5nLXZhbHVlZCBkYXRhIHByb3BlcnR5LmA7XG4hbURlc2MuZW51bWVyYWJsZXx8XG5GYWlsIGBQYXNzZWQgRXJyb3IgXCJtZXNzYWdlXCIgJHttRGVzY30gbXVzdCBub3QgYmUgZW51bWVyYWJsZWA7XG4gfVxucmV0dXJuIHRydWU7XG4gfX0pO1xuXG5cbi8qKlxuICogUmV0dXJuIGEgbmV3IHBhc3NhYmxlIGVycm9yIHRoYXQgcHJvcGFnYXRlcyB0aGUgZGlhZ25vc3RpYyBpbmZvIG9mIHRoZVxuICogb3JpZ2luYWwsIGFuZCBpcyBsaW5rZWQgdG8gdGhlIG9yaWdpbmFsIGFzIGEgbm90ZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEByZXR1cm5zIHtFcnJvcn1cbiAqLyRo4oCNX29uY2UuRXJyb3JIZWxwZXIoRXJyb3JIZWxwZXIpO1xuY29uc3QgICAgICAgIHRvUGFzc2FibGVFcnJvcj0oZXJyKT0+e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1lcnI7XG5cbmNvbnN0IEVDPWdldEVycm9yQ29uc3RydWN0b3IoIGAke25hbWV9YCl8fEVycm9yO1xuY29uc3QgbmV3RXJyb3I9aGFyZGVuKG5ldyBFQyggYCR7bWVzc2FnZX1gKSk7XG4vKiBFdmVuIHRoZSBjbGVhbmVkIHVwIGVycm9yIGNvcHksIGlmIHNlbnQgdG8gdGhlIGNvbnNvbGUsIHNob3VsZCovXG4vKiBjYXVzZSBoaWRkZW4gZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiBvZiB0aGUgb3JpZ2luYWwgZXJyb3IqL1xuLyogdG8gYmUgbG9nZ2VkLiovXG5hc3NlcnQubm90ZShuZXdFcnJvcixYIGBjb3BpZWQgZnJvbSBlcnJvciAke2Vycn1gKTtcbnJldHVybiBuZXdFcnJvcjtcbiB9OyRo4oCNX29uY2UudG9QYXNzYWJsZUVycm9yKHRvUGFzc2FibGVFcnJvcik7XG5oYXJkZW4odG9QYXNzYWJsZUVycm9yKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRFcnJvckNvbnN0cnVjdG9yIjpbImdldEVycm9yQ29uc3RydWN0b3IiXSwiaXNFcnJvckxpa2UiOlsiaXNFcnJvckxpa2UiXSwiRXJyb3JIZWxwZXIiOlsiRXJyb3JIZWxwZXIiXSwidG9QYXNzYWJsZUVycm9yIjpbInRvUGFzc2FibGVFcnJvciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABKO2aDVQgAAFUIAAArAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2l0ZXItaGVscGVycy5qc3siaW1wb3J0cyI6WyIuL21ha2UtZmFyLmpzIl0sImV4cG9ydHMiOlsiZmlsdGVySXRlcmFibGUiLCJtYXBJdGVyYWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYXI7JGjigI1faW1wb3J0cyhbW1wiLi9tYWtlLWZhci5qc1wiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuLyoqXG4gKiBUaGUgcmVzdWx0IGl0ZXJhdG9yIGhhcyBhcyBtYW55IGVsZW1lbnRzIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCBhbmRcbiAqIGhhdmUgdGhlIHNhbWUgdGVybWluYXRpb24gLS0gdGhlIHNhbWUgY29tcGxldGlvbiB2YWx1ZSBvciBmYWlsdXJlXG4gKiByZWFzb24uIEJ1dCB0aGUgbm9uLWZpbmFsIHZhbHVlcyBhcmUgdGhlIGNvcnJlc3BvbmRpbmcgbm9uLWZpbmFsXG4gKiB2YWx1ZXMgZnJvbSBgYmFzZUl0ZXJhdG9yYCBhcyB0cmFuc2Zvcm1lZCBieSBgZnVuY2AuXG4gKlxuICogQHRlbXBsYXRlIFQsVVxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gVX0gZnVuY1xuICogQHJldHVybnMge0l0ZXJhYmxlPFU+fVxuICovXG5jb25zdCAgICAgICAgbWFwSXRlcmFibGU9KGJhc2VJdGVyYWJsZSxmdW5jKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdtYXBwZWQgaXRlcmFibGUnLHtcbltTeW1ib2wuaXRlcmF0b3JdOigpPT57XG5jb25zdCBiYXNlSXRlcmF0b3I9YmFzZUl0ZXJhYmxlW1N5bWJvbC5pdGVyYXRvcl0oKTtcbnJldHVybiBGYXIoJ21hcHBlZCBpdGVyYXRvcicse1xubmV4dDooKT0+e1xuY29uc3R7dmFsdWU6YmFzZVZhbHVlLGRvbmV9PWJhc2VJdGVyYXRvci5uZXh0KCk7XG5jb25zdCB2YWx1ZT1kb25lP2Jhc2VWYWx1ZTpmdW5jKGJhc2VWYWx1ZSk7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZSxkb25lfSk7XG4gfX0pO1xuXG4gfX0pOyRo4oCNX29uY2UubWFwSXRlcmFibGUobWFwSXRlcmFibGUpO1xuXG5oYXJkZW4obWFwSXRlcmFibGUpO1xuXG4vKipcbiAqIFRoZSByZXN1bHQgaXRlcmF0b3IgaGFzIGEgc3Vic2V0IG9mIHRoZSBub24tZmluYWwgdmFsdWVzIGZyb20gdGhlXG4gKiBgYmFzZUl0ZXJhdG9yYCAtLS0gdGhvc2UgZm9yIHdoaWNoIGBwcmVkKHZhbHVlKWAgd2FzIHRydXRoeS4gVGhlIHJlc3VsdFxuICogaGFzIHRoZSBzYW1lIHRlcm1pbmF0aW9uIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCAtLSB0aGUgc2FtZSBjb21wbGV0aW9uIHZhbHVlXG4gKiBvciBmYWlsdXJlIHJlYXNvbi5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gYm9vbGVhbn0gcHJlZFxuICogQHJldHVybnMge0l0ZXJhYmxlPFQ+fVxuICovXG5jb25zdCAgICAgICAgZmlsdGVySXRlcmFibGU9KGJhc2VJdGVyYWJsZSxwcmVkKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdmaWx0ZXJlZCBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGJhc2VJdGVyYXRvcj1iYXNlSXRlcmFibGVbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIEZhcignZmlsdGVyZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmZvcig7Oyl7XG5jb25zdCByZXN1bHQ9YmFzZUl0ZXJhdG9yLm5leHQoKTtcbmNvbnN0e3ZhbHVlLGRvbmV9PXJlc3VsdDtcbmlmKGRvbmV8fHByZWQodmFsdWUpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbiB9fSk7XG5cbiB9fSk7JGjigI1fb25jZS5maWx0ZXJJdGVyYWJsZShmaWx0ZXJJdGVyYWJsZSk7XG5cbmhhcmRlbihmaWx0ZXJJdGVyYWJsZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFwSXRlcmFibGUiOlsibWFwSXRlcmFibGUiXSwiZmlsdGVySXRlcmFibGUiOlsiZmlsdGVySXRlcmFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAYk1nA04aAABOGgAAJwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9tYWtlLWZhci5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9yZW1vdGFibGUuanMiXSwiZXhwb3J0cyI6WyJGYXIiLCJSZW1vdGFibGUiLCJUb0ZhckZ1bmN0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydENoZWNrZXIsUEFTU19TVFlMRSxhc3NlcnRJZmFjZSxnZXRJbnRlcmZhY2VPZixSZW1vdGFibGVIZWxwZXI7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjigI1fYSA9PiAoUEFTU19TVFlMRSA9ICRo4oCNX2EpXV1dXSxbXCIuL3JlbW90YWJsZS5qc1wiLCBbW1wiYXNzZXJ0SWZhY2VcIiwgWyRo4oCNX2EgPT4gKGFzc2VydElmYWNlID0gJGjigI1fYSldXSxbXCJnZXRJbnRlcmZhY2VPZlwiLCBbJGjigI1fYSA9PiAoZ2V0SW50ZXJmYWNlT2YgPSAkaOKAjV9hKV1dLFtcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjigI1fYSA9PiAoUmVtb3RhYmxlSGVscGVyID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkludGVyZmFjZVNwZWN9IEludGVyZmFjZVNwZWMgKi9cbi8qKiBAdGVtcGxhdGUgTCxSIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9ldmVudHVhbC1zZW5kJykuUmVtb3RhYmxlQnJhbmQ8TCwgUj59IFJlbW90YWJsZUJyYW5kICovXG5cbmNvbnN0e3F1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG5jb25zdHtwcm90b3R5cGU6ZnVuY3Rpb25Qcm90b3R5cGV9PUZ1bmN0aW9uO1xuY29uc3R7XG5nZXRQcm90b3R5cGVPZixcbnNldFByb3RvdHlwZU9mLFxuY3JlYXRlLFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1cbk9iamVjdDtcblxuLyoqXG4gKiBOb3cgdGhhdCB0aGUgcmVtb3RhYmxlUHJvdG8gZG9lcyBub3QgcHJvdmlkZSBpdHMgb3duIGB0b1N0cmluZ2AgbWV0aG9kLFxuICogZW5zdXJlIGl0IGFsd2F5cyBpbmhlcml0cyBmcm9tIHNvbWV0aGluZy4gVGhlIG9yaWdpbmFsIHByb3RvdHlwZSBvZlxuICogYHJlbW90YWJsZWAgaWYgdGhlcmUgd2FzIG9uZSwgb3IgYE9iamVjdC5wcm90b3R5cGVgIG90aGVyd2lzZS5cbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gcmVtb3RhYmxlXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IGlmYWNlXG4gKiBAcmV0dXJucyB7b2JqZWN0fVxuICovXG5jb25zdCBtYWtlUmVtb3RhYmxlUHJvdG89KHJlbW90YWJsZSxpZmFjZSk9PntcbmxldCBvbGRQcm90bz1nZXRQcm90b3R5cGVPZihyZW1vdGFibGUpO1xuaWYodHlwZW9mIHJlbW90YWJsZT09PSdvYmplY3QnKXtcbmlmKG9sZFByb3RvPT09bnVsbCl7XG5vbGRQcm90bz1vYmplY3RQcm90b3R5cGU7XG4gfVxub2xkUHJvdG89PT1vYmplY3RQcm90b3R5cGV8fFxuRmFpbCBgRm9yIG5vdywgcmVtb3RhYmxlcyBjYW5ub3QgaW5oZXJpdCBmcm9tIGFueXRoaW5nIHVudXN1YWwsIGluICR7cmVtb3RhYmxlfWA7XG4gfWVsc2UgaWYodHlwZW9mIHJlbW90YWJsZT09PSdmdW5jdGlvbicpe1xub2xkUHJvdG8hPT1udWxsfHxcbkZhaWwgYE9yaWdpbmFsIGZ1bmN0aW9uIG11c3Qgbm90IGluaGVyaXQgZnJvbSBudWxsOiAke3JlbW90YWJsZX1gO1xub2xkUHJvdG89PT1mdW5jdGlvblByb3RvdHlwZXx8XG5nZXRQcm90b3R5cGVPZihvbGRQcm90byk9PT1mdW5jdGlvblByb3RvdHlwZXx8XG5GYWlsIGBGYXIgZnVuY3Rpb25zIG11c3Qgb3JpZ2luYWxseSBpbmhlcml0IGZyb20gRnVuY3Rpb24ucHJvdG90eXBlLCBpbiAke3JlbW90YWJsZX1gO1xuIH1lbHNle1xuRmFpbCBgdW5yZWNvZ25pemVkIHR5cGVvZiAke3JlbW90YWJsZX1gO1xuIH1cbnJldHVybiBoYXJkZW4oXG5jcmVhdGUob2xkUHJvdG8se1xuW1BBU1NfU1RZTEVdOnt2YWx1ZToncmVtb3RhYmxlJ30sXG5bU3ltYm9sLnRvU3RyaW5nVGFnXTp7dmFsdWU6aWZhY2V9fSkpO1xuXG5cbiB9O1xuXG5jb25zdCBhc3NlcnRDYW5CZVJlbW90YWJsZT0oY2FuZGlkYXRlKT0+XG5SZW1vdGFibGVIZWxwZXIuY2FuQmVWYWxpZChjYW5kaWRhdGUsYXNzZXJ0Q2hlY2tlcik7XG5cbi8qKlxuICogQ3JlYXRlIGFuZCByZWdpc3RlciBhIFJlbW90YWJsZS4gIEFmdGVyIHRoaXMsIGdldEludGVyZmFjZU9mKHJlbW90YWJsZSlcbiAqIHJldHVybnMgaWZhY2UuXG4gKlxuICogLy8gaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy84MDRcbiAqXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IFtpZmFjZT0nUmVtb3RhYmxlJ10gVGhlIGludGVyZmFjZSBzcGVjaWZpY2F0aW9uIGZvclxuICogdGhlIHJlbW90YWJsZS4gRm9yIG5vdywgYSBzdHJpbmcgaWZhY2UgbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGhcbiAqIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiLCB0byBzZXJ2ZSBhcyB0aGUgYWxsZWdlZCBuYW1lLiBNb3JlXG4gKiBnZW5lcmFsIGlmYWNlcyBhcmUgbm90IHlldCBpbXBsZW1lbnRlZC4gVGhpcyBpcyB0ZW1wb3JhcnkuIFdlIGluY2x1ZGUgdGhlXG4gKiBcIkFsbGVnZWRcIiBvciBcIkRlYnVnTmFtZVwiIGFzIGEgcmVtaW5kZXIgdGhhdCB3ZSBkbyBub3QgeWV0IGhhdmUgU3dpbmdTZXRcbiAqIG9yIENvbW1zIFZhdFxuICogc3VwcG9ydCBmb3IgZW5zdXJpbmcgdGhpcyBpcyBhY2NvcmRpbmcgdG8gdGhlIHZhdCBob3N0aW5nIHRoZSBvYmplY3QuXG4gKiBDdXJyZW50bHksIEFsaWNlIGNhbiB0ZWxsIEJvYiBhYm91dCBDYXJvbCwgd2hlcmUgVmF0QSAob24gQWxpY2UncyBiZWhhbGYpXG4gKiBtaXNyZXByZXNlbnRzIENhcm9sJ3MgYGlmYWNlYC4gVmF0QiBhbmQgdGhlcmVmb3JlIEJvYiB3aWxsIHRoZW4gc2VlXG4gKiBDYXJvbCdzIGBpZmFjZWAgYXMgbWlzcmVwcmVzZW50ZWQgYnkgVmF0QS5cbiAqIEBwYXJhbSB7dW5kZWZpbmVkfSBbcHJvcHM9dW5kZWZpbmVkXSBDdXJyZW50bHkgbWF5IG9ubHkgYmUgdW5kZWZpbmVkLlxuICogVGhhdCBwbGFuIGlzIHRoYXQgb3duLXByb3BlcnRpZXMgYXJlIGNvcGllZCB0byB0aGUgcmVtb3RhYmxlXG4gKiBAcGFyYW0ge1R9IFtyZW1vdGFibGU9e31dIFRoZSBvYmplY3QgdXNlZCBhcyB0aGUgcmVtb3RhYmxlXG4gKiBAcmV0dXJucyB7VCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPn0gcmVtb3RhYmxlLCBtb2RpZmllZCBmb3IgZGVidWdnYWJpbGl0eVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlPShcbmlmYWNlPSdSZW1vdGFibGUnLFxucHJvcHM9dW5kZWZpbmVkLFxucmVtb3RhYmxlPS8qKiBAdHlwZSB7VH0gKi97fSk9Plxue1xuYXNzZXJ0SWZhY2UoaWZhY2UpO1xuYXNzZXJ0KGlmYWNlKTtcbi8qIFRPRE86IFdoZW4gaWZhY2UgaXMgcmljaGVyIHRoYW4ganVzdCBzdHJpbmcsIHdlIG5lZWQgdG8gZ2V0IHRoZSBhbGxlZ2VkTmFtZSovXG4vKiBpbiBhIGRpZmZlcmVudCB3YXkuKi9cbnByb3BzPT09dW5kZWZpbmVkfHxGYWlsIGBSZW1vdGFibGUgcHJvcHMgbm90IHlldCBpbXBsZW1lbnRlZCAke3Byb3BzfWA7XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgdGhhdCB0aGUgdW5tb2RpZmllZCBvYmplY3QgaXMgYWJsZSB0byBiZWNvbWUgYSBSZW1vdGFibGUuKi9cbmFzc2VydENhbkJlUmVtb3RhYmxlKHJlbW90YWJsZSk7XG5cbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBtYXJrZWQuKi9cbiEoUEFTU19TVFlMRSBpbiByZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBtYXJrZWQgYXMgYSAke3EoXG5yZW1vdGFibGVbUEFTU19TVFlMRV0pXG4gfWA7XG4vKiBgaXNGcm96ZW5gIGFsd2F5cyByZXR1cm5zIHRydWUgd2l0aCBhIGZha2UgYGhhcmRlbmAsIGJ1dCB3ZSB3YW50IHRoYXQgY2FzZSovXG4vKiB0byBzdWNjZWVkIGFueXdheS4gRmFraW5nIGBoYXJkZW5gIGlzIG9ubHkgY29ycmVjdG5lc3MgcHJlc2VydmluZyovXG4vKiBpZiB0aGUgY29kZSBpbiBxdWVzdGlvbiBjb250YWlucyBubyBidWdzIHRoYXQgdGhlIHJlYWwgYGhhcmRlbmAgd291bGQqL1xuLyogaGF2ZSBjYXVnaHQuKi9cbi8qIEB0cy1pZ25vcmUgYGlzRmFrZWAgcHVycG9zZWx5IG5vdCBpbiB0aGUgdHlwZSovXG5oYXJkZW4uaXNGYWtlfHxcbi8qIEVuc3VyZSB0aGF0IHRoZSByZW1vdGFibGUgaXNuJ3QgYWxyZWFkeSBmcm96ZW4uKi9cbiFpc0Zyb3plbihyZW1vdGFibGUpfHxcbkZhaWwgYFJlbW90YWJsZSAke3JlbW90YWJsZX0gaXMgYWxyZWFkeSBmcm96ZW5gO1xuY29uc3QgcmVtb3RhYmxlUHJvdG89bWFrZVJlbW90YWJsZVByb3RvKHJlbW90YWJsZSxpZmFjZSk7XG5cbi8qIFRha2UgYSBzdGF0aWMgY29weSBvZiB0aGUgZW51bWVyYWJsZSBvd24gcHJvcGVydGllcyBhcyBkYXRhIHByb3BlcnRpZXMuKi9cbi8qIGNvbnN0IHByb3BEZXNjcyA9IGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoeyAuLi5wcm9wcyB9KTsqL1xuY29uc3QgbXV0YXRlSGFyZGVuQW5kQ2hlY2s9KHRhcmdldCk9Pntcbi8qIGRlZmluZVByb3BlcnRpZXModGFyZ2V0LCBwcm9wRGVzY3MpOyovXG5zZXRQcm90b3R5cGVPZih0YXJnZXQscmVtb3RhYmxlUHJvdG8pO1xuaGFyZGVuKHRhcmdldCk7XG5hc3NlcnRDYW5CZVJlbW90YWJsZSh0YXJnZXQpO1xuIH07XG5cbi8qIEZhaWwgZmFzdDogY2hlY2sgYSBmcmVzaCByZW1vdGFibGUgdG8gc2VlIGlmIG91ciBydWxlcyBmaXQuKi9cbm11dGF0ZUhhcmRlbkFuZENoZWNrKHt9KTtcblxuLyogQWN0dWFsbHkgZmluaXNoIHRoZSBuZXcgcmVtb3RhYmxlLiovXG5tdXRhdGVIYXJkZW5BbmRDaGVjayhyZW1vdGFibGUpO1xuXG4vKiBDT01NSVRURUQhKi9cbi8qIFdlJ3JlIGNvbW1pdHRlZCwgc28ga2VlcCB0aGUgaW50ZXJmYWNlIGZvciBmdXR1cmUgcmVmZXJlbmNlLiovXG5hc3NlcnQoaWZhY2UhPT11bmRlZmluZWQpOy8qIFRvIG1ha2UgVHlwZVNjcmlwdCBoYXBweSovXG5yZXR1cm4gKC8qKiBAdHlwZSB7VCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPn0gKi9yZW1vdGFibGUpO1xuIH07JGjigI1fb25jZS5SZW1vdGFibGUoUmVtb3RhYmxlKTtcbmhhcmRlbihSZW1vdGFibGUpO1xuXG4vKipcbiAqIEEgY29uY2lzZSBjb252ZW5pZW5jZSBmb3IgdGhlIG1vc3QgY29tbW9uIGBSZW1vdGFibGVgIHVzZS5cbiAqXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge3N0cmluZ30gZmFyTmFtZSBUaGlzIG5hbWUgd2lsbCBiZSBwcmVwZW5kZWQgd2l0aCBgQWxsZWdlZDogYFxuICogZm9yIG5vdyB0byBmb3JtIHRoZSBgUmVtb3RhYmxlYCBgaWZhY2VgIGFyZ3VtZW50LlxuICogQHBhcmFtIHtUfSBbcmVtb3RhYmxlPXt9XSBUaGUgb2JqZWN0IHVzZWQgYXMgdGhlIHJlbW90YWJsZVxuICovXG5jb25zdCAgICAgICAgRmFyPShmYXJOYW1lLHJlbW90YWJsZT11bmRlZmluZWQpPT57XG5jb25zdCByPXJlbW90YWJsZT09PXVuZGVmaW5lZD8vKiogQHR5cGUge1R9ICove306cmVtb3RhYmxlO1xucmV0dXJuIFJlbW90YWJsZSggYEFsbGVnZWQ6ICR7ZmFyTmFtZX1gLHVuZGVmaW5lZCxyKTtcbiB9OyRo4oCNX29uY2UuRmFyKEZhcik7XG5oYXJkZW4oRmFyKTtcblxuLyoqXG4gKiBDb2VyY2UgYGZ1bmNgIHRvIGEgZmFyIGZ1bmN0aW9uIHRoYXQgcHJlc2VydmVzIGl0cyBjYWxsIGJlaGF2aW9yLlxuICogSWYgaXQgaXMgYWxyZWFkeSBhIGZhciBmdW5jdGlvbiwgcmV0dXJuIGl0LiBPdGhlcndpc2UgbWFrZSBhbmQgcmV0dXJuIGFcbiAqIG5ldyBmYXIgZnVuY3Rpb24gdGhhdCB3cmFwcyBgZnVuY2AgYW5kIGZvcndhcmRzIGNhbGxzIHRvIGl0LiBUaGlzXG4gKiB3b3JrcyBldmVuIGlmIGBmdW5jYCBpcyBhbHJlYWR5IGZyb3plbi4gYFRvRmFyRnVuY3Rpb25gIGlzIHRvIGJlIHVzZWRcbiAqIHdoZW4gdGhlIGZ1bmN0aW9uIGNvbWVzIGZyb20gZWxzZXdoZXJlIHVuZGVyIGxlc3MgY29udHJvbC4gRm9yIGZ1bmN0aW9uc1xuICogeW91IGF1dGhvciBpbiBwbGFjZSwgYmV0dGVyIHRvIHVzZSBgRmFyYCBvbiB0aGVpciBmdW5jdGlvbiBsaXRlcmFsIGRpcmVjdGx5LlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfSBmYXJOYW1lIHRvIGJlIHVzZWQgb25seSBpZiBgZnVuY2AgaXMgbm90IGFscmVhZHkgYVxuICogZmFyIGZ1bmN0aW9uLlxuICogQHBhcmFtIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gZnVuY1xuICovXG5jb25zdCAgICAgICAgVG9GYXJGdW5jdGlvbj0oZmFyTmFtZSxmdW5jKT0+e1xuaWYoZ2V0SW50ZXJmYWNlT2YoZnVuYykhPT11bmRlZmluZWQpe1xucmV0dXJuIGZ1bmM7XG4gfVxucmV0dXJuIEZhcihmYXJOYW1lLCguLi5hcmdzKT0+ZnVuYyguLi5hcmdzKSk7XG4gfTskaOKAjV9vbmNlLlRvRmFyRnVuY3Rpb24oVG9GYXJGdW5jdGlvbik7XG5oYXJkZW4oVG9GYXJGdW5jdGlvbik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiUmVtb3RhYmxlIjpbIlJlbW90YWJsZSJdLCJGYXIiOlsiRmFyIl0sIlRvRmFyRnVuY3Rpb24iOlsiVG9GYXJGdW5jdGlvbiJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAACkXvlHQQAAB0EAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL21ha2VUYWdnZWQuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIi4vcGFzc1N0eWxlT2YuanMiXSwiZXhwb3J0cyI6WyJtYWtlVGFnZ2VkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IFBBU1NfU1RZTEUsYXNzZXJ0UGFzc2FibGU7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiUEFTU19TVFlMRVwiLCBbJGjigI1fYSA9PiAoUEFTU19TVFlMRSA9ICRo4oCNX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZU9mLmpzXCIsIFtbXCJhc3NlcnRQYXNzYWJsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuY29uc3R7Y3JlYXRlLHByb3RvdHlwZTpvYmplY3RQcm90b3R5cGV9PU9iamVjdDtcbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuY29uc3QgICAgICAgIG1ha2VUYWdnZWQ9KHRhZyxwYXlsb2FkKT0+e1xudHlwZW9mIHRhZz09PSdzdHJpbmcnfHxcbkZhaWwgYFRoZSB0YWcgb2YgYSB0YWdnZWQgcmVjb3JkIG11c3QgYmUgYSBzdHJpbmc6ICR7dGFnfWA7XG5hc3NlcnRQYXNzYWJsZShoYXJkZW4ocGF5bG9hZCkpO1xucmV0dXJuIGhhcmRlbihcbmNyZWF0ZShvYmplY3RQcm90b3R5cGUse1xuW1BBU1NfU1RZTEVdOnt2YWx1ZTondGFnZ2VkJ30sXG5bU3ltYm9sLnRvU3RyaW5nVGFnXTp7dmFsdWU6dGFnfSxcbnBheWxvYWQ6e3ZhbHVlOnBheWxvYWQsZW51bWVyYWJsZTp0cnVlfX0pKTtcblxuXG4gfTskaOKAjV9vbmNlLm1ha2VUYWdnZWQobWFrZVRhZ2dlZCk7XG5oYXJkZW4obWFrZVRhZ2dlZCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVRhZ2dlZCI6WyJtYWtlVGFnZ2VkIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABlAKMb1GQAA9RkAADAAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbIlBBU1NfU1RZTEUiLCJhc3NlcnRDaGVja2VyIiwiY2FuQmVNZXRob2QiLCJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkIiwiY2hlY2tOb3JtYWxQcm9wZXJ0eSIsImNoZWNrUGFzc1N0eWxlIiwiY2hlY2tUYWdSZWNvcmQiLCJnZXRUYWciLCJoYXNPd25Qcm9wZXJ0eU9mIiwiaXNPYmplY3QiLCJpc1R5cGVkQXJyYXkiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5DaGVja2VyfSBDaGVja2VyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5QYXNzU3R5bGV9IFBhc3NTdHlsZSAqL1xuXG5jb25zdHtkZXRhaWxzOlgscXVvdGU6cX09YXNzZXJ0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtwcm90b3R5cGU6ZnVuY3Rpb25Qcm90b3R5cGV9PUZ1bmN0aW9uO1xuY29uc3R7XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IsXG5nZXRQcm90b3R5cGVPZixcbmhhc093blByb3BlcnR5Om9iamVjdEhhc093blByb3BlcnR5LFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1cbk9iamVjdDtcbmNvbnN0e2FwcGx5fT1SZWZsZWN0O1xuY29uc3R7dG9TdHJpbmdUYWc6dG9TdHJpbmdUYWdTeW1ib2x9PVN5bWJvbDtcblxuY29uc3QgdHlwZWRBcnJheVByb3RvdHlwZT1nZXRQcm90b3R5cGVPZihVaW50OEFycmF5LnByb3RvdHlwZSk7XG5jb25zdCB0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjPWdldE93blByb3BlcnR5RGVzY3JpcHRvcihcbnR5cGVkQXJyYXlQcm90b3R5cGUsXG50b1N0cmluZ1RhZ1N5bWJvbCk7XG5cbmFzc2VydCh0eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjKTtcbmNvbnN0IGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZz10eXBlZEFycmF5VG9TdHJpbmdUYWdEZXNjLmdldDtcbmFzc2VydCh0eXBlb2YgZ2V0VHlwZWRBcnJheVRvU3RyaW5nVGFnPT09J2Z1bmN0aW9uJyk7XG5cbmNvbnN0ICAgICAgICBoYXNPd25Qcm9wZXJ0eU9mPShvYmoscHJvcCk9PlxuYXBwbHkob2JqZWN0SGFzT3duUHJvcGVydHksb2JqLFtwcm9wXSk7JGjigI1fb25jZS5oYXNPd25Qcm9wZXJ0eU9mKGhhc093blByb3BlcnR5T2YpO1xuaGFyZGVuKGhhc093blByb3BlcnR5T2YpO1xuXG5jb25zdCAgICAgICAgaXNPYmplY3Q9KHZhbCk9Pk9iamVjdCh2YWwpPT09dmFsOyRo4oCNX29uY2UuaXNPYmplY3QoaXNPYmplY3QpO1xuaGFyZGVuKGlzT2JqZWN0KTtcblxuLyoqXG4gKiBEdXBsaWNhdGVzIHBhY2thZ2VzL3Nlcy9zcmMvbWFrZS1oYXJkZW5lci5qcyB0byBhdm9pZCBhIGRlcGVuZGVuY3kuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBvYmplY3RcbiAqL1xuY29uc3QgICAgICAgIGlzVHlwZWRBcnJheT0ob2JqZWN0KT0+e1xuLyogVGhlIG9iamVjdCBtdXN0IHBhc3MgYSBicmFuZCBjaGVjayBvciB0b1N0cmluZ1RhZyB3aWxsIHJldHVybiB1bmRlZmluZWQuKi9cbmNvbnN0IHRhZz1hcHBseShnZXRUeXBlZEFycmF5VG9TdHJpbmdUYWcsb2JqZWN0LFtdKTtcbnJldHVybiB0YWchPT11bmRlZmluZWQ7XG4gfTskaOKAjV9vbmNlLmlzVHlwZWRBcnJheShpc1R5cGVkQXJyYXkpO1xuaGFyZGVuKGlzVHlwZWRBcnJheSk7XG5cbmNvbnN0ICAgICAgICBQQVNTX1NUWUxFPVN5bWJvbC5mb3IoJ3Bhc3NTdHlsZScpO1xuXG4vKipcbiAqIEZvciBhIGZ1bmN0aW9uIHRvIGJlIGEgdmFsaWQgbWV0aG9kLCBpdCBtdXN0IG5vdCBiZSBwYXNzYWJsZS5cbiAqIE90aGVyd2lzZSwgd2UgcmlzayBjb25mdXNpbmcgcGFzcy1ieS1jb3B5IGRhdGEgY2FycnlpbmdcbiAqIGZhciBmdW5jdGlvbnMgd2l0aCBhdHRlbXB0cyBhdCBmYXIgb2JqZWN0cyB3aXRoIG1ldGhvZHMuXG4gKlxuICogVE9ETyBIQVpBUkQgQmVjYXVzZSB3ZSBjaGVjayB0aGlzIG9uIHRoZSB3YXkgdG8gaGFyZGVuaW5nIGEgcmVtb3RhYmxlLFxuICogd2UgY2Fubm90IHlldCBjaGVjayB0aGF0IGBmdW5jYCBpcyBoYXJkZW5lZC4gSG93ZXZlciwgd2l0aG91dFxuICogZG9pbmcgc28sIGl0J3MgaW5oZXJpdGFuY2UgbWlnaHQgY2hhbmdlIGFmdGVyIHRoZSBgUEFTU19TVFlMRWBcbiAqIGNoZWNrIGJlbG93LlxuICpcbiAqIEBwYXJhbSB7YW55fSBmdW5jXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqLyRo4oCNX29uY2UuUEFTU19TVFlMRShQQVNTX1NUWUxFKTtcbmNvbnN0ICAgICAgICBjYW5CZU1ldGhvZD0oZnVuYyk9PlxudHlwZW9mIGZ1bmM9PT0nZnVuY3Rpb24nJiYhKFBBU1NfU1RZTEUgaW4gZnVuYyk7JGjigI1fb25jZS5jYW5CZU1ldGhvZChjYW5CZU1ldGhvZCk7XG5oYXJkZW4oY2FuQmVNZXRob2QpO1xuXG4vKipcbiAqIEJlbG93IHdlIGhhdmUgYSBzZXJpZXMgb2YgcHJlZGljYXRlIGZ1bmN0aW9ucyBhbmQgdGhlaXIgKGN1cnJpZWQpIGFzc2VydGlvblxuICogZnVuY3Rpb25zLiBUaGUgc2VtYW50aWNzIG9mIHRoZSBhc3NlcnRpb24gZnVuY3Rpb24gaXMganVzdCB0byBhc3NlcnQgdGhhdFxuICogdGhlIGNvcnJlc3BvbmRpbmcgcHJlZGljYXRlIGZ1bmN0aW9uIHdvdWxkIGhhdmUgcmV0dXJuZWQgdHJ1ZS4gQnV0IGl0XG4gKiByZXByb2R1Y2VzIHRoZSBpbnRlcm5hbCB0ZXN0cyBzbyBmYWlsdXJlcyBjYW4gZ2l2ZSBhIGJldHRlciBlcnJvciBtZXNzYWdlLlxuICpcbiAqIEB0eXBlIHtDaGVja2VyfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0Q2hlY2tlcj0oY29uZCxkZXRhaWxzKT0+e1xuYXNzZXJ0KGNvbmQsZGV0YWlscyk7XG5yZXR1cm4gdHJ1ZTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0Q2hlY2tlcihhc3NlcnRDaGVja2VyKTtcbmhhcmRlbihhc3NlcnRDaGVja2VyKTtcblxuLyoqXG4gKiBDaGVja3MgZm9yIHRoZSBwcmVzZW5jZSBhbmQgZW51bWVyYWJpbGl0eSBvZiBhbiBvd24gZGF0YSBwcm9wZXJ0eS5cbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge3N0cmluZ3xudW1iZXJ8c3ltYm9sfSBwcm9wZXJ0eU5hbWVcbiAqIEBwYXJhbSB7Ym9vbGVhbn0gc2hvdWxkQmVFbnVtZXJhYmxlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgY2hlY2tOb3JtYWxQcm9wZXJ0eT0oXG5jYW5kaWRhdGUsXG5wcm9wZXJ0eU5hbWUsXG5zaG91bGRCZUVudW1lcmFibGUsXG5jaGVjayk9Plxue1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbmNvbnN0IGRlc2M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKGNhbmRpZGF0ZSxwcm9wZXJ0eU5hbWUpO1xuaWYoZGVzYz09PXVuZGVmaW5lZCl7XG5yZXR1cm4oXG5yZWplY3QmJnJlamVjdChYIGAke3EocHJvcGVydHlOYW1lKX0gcHJvcGVydHkgZXhwZWN0ZWQ6ICR7Y2FuZGlkYXRlfWApKTtcblxuIH1cbnJldHVybihcbihoYXNPd25Qcm9wZXJ0eU9mKGRlc2MsJ3ZhbHVlJyl8fFxucmVqZWN0JiZcbnJlamVjdChcblggYCR7cShwcm9wZXJ0eU5hbWUpfSBtdXN0IG5vdCBiZSBhbiBhY2Nlc3NvciBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCkpJiYoXG5cbnNob3VsZEJlRW51bWVyYWJsZT9cbmRlc2MuZW51bWVyYWJsZXx8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgJHtxKHByb3BlcnR5TmFtZSl9IG11c3QgYmUgYW4gZW51bWVyYWJsZSBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCk6XG5cbiFkZXNjLmVudW1lcmFibGV8fFxucmVqZWN0JiZcbnJlamVjdChcblggYCR7cShcbnByb3BlcnR5TmFtZSlcbiB9IG11c3Qgbm90IGJlIGFuIGVudW1lcmFibGUgcHJvcGVydHk6ICR7Y2FuZGlkYXRlfWApKSk7XG5cblxuIH07JGjigI1fb25jZS5jaGVja05vcm1hbFByb3BlcnR5KGNoZWNrTm9ybWFsUHJvcGVydHkpO1xuaGFyZGVuKGNoZWNrTm9ybWFsUHJvcGVydHkpO1xuXG5jb25zdCAgICAgICAgZ2V0VGFnPSh0YWdSZWNvcmQpPT50YWdSZWNvcmRbU3ltYm9sLnRvU3RyaW5nVGFnXTskaOKAjV9vbmNlLmdldFRhZyhnZXRUYWcpO1xuaGFyZGVuKGdldFRhZyk7XG5cbmNvbnN0ICAgICAgICBjaGVja1Bhc3NTdHlsZT0ob2JqLGV4cGVjdGVkUGFzc1N0eWxlLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbmNvbnN0IGFjdHVhbD1vYmpbUEFTU19TVFlMRV07XG5yZXR1cm4oXG5hY3R1YWw9PT1leHBlY3RlZFBhc3NTdHlsZXx8XG5yZWplY3QmJlxucmVqZWN0KFggYEV4cGVjdGVkICR7cShleHBlY3RlZFBhc3NTdHlsZSl9LCBub3QgJHtxKGFjdHVhbCl9OiAke29ian1gKSk7XG5cbiB9OyRo4oCNX29uY2UuY2hlY2tQYXNzU3R5bGUoY2hlY2tQYXNzU3R5bGUpO1xuaGFyZGVuKGNoZWNrUGFzc1N0eWxlKTtcblxuY29uc3QgbWFrZUNoZWNrVGFnUmVjb3JkPShjaGVja1Byb3RvKT0+e1xuLyoqXG4gKiBAcGFyYW0ge3sgW1BBU1NfU1RZTEVdOiBzdHJpbmcgfX0gdGFnUmVjb3JkXG4gKiBAcGFyYW0ge1Bhc3NTdHlsZX0gcGFzc1N0eWxlXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja1RhZ1JlY29yZD0odGFnUmVjb3JkLHBhc3NTdHlsZSxjaGVjayk9PntcbmNvbnN0IHJlamVjdD0hIWNoZWNrJiYoKGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKSk7XG5yZXR1cm4oXG4oaXNPYmplY3QodGFnUmVjb3JkKXx8XG5yZWplY3QmJlxucmVqZWN0KFggYEEgbm9uLW9iamVjdCBjYW5ub3QgYmUgYSB0YWdSZWNvcmQ6ICR7dGFnUmVjb3JkfWApKSYmKFxuaXNGcm96ZW4odGFnUmVjb3JkKXx8XG5yZWplY3QmJnJlamVjdChYIGBBIHRhZ1JlY29yZCBtdXN0IGJlIGZyb3plbjogJHt0YWdSZWNvcmR9YCkpJiYoXG4haXNBcnJheSh0YWdSZWNvcmQpfHxcbnJlamVjdCYmcmVqZWN0KFggYEFuIGFycmF5IGNhbm5vdCBiZSBhIHRhZ1JlY29yZDogJHt0YWdSZWNvcmR9YCkpJiZcbmNoZWNrTm9ybWFsUHJvcGVydHkodGFnUmVjb3JkLFBBU1NfU1RZTEUsZmFsc2UsY2hlY2spJiZcbmNoZWNrUGFzc1N0eWxlKHRhZ1JlY29yZCxwYXNzU3R5bGUsY2hlY2spJiZcbmNoZWNrTm9ybWFsUHJvcGVydHkodGFnUmVjb3JkLFN5bWJvbC50b1N0cmluZ1RhZyxmYWxzZSxjaGVjaykmJihcbnR5cGVvZiBnZXRUYWcodGFnUmVjb3JkKT09PSdzdHJpbmcnfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBBIFtTeW1ib2wudG9TdHJpbmdUYWddLW5hbWVkIHByb3BlcnR5IG11c3QgYmUgYSBzdHJpbmc6ICR7dGFnUmVjb3JkfWApKSYmXG5cbmNoZWNrUHJvdG8odGFnUmVjb3JkLGdldFByb3RvdHlwZU9mKHRhZ1JlY29yZCksY2hlY2spKTtcblxuIH07XG5yZXR1cm4gaGFyZGVuKGNoZWNrVGFnUmVjb3JkKTtcbiB9O1xuXG5jb25zdCAgICAgICAgY2hlY2tUYWdSZWNvcmQ9bWFrZUNoZWNrVGFnUmVjb3JkKFxuKHZhbCxwcm90byxjaGVjayk9PlxucHJvdG89PT1vYmplY3RQcm90b3R5cGV8fFxuISFjaGVjayYmXG5jaGVjayhmYWxzZSxYIGBBIHRhZ1JlY29yZCBtdXN0IGluaGVyaXQgZnJvbSBPYmplY3QucHJvdG90eXBlOiAke3ZhbH1gKSk7JGjigI1fb25jZS5jaGVja1RhZ1JlY29yZChjaGVja1RhZ1JlY29yZCk7XG5cbmhhcmRlbihjaGVja1RhZ1JlY29yZCk7XG5cbmNvbnN0ICAgICAgICBjaGVja0Z1bmN0aW9uVGFnUmVjb3JkPW1ha2VDaGVja1RhZ1JlY29yZChcbih2YWwscHJvdG8sY2hlY2spPT5cbnByb3RvPT09ZnVuY3Rpb25Qcm90b3R5cGV8fFxucHJvdG8hPT1udWxsJiZnZXRQcm90b3R5cGVPZihwcm90byk9PT1mdW5jdGlvblByb3RvdHlwZXx8XG4hIWNoZWNrJiZcbmNoZWNrKFxuZmFsc2UsXG5YIGBGb3IgZnVuY3Rpb25zLCBhIHRhZ1JlY29yZCBtdXN0IGluaGVyaXQgZnJvbSBGdW5jdGlvbi5wcm90b3R5cGU6ICR7dmFsfWApKTskaOKAjV9vbmNlLmNoZWNrRnVuY3Rpb25UYWdSZWNvcmQoY2hlY2tGdW5jdGlvblRhZ1JlY29yZCk7XG5cblxuaGFyZGVuKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Imhhc093blByb3BlcnR5T2YiOlsiaGFzT3duUHJvcGVydHlPZiJdLCJpc09iamVjdCI6WyJpc09iamVjdCJdLCJpc1R5cGVkQXJyYXkiOlsiaXNUeXBlZEFycmF5Il0sIlBBU1NfU1RZTEUiOlsiUEFTU19TVFlMRSJdLCJjYW5CZU1ldGhvZCI6WyJjYW5CZU1ldGhvZCJdLCJhc3NlcnRDaGVja2VyIjpbImFzc2VydENoZWNrZXIiXSwiY2hlY2tOb3JtYWxQcm9wZXJ0eSI6WyJjaGVja05vcm1hbFByb3BlcnR5Il0sImdldFRhZyI6WyJnZXRUYWciXSwiY2hlY2tQYXNzU3R5bGUiOlsiY2hlY2tQYXNzU3R5bGUiXSwiY2hlY2tUYWdSZWNvcmQiOlsiY2hlY2tUYWdSZWNvcmQiXSwiY2hlY2tGdW5jdGlvblRhZ1JlY29yZCI6WyJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAC5usQ2DGwAAgxsAACoAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvcGFzc1N0eWxlT2YuanN7ImltcG9ydHMiOlsiLi9jb3B5QXJyYXkuanMiLCIuL2NvcHlSZWNvcmQuanMiLCIuL2Vycm9yLmpzIiwiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIi4vcmVtb3RhYmxlLmpzIiwiLi9zYWZlLXByb21pc2UuanMiLCIuL3N5bWJvbC5qcyIsIi4vdGFnZ2VkLmpzIiwiQGVuZG8vcHJvbWlzZS1raXQiXSwiZXhwb3J0cyI6WyJhc3NlcnRQYXNzYWJsZSIsInBhc3NTdHlsZU9mIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzUHJvbWlzZSxpc09iamVjdCxpc1R5cGVkQXJyYXksUEFTU19TVFlMRSxDb3B5QXJyYXlIZWxwZXIsQ29weVJlY29yZEhlbHBlcixUYWdnZWRIZWxwZXIsRXJyb3JIZWxwZXIsUmVtb3RhYmxlSGVscGVyLGFzc2VydFBhc3NhYmxlU3ltYm9sLGFzc2VydFNhZmVQcm9taXNlOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRo4oCNX2EgPT4gKGlzUHJvbWlzZSA9ICRo4oCNX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJpc09iamVjdFwiLCBbJGjigI1fYSA9PiAoaXNPYmplY3QgPSAkaOKAjV9hKV1dLFtcImlzVHlwZWRBcnJheVwiLCBbJGjigI1fYSA9PiAoaXNUeXBlZEFycmF5ID0gJGjigI1fYSldXSxbXCJQQVNTX1NUWUxFXCIsIFskaOKAjV9hID0+IChQQVNTX1NUWUxFID0gJGjigI1fYSldXV1dLFtcIi4vY29weUFycmF5LmpzXCIsIFtbXCJDb3B5QXJyYXlIZWxwZXJcIiwgWyRo4oCNX2EgPT4gKENvcHlBcnJheUhlbHBlciA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvcHlSZWNvcmQuanNcIiwgW1tcIkNvcHlSZWNvcmRIZWxwZXJcIiwgWyRo4oCNX2EgPT4gKENvcHlSZWNvcmRIZWxwZXIgPSAkaOKAjV9hKV1dXV0sW1wiLi90YWdnZWQuanNcIiwgW1tcIlRhZ2dlZEhlbHBlclwiLCBbJGjigI1fYSA9PiAoVGFnZ2VkSGVscGVyID0gJGjigI1fYSldXV1dLFtcIi4vZXJyb3IuanNcIiwgW1tcIkVycm9ySGVscGVyXCIsIFskaOKAjV9hID0+IChFcnJvckhlbHBlciA9ICRo4oCNX2EpXV1dXSxbXCIuL3JlbW90YWJsZS5qc1wiLCBbW1wiUmVtb3RhYmxlSGVscGVyXCIsIFskaOKAjV9hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaOKAjV9hKV1dXV0sW1wiLi9zeW1ib2wuanNcIiwgW1tcImFzc2VydFBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV1dXSxbXCIuL3NhZmUtcHJvbWlzZS5qc1wiLCBbW1wiYXNzZXJ0U2FmZVByb21pc2VcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFNhZmVQcm9taXNlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn0gUGFzc1N0eWxlSGVscGVyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5QYXNzU3R5bGVPZn0gUGFzc1N0eWxlT2YgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlByaW1pdGl2ZVN0eWxlfSBQcmltaXRpdmVTdHlsZSAqL1xuXG4vKiogQHR5cGVkZWYge0V4Y2x1ZGU8UGFzc1N0eWxlLCBQcmltaXRpdmVTdHlsZSB8IFwicHJvbWlzZVwiPn0gSGVscGVyUGFzc1N0eWxlICovXG5cbmNvbnN0e2RldGFpbHM6WCxGYWlsLHF1b3RlOnF9PWFzc2VydDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0Zyb3plbn09T2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc1N0eWxlSGVscGVyW119IHBhc3NTdHlsZUhlbHBlcnNcbiAqIEByZXR1cm5zIHtSZWNvcmQ8SGVscGVyUGFzc1N0eWxlLCBQYXNzU3R5bGVIZWxwZXI+IH1cbiAqL1xuXG5jb25zdCBtYWtlSGVscGVyVGFibGU9KHBhc3NTdHlsZUhlbHBlcnMpPT57XG4vKiogQHR5cGUge1JlY29yZDxIZWxwZXJQYXNzU3R5bGUsIGFueT4gJiB7X19wcm90b19fOiBudWxsfX0gKi9cbmNvbnN0IEhlbHBlclRhYmxlPXtcbl9fcHJvdG9fXzpudWxsLFxuY29weUFycmF5OnVuZGVmaW5lZCxcbmNvcHlSZWNvcmQ6dW5kZWZpbmVkLFxudGFnZ2VkOnVuZGVmaW5lZCxcbmVycm9yOnVuZGVmaW5lZCxcbnJlbW90YWJsZTp1bmRlZmluZWR9O1xuXG5mb3IoY29uc3QgaGVscGVyIG9mIHBhc3NTdHlsZUhlbHBlcnMpe1xuY29uc3R7c3R5bGVOYW1lfT1oZWxwZXI7XG5zdHlsZU5hbWUgaW4gSGVscGVyVGFibGV8fEZhaWwgYFVucmVjb2duaXplZCBoZWxwZXI6ICR7cShzdHlsZU5hbWUpfWA7XG5IZWxwZXJUYWJsZVtzdHlsZU5hbWVdPT09dW5kZWZpbmVkfHxcbkZhaWwgYGNvbmZsaWN0aW5nIGhlbHBlcnMgZm9yICR7cShzdHlsZU5hbWUpfWA7XG5IZWxwZXJUYWJsZVtzdHlsZU5hbWVdPWhlbHBlcjtcbiB9XG5mb3IoY29uc3Qgc3R5bGVOYW1lIG9mIG93bktleXMoSGVscGVyVGFibGUpKXtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV0hPT11bmRlZmluZWR8fFxuRmFpbCBgbWlzc2luZyBoZWxwZXIgZm9yICR7cShzdHlsZU5hbWUpfWA7XG4gfVxuXG5yZXR1cm4gaGFyZGVuKEhlbHBlclRhYmxlKTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc1N0eWxlSGVscGVyW119IHBhc3NTdHlsZUhlbHBlcnMgVGhlIHBhc3NTdHlsZUhlbHBlcnMgdG8gcmVnaXN0ZXIsXG4gKiBpbiBwcmlvcml0eSBvcmRlci5cbiAqIE5PVEUgVGhlc2UgbXVzdCBhbGwgYmUgXCJ0cnVzdGVkXCIsXG4gKiBjb21wbGV0ZSwgYW5kIG5vbi1jb2xsaWRpbmcuIGBtYWtlUGFzc1N0eWxlT2ZgIG1heSAqYXNzdW1lKiB0aGF0IGVhY2ggaGVscGVyXG4gKiBkb2VzIHdoYXQgaXQgaXMgc3VwcG9zZWQgdG8gZG8uIGBtYWtlUGFzc1N0eWxlT2ZgIGlzIG5vdCB0cnlpbmcgdG8gZGVmZW5kXG4gKiBpdHNlbGYgYWdhaW5zdCBtYWxpY2lvdXMgaGVscGVycywgdGhvdWdoIGl0IGRvZXMgZGVmZW5kIGFnYWluc3Qgc29tZVxuICogYWNjaWRlbnRzLlxuICogQHJldHVybnMge1Bhc3NTdHlsZU9mfVxuICovXG5jb25zdCBtYWtlUGFzc1N0eWxlT2Y9KHBhc3NTdHlsZUhlbHBlcnMpPT57XG5jb25zdCBIZWxwZXJUYWJsZT1tYWtlSGVscGVyVGFibGUocGFzc1N0eWxlSGVscGVycyk7XG5jb25zdCByZW1vdGFibGVIZWxwZXI9SGVscGVyVGFibGUucmVtb3RhYmxlO1xuXG4vKipcbiAqIFB1cmVseSBmb3IgcGVyZm9ybWFuY2UuIEhvd2V2ZXIgaXQgaXMgbXV0YWJsZSBzdGF0aWMgc3RhdGUsIGFuZFxuICogaXQgZG9lcyBoYXZlIHNvbWUgb2JzZXJ2YWJpbGl0eSBvbiBwcm94aWVzLiBUT0RPIG5lZWQgdG8gYXNzZXNzXG4gKiB3aGV0aGVyIHRoaXMgY3JlYXRlcyBhIHN0YXRpYyBjb21tdW5pY2F0aW9ucyBjaGFubmVsLlxuICpcbiAqIHBhc3NTdHlsZU9mIGRvZXMgYSBmdWxsIHJlY3Vyc2l2ZSB3YWxrIG9mIHBhc3MtYnktY29weVxuICogc3RydWN0dXJlcywgaW4gb3JkZXIgdG8gdmFsaWRhdGUgdGhhdCB0aGV5IGFyZSBhY3ljbGljLiBJbiBhZGRpdGlvblxuICogaXQgaXMgdXNlZCBieSBvdGhlciBhbGdvcml0aG1zIHRvIHJlY3Vyc2l2ZWx5IHdhbGsgdGhlc2UgcGFzcy1ieS1jb3B5XG4gKiBzdHJ1Y3R1cmVzLCBzbyB3aXRob3V0IHRoaXMgY2FjaGUsIHRoZXNlIGFsZ29yaXRobXMgY291bGQgYmVcbiAqIE8oTioqMikgb3Igd29yc2UuXG4gKlxuICogQHR5cGUge1dlYWtNYXA8UGFzc2FibGUsIFBhc3NTdHlsZT59XG4gKi9cbmNvbnN0IHBhc3NTdHlsZU1lbW89bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAdHlwZSB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IHBhc3NTdHlsZU9mPShwYXNzYWJsZSk9Pntcbi8qIEV2ZW4gd2hlbiBhIFdlYWtTZXQgaXMgY29ycmVjdCwgd2hlbiB0aGUgc2V0IGhhcyBhIHNob3J0ZXIgbGlmZXRpbWUqL1xuLyogdGhhbiBpdHMga2V5cywgd2UgcHJlZmVyIGEgU2V0IGR1ZSB0byBleHBlY3RlZCBpbXBsZW1lbnRhdGlvbiovXG4vKiB0cmFkZW9mZnMuKi9cbmNvbnN0IGluUHJvZ3Jlc3M9bmV3IFNldCgpO1xuXG4vKipcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqL1xuY29uc3QgcGFzc1N0eWxlT2ZSZWN1cj0oaW5uZXIpPT57XG5jb25zdCBpbm5lcklzT2JqZWN0PWlzT2JqZWN0KGlubmVyKTtcbmlmKGlubmVySXNPYmplY3Qpe1xuaWYocGFzc1N0eWxlTWVtby5oYXMoaW5uZXIpKXtcbi8qIEB0cy1pZ25vcmUgVHlwZVNjcmlwdCBkb2Vzbid0IGtub3cgdGhhdCBgZ2V0YCBhZnRlciBgaGFzYCBpcyBzYWZlKi9cbnJldHVybiBwYXNzU3R5bGVNZW1vLmdldChpbm5lcik7XG4gfVxuIWluUHJvZ3Jlc3MuaGFzKGlubmVyKXx8XG5GYWlsIGBQYXNzLWJ5LWNvcHkgZGF0YSBjYW5ub3QgYmUgY3ljbGljICR7aW5uZXJ9YDtcbmluUHJvZ3Jlc3MuYWRkKGlubmVyKTtcbiB9XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mSW50ZXJuYWwoaW5uZXIpO1xuaWYoaW5uZXJJc09iamVjdCl7XG5wYXNzU3R5bGVNZW1vLnNldChpbm5lcixwYXNzU3R5bGUpO1xuaW5Qcm9ncmVzcy5kZWxldGUoaW5uZXIpO1xuIH1cbnJldHVybiBwYXNzU3R5bGU7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IHBhc3NTdHlsZU9mSW50ZXJuYWw9KGlubmVyKT0+e1xuY29uc3QgdHlwZXN0cj10eXBlb2YgaW5uZXI7XG5zd2l0Y2godHlwZXN0cil7XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ3N0cmluZyc6XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdudW1iZXInOlxuY2FzZSdiaWdpbnQnOntcbnJldHVybiB0eXBlc3RyO1xuIH1cbmNhc2Unc3ltYm9sJzp7XG5hc3NlcnRQYXNzYWJsZVN5bWJvbChpbm5lcik7XG5yZXR1cm4nc3ltYm9sJztcbiB9XG5jYXNlJ29iamVjdCc6e1xuaWYoaW5uZXI9PT1udWxsKXtcbnJldHVybidudWxsJztcbiB9XG5pZighaXNGcm96ZW4oaW5uZXIpKXtcbmFzc2VydC5mYWlsKFxuLyogVHlwZWRBcnJheXMgZ2V0IHNwZWNpYWwgdHJlYXRtZW50IGluIGhhcmRlbigpKi9cbi8qIGFuZCBhIGNvcnJlc3BvbmRpbmcgc3BlY2lhbCBlcnJvciBtZXNzYWdlIGhlcmUuKi9cbmlzVHlwZWRBcnJheShpbm5lcik/XG5YIGBDYW5ub3QgcGFzcyBtdXRhYmxlIHR5cGVkIGFycmF5cyBsaWtlICR7aW5uZXJ9LmA6XG5YIGBDYW5ub3QgcGFzcyBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke2lubmVyfS4gVXNlIGhhcmRlbigpYCk7XG5cbiB9XG5pZihpc1Byb21pc2UoaW5uZXIpKXtcbmFzc2VydFNhZmVQcm9taXNlKGlubmVyKTtcbnJldHVybidwcm9taXNlJztcbiB9XG50eXBlb2YgaW5uZXIudGhlbiE9PSdmdW5jdGlvbid8fFxuRmFpbCBgQ2Fubm90IHBhc3Mgbm9uLXByb21pc2UgdGhlbmFibGVzYDtcbmNvbnN0IHBhc3NTdHlsZVRhZz1pbm5lcltQQVNTX1NUWUxFXTtcbmlmKHBhc3NTdHlsZVRhZyE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKHBhc3NTdHlsZVRhZywnc3RyaW5nJyk7XG5jb25zdCBoZWxwZXI9SGVscGVyVGFibGVbcGFzc1N0eWxlVGFnXTtcbmhlbHBlciE9PXVuZGVmaW5lZHx8XG5GYWlsIGBVbnJlY29nbml6ZWQgUGFzc1N0eWxlOiAke3EocGFzc1N0eWxlVGFnKX1gO1xuaGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuICgvKiogQHR5cGUge1Bhc3NTdHlsZX0gKi9wYXNzU3R5bGVUYWcpO1xuIH1cbmZvcihjb25zdCBoZWxwZXIgb2YgcGFzc1N0eWxlSGVscGVycyl7XG5pZihoZWxwZXIuY2FuQmVWYWxpZChpbm5lcikpe1xuaGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuIGhlbHBlci5zdHlsZU5hbWU7XG4gfVxuIH1cbnJlbW90YWJsZUhlbHBlci5hc3NlcnRWYWxpZChpbm5lcixwYXNzU3R5bGVPZlJlY3VyKTtcbnJldHVybidyZW1vdGFibGUnO1xuIH1cbmNhc2UnZnVuY3Rpb24nOntcbmlzRnJvemVuKGlubmVyKXx8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke2lubmVyfS4gVXNlIGhhcmRlbigpYDtcbnR5cGVvZiBpbm5lci50aGVuIT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tcHJvbWlzZSB0aGVuYWJsZXNgO1xucmVtb3RhYmxlSGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuJ3JlbW90YWJsZSc7XG4gfVxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGBVbnJlY29nbml6ZWQgdHlwZW9mICR7cSh0eXBlc3RyKX1gLFR5cGVFcnJvcik7XG4gfX1cblxuIH07XG5cbnJldHVybiBwYXNzU3R5bGVPZlJlY3VyKHBhc3NhYmxlKTtcbiB9O1xucmV0dXJuIGhhcmRlbihwYXNzU3R5bGVPZik7XG4gfTtcblxuY29uc3QgICAgICAgIHBhc3NTdHlsZU9mPW1ha2VQYXNzU3R5bGVPZihbXG5Db3B5QXJyYXlIZWxwZXIsXG5Db3B5UmVjb3JkSGVscGVyLFxuVGFnZ2VkSGVscGVyLFxuRXJyb3JIZWxwZXIsXG5SZW1vdGFibGVIZWxwZXJdKTskaOKAjV9vbmNlLnBhc3NTdHlsZU9mKHBhc3NTdHlsZU9mKTtcblxuXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGU9KHZhbCk9PntcbnBhc3NTdHlsZU9mKHZhbCk7LyogdGhyb3dzIGlmIHZhbCBpcyBub3QgYSBwYXNzYWJsZSovXG4gfTskaOKAjV9vbmNlLmFzc2VydFBhc3NhYmxlKGFzc2VydFBhc3NhYmxlKTtcbmhhcmRlbihhc3NlcnRQYXNzYWJsZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicGFzc1N0eWxlT2YiOlsicGFzc1N0eWxlT2YiXSwiYXNzZXJ0UGFzc2FibGUiOlsiYXNzZXJ0UGFzc2FibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAFLGifcMhAADDIQAAKAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9yZW1vdGFibGUuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIlJlbW90YWJsZUhlbHBlciIsImFzc2VydElmYWNlIiwiZ2V0SW50ZXJmYWNlT2YiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixjYW5CZU1ldGhvZCxoYXNPd25Qcm9wZXJ0eU9mLFBBU1NfU1RZTEUsY2hlY2tUYWdSZWNvcmQsY2hlY2tGdW5jdGlvblRhZ1JlY29yZCxpc09iamVjdCxnZXRUYWc7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRo4oCNX2EgPT4gKGNhbkJlTWV0aG9kID0gJGjigI1fYSldXSxbXCJoYXNPd25Qcm9wZXJ0eU9mXCIsIFskaOKAjV9hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjigI1fYSldXSxbXCJQQVNTX1NUWUxFXCIsIFskaOKAjV9hID0+IChQQVNTX1NUWUxFID0gJGjigI1fYSldXSxbXCJjaGVja1RhZ1JlY29yZFwiLCBbJGjigI1fYSA9PiAoY2hlY2tUYWdSZWNvcmQgPSAkaOKAjV9hKV1dLFtcImNoZWNrRnVuY3Rpb25UYWdSZWNvcmRcIiwgWyRo4oCNX2EgPT4gKGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQgPSAkaOKAjV9hKV1dLFtcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wiZ2V0VGFnXCIsIFskaOKAjV9hID0+IChnZXRUYWcgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IENoZWNrZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkludGVyZmFjZVNwZWN9IEludGVyZmFjZVNwZWMgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLk1hcnNoYWxHZXRJbnRlcmZhY2VPZn0gTWFyc2hhbEdldEludGVyZmFjZU9mICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vaW50ZXJuYWwtdHlwZXMuanMnKS5QYXNzU3R5bGVIZWxwZXJ9IFBhc3NTdHlsZUhlbHBlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVtb3RhYmxlT2JqZWN0fSBSZW1vdGFibGUgKi9cblxuY29uc3R7ZGV0YWlsczpYLEZhaWwscXVvdGU6cX09YXNzZXJ0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7XG5nZXRQcm90b3R5cGVPZixcbmlzRnJvemVuLFxucHJvdG90eXBlOm9iamVjdFByb3RvdHlwZSxcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PVxuT2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gaWZhY2VcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICovXG5jb25zdCBjaGVja0lmYWNlPShpZmFjZSxjaGVjayk9PntcbmNvbnN0IHJlamVjdD0hIWNoZWNrJiYoKGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKSk7XG5yZXR1cm4oXG4vKiBUT0RPIG90aGVyIHBvc3NpYmxlIGlmYWNlcywgb25jZSB3ZSBoYXZlIHRoaXJkIHBhcnR5IHZlcmFjaXR5Ki9cbih0eXBlb2YgaWZhY2U9PT0nc3RyaW5nJ3x8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgRm9yIG5vdywgaW50ZXJmYWNlICR7aWZhY2V9IG11c3QgYmUgYSBzdHJpbmc7IHVuaW1wbGVtZW50ZWRgKSkmJihcblxuaWZhY2U9PT0nUmVtb3RhYmxlJ3x8XG5pZmFjZS5zdGFydHNXaXRoKCdBbGxlZ2VkOiAnKXx8XG5pZmFjZS5zdGFydHNXaXRoKCdEZWJ1Z05hbWU6ICcpfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBGb3Igbm93LCBpZmFjZSAke3EoXG5pZmFjZSlcbiB9IG11c3QgYmUgXCJSZW1vdGFibGVcIiBvciBiZWdpbiB3aXRoIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiOyB1bmltcGxlbWVudGVkYCkpKTtcblxuXG4gfTtcblxuLyoqXG4gKiBBbiBgaWZhY2VgIG11c3QgYmUgcHVyZS4gUmlnaHQgbm93IGl0IG11c3QgYmUgYSBzdHJpbmcsIHdoaWNoIGlzIHB1cmUuXG4gKiBMYXRlciB3ZSBleHBlY3QgdG8gaW5jbHVkZSBzb21lIG90aGVyIHZhbHVlcyB0aGF0IHF1YWxpZnkgYXMgYFB1cmVEYXRhYCxcbiAqIHdoaWNoIGlzIGEgcGFzcy1ieS1jb3B5IHN1cGVyc3RydWN0dXJlIGVuZGluZyBvbmx5IGluIHByaW1pdGl2ZXMgb3JcbiAqIGVtcHR5IHBhc3MtYnktY29weSBjb21wb3NpdGVzLiBObyByZW1vdGFibGVzLCBwcm9taXNlcywgb3IgZXJyb3JzLlxuICogV2UgKmFzc3VtZSogZm9yIG5vdyB0aGF0IHRoZSBwYXNzLWJ5LWNvcHkgc3VwZXJzdHJ1Y3R1cmUgY29udGFpbnMgbm9cbiAqIHByb3hpZXMuXG4gKlxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0SWZhY2U9KGlmYWNlKT0+Y2hlY2tJZmFjZShpZmFjZSxhc3NlcnRDaGVja2VyKTskaOKAjV9vbmNlLmFzc2VydElmYWNlKGFzc2VydElmYWNlKTtcbmhhcmRlbihhc3NlcnRJZmFjZSk7XG5cbi8qKlxuICogQHBhcmFtIHtvYmplY3QgfCBGdW5jdGlvbn0gb3JpZ2luYWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrUmVtb3RhYmxlUHJvdG9PZj0ob3JpZ2luYWwsY2hlY2spPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuaXNPYmplY3Qob3JpZ2luYWwpfHxcbkZhaWwgYFJlbW90YWJsZXMgbXVzdCBiZSBvYmplY3RzIG9yIGZ1bmN0aW9uczogJHtvcmlnaW5hbH1gO1xuXG4vKiBBIHZhbGlkIHJlbW90YWJsZSBvYmplY3QgbXVzdCBpbmhlcml0IGZyb20gYSBcInRhZyByZWNvcmRcIiAtLSBhKi9cbi8qIHBsYWluLW9iamVjdCBwcm90b3R5cGUgY29uc2lzdGluZyBvZiBvbmx5Ki9cbi8qIGEgYFBBU1NfU1RZTEVgIHByb3BlcnR5IHdpdGggdmFsdWUgXCJyZW1vdGFibGVcIiBhbmQgYSBzdWl0YWJsZSBgU3ltYm9sLnRvU3RyaW5nVGFnYCovXG4vKiBwcm9wZXJ0eS4gVGhlIHJlbW90YWJsZSBjb3VsZCBpbmhlcml0IGRpcmVjdGx5IGZyb20gc3VjaCBhIHRhZyByZWNvcmQsIG9yKi9cbi8qIGl0IGNvdWxkIGluaGVyaXQgZnJvbSBhbm90aGVyIHZhbGlkIHJlbW90YWJsZSwgdGhhdCB0aGVyZWZvcmUgaXRzZWxmKi9cbi8qIGluaGVyaXRzIGRpcmVjdGx5IG9yIGluZGlyZWN0bHkgZnJvbSBzdWNoIGEgdGFnIHJlY29yZC4qL1xuLyoqL1xuLyogVE9ETzogSXQgd291bGQgYmUgbmljZSB0byB0eXBlZGVmIHRoaXMgc2hhcGUsIGJ1dCB3ZSBjYW4ndCBkZWNsYXJlIGEgdHlwZSovXG4vKiB3aXRoIFBBU1NfU1RZTEUgZnJvbSBKU0RvYy4qL1xuLyoqL1xuLyogQHR5cGUge3sgW1BBU1NfU1RZTEVdOiBzdHJpbmcsKi9cbi8qIFtTeW1ib2wudG9TdHJpbmdUYWddOiBzdHJpbmcsKi9cbi8qIH19Ki9cbi8qKi9cbmNvbnN0IHByb3RvPWdldFByb3RvdHlwZU9mKG9yaWdpbmFsKTtcbmlmKHByb3RvPT09b2JqZWN0UHJvdG90eXBlfHxwcm90bz09PW51bGwpe1xucmV0dXJuKFxucmVqZWN0JiZcbnJlamVjdChYIGBSZW1vdGFibGVzIG11c3QgYmUgZXhwbGljaXRseSBkZWNsYXJlZDogJHtxKG9yaWdpbmFsKX1gKSk7XG5cbiB9XG5cbmlmKHR5cGVvZiBvcmlnaW5hbD09PSdvYmplY3QnKXtcbmNvbnN0IHByb3RvUHJvdG89Z2V0UHJvdG90eXBlT2YocHJvdG8pO1xuaWYocHJvdG9Qcm90byE9PW9iamVjdFByb3RvdHlwZSYmcHJvdG9Qcm90byE9PW51bGwpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbnJldHVybiBjaGVja1JlbW90YWJsZShwcm90byxjaGVjayk7XG4gfVxuaWYoIWNoZWNrVGFnUmVjb3JkKHByb3RvLCdyZW1vdGFibGUnLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuIH1lbHNlIGlmKHR5cGVvZiBvcmlnaW5hbD09PSdmdW5jdGlvbicpe1xuaWYoIWNoZWNrRnVuY3Rpb25UYWdSZWNvcmQocHJvdG8sJ3JlbW90YWJsZScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfVxuXG4vKiBUeXBlY2FzdHMgbmVlZGVkIGR1ZSB0byBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzE4NjMqL1xuY29uc3QgcGFzc1N0eWxlS2V5PS8qKiBAdHlwZSB7dW5rbm93bn0gKi9QQVNTX1NUWUxFO1xuY29uc3QgdGFnS2V5PS8qKiBAdHlwZSB7dW5rbm93bn0gKi9TeW1ib2wudG9TdHJpbmdUYWc7XG5jb25zdHtcbi8qIGNoZWNrVGFnUmVjb3JkIGFscmVhZHkgdmVyaWZpZWQgUEFTU19TVFlMRSBhbmQgU3ltYm9sLnRvU3RyaW5nVGFnIG93biBkYXRhIHByb3BlcnRpZXMuKi9cblsvKiogQHR5cGUge3N0cmluZ30gKi9wYXNzU3R5bGVLZXldOl9wYXNzU3R5bGVEZXNjLFxuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3RhZ0tleV06e3ZhbHVlOmlmYWNlfSxcbi4uLnJlc3REZXNjc309XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKHByb3RvKTtcblxucmV0dXJuKFxuKG93bktleXMocmVzdERlc2NzKS5sZW5ndGg9PT0wfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBVbmV4cGVjdGVkIHByb3BlcnRpZXMgb24gUmVtb3RhYmxlIFByb3RvICR7b3duS2V5cyhyZXN0RGVzY3MpfWApKSYmXG5cbmNoZWNrSWZhY2UoaWZhY2UsY2hlY2spKTtcblxuIH07XG5cbi8qKlxuICogS2VlcCBhIHdlYWsgc2V0IG9mIGNvbmZpcm1lZCByZW1vdGFibGVzIGZvciBtYXJzaGFsIHBlcmZvcm1hbmNlXG4gKiAod2l0aG91dCB3aGljaCB3ZSB3b3VsZCBpbmN1ciBhIHJlZHVuZGFudCB2ZXJpZmljYXRpb24gaW5cbiAqIGdldEludGVyZmFjZU9mKS5cbiAqIFdlIGRvbid0IHJlbWVtYmVyIHJlamVjdGlvbnMgYmVjYXVzZSB0aGV5IGFyZSBwb3NzaWJsZSB0byBjb3JyZWN0XG4gKiB3aXRoIGUuZy4gYGhhcmRlbmAuXG4gKlxuICogQHR5cGUge1dlYWtTZXQ8UmVtb3RhYmxlPn1cbiAqL1xuY29uc3QgY29uZmlybWVkUmVtb3RhYmxlcz1uZXcgV2Vha1NldCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UmVtb3RhYmxlfSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrUmVtb3RhYmxlPSh2YWwsY2hlY2spPT57XG5pZihjb25maXJtZWRSZW1vdGFibGVzLmhhcyh2YWwpKXtcbnJldHVybiB0cnVlO1xuIH1cbmNvbnN0IHJlamVjdD0hIWNoZWNrJiYoKGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKSk7XG5pZighaXNGcm96ZW4odmFsKSl7XG5yZXR1cm4gcmVqZWN0JiZyZWplY3QoWCBgY2Fubm90IHNlcmlhbGl6ZSBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke3ZhbH1gKTtcbiB9XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuaWYoIVJlbW90YWJsZUhlbHBlci5jYW5CZVZhbGlkKHZhbCxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmNvbnN0IHJlc3VsdD1jaGVja1JlbW90YWJsZVByb3RvT2YodmFsLGNoZWNrKTtcbmlmKHJlc3VsdCl7XG5jb25maXJtZWRSZW1vdGFibGVzLmFkZCh2YWwpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfTtcblxuLyoqIEB0eXBlIHtNYXJzaGFsR2V0SW50ZXJmYWNlT2Z9ICovXG5jb25zdCAgICAgICAgZ2V0SW50ZXJmYWNlT2Y9KHZhbCk9PntcbmlmKFxuIWlzT2JqZWN0KHZhbCl8fFxudmFsW1BBU1NfU1RZTEVdIT09J3JlbW90YWJsZSd8fFxuIWNoZWNrUmVtb3RhYmxlKHZhbCkpXG57XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbnJldHVybiBnZXRUYWcodmFsKTtcbiB9OyRo4oCNX29uY2UuZ2V0SW50ZXJmYWNlT2YoZ2V0SW50ZXJmYWNlT2YpO1xuaGFyZGVuKGdldEludGVyZmFjZU9mKTtcblxuLyoqXG4gKlxuICogQHR5cGUge1Bhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIFJlbW90YWJsZUhlbHBlcj1oYXJkZW4oe1xuc3R5bGVOYW1lOidyZW1vdGFibGUnLFxuXG5jYW5CZVZhbGlkOihjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbmNvbnN0IHZhbGlkVHlwZT1cbihpc09iamVjdChjYW5kaWRhdGUpfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgY2Fubm90IHNlcmlhbGl6ZSBub24tb2JqZWN0cyBhcyBSZW1vdGFibGUgJHtjYW5kaWRhdGV9YCkpJiYoXG4haXNBcnJheShjYW5kaWRhdGUpfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgY2Fubm90IHNlcmlhbGl6ZSBhcnJheXMgYXMgUmVtb3RhYmxlICR7Y2FuZGlkYXRlfWApKTtcbmlmKCF2YWxpZFR5cGUpe1xucmV0dXJuIGZhbHNlO1xuIH1cblxuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhjYW5kaWRhdGUpO1xuaWYodHlwZW9mIGNhbmRpZGF0ZT09PSdvYmplY3QnKXtcbi8qIEV2ZXJ5IG93biBwcm9wZXJ0eSAocmVnYXJkbGVzcyBvZiBlbnVtZXJhYmlsaXR5KSovXG4vKiBtdXN0IGhhdmUgYSBmdW5jdGlvbiB2YWx1ZS4qL1xucmV0dXJuIG93bktleXMoZGVzY3MpLmV2ZXJ5KChrZXkpPT57XG5yZXR1cm4oXG4vKiBUeXBlY2FzdCBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG4oaGFzT3duUHJvcGVydHlPZihkZXNjc1svKiogQHR5cGUge3N0cmluZ30gKi9rZXldLCd2YWx1ZScpfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBjYW5ub3Qgc2VyaWFsaXplIFJlbW90YWJsZXMgd2l0aCBhY2Nlc3NvcnMgbGlrZSAke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGluICR7Y2FuZGlkYXRlfWApKSYmKFxuXG5rZXk9PT1TeW1ib2wudG9TdHJpbmdUYWcmJmNoZWNrSWZhY2UoY2FuZGlkYXRlW2tleV0sY2hlY2spfHxcbihjYW5CZU1ldGhvZChjYW5kaWRhdGVba2V5XSl8fFxucmVqZWN0JiZcbnJlamVjdChcblggYGNhbm5vdCBzZXJpYWxpemUgUmVtb3RhYmxlcyB3aXRoIG5vbi1tZXRob2RzIGxpa2UgJHtxKFxuU3RyaW5nKGtleSkpXG4gfSBpbiAke2NhbmRpZGF0ZX1gKSkmJihcblxua2V5IT09UEFTU19TVFlMRXx8XG5yZWplY3QmJlxucmVqZWN0KFggYEEgcGFzcy1ieS1yZW1vdGUgY2Fubm90IHNoYWRvdyAke3EoUEFTU19TVFlMRSl9YCkpKSk7XG5cbiB9KTtcbiB9ZWxzZSBpZih0eXBlb2YgY2FuZGlkYXRlPT09J2Z1bmN0aW9uJyl7XG4vKiBGYXIgZnVuY3Rpb25zIGNhbm5vdCBiZSBtZXRob2RzLCBhbmQgY2Fubm90IGhhdmUgbWV0aG9kcy4qL1xuLyogVGhleSBtdXN0IGhhdmUgZXhhY3RseSBleHBlY3RlZCBgLm5hbWVgIGFuZCBgLmxlbmd0aGAgcHJvcGVydGllcyovXG5jb25zdHtcbm5hbWU6bmFtZURlc2MsXG5sZW5ndGg6bGVuZ3RoRGVzYyxcbi8qIEB0cy1pZ25vcmUgVFMgZG9lc24ndCBsaWtlIHN5bWJvbHMgYXMgY29tcHV0ZWQgaW5kZXhlcz8/Ki9cbltTeW1ib2wudG9TdHJpbmdUYWddOnRvU3RyaW5nVGFnRGVzYyxcbi4uLnJlc3REZXNjc309XG5kZXNjcztcbmNvbnN0IHJlc3RLZXlzPW93bktleXMocmVzdERlc2NzKTtcbnJldHVybihcbihuYW1lRGVzYyYmdHlwZW9mIG5hbWVEZXNjLnZhbHVlPT09J3N0cmluZyd8fFxucmVqZWN0JiZcbnJlamVjdChYIGBGYXIgZnVuY3Rpb24gbmFtZSBtdXN0IGJlIGEgc3RyaW5nLCBpbiAke2NhbmRpZGF0ZX1gKSkmJihcbmxlbmd0aERlc2MmJnR5cGVvZiBsZW5ndGhEZXNjLnZhbHVlPT09J251bWJlcid8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEZhciBmdW5jdGlvbiBsZW5ndGggbXVzdCBiZSBhIG51bWJlciwgaW4gJHtjYW5kaWRhdGV9YCkpJiYoXG5cbnRvU3RyaW5nVGFnRGVzYz09PXVuZGVmaW5lZHx8XG4odHlwZW9mIHRvU3RyaW5nVGFnRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBGYXIgZnVuY3Rpb24gQEB0b1N0cmluZ1RhZyBtdXN0IGJlIGEgc3RyaW5nLCBpbiAke2NhbmRpZGF0ZX1gKSkmJlxuXG5jaGVja0lmYWNlKHRvU3RyaW5nVGFnRGVzYy52YWx1ZSxjaGVjaykpJiYoXG5yZXN0S2V5cy5sZW5ndGg9PT0wfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBGYXIgZnVuY3Rpb25zIHVuZXhwZWN0ZWQgcHJvcGVydGllcyBiZXNpZGVzIC5uYW1lIGFuZCAubGVuZ3RoICR7cmVzdEtleXN9YCkpKTtcblxuXG4gfVxucmV0dXJuIHJlamVjdCYmcmVqZWN0KFggYHVucmVjb2duaXplZCB0eXBlb2YgJHtjYW5kaWRhdGV9YCk7XG4gfSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSk9PmNoZWNrUmVtb3RhYmxlKGNhbmRpZGF0ZSxhc3NlcnRDaGVja2VyKSxcblxuZXZlcnk6KF9wYXNzYWJsZSxfZm4pPT50cnVlfSk7JGjigI1fb25jZS5SZW1vdGFibGVIZWxwZXIoUmVtb3RhYmxlSGVscGVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRJZmFjZSI6WyJhc3NlcnRJZmFjZSJdLCJnZXRJbnRlcmZhY2VPZiI6WyJnZXRJbnRlcmZhY2VPZiJdLCJSZW1vdGFibGVIZWxwZXIiOlsiUmVtb3RhYmxlSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAADXiToqaDwAAmg8AACsAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvc2FmZS1wcm9taXNlLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbImFzc2VydFNhZmVQcm9taXNlIiwiaXNTYWZlUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBpc1Byb21pc2UsYXNzZXJ0Q2hlY2tlcixoYXNPd25Qcm9wZXJ0eU9mOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRo4oCNX2EgPT4gKGlzUHJvbWlzZSA9ICRo4oCNX2EpXV1dXSxbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJoYXNPd25Qcm9wZXJ0eU9mXCIsIFskaOKAjV9hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IENoZWNrZXIgKi9cblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnF9PWFzc2VydDtcbmNvbnN0e2lzRnJvemVuLGdldFByb3RvdHlwZU9mfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7UHJvbWlzZX0gcHIgVGhlIHZhbHVlIHRvIGV4YW1pbmVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtwciBpcyBQcm9taXNlfSBXaGV0aGVyIGl0IGlzIGEgc2FmZSBwcm9taXNlXG4gKi9cbmNvbnN0IGNoZWNrUHJvbWlzZU93bktleXM9KHByLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PShkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscyk7XG5jb25zdCBrZXlzPW93bktleXMocHIpO1xuXG5pZihrZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG5jb25zdCB1bmtub3duS2V5cz1rZXlzLmZpbHRlcihcbihrZXkpPT50eXBlb2Yga2V5IT09J3N5bWJvbCd8fCFoYXNPd25Qcm9wZXJ0eU9mKFByb21pc2UucHJvdG90eXBlLGtleSkpO1xuXG5cbmlmKHVua25vd25LZXlzLmxlbmd0aCE9PTApe1xucmV0dXJuIHJlamVjdChcblggYCR7cHJ9IC0gTXVzdCBub3QgaGF2ZSBhbnkgb3duIHByb3BlcnRpZXM6ICR7cSh1bmtub3duS2V5cyl9YCk7XG5cbiB9XG5cbi8qKlxuICogQXQgdGhlIHRpbWUgb2YgdGhpcyB3cml0aW5nLCBOb2RlJ3MgYXN5bmNfaG9va3MgY29udGFpbnMgdGhlXG4gKiBmb2xsb3dpbmcgY29kZSwgd2hpY2ggd2UgY2FuIGFsc28gc2FmZWx5IHRvbGVyYXRlXG4gKlxuICogYGBganNcbiAqIGZ1bmN0aW9uIGRlc3Ryb3lUcmFja2luZyhwcm9taXNlLCBwYXJlbnQpIHtcbiAqIHRyYWNrUHJvbWlzZShwcm9taXNlLCBwYXJlbnQpO1xuICogICBjb25zdCBhc3luY0lkID0gcHJvbWlzZVthc3luY19pZF9zeW1ib2xdO1xuICogICBjb25zdCBkZXN0cm95ZWQgPSB7IGRlc3Ryb3llZDogZmFsc2UgfTtcbiAqICAgcHJvbWlzZVtkZXN0cm95ZWRTeW1ib2xdID0gZGVzdHJveWVkO1xuICogICByZWdpc3RlckRlc3Ryb3lIb29rKHByb21pc2UsIGFzeW5jSWQsIGRlc3Ryb3llZCk7XG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAcGFyYW0ge3N0cmluZ3xzeW1ib2x9IGtleVxuICovXG5jb25zdCBjaGVja1NhZmVBc3luY0hvb2tzS2V5PShrZXkpPT57XG5jb25zdCB2YWw9cHJba2V5XTtcbmlmKHZhbD09PXVuZGVmaW5lZHx8dHlwZW9mIHZhbD09PSdudW1iZXInKXtcbnJldHVybiB0cnVlO1xuIH1cbmlmKFxudHlwZW9mIHZhbD09PSdvYmplY3QnJiZcbnZhbCE9PW51bGwmJlxuaXNGcm96ZW4odmFsKSYmXG5nZXRQcm90b3R5cGVPZih2YWwpPT09T2JqZWN0LnByb3RvdHlwZSlcbntcbmNvbnN0IHN1YktleXM9b3duS2V5cyh2YWwpO1xuaWYoc3ViS2V5cy5sZW5ndGg9PT0wKXtcbnJldHVybiB0cnVlO1xuIH1cblxuaWYoXG5zdWJLZXlzLmxlbmd0aD09PTEmJlxuc3ViS2V5c1swXT09PSdkZXN0cm95ZWQnJiZcbnZhbC5kZXN0cm95ZWQ9PT1mYWxzZSlcbntcbnJldHVybiB0cnVlO1xuIH1cbiB9XG5yZXR1cm4gcmVqZWN0KFxuWCBgVW5leHBlY3RlZCBOb2RlIGFzeW5jX2hvb2tzIGFkZGl0aW9ucyB0byBwcm9taXNlOiAke3ByfS4ke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGlzICR7dmFsfWApO1xuXG4gfTtcblxucmV0dXJuIGtleXMuZXZlcnkoY2hlY2tTYWZlQXN5bmNIb29rc0tleSk7XG4gfTtcblxuLyoqXG4gKiBVbmRlciBIYXJkZW5lZCBKUyBhIHByb21pc2UgaXMgXCJzYWZlXCIgaWYgaXRzIGB0aGVuYCBtZXRob2QgY2FuIGJlIGNhbGxlZFxuICogc3luY2hyb25vdXNseSB3aXRob3V0IGdpdmluZyB0aGUgcHJvbWlzZSBhbiBvcHBvcnR1bml0eSBmb3IgYVxuICogcmVlbnRyYW5jeSBhdHRhY2sgZHVyaW5nIHRoYXQgY2FsbC5cbiAqXG4gKiBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzlcbiAqIHJhaXNlcyB0aGUgaXNzdWUgb2YgdGVzdGluZyB0aGF0IGEgc3BlY2ltZW4gaXMgYSBzYWZlIHByb21pc2VcbiAqIHN1Y2ggdGhhdCB0aGUgdGVzdCBhbHNvIGRvZXMgbm90IGdpdmUgdGhlIHNwZWNpbWVuIGFcbiAqIHJlZW50cmFuY3kgb3Bwb3J0dW5pdHkuIFRoYXQgaXMgd2VsbCBiZXlvbmQgdGhlIGFtYml0aW9uIGhlcmUuXG4gKiBUT0RPIFRob3VnaCBpZiB3ZSBmaWd1cmUgb3V0IGEgbmljZSBzb2x1dGlvbiwgaXQgbWlnaHQgYmUgZ29vZCB0b1xuICogdXNlIGl0IGhlcmUgYXMgd2VsbC5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IHByIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7cHIgaXMgUHJvbWlzZX0gV2hldGhlciBpdCBpcyBhIHNhZmUgcHJvbWlzZVxuICovXG5jb25zdCBjaGVja1NhZmVQcm9taXNlPShwcixjaGVjayk9PntcbmNvbnN0IHJlamVjdD0oZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpO1xucmV0dXJuKFxuKGlzRnJvemVuKHByKXx8cmVqZWN0KFggYCR7cHJ9IC0gTXVzdCBiZSBmcm96ZW5gKSkmJihcbmlzUHJvbWlzZShwcil8fHJlamVjdChYIGAke3ByfSAtIE11c3QgYmUgYSBwcm9taXNlYCkpJiYoXG5nZXRQcm90b3R5cGVPZihwcik9PT1Qcm9taXNlLnByb3RvdHlwZXx8XG5yZWplY3QoXG5YIGAke3ByfSAtIE11c3QgaW5oZXJpdCBmcm9tIFByb21pc2UucHJvdG90eXBlOiAke3EoXG5nZXRQcm90b3R5cGVPZihwcikpXG4gfWApKSYmXG5cbmNoZWNrUHJvbWlzZU93bktleXMoLyoqIEB0eXBlIHtQcm9taXNlfSAqL3ByLGNoZWNrKSk7XG5cbiB9O1xuaGFyZGVuKGNoZWNrU2FmZVByb21pc2UpO1xuXG4vKipcbiAqIERldGVybWluZSBpZiB0aGUgYXJndW1lbnQgaXMgYSBQcm9taXNlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gcHIgVGhlIHZhbHVlIHRvIGV4YW1pbmVcbiAqIEByZXR1cm5zIHtwciBpcyBQcm9taXNlfSBXaGV0aGVyIGl0IGlzIGEgcHJvbWlzZVxuICovXG5jb25zdCAgICAgICAgaXNTYWZlUHJvbWlzZT0ocHIpPT5jaGVja1NhZmVQcm9taXNlKHByLCh4KT0+eCk7JGjigI1fb25jZS5pc1NhZmVQcm9taXNlKGlzU2FmZVByb21pc2UpO1xuaGFyZGVuKGlzU2FmZVByb21pc2UpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0U2FmZVByb21pc2U9KHByKT0+Y2hlY2tTYWZlUHJvbWlzZShwcixhc3NlcnRDaGVja2VyKTskaOKAjV9vbmNlLmFzc2VydFNhZmVQcm9taXNlKGFzc2VydFNhZmVQcm9taXNlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJpc1NhZmVQcm9taXNlIjpbImlzU2FmZVByb21pc2UiXSwiYXNzZXJ0U2FmZVByb21pc2UiOlsiYXNzZXJ0U2FmZVByb21pc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAxx/VUEcSAABHEgAAJQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9zeW1ib2wuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImFzc2VydFBhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsIm5hbWVGb3JQYXNzYWJsZVN5bWJvbCIsInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIGNvbnN0e0ZhaWwscXVvdGU6cX09YXNzZXJ0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcblxuLyoqXG4gKiBUaGUgd2VsbCBrbm93biBzeW1ib2xzIGFyZSBzdGF0aWMgc3ltYm9sIHZhbHVlcyBvbiB0aGUgYFN5bWJvbGAgY29uc3RydWN0b3IuXG4gKi9cbmNvbnN0IHdlbGxLbm93blN5bWJvbE5hbWVzPW5ldyBNYXAoXG5vd25LZXlzKFN5bWJvbCkuXG5maWx0ZXIoXG4obmFtZSk9PnR5cGVvZiBuYW1lPT09J3N0cmluZycmJnR5cGVvZiBTeW1ib2xbbmFtZV09PT0nc3ltYm9sJykuXG5cbmZpbHRlcigobmFtZSk9Pntcbi8qIEB0cy1leHBlY3QtZXJyb3IgSXQgZG9lc24ndCBrbm93IG5hbWUgY2Fubm90IGJlIGEgc3ltYm9sKi9cbiFuYW1lLnN0YXJ0c1dpdGgoJ0BAJyl8fFxuRmFpbCBgRGlkIG5vdCBleHBlY3QgU3ltYm9sIHRvIGhhdmUgYSBzeW1ib2wtdmFsdWVkIHByb3BlcnR5IG5hbWUgc3RhcnRpbmcgd2l0aCBcIkBAXCIgJHtxKFxubmFtZSlcbiB9YDtcbnJldHVybiB0cnVlO1xuIH0pXG4vKiBAdHMtaWdub3JlIEl0IGRvZXNuJ3Qga25vdyBuYW1lIGNhbm5vdCBiZSBhIHN5bWJvbCovLlxubWFwKChuYW1lKT0+W1N5bWJvbFtuYW1lXSwgYEBAJHtuYW1lfWBdKSk7XG5cblxuLyoqXG4gKiBUaGUgcGFzc2FibGUgc3ltYm9scyBhcmUgdGhlIHdlbGwga25vd24gc3ltYm9scyAodGhlIHN5bWJvbCB2YWx1ZXNcbiAqIG9mIHN0YXRpYyBwcm9wZXJ0aWVzIG9mIHRoZSBgU3ltYm9sYCBjb25zdHJ1Y3RvcikgYW5kIHRoZSByZWdpc3RlcmVkXG4gKiBzeW1ib2xzLlxuICpcbiAqIEBwYXJhbSB7YW55fSBzeW1cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgaXNQYXNzYWJsZVN5bWJvbD0oc3ltKT0+XG50eXBlb2Ygc3ltPT09J3N5bWJvbCcmJihcbnR5cGVvZiBTeW1ib2wua2V5Rm9yKHN5bSk9PT0nc3RyaW5nJ3x8d2VsbEtub3duU3ltYm9sTmFtZXMuaGFzKHN5bSkpOyRo4oCNX29uY2UuaXNQYXNzYWJsZVN5bWJvbChpc1Bhc3NhYmxlU3ltYm9sKTtcbmhhcmRlbihpc1Bhc3NhYmxlU3ltYm9sKTtcblxuY29uc3QgICAgICAgIGFzc2VydFBhc3NhYmxlU3ltYm9sPShzeW0pPT5cbmlzUGFzc2FibGVTeW1ib2woc3ltKXx8XG5GYWlsIGBPbmx5IHJlZ2lzdGVyZWQgc3ltYm9scyBvciB3ZWxsLWtub3duIHN5bWJvbHMgYXJlIHBhc3NhYmxlOiAke3Eoc3ltKX1gOyRo4oCNX29uY2UuYXNzZXJ0UGFzc2FibGVTeW1ib2woYXNzZXJ0UGFzc2FibGVTeW1ib2wpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlU3ltYm9sKTtcblxuLyoqXG4gKiBJZiBgc3ltYCBpcyBhIHBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGEgc3RyaW5nIHRoYXQgdW5pcXVlbHkgaWRlbnRpZmllcyB0aGlzXG4gKiBzeW1ib2wuIElmIGBzeW1gIGlzIGEgbm9uLXBhc3NhYmxlIHN5bWJvbCwgcmV0dXJuIGB1bmRlZmluZWRgLlxuICpcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuIFNpbmNlIHRoZSByZWdpc3RyYXRpb24gc3RyaW5nIG9mIGEgcmVnaXN0ZXJlZCBzeW1ib2wgY2FuIGJlIGFueVxuICogc3RyaW5nLCBpZiB3ZSBzaW1wbHkgdXNlZCB0aGF0IHRvIGlkZW50aWZ5IHRob3NlIHN5bWJvbHMsIHRoZXJlIHdvdWxkIG5vdFxuICogYmUgYW55IHJlbWFpbmluZyBzdHJpbmdzIGxlZnQgb3ZlciB0byBpZGVudGlmeSB0aGUgd2VsbC1rbm93biBzeW1ib2xzLlxuICogSW5zdGVhZCwgd2UgcmVzZXJ2ZSBzdHJpbmdzIGJlZ2lubmluZyB3aXRoIGBcIkBAXCJgIGZvciBwdXJwb3NlcyBvZiB0aGlzXG4gKiBlbmNvZGluZy4gV2UgaWRlbnRpZnkgYSB3ZWxsIGtub3duIHN5bWJvbCBzdWNoIGFzIGBTeW1ib2wuaXRlcmF0b3JgXG4gKiBieSBwcmVmaXhpbmcgdGhlIHByb3BlcnR5IG5hbWUgd2l0aCBgXCJAQFwiYCwgc3VjaCBhcyBgXCJAQGl0ZXJhdG9yXCJgLlxuICogRm9yIHJlZ2lzdGVyZWQgc3ltYm9scyB3aG9zZSBuYW1lIGhhcHBlbnMgdG8gYmVnaW4gd2l0aCBgXCJAQFwiYCwgc3VjaFxuICogYXMgYFN5bWJvbC5mb3IoJ0BAaXRlcmF0b3InKWAgb3IgYFN5bWJvbC5mb3IoJ0BAZm9vJylgLCB3ZSBpZGVudGlmeVxuICogdGhlbSBieSBwcmVmaXhpbmcgdGhlbSB3aXRoIGFuIGV4dHJhIGBcIkBAXCJgLCBzdWNoIGFzXG4gKiBgXCJAQEBAaXRlcmF0b3JcImAgb3IgYFwiQEBAQGZvb1wiYC4gKFRoaXMgaXMgdGhlIEhpbGJlcnQgSG90ZWwgZW5jb2RpbmdcbiAqIHRlY2huaXF1ZS4pXG4gKlxuICogQHBhcmFtIHtzeW1ib2x9IHN5bVxuICogQHJldHVybnMge3N0cmluZz19XG4gKi9cbmNvbnN0ICAgICAgICBuYW1lRm9yUGFzc2FibGVTeW1ib2w9KHN5bSk9PntcbmNvbnN0IG5hbWU9U3ltYm9sLmtleUZvcihzeW0pO1xuaWYobmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gd2VsbEtub3duU3ltYm9sTmFtZXMuZ2V0KHN5bSk7XG4gfVxuaWYobmFtZS5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBgQEAke25hbWV9YDtcbiB9XG5yZXR1cm4gbmFtZTtcbiB9OyRo4oCNX29uY2UubmFtZUZvclBhc3NhYmxlU3ltYm9sKG5hbWVGb3JQYXNzYWJsZVN5bWJvbCk7XG5oYXJkZW4obmFtZUZvclBhc3NhYmxlU3ltYm9sKTtcblxuY29uc3QgQXRBdFByZWZpeFBhdHRlcm49L15AQCguKikkLztcbmhhcmRlbihBdEF0UHJlZml4UGF0dGVybik7XG5cbi8qKlxuICogSWYgYG5hbWVgIGlzIGEgc3RyaW5nIHRoYXQgY291bGQgaGF2ZSBiZWVuIHByb2R1Y2VkIGJ5XG4gKiBgbmFtZUZvclBhc3NhYmxlU3ltYm9sYCwgcmV0dXJuIHRoZSBzeW1ib2wgYXJndW1lbnQgaXQgd2FzIHByb2R1Y2VkIHRvXG4gKiByZXByZXNlbnQuXG4gKlxuICogICAgSWYgYG5hbWVgIGRvZXMgbm90IGJlZ2luIHdpdGggYFwiQEBcImAsIHRoZW4ganVzdCB0aGUgY29ycmVzcG9uZGluZ1xuICogICAgICByZWdpc3RlcmVkIHN5bWJvbCwgYFN5bWJvbC5mb3IobmFtZSlgLlxuICogICAgSWYgYG5hbWVgIGlzIGBcIkBAXCJgIGZvbGxvd2VkIGJ5IGEgd2VsbCBrbm93biBzeW1ib2wncyBwcm9wZXJ0eSBuYW1lIG9uXG4gKiAgICAgIGBTeW1ib2xgIHN1Y2ggYFwiQEBpdGVyYXRvclwiLCByZXR1cm4gdGhhdCB3ZWxsIGtub3duIHN5bWJvbCBzdWNoIGFzXG4gKiAgICAgIGBTeW1ib2wuaXRlcmF0b3JgXG4gKiAgICBJZiBgbmFtZWAgYmVnaW5zIHdpdGggYFwiQEBAQFwiYCBpdCBlbmNvZGVzIHRoZSByZWdpc3RlcmVkIHN5bWJvbCB3aG9zZVxuICogICAgICBuYW1lIGJlZ2lucyB3aXRoIGBcIkBAXCJgIGluc3RlYWQuXG4gKiAgICBPdGhlcndpc2UsIGlmIG5hbWUgYmVnaW5zIHdpdGggYFwiQEBcImAgaXQgbWF5IGVuY29kZSBhIHJlZ2lzdGVyZWQgc3ltYm9sXG4gKiAgICAgIGZyb20gYSBmdXR1cmUgdmVyc2lvbiBvZiBKYXZhU2NyaXB0LCBidXQgaXQgaXMgbm90IG9uZSB3ZSBjYW4gZGVjb2RlXG4gKiAgICAgIHlldCwgc28gdGhyb3cuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IG5hbWVcbiAqIEByZXR1cm5zIHtzeW1ib2w9fVxuICovXG5jb25zdCAgICAgICAgcGFzc2FibGVTeW1ib2xGb3JOYW1lPShuYW1lKT0+e1xuaWYodHlwZW9mIG5hbWUhPT0nc3RyaW5nJyl7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbmNvbnN0IG1hdGNoPUF0QXRQcmVmaXhQYXR0ZXJuLmV4ZWMobmFtZSk7XG5pZihtYXRjaCl7XG5jb25zdCBzdWZmaXg9bWF0Y2hbMV07XG5pZihzdWZmaXguc3RhcnRzV2l0aCgnQEAnKSl7XG5yZXR1cm4gU3ltYm9sLmZvcihzdWZmaXgpO1xuIH1lbHNle1xuY29uc3Qgc3ltPVN5bWJvbFtzdWZmaXhdO1xuaWYodHlwZW9mIHN5bT09PSdzeW1ib2wnKXtcbnJldHVybiBzeW07XG4gfVxuRmFpbCBgUmVzZXJ2ZWQgZm9yIHdlbGwga25vd24gc3ltYm9sICR7cShzdWZmaXgpfTogJHtxKG5hbWUpfWA7XG4gfVxuIH1cbnJldHVybiBTeW1ib2wuZm9yKG5hbWUpO1xuIH07JGjigI1fb25jZS5wYXNzYWJsZVN5bWJvbEZvck5hbWUocGFzc2FibGVTeW1ib2xGb3JOYW1lKTtcbmhhcmRlbihwYXNzYWJsZVN5bWJvbEZvck5hbWUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUGFzc2FibGVTeW1ib2wiOlsiaXNQYXNzYWJsZVN5bWJvbCJdLCJhc3NlcnRQYXNzYWJsZVN5bWJvbCI6WyJhc3NlcnRQYXNzYWJsZVN5bWJvbCJdLCJuYW1lRm9yUGFzc2FibGVTeW1ib2wiOlsibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sInBhc3NhYmxlU3ltYm9sRm9yTmFtZSI6WyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAJbxc+/0HAAD9BwAAJQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy90YWdnZWQuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIlRhZ2dlZEhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLGNoZWNrVGFnUmVjb3JkLFBBU1NfU1RZTEUsY2hlY2tOb3JtYWxQcm9wZXJ0eSxjaGVja1Bhc3NTdHlsZTskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJjaGVja1RhZ1JlY29yZFwiLCBbJGjigI1fYSA9PiAoY2hlY2tUYWdSZWNvcmQgPSAkaOKAjV9hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRo4oCNX2EgPT4gKFBBU1NfU1RZTEUgPSAkaOKAjV9hKV1dLFtcImNoZWNrTm9ybWFsUHJvcGVydHlcIiwgWyRo4oCNX2EgPT4gKGNoZWNrTm9ybWFsUHJvcGVydHkgPSAkaOKAjV9hKV1dLFtcImNoZWNrUGFzc1N0eWxlXCIsIFskaOKAjV9hID0+IChjaGVja1Bhc3NTdHlsZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2dldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PU9iamVjdDtcblxuLyoqXG4gKlxuICogQHR5cGUge1hpbXBvcnQoJy4vaW50ZXJuYWwtdHlwZXMuanMnKS5QYXNzU3R5bGVIZWxwZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBUYWdnZWRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTondGFnZ2VkJyxcblxuY2FuQmVWYWxpZDooY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9PlxuY2hlY2tQYXNzU3R5bGUoY2FuZGlkYXRlLCd0YWdnZWQnLGNoZWNrKSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+e1xuY2hlY2tUYWdSZWNvcmQoY2FuZGlkYXRlLCd0YWdnZWQnLGFzc2VydENoZWNrZXIpO1xuXG4vKiBUeXBlY2FzdHMgbmVlZGVkIGR1ZSB0byBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzE4NjMqL1xuY29uc3QgcGFzc1N0eWxlS2V5PS8qKiBAdHlwZSB7dW5rbm93bn0gKi9QQVNTX1NUWUxFO1xuY29uc3QgdGFnS2V5PS8qKiBAdHlwZSB7dW5rbm93bn0gKi9TeW1ib2wudG9TdHJpbmdUYWc7XG5jb25zdHtcbi8qIGNoZWNrVGFnUmVjb3JkIGFscmVhZHkgdmVyaWZpZWQgUEFTU19TVFlMRSBhbmQgU3ltYm9sLnRvU3RyaW5nVGFnIG93biBkYXRhIHByb3BlcnRpZXMuKi9cblsvKiogQHR5cGUge3N0cmluZ30gKi9wYXNzU3R5bGVLZXldOl9wYXNzU3R5bGVEZXNjLFxuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3RhZ0tleV06X2xhYmVsRGVzYyxcbnBheWxvYWQ6X3BheWxvYWREZXNjLC8qIHZhbHVlIGNoZWNrZWQgYnkgcmVjdXJzaXZlIHdhbGsgYXQgdGhlIGVuZCovXG4uLi5yZXN0RGVzY3N9PVxuZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhjYW5kaWRhdGUpO1xub3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aD09PTB8fFxuRmFpbCBgVW5leHBlY3RlZCBwcm9wZXJ0aWVzIG9uIHRhZ2dlZCByZWNvcmQgJHtvd25LZXlzKHJlc3REZXNjcyl9YDtcblxuY2hlY2tOb3JtYWxQcm9wZXJ0eShjYW5kaWRhdGUsJ3BheWxvYWQnLHRydWUsYXNzZXJ0Q2hlY2tlcik7XG5cbi8qIFJlY3Vyc2l2ZWx5IHZhbGlkYXRlIHRoYXQgZWFjaCBtZW1iZXIgaXMgcGFzc2FibGUuKi9cbnBhc3NTdHlsZU9mUmVjdXIoY2FuZGlkYXRlLnBheWxvYWQpO1xuIH19KTskaOKAjV9vbmNlLlRhZ2dlZEhlbHBlcihUYWdnZWRIZWxwZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IlRhZ2dlZEhlbHBlciI6WyJUYWdnZWRIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAeqB+aBINAAASDQAAKQAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy90eXBlR3VhcmRzLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlT2YuanMiXSwiZXhwb3J0cyI6WyJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRSZWNvcmQiLCJhc3NlcnRSZW1vdGFibGUiLCJpc0NvcHlBcnJheSIsImlzUmVjb3JkIiwiaXNSZW1vdGFibGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcGFzc1N0eWxlT2Y7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGVPZi5qc1wiLCBbW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXV1dXSk7ICAgXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ29weUFycmF5PFQ+fSBDb3B5QXJyYXkgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNvcHlSZWNvcmQ8VD59IENvcHlSZWNvcmQgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlbW90YWJsZU9iamVjdH0gUmVtb3RhYmxlICovXG5cbmNvbnN0e0ZhaWwscXVvdGU6cX09YXNzZXJ0O1xuXG4vKipcbiAqIENoZWNrIHdoZXRoZXIgdGhlIGFyZ3VtZW50IGlzIGEgcGFzcy1ieS1jb3B5IGFycmF5LCBBS0EgYSBcImNvcHlBcnJheVwiXG4gKiBpbiBAZW5kby9tYXJzaGFsIHRlcm1zXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gYXJyXG4gKiBAcmV0dXJucyB7YXJyIGlzIENvcHlBcnJheTxhbnk+fVxuICovXG5jb25zdCBpc0NvcHlBcnJheT0oYXJyKT0+cGFzc1N0eWxlT2YoYXJyKT09PSdjb3B5QXJyYXknOyRo4oCNX29uY2UuaXNDb3B5QXJyYXkoaXNDb3B5QXJyYXkpO1xuaGFyZGVuKGlzQ29weUFycmF5KTtcblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIHRoZSBhcmd1bWVudCBpcyBhIHBhc3MtYnktY29weSByZWNvcmQsIEFLQSBhXG4gKiBcImNvcHlSZWNvcmRcIiBpbiBAZW5kby9tYXJzaGFsIHRlcm1zXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVjb3JkXG4gKiBAcmV0dXJucyB7cmVjb3JkIGlzIENvcHlSZWNvcmQ8YW55Pn1cbiAqL1xuY29uc3QgaXNSZWNvcmQ9KHJlY29yZCk9PnBhc3NTdHlsZU9mKHJlY29yZCk9PT0nY29weVJlY29yZCc7JGjigI1fb25jZS5pc1JlY29yZChpc1JlY29yZCk7XG5oYXJkZW4oaXNSZWNvcmQpO1xuXG4vKipcbiAqIENoZWNrIHdoZXRoZXIgdGhlIGFyZ3VtZW50IGlzIGEgcmVtb3RhYmxlLlxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHJlbW90YWJsZVxuICogQHJldHVybnMge3JlbW90YWJsZSBpcyBSZW1vdGFibGV9XG4gKi9cbmNvbnN0IGlzUmVtb3RhYmxlPShyZW1vdGFibGUpPT5wYXNzU3R5bGVPZihyZW1vdGFibGUpPT09J3JlbW90YWJsZSc7JGjigI1fb25jZS5pc1JlbW90YWJsZShpc1JlbW90YWJsZSk7XG5oYXJkZW4oaXNSZW1vdGFibGUpO1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRBcnJheVxuICogQHBhcmFtIHtQYXNzYWJsZX0gYXJyYXlcbiAqIEBwYXJhbSB7c3RyaW5nPX0gb3B0TmFtZU9mQXJyYXlcbiAqIEByZXR1cm5zIHthc3NlcnRzIGFycmF5IGlzIENvcHlBcnJheTxhbnk+fVxuICovXG5cbi8qKiBAdHlwZSB7QXNzZXJ0QXJyYXl9ICovXG5jb25zdCBhc3NlcnRDb3B5QXJyYXk9KGFycmF5LG9wdE5hbWVPZkFycmF5PSdBbGxlZ2VkIGFycmF5Jyk9PntcbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihhcnJheSk7XG5wYXNzU3R5bGU9PT0nY29weUFycmF5J3x8XG5GYWlsIGAke3Eob3B0TmFtZU9mQXJyYXkpfSAke2FycmF5fSBtdXN0IGJlIGEgcGFzcy1ieS1jb3B5IGFycmF5LCBub3QgJHtxKFxucGFzc1N0eWxlKVxuIH1gO1xuIH07JGjigI1fb25jZS5hc3NlcnRDb3B5QXJyYXkoYXNzZXJ0Q29weUFycmF5KTtcbmhhcmRlbihhc3NlcnRDb3B5QXJyYXkpO1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRSZWNvcmRcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHJlY29yZFxuICogQHBhcmFtIHtzdHJpbmc9fSBvcHROYW1lT2ZSZWNvcmRcbiAqIEByZXR1cm5zIHthc3NlcnRzIHJlY29yZCBpcyBDb3B5UmVjb3JkPGFueT59XG4gKi9cblxuLyoqIEB0eXBlIHtBc3NlcnRSZWNvcmR9ICovXG5jb25zdCBhc3NlcnRSZWNvcmQ9KHJlY29yZCxvcHROYW1lT2ZSZWNvcmQ9J0FsbGVnZWQgcmVjb3JkJyk9PntcbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihyZWNvcmQpO1xucGFzc1N0eWxlPT09J2NvcHlSZWNvcmQnfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZSZWNvcmQpfSAke3JlY29yZH0gbXVzdCBiZSBhIHBhc3MtYnktY29weSByZWNvcmQsIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaOKAjV9vbmNlLmFzc2VydFJlY29yZChhc3NlcnRSZWNvcmQpO1xuaGFyZGVuKGFzc2VydFJlY29yZCk7XG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFJlbW90YWJsZVxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVtb3RhYmxlXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlbW90YWJsZVxuICogQHJldHVybnMge2Fzc2VydHMgcmVtb3RhYmxlIGlzIFJlbW90YWJsZX1cbiAqL1xuXG4vKiogQHR5cGUge0Fzc2VydFJlbW90YWJsZX0gKi9cbmNvbnN0IGFzc2VydFJlbW90YWJsZT0oXG5yZW1vdGFibGUsXG5vcHROYW1lT2ZSZW1vdGFibGU9J0FsbGVnZWQgcmVtb3RhYmxlJyk9Plxue1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHJlbW90YWJsZSk7XG5wYXNzU3R5bGU9PT0ncmVtb3RhYmxlJ3x8XG5GYWlsIGAke3Eob3B0TmFtZU9mUmVtb3RhYmxlKX0gJHtyZW1vdGFibGV9IG11c3QgYmUgYSByZW1vdGFibGUsIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaOKAjV9vbmNlLmFzc2VydFJlbW90YWJsZShhc3NlcnRSZW1vdGFibGUpO1xuaGFyZGVuKGFzc2VydFJlbW90YWJsZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNDb3B5QXJyYXkiOlsiaXNDb3B5QXJyYXkiXSwiaXNSZWNvcmQiOlsiaXNSZWNvcmQiXSwiaXNSZW1vdGFibGUiOlsiaXNSZW1vdGFibGUiXSwiYXNzZXJ0Q29weUFycmF5IjpbImFzc2VydENvcHlBcnJheSJdLCJhc3NlcnRSZWNvcmQiOlsiYXNzZXJ0UmVjb3JkIl0sImFzc2VydFJlbW90YWJsZSI6WyJhc3NlcnRSZW1vdGFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAmBk7szQBAAA0AQAAJAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACwnEJ+4goAAOIKAAAeAAAAQGVuZG8vcGF0dGVybnMtdjAuMi4yL2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2tleXMvY2hlY2tLZXkuanMiLCIuL3NyYy9rZXlzL2NvbXBhcmVLZXlzLmpzIiwiLi9zcmMva2V5cy9jb3B5QmFnLmpzIiwiLi9zcmMva2V5cy9jb3B5U2V0LmpzIiwiLi9zcmMva2V5cy9tZXJnZS1iYWctb3BlcmF0b3JzLmpzIiwiLi9zcmMva2V5cy9tZXJnZS1zZXQtb3BlcmF0b3JzLmpzIiwiLi9zcmMvcGF0dGVybnMvcGF0dGVybk1hdGNoZXJzLmpzIiwiLi9zcmMvdHlwZXMuanMiLCIuL3NyYy91dGlscy5qcyJdLCJleHBvcnRzIjpbImFzc2VydEtleSIsImFzc2VydEtleSIsImJhZ0NvbXBhcmUiLCJiYWdDb21wYXJlIiwiZWxlbWVudHNJc0Rpc2pvaW50IiwiZWxlbWVudHNJc0Rpc2pvaW50IiwiZ2V0UmFua0NvdmVyIiwiZ2V0UmFua0NvdmVyIiwia2V5TFQiLCJrZXlMVCIsIm9iamVjdE1hcCIsIm9iamVjdE1hcCIsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9zcmMva2V5cy9jaGVja0tleS5qc1wiLCBbXV0sW1wiLi9zcmMva2V5cy9jb3B5U2V0LmpzXCIsIFtdXSxbXCIuL3NyYy9rZXlzL2NvcHlCYWcuanNcIiwgW11dLFtcIi4vc3JjL2tleXMvY29tcGFyZUtleXMuanNcIiwgW11dLFtcIi4vc3JjL2tleXMvbWVyZ2Utc2V0LW9wZXJhdG9ycy5qc1wiLCBbXV0sW1wiLi9zcmMva2V5cy9tZXJnZS1iYWctb3BlcmF0b3JzLmpzXCIsIFtdXSxbXCIuL3NyYy9wYXR0ZXJucy9wYXR0ZXJuTWF0Y2hlcnMuanNcIiwgW11dLFtcIi4vc3JjL3V0aWxzLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3NyYy9rZXlzL2NoZWNrS2V5LmpzIjpbWyJpc0tleSIsImlzS2V5Il0sWyJhc3NlcnRLZXkiLCJhc3NlcnRLZXkiXSxbImFzc2VydFNjYWxhcktleSIsImFzc2VydFNjYWxhcktleSJdLFsibWFrZUNvcHlTZXQiLCJtYWtlQ29weVNldCJdLFsiZ2V0Q29weVNldEtleXMiLCJnZXRDb3B5U2V0S2V5cyJdLFsibWFrZUNvcHlCYWciLCJtYWtlQ29weUJhZyJdLFsibWFrZUNvcHlCYWdGcm9tRWxlbWVudHMiLCJtYWtlQ29weUJhZ0Zyb21FbGVtZW50cyJdLFsiZ2V0Q29weUJhZ0VudHJpZXMiLCJnZXRDb3B5QmFnRW50cmllcyJdLFsibWFrZUNvcHlNYXAiLCJtYWtlQ29weU1hcCJdLFsiZ2V0Q29weU1hcEVudHJpZXMiLCJnZXRDb3B5TWFwRW50cmllcyJdXSwiLi9zcmMva2V5cy9jb3B5U2V0LmpzIjpbWyJjb2VyY2VUb0VsZW1lbnRzIiwiY29lcmNlVG9FbGVtZW50cyJdXSwiLi9zcmMva2V5cy9jb3B5QmFnLmpzIjpbWyJjb2VyY2VUb0JhZ0VudHJpZXMiLCJjb2VyY2VUb0JhZ0VudHJpZXMiXV0sIi4vc3JjL2tleXMvY29tcGFyZUtleXMuanMiOltbImNvbXBhcmVLZXlzIiwiY29tcGFyZUtleXMiXSxbImtleUxUIiwia2V5TFQiXSxbImtleUxURSIsImtleUxURSJdLFsia2V5RVEiLCJrZXlFUSJdLFsia2V5R1RFIiwia2V5R1RFIl0sWyJrZXlHVCIsImtleUdUIl1dLCIuL3NyYy9rZXlzL21lcmdlLXNldC1vcGVyYXRvcnMuanMiOltbImVsZW1lbnRzSXNTdXBlcnNldCIsImVsZW1lbnRzSXNTdXBlcnNldCJdLFsiZWxlbWVudHNJc0Rpc2pvaW50IiwiZWxlbWVudHNJc0Rpc2pvaW50Il0sWyJlbGVtZW50c0NvbXBhcmUiLCJlbGVtZW50c0NvbXBhcmUiXSxbImVsZW1lbnRzVW5pb24iLCJlbGVtZW50c1VuaW9uIl0sWyJlbGVtZW50c0Rpc2pvaW50VW5pb24iLCJlbGVtZW50c0Rpc2pvaW50VW5pb24iXSxbImVsZW1lbnRzSW50ZXJzZWN0aW9uIiwiZWxlbWVudHNJbnRlcnNlY3Rpb24iXSxbImVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCIsImVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCJdLFsic2V0SXNTdXBlcnNldCIsInNldElzU3VwZXJzZXQiXSxbInNldElzRGlzam9pbnQiLCJzZXRJc0Rpc2pvaW50Il0sWyJzZXRDb21wYXJlIiwic2V0Q29tcGFyZSJdLFsic2V0VW5pb24iLCJzZXRVbmlvbiJdLFsic2V0RGlzam9pbnRVbmlvbiIsInNldERpc2pvaW50VW5pb24iXSxbInNldEludGVyc2VjdGlvbiIsInNldEludGVyc2VjdGlvbiJdLFsic2V0RGlzam9pbnRTdWJ0cmFjdCIsInNldERpc2pvaW50U3VidHJhY3QiXV0sIi4vc3JjL2tleXMvbWVyZ2UtYmFnLW9wZXJhdG9ycy5qcyI6W1siYmFnSXNTdXBlcmJhZyIsImJhZ0lzU3VwZXJiYWciXSxbImJhZ0NvbXBhcmUiLCJiYWdDb21wYXJlIl0sWyJiYWdVbmlvbiIsImJhZ1VuaW9uIl0sWyJiYWdJbnRlcnNlY3Rpb24iLCJiYWdJbnRlcnNlY3Rpb24iXSxbImJhZ0Rpc2pvaW50U3VidHJhY3QiLCJiYWdEaXNqb2ludFN1YnRyYWN0Il1dLCIuL3NyYy9wYXR0ZXJucy9wYXR0ZXJuTWF0Y2hlcnMuanMiOltbIk0iLCJNIl0sWyJnZXRSYW5rQ292ZXIiLCJnZXRSYW5rQ292ZXIiXSxbImlzUGF0dGVybiIsImlzUGF0dGVybiJdLFsiYXNzZXJ0UGF0dGVybiIsImFzc2VydFBhdHRlcm4iXSxbIm1hdGNoZXMiLCJtYXRjaGVzIl0sWyJtdXN0TWF0Y2giLCJtdXN0TWF0Y2giXV0sIi4vc3JjL3V0aWxzLmpzIjpbWyJsaXN0RGlmZmVyZW5jZSIsImxpc3REaWZmZXJlbmNlIl0sWyJvYmplY3RNYXAiLCJvYmplY3RNYXAiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMsXGeCkRgAApEYAACoAAABAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvY2hlY2tLZXkuanN7ImltcG9ydHMiOlsiLi4vdXRpbHMuanMiLCIuL2NvcHlCYWcuanMiLCIuL2NvcHlTZXQuanMiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiYXNzZXJ0Q29weUJhZyIsImFzc2VydENvcHlNYXAiLCJhc3NlcnRDb3B5U2V0IiwiYXNzZXJ0S2V5IiwiYXNzZXJ0UHJpbWl0aXZlS2V5IiwiYXNzZXJ0U2NhbGFyS2V5IiwiY2hlY2tDb3B5QmFnIiwiY2hlY2tDb3B5TWFwIiwiY2hlY2tDb3B5U2V0IiwiY2hlY2tLZXkiLCJjaGVja1NjYWxhcktleSIsImNvcHlNYXBLZXlTZXQiLCJldmVyeUNvcHlCYWdFbnRyeSIsImV2ZXJ5Q29weU1hcEtleSIsImV2ZXJ5Q29weU1hcFZhbHVlIiwiZXZlcnlDb3B5U2V0S2V5IiwiZ2V0Q29weUJhZ0VudHJpZXMiLCJnZXRDb3B5TWFwRW50cmllcyIsImdldENvcHlNYXBLZXlzIiwiZ2V0Q29weU1hcFZhbHVlcyIsImdldENvcHlTZXRLZXlzIiwiaXNDb3B5QmFnIiwiaXNDb3B5TWFwIiwiaXNDb3B5U2V0IiwiaXNLZXkiLCJpc1ByaW1pdGl2ZUtleSIsImlzU2NhbGFyS2V5IiwibWFrZUNvcHlCYWciLCJtYWtlQ29weUJhZ0Zyb21FbGVtZW50cyIsIm1ha2VDb3B5TWFwIiwibWFrZUNvcHlTZXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixhc3NlcnRQYXNzYWJsZSxGYXIsZ2V0VGFnLGlzT2JqZWN0LG1ha2VUYWdnZWQscGFzc1N0eWxlT2YsY29tcGFyZUFudGlSYW5rLG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0LHNvcnRCeVJhbmssaWRlbnRDaGVja2VyLGNoZWNrRWxlbWVudHMsbWFrZVNldE9mRWxlbWVudHMsY2hlY2tCYWdFbnRyaWVzLG1ha2VCYWdPZkVudHJpZXM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UGFzc2FibGVcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFBhc3NhYmxlID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV0sW1wiZ2V0VGFnXCIsIFskaOKAjV9hID0+IChnZXRUYWcgPSAkaOKAjV9hKV1dLFtcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjigI1fYSA9PiAobWFrZVRhZ2dlZCA9ICRo4oCNX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXSxbXCJjb21wYXJlQW50aVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVBbnRpUmFuayA9ICRo4oCNX2EpXV0sW1wibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0ID0gJGjigI1fYSldXSxbXCJzb3J0QnlSYW5rXCIsIFskaOKAjV9hID0+IChzb3J0QnlSYW5rID0gJGjigI1fYSldXV1dLFtcIi4uL3V0aWxzLmpzXCIsIFtbXCJpZGVudENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGlkZW50Q2hlY2tlciA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvcHlTZXQuanNcIiwgW1tcImNoZWNrRWxlbWVudHNcIiwgWyRo4oCNX2EgPT4gKGNoZWNrRWxlbWVudHMgPSAkaOKAjV9hKV1dLFtcIm1ha2VTZXRPZkVsZW1lbnRzXCIsIFskaOKAjV9hID0+IChtYWtlU2V0T2ZFbGVtZW50cyA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvcHlCYWcuanNcIiwgW1tcImNoZWNrQmFnRW50cmllc1wiLCBbJGjigI1fYSA9PiAoY2hlY2tCYWdFbnRyaWVzID0gJGjigI1fYSldXSxbXCJtYWtlQmFnT2ZFbnRyaWVzXCIsIFskaOKAjV9hID0+IChtYWtlQmFnT2ZFbnRyaWVzID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtkZXRhaWxzOlgscXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5DaGVja2VyfSBDaGVja2VyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXlDb21wYXJpc29ufSBLZXlDb21wYXJpc29uICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuS2V5fSBLZXkgKi9cbi8qKiBAdGVtcGxhdGUge0tleX0gW0s9S2V5XSBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5Db3B5QmFnPEs+fSBDb3B5QmFnICovXG4vKiogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV0gQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuQ29weVNldDxLPn0gQ29weVNldCAqL1xuLyoqIEB0ZW1wbGF0ZSB7S2V5fSBbSz1LZXldIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFtWPVBhc3NhYmxlXSBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5Db3B5TWFwPEssIFY+fSBDb3B5TWFwICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuS2V5Q29tcGFyZX0gS2V5Q29tcGFyZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkZ1bGxDb21wYXJlfSBGdWxsQ29tcGFyZSAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8gUHJpbWl0aXZlIGFuZCBTY2FsYXIga2V5cyAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdmFsXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tQcmltaXRpdmVLZXk9KHZhbCxjaGVjayk9PntcbmlmKGlzT2JqZWN0KHZhbCkpe1xucmV0dXJuKFxuY2hlY2shPT1pZGVudENoZWNrZXImJlxuY2hlY2soZmFsc2UsWCBgQSAke3EodHlwZW9mIHZhbCl9IGNhbm5vdCBiZSBhIHByaW1pdGl2ZTogJHt2YWx9YCkpO1xuXG4gfVxuLyogVE9ETyBUaGVyZSBpcyBub3QgeWV0IGEgY2hlY2tQYXNzYWJsZSwgYnV0IHBlcmhhcHMgdGhlcmUgc2hvdWxkIGJlLiovXG4vKiBJZiB0aGF0IGhhcHBlbnMsIHdlIHNob3VsZCBjYWxsIGl0IGhlcmUgaW5zdGVhZC4qL1xuYXNzZXJ0UGFzc2FibGUodmFsKTtcbnJldHVybiB0cnVlO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdmFsXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGlzUHJpbWl0aXZlS2V5PSh2YWwpPT5jaGVja1ByaW1pdGl2ZUtleSh2YWwsaWRlbnRDaGVja2VyKTskaOKAjV9vbmNlLmlzUHJpbWl0aXZlS2V5KGlzUHJpbWl0aXZlS2V5KTtcbmhhcmRlbihpc1ByaW1pdGl2ZUtleSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdmFsXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFByaW1pdGl2ZUtleT0odmFsKT0+e1xuY2hlY2tQcmltaXRpdmVLZXkodmFsLGFzc2VydENoZWNrZXIpO1xuIH07JGjigI1fb25jZS5hc3NlcnRQcmltaXRpdmVLZXkoYXNzZXJ0UHJpbWl0aXZlS2V5KTtcbmhhcmRlbihhc3NlcnRQcmltaXRpdmVLZXkpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja1NjYWxhcktleT0odmFsLGNoZWNrKT0+e1xuaWYoaXNQcmltaXRpdmVLZXkodmFsKSl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YodmFsKTtcbmlmKHBhc3NTdHlsZT09PSdyZW1vdGFibGUnKXtcbnJldHVybiB0cnVlO1xuIH1cbnJldHVybiBjaGVjayhmYWxzZSxYIGBBICR7cShwYXNzU3R5bGUpfSBjYW5ub3QgYmUgYSBzY2FsYXIga2V5OiAke3ZhbH1gKTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi8kaOKAjV9vbmNlLmNoZWNrU2NhbGFyS2V5KGNoZWNrU2NhbGFyS2V5KTtcbmNvbnN0ICAgICAgICBpc1NjYWxhcktleT0odmFsKT0+Y2hlY2tTY2FsYXJLZXkodmFsLGlkZW50Q2hlY2tlcik7JGjigI1fb25jZS5pc1NjYWxhcktleShpc1NjYWxhcktleSk7XG5oYXJkZW4oaXNTY2FsYXJLZXkpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge3ZvaWR9XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRTY2FsYXJLZXk9KHZhbCk9PntcbmNoZWNrU2NhbGFyS2V5KHZhbCxhc3NlcnRDaGVja2VyKTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0U2NhbGFyS2V5KGFzc2VydFNjYWxhcktleSk7XG5oYXJkZW4oYXNzZXJ0U2NhbGFyS2V5KTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIEtleXMgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiogQHR5cGUge1dlYWtTZXQ8S2V5Pn0gKi9cbmNvbnN0IGtleU1lbW89bmV3IFdlYWtTZXQoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgY2hlY2tLZXk9KHZhbCxjaGVjayk9PntcbmlmKCFpc09iamVjdCh2YWwpKXtcbi8qIFRPRE8gVGhlcmUgaXMgbm90IHlldCBhIGNoZWNrUGFzc2FibGUsIGJ1dCBwZXJoYXBzIHRoZXJlIHNob3VsZCBiZS4qL1xuLyogSWYgdGhhdCBoYXBwZW5zLCB3ZSBzaG91bGQgY2FsbCBpdCBoZXJlIGluc3RlYWQuKi9cbmFzc2VydFBhc3NhYmxlKHZhbCk7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5pZihrZXlNZW1vLmhhcyh2YWwpKXtcbnJldHVybiB0cnVlO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5jb25zdCByZXN1bHQ9Y2hlY2tLZXlJbnRlcm5hbCh2YWwsY2hlY2spO1xuaWYocmVzdWx0KXtcbi8qIERvbid0IGNhY2hlIHRoZSB1bmRlZmluZWQgY2FzZXMsIHNvIHRoYXQgaWYgaXQgaXMgdHJpZWQgYWdhaW4qL1xuLyogd2l0aCBgYXNzZXJ0Q2hlY2tlcmAgaXQnbGwgdGhyb3cgYSBkaWFnbm9zdGljIGFnYWluKi9cbmtleU1lbW8uYWRkKHZhbCk7XG4gfVxuLyogTm90ZSB0aGF0IHdlIGRvIG5vdCBtZW1vaXplIGEgbmVnYXRpdmUganVkZ2VtZW50LCBzbyB0aGF0IGlmIGl0IGlzIHRyaWVkKi9cbi8qIGFnYWluIHdpdGggYSBjaGVja2VyLCBpdCB3aWxsIHN0aWxsIHByb2R1Y2UgYSB1c2VmdWwgZGlhZ25vc3RpYy4qL1xucmV0dXJuIHJlc3VsdDtcbiB9OyRo4oCNX29uY2UuY2hlY2tLZXkoY2hlY2tLZXkpO1xuaGFyZGVuKGNoZWNrS2V5KTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB2YWxcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgaXNLZXk9KHZhbCk9PmNoZWNrS2V5KHZhbCxpZGVudENoZWNrZXIpOyRo4oCNX29uY2UuaXNLZXkoaXNLZXkpO1xuaGFyZGVuKGlzS2V5KTtcblxuLyoqXG4gKiBAcGFyYW0ge0tleX0gdmFsXG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRLZXk9KHZhbCk9PntcbmNoZWNrS2V5KHZhbCxhc3NlcnRDaGVja2VyKTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0S2V5KGFzc2VydEtleSk7XG5oYXJkZW4oYXNzZXJ0S2V5KTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBDb3B5U2V0IC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiBNb3ZlZCB0byBoZXJlIHNvIHRoZXkgY2FuIGNoZWNrIHRoYXQgdGhlIGNvcHlTZXQgY29udGFpbnMgb25seSBrZXlzKi9cbi8qIHdpdGhvdXQgY3JlYXRpbmcgYW4gaW1wb3J0IGN5Y2xlLiovXG5cbi8qKiBAdHlwZSB7V2Vha1NldDxDb3B5U2V0Pn0gKi9cbmNvbnN0IGNvcHlTZXRNZW1vPW5ldyBXZWFrU2V0KCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gc1xuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja0NvcHlTZXQ9KHMsY2hlY2spPT57XG5pZihjb3B5U2V0TWVtby5oYXMocykpe1xucmV0dXJuIHRydWU7XG4gfVxuY29uc3QgcmVzdWx0PVxuKHBhc3NTdHlsZU9mKHMpPT09J3RhZ2dlZCcmJmdldFRhZyhzKT09PSdjb3B5U2V0J3x8XG5jaGVjayhmYWxzZSxYIGBOb3QgYSBjb3B5U2V0OiAke3N9YCkpJiZcbmNoZWNrRWxlbWVudHMocy5wYXlsb2FkLGNoZWNrKSYmXG5jaGVja0tleShzLnBheWxvYWQsY2hlY2spO1xuaWYocmVzdWx0KXtcbmNvcHlTZXRNZW1vLmFkZChzKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjigI1fb25jZS5jaGVja0NvcHlTZXQoY2hlY2tDb3B5U2V0KTtcbmhhcmRlbihjaGVja0NvcHlTZXQpO1xuXG4vKipcbiAqIEBjYWxsYmFjayBJc0NvcHlTZXRcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNcbiAqIEByZXR1cm5zIHtzIGlzIENvcHlTZXR9XG4gKi9cblxuLyoqIEB0eXBlIHtJc0NvcHlTZXR9ICovXG5jb25zdCAgICAgICAgaXNDb3B5U2V0PShzKT0+Y2hlY2tDb3B5U2V0KHMsaWRlbnRDaGVja2VyKTskaOKAjV9vbmNlLmlzQ29weVNldChpc0NvcHlTZXQpO1xuaGFyZGVuKGlzQ29weVNldCk7XG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydENvcHlTZXRcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNcbiAqIEByZXR1cm5zIHthc3NlcnRzIHMgaXMgQ29weVNldH1cbiAqL1xuXG4vKiogQHR5cGUge0Fzc2VydENvcHlTZXR9ICovXG5jb25zdCAgICAgICAgYXNzZXJ0Q29weVNldD0ocyk9PntcbmNoZWNrQ29weVNldChzLGFzc2VydENoZWNrZXIpO1xuIH07JGjigI1fb25jZS5hc3NlcnRDb3B5U2V0KGFzc2VydENvcHlTZXQpO1xuaGFyZGVuKGFzc2VydENvcHlTZXQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAcGFyYW0ge0NvcHlTZXQ8Sz59IHNcbiAqIEByZXR1cm5zIHtLW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRDb3B5U2V0S2V5cz0ocyk9PntcbmFzc2VydENvcHlTZXQocyk7XG5yZXR1cm4gcy5wYXlsb2FkO1xuIH07JGjigI1fb25jZS5nZXRDb3B5U2V0S2V5cyhnZXRDb3B5U2V0S2V5cyk7XG5oYXJkZW4oZ2V0Q29weVNldEtleXMpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAcGFyYW0ge0NvcHlTZXQ8Sz59IHNcbiAqIEBwYXJhbSB7KGtleTogSywgaW5kZXg6IG51bWJlcikgPT4gYm9vbGVhbn0gZm5cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgZXZlcnlDb3B5U2V0S2V5PShzLGZuKT0+XG5nZXRDb3B5U2V0S2V5cyhzKS5ldmVyeSgoa2V5LGluZGV4KT0+Zm4oa2V5LGluZGV4KSk7JGjigI1fb25jZS5ldmVyeUNvcHlTZXRLZXkoZXZlcnlDb3B5U2V0S2V5KTtcbmhhcmRlbihldmVyeUNvcHlTZXRLZXkpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPEs+fSBlbGVtZW50SXRlclxuICogQHJldHVybnMge0NvcHlTZXQ8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29weVNldD0oZWxlbWVudEl0ZXIpPT57XG5jb25zdCByZXN1bHQ9bWFrZVNldE9mRWxlbWVudHMoZWxlbWVudEl0ZXIpO1xuYXNzZXJ0Q29weVNldChyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9OyRo4oCNX29uY2UubWFrZUNvcHlTZXQobWFrZUNvcHlTZXQpO1xuaGFyZGVuKG1ha2VDb3B5U2V0KTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBDb3B5QmFnIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiBNb3ZlZCB0byBoZXJlIHNvIHRoZXkgY2FuIGNoZWNrIHRoYXQgdGhlIGNvcHlCYWcgY29udGFpbnMgb25seSBrZXlzKi9cbi8qIHdpdGhvdXQgY3JlYXRpbmcgYW4gaW1wb3J0IGN5Y2xlLiovXG5cbi8qKiBAdHlwZSB7V2Vha1NldDxDb3B5QmFnPn0gKi9cbmNvbnN0IGNvcHlCYWdNZW1vPW5ldyBXZWFrU2V0KCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gYlxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja0NvcHlCYWc9KGIsY2hlY2spPT57XG5pZihjb3B5QmFnTWVtby5oYXMoYikpe1xucmV0dXJuIHRydWU7XG4gfVxuY29uc3QgcmVzdWx0PVxuKHBhc3NTdHlsZU9mKGIpPT09J3RhZ2dlZCcmJmdldFRhZyhiKT09PSdjb3B5QmFnJ3x8XG5jaGVjayhmYWxzZSxYIGBOb3QgYSBjb3B5QmFnOiAke2J9YCkpJiZcbmNoZWNrQmFnRW50cmllcyhiLnBheWxvYWQsY2hlY2spJiZcbmNoZWNrS2V5KGIucGF5bG9hZCxjaGVjayk7XG5pZihyZXN1bHQpe1xuY29weUJhZ01lbW8uYWRkKGIpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfTskaOKAjV9vbmNlLmNoZWNrQ29weUJhZyhjaGVja0NvcHlCYWcpO1xuaGFyZGVuKGNoZWNrQ29weUJhZyk7XG5cbi8qKlxuICogQGNhbGxiYWNrIElzQ29weUJhZ1xuICogQHBhcmFtIHtQYXNzYWJsZX0gYlxuICogQHJldHVybnMge2IgaXMgQ29weUJhZ31cbiAqL1xuXG4vKiogQHR5cGUge0lzQ29weUJhZ30gKi9cbmNvbnN0ICAgICAgICBpc0NvcHlCYWc9KGIpPT5jaGVja0NvcHlCYWcoYixpZGVudENoZWNrZXIpOyRo4oCNX29uY2UuaXNDb3B5QmFnKGlzQ29weUJhZyk7XG5oYXJkZW4oaXNDb3B5QmFnKTtcblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0Q29weUJhZ1xuICogQHBhcmFtIHtQYXNzYWJsZX0gYlxuICogQHJldHVybnMge2Fzc2VydHMgYiBpcyBDb3B5QmFnfVxuICovXG5cbi8qKiBAdHlwZSB7QXNzZXJ0Q29weUJhZ30gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDb3B5QmFnPShiKT0+e1xuY2hlY2tDb3B5QmFnKGIsYXNzZXJ0Q2hlY2tlcik7XG4gfTskaOKAjV9vbmNlLmFzc2VydENvcHlCYWcoYXNzZXJ0Q29weUJhZyk7XG5oYXJkZW4oYXNzZXJ0Q29weUJhZyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7Q29weUJhZzxLPn0gYlxuICogQHJldHVybnMge0NvcHlCYWc8Sz5bJ3BheWxvYWQnXX1cbiAqL1xuY29uc3QgICAgICAgIGdldENvcHlCYWdFbnRyaWVzPShiKT0+e1xuYXNzZXJ0Q29weUJhZyhiKTtcbnJldHVybiBiLnBheWxvYWQ7XG4gfTskaOKAjV9vbmNlLmdldENvcHlCYWdFbnRyaWVzKGdldENvcHlCYWdFbnRyaWVzKTtcbmhhcmRlbihnZXRDb3B5QmFnRW50cmllcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7Q29weUJhZzxLPn0gYlxuICogQHBhcmFtIHsoZW50cnk6IFtLLCBiaWdpbnRdLCBpbmRleDogbnVtYmVyKSA9PiBib29sZWFufSBmblxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBldmVyeUNvcHlCYWdFbnRyeT0oYixmbik9PlxuZ2V0Q29weUJhZ0VudHJpZXMoYikuZXZlcnkoKGVudHJ5LGluZGV4KT0+Zm4oZW50cnksaW5kZXgpKTskaOKAjV9vbmNlLmV2ZXJ5Q29weUJhZ0VudHJ5KGV2ZXJ5Q29weUJhZ0VudHJ5KTtcbmhhcmRlbihldmVyeUNvcHlCYWdFbnRyeSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7SXRlcmFibGU8W0ssYmlnaW50XT59IGJhZ0VudHJ5SXRlclxuICogQHJldHVybnMge0NvcHlCYWc8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29weUJhZz0oYmFnRW50cnlJdGVyKT0+e1xuY29uc3QgcmVzdWx0PW1ha2VCYWdPZkVudHJpZXMoYmFnRW50cnlJdGVyKTtcbmFzc2VydENvcHlCYWcocmVzdWx0KTtcbnJldHVybiByZXN1bHQ7XG4gfTskaOKAjV9vbmNlLm1ha2VDb3B5QmFnKG1ha2VDb3B5QmFnKTtcbmhhcmRlbihtYWtlQ29weUJhZyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7SXRlcmFibGU8Sz59IGVsZW1lbnRJdGVyXG4gKiBAcmV0dXJucyB7Q29weUJhZzxLPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VDb3B5QmFnRnJvbUVsZW1lbnRzPShlbGVtZW50SXRlcik9Pntcbi8qIFRoaXMgZnVsbE9yZGVyIGNvbnRhaW5zIGhpc3RvcnkgZGVwZW5kZW50IHN0YXRlLiBJdCBpcyBzcGVjaWZpYyovXG4vKiB0byB0aGlzIG9uZSBjYWxsIGFuZCBkb2VzIG5vdCBzdXJ2aXZlIGl0LiovXG5jb25zdCBmdWxsQ29tcGFyZT1tYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCgpLmFudGlDb21wYXJhdG9yO1xuY29uc3Qgc29ydGVkPXNvcnRCeVJhbmsoZWxlbWVudEl0ZXIsZnVsbENvbXBhcmUpO1xuLyoqIEB0eXBlIHtbSyxiaWdpbnRdW119ICovXG5jb25zdCBlbnRyaWVzPVtdO1xuZm9yKGxldCBpPTA7aTxzb3J0ZWQubGVuZ3RoOyl7XG5jb25zdCBrPXNvcnRlZFtpXTtcbmxldCBqPWkrMTtcbndoaWxlKGo8c29ydGVkLmxlbmd0aCYmZnVsbENvbXBhcmUoayxzb3J0ZWRbal0pPT09MCl7XG5qKz0xO1xuIH1cbmVudHJpZXMucHVzaChbayxCaWdJbnQoai1pKV0pO1xuaT1qO1xuIH1cbnJldHVybiBtYWtlQ29weUJhZyhlbnRyaWVzKTtcbiB9OyRo4oCNX29uY2UubWFrZUNvcHlCYWdGcm9tRWxlbWVudHMobWFrZUNvcHlCYWdGcm9tRWxlbWVudHMpO1xuaGFyZGVuKG1ha2VDb3B5QmFnRnJvbUVsZW1lbnRzKTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBDb3B5TWFwIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiBNb3ZlZCB0byBoZXJlIHNvIHRoZXkgY2FuIGNoZWNrIHRoYXQgdGhlIGNvcHlNYXAncyBrZXlzIGNvbnRhaW5zIG9ubHkga2V5cyovXG4vKiB3aXRob3V0IGNyZWF0aW5nIGFuIGltcG9ydCBjeWNsZS4qL1xuXG4vKiogQHR5cGUge1dlYWtTZXQ8Q29weU1hcD59ICovXG5jb25zdCBjb3B5TWFwTWVtbz1uZXcgV2Vha1NldCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IG1cbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgY2hlY2tDb3B5TWFwPShtLGNoZWNrKT0+e1xuaWYoY29weU1hcE1lbW8uaGFzKG0pKXtcbnJldHVybiB0cnVlO1xuIH1cbmlmKCEocGFzc1N0eWxlT2YobSk9PT0ndGFnZ2VkJyYmZ2V0VGFnKG0pPT09J2NvcHlNYXAnKSl7XG5yZXR1cm4gY2hlY2soZmFsc2UsWCBgTm90IGEgY29weU1hcDogJHttfWApO1xuIH1cbmNvbnN0e3BheWxvYWR9PW07XG5pZihwYXNzU3R5bGVPZihwYXlsb2FkKSE9PSdjb3B5UmVjb3JkJyl7XG5yZXR1cm4gY2hlY2soZmFsc2UsWCBgQSBjb3B5TWFwJ3MgcGF5bG9hZCBtdXN0IGJlIGEgcmVjb3JkOiAke219YCk7XG4gfVxuY29uc3R7a2V5cyx2YWx1ZXMsLi4ucmVzdH09cGF5bG9hZDtcbmNvbnN0IHJlc3VsdD1cbihvd25LZXlzKHJlc3QpLmxlbmd0aD09PTB8fFxuY2hlY2soXG5mYWxzZSxcblggYEEgY29weU1hcCdzIHBheWxvYWQgbXVzdCBvbmx5IGhhdmUgLmtleXMgYW5kIC52YWx1ZXM6ICR7bX1gKSkmJlxuXG5jaGVja0VsZW1lbnRzKGtleXMsY2hlY2spJiZcbmNoZWNrS2V5KGtleXMsY2hlY2spJiYoXG5wYXNzU3R5bGVPZih2YWx1ZXMpPT09J2NvcHlBcnJheSd8fFxuY2hlY2soZmFsc2UsWCBgQSBjb3B5TWFwJ3MgLnZhbHVlcyBtdXN0IGJlIGEgY29weUFycmF5OiAke219YCkpJiYoXG5rZXlzLmxlbmd0aD09PXZhbHVlcy5sZW5ndGh8fFxuY2hlY2soXG5mYWxzZSxcblggYEEgY29weU1hcCBtdXN0IGhhdmUgdGhlIHNhbWUgbnVtYmVyIG9mIGtleXMgYW5kIHZhbHVlczogJHttfWApKTtcblxuaWYocmVzdWx0KXtcbmNvcHlNYXBNZW1vLmFkZChtKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjigI1fb25jZS5jaGVja0NvcHlNYXAoY2hlY2tDb3B5TWFwKTtcbmhhcmRlbihjaGVja0NvcHlNYXApO1xuXG4vKipcbiAqIEBjYWxsYmFjayBJc0NvcHlNYXBcbiAqIEBwYXJhbSB7UGFzc2FibGV9IG1cbiAqIEByZXR1cm5zIHttIGlzIENvcHlNYXA8S2V5LCBQYXNzYWJsZT59XG4gKi9cblxuLyoqIEB0eXBlIHtJc0NvcHlNYXB9ICovXG5jb25zdCAgICAgICAgaXNDb3B5TWFwPShtKT0+Y2hlY2tDb3B5TWFwKG0saWRlbnRDaGVja2VyKTskaOKAjV9vbmNlLmlzQ29weU1hcChpc0NvcHlNYXApO1xuaGFyZGVuKGlzQ29weU1hcCk7XG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydENvcHlNYXBcbiAqIEBwYXJhbSB7UGFzc2FibGV9IG1cbiAqIEByZXR1cm5zIHthc3NlcnRzIG0gaXMgQ29weU1hcDxLZXksIFBhc3NhYmxlPn1cbiAqL1xuXG4vKiogQHR5cGUge0Fzc2VydENvcHlNYXB9ICovXG5jb25zdCAgICAgICAgYXNzZXJ0Q29weU1hcD0obSk9PntcbmNoZWNrQ29weU1hcChtLGFzc2VydENoZWNrZXIpO1xuIH07JGjigI1fb25jZS5hc3NlcnRDb3B5TWFwKGFzc2VydENvcHlNYXApO1xuaGFyZGVuKGFzc2VydENvcHlNYXApO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7S2V5fSBLXG4gKiBAdGVtcGxhdGUge1Bhc3NhYmxlfSBWXG4gKiBAcGFyYW0ge0NvcHlNYXA8SyxWPn0gbVxuICogQHJldHVybnMge0tbXX1cbiAqL1xuY29uc3QgICAgICAgIGdldENvcHlNYXBLZXlzPShtKT0+e1xuYXNzZXJ0Q29weU1hcChtKTtcbnJldHVybiBtLnBheWxvYWQua2V5cztcbiB9OyRo4oCNX29uY2UuZ2V0Q29weU1hcEtleXMoZ2V0Q29weU1hcEtleXMpO1xuaGFyZGVuKGdldENvcHlNYXBLZXlzKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gS1xuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVlxuICogQHBhcmFtIHtDb3B5TWFwPEssVj59IG1cbiAqIEByZXR1cm5zIHtWW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRDb3B5TWFwVmFsdWVzPShtKT0+e1xuYXNzZXJ0Q29weU1hcChtKTtcbnJldHVybiBtLnBheWxvYWQudmFsdWVzO1xuIH07JGjigI1fb25jZS5nZXRDb3B5TWFwVmFsdWVzKGdldENvcHlNYXBWYWx1ZXMpO1xuaGFyZGVuKGdldENvcHlNYXBWYWx1ZXMpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7S2V5fSBLXG4gKiBAdGVtcGxhdGUge1Bhc3NhYmxlfSBWXG4gKiBAcGFyYW0ge0NvcHlNYXA8SyxWPn0gbVxuICogQHJldHVybnMge0l0ZXJhYmxlPFtLLFZdPn1cbiAqL1xuY29uc3QgICAgICAgIGdldENvcHlNYXBFbnRyaWVzPShtKT0+e1xuYXNzZXJ0Q29weU1hcChtKTtcbmNvbnN0e1xucGF5bG9hZDp7a2V5cyx2YWx1ZXN9fT1cbm07XG5jb25zdHtsZW5ndGh9PS8qKiBAdHlwZSB7QXJyYXl9ICova2V5cztcbnJldHVybiBGYXIoJ0NvcHlNYXAgZW50cmllcyBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmxldCBpPTA7XG5yZXR1cm4gRmFyKCdDb3B5TWFwIGVudHJpZXMgaXRlcmF0b3InLHtcbm5leHQ6KCk9Pntcbi8qKiBAdHlwZSB7SXRlcmF0b3JSZXN1bHQ8W0ssVl0sdm9pZD59ICovXG5sZXQgcmVzdWx0O1xuaWYoaTxsZW5ndGgpe1xucmVzdWx0PWhhcmRlbih7ZG9uZTpmYWxzZSx2YWx1ZTpba2V5c1tpXSx2YWx1ZXNbaV1dfSk7XG5pKz0xO1xucmV0dXJuIHJlc3VsdDtcbiB9ZWxzZXtcbnJlc3VsdD1oYXJkZW4oe2RvbmU6dHJ1ZSx2YWx1ZTp1bmRlZmluZWR9KTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH19KTtcblxuIH19KTtcblxuIH07JGjigI1fb25jZS5nZXRDb3B5TWFwRW50cmllcyhnZXRDb3B5TWFwRW50cmllcyk7XG5oYXJkZW4oZ2V0Q29weU1hcEVudHJpZXMpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7S2V5fSBLXG4gKiBAdGVtcGxhdGUge1Bhc3NhYmxlfSBWXG4gKiBAcGFyYW0ge0NvcHlNYXA8SyxWPn0gbVxuICogQHBhcmFtIHsoa2V5OiBLLCBpbmRleDogbnVtYmVyKSA9PiBib29sZWFufSBmblxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBldmVyeUNvcHlNYXBLZXk9KG0sZm4pPT5cbmdldENvcHlNYXBLZXlzKG0pLmV2ZXJ5KChrZXksaW5kZXgpPT5mbihrZXksaW5kZXgpKTskaOKAjV9vbmNlLmV2ZXJ5Q29weU1hcEtleShldmVyeUNvcHlNYXBLZXkpO1xuaGFyZGVuKGV2ZXJ5Q29weU1hcEtleSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IEtcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFZcbiAqIEBwYXJhbSB7Q29weU1hcDxLLFY+fSBtXG4gKiBAcGFyYW0geyh2YWx1ZTogViwgaW5kZXg6IG51bWJlcikgPT4gYm9vbGVhbn0gZm5cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgZXZlcnlDb3B5TWFwVmFsdWU9KG0sZm4pPT5cbmdldENvcHlNYXBWYWx1ZXMobSkuZXZlcnkoKHZhbHVlLGluZGV4KT0+Zm4odmFsdWUsaW5kZXgpKTskaOKAjV9vbmNlLmV2ZXJ5Q29weU1hcFZhbHVlKGV2ZXJ5Q29weU1hcFZhbHVlKTtcbmhhcmRlbihldmVyeUNvcHlNYXBWYWx1ZSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IEtcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFZcbiAqIEBwYXJhbSB7Q29weU1hcDxLLFY+fSBtXG4gKiBAcmV0dXJucyB7Q29weVNldDxLPn1cbiAqL1xuY29uc3QgICAgICAgIGNvcHlNYXBLZXlTZXQ9KG0pPT5cbi8qIEEgY29weU1hcCdzIGtleXMgYXJlIGFscmVhZHkgaW4gdGhlIGludGVybmFsIGZvcm0gdXNlZCBieSBjb3B5U2V0cy4qL1xubWFrZVRhZ2dlZCgnY29weVNldCcsbS5wYXlsb2FkLmtleXMpOyRo4oCNX29uY2UuY29weU1hcEtleVNldChjb3B5TWFwS2V5U2V0KTtcbmhhcmRlbihjb3B5TWFwS2V5U2V0KTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gS1xuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVlxuICogQHBhcmFtIHtJdGVyYWJsZTxbSywgVl0+fSBlbnRyaWVzXG4gKiBAcmV0dXJucyB7Q29weU1hcDxLLFY+fVxuICovXG5jb25zdCAgICAgICAgbWFrZUNvcHlNYXA9KGVudHJpZXMpPT57XG4vKiBUaGlzIGlzIHdlaXJkLCBidXQgcmV2ZXJzZSByYW5rIHNvcnRpbmcgdGhlIGVudHJpZXMgaXMgYSBnb29kIGZpcnN0IHN0ZXAqL1xuLyogZm9yIGdldHRpbmcgdGhlIHJhbmsgc29ydGVkIGtleXMgdG9nZXRoZXIgd2l0aCB0aGUgdmFsdWVzKi9cbi8qIG9yZ2FuaXplZCBieSB0aG9zZSBrZXlzLiBBbHNvLCBhbW9uZyB2YWx1ZXMgYXNzb2NpYXRlZCB3aXRoKi9cbi8qIGtleXMgaW4gdGhlIHNhbWUgZXF1aXZhbGVuY2UgY2xhc3MsIHRob3NlIGFyZSByYW5rIHNvcnRlZC4qL1xuLyogVE9ETyBUaGlzKi9cbi8qIGNvdWxkIHNvbHZlIHRoZSBjb3B5TWFwIGNvdmVyIGlzc3VlIGV4cGxhaW5lZCBpbiBwYXR0ZXJuTWF0Y2hlcnMuanMuKi9cbi8qIEJ1dCBvbmx5IGlmIHdlIGluY2x1ZGUgdGhpcyBjcml0ZXJpYSBpbiBvdXIgdmFsaWRhdGlvbiBvZiBjb3B5TWFwcywqL1xuLyogd2hpY2ggd2UgY3VycmVudGx5IGRvIG5vdC4qL1xuY29uc3Qgc29ydGVkRW50cmllcz1zb3J0QnlSYW5rKGVudHJpZXMsY29tcGFyZUFudGlSYW5rKTtcbmNvbnN0IGtleXM9c29ydGVkRW50cmllcy5tYXAoKFtrLF92XSk9PmspO1xuY29uc3QgdmFsdWVzPXNvcnRlZEVudHJpZXMubWFwKChbX2ssdl0pPT52KTtcbmNvbnN0IHJlc3VsdD1tYWtlVGFnZ2VkKCdjb3B5TWFwJyx7a2V5cyx2YWx1ZXN9KTtcbmFzc2VydENvcHlNYXAocmVzdWx0KTtcbnJldHVybiByZXN1bHQ7XG4gfTskaOKAjV9vbmNlLm1ha2VDb3B5TWFwKG1ha2VDb3B5TWFwKTtcbmhhcmRlbihtYWtlQ29weU1hcCk7XG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBLZXlzIFJlY3VyIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja0tleUludGVybmFsPSh2YWwsY2hlY2spPT57XG5jb25zdCBjaGVja0l0PShjaGlsZCk9PmNoZWNrS2V5KGNoaWxkLGNoZWNrKTtcblxuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHZhbCk7XG5zd2l0Y2gocGFzc1N0eWxlKXtcbmNhc2UnY29weVJlY29yZCc6e1xuLyogQSBjb3B5UmVjb3JkIGlzIGEga2V5IGlmZiBhbGwgaXRzIGNoaWxkcmVuIGFyZSBrZXlzKi9cbnJldHVybiBPYmplY3QudmFsdWVzKHZhbCkuZXZlcnkoY2hlY2tJdCk7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIEEgY29weUFycmF5IGlzIGEga2V5IGlmZiBhbGwgaXRzIGNoaWxkcmVuIGFyZSBrZXlzKi9cbnJldHVybiB2YWwuZXZlcnkoY2hlY2tJdCk7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IHRhZz1nZXRUYWcodmFsKTtcbnN3aXRjaCh0YWcpe1xuY2FzZSdjb3B5U2V0Jzp7XG5yZXR1cm4gY2hlY2tDb3B5U2V0KHZhbCxjaGVjayk7XG4gfVxuY2FzZSdjb3B5QmFnJzp7XG5yZXR1cm4gY2hlY2tDb3B5QmFnKHZhbCxjaGVjayk7XG4gfVxuY2FzZSdjb3B5TWFwJzp7XG5yZXR1cm4oXG5jaGVja0NvcHlNYXAodmFsLGNoZWNrKSYmXG4vKiBGb3IgYSBjb3B5TWFwIHRvIGJlIGEga2V5LCBhbGwgaXRzIGtleXMgYW5kIHZhbHVlcyBtdXN0Ki9cbi8qIGJlIGtleXMuIEtleXMgYWxyZWFkeSBjaGVja2VkIGJ5IGBjaGVja0NvcHlNYXBgIHNpbmNlKi9cbi8qIHRoYXQncyBhIGNvcHlNYXAgcmVxdWlyZW1lbnQgaW4gZ2VuZXJhbC4qL1xuZXZlcnlDb3B5TWFwVmFsdWUodmFsLGNoZWNrSXQpKTtcblxuIH1cbmRlZmF1bHQ6e1xucmV0dXJuKFxuY2hlY2shPT1pZGVudENoZWNrZXImJlxuY2hlY2soZmFsc2UsWCBgQSBwYXNzYWJsZSB0YWdnZWQgJHtxKHRhZyl9IGlzIG5vdCBhIGtleTogJHt2YWx9YCkpO1xuXG4gfX1cblxuIH1cbmNhc2UncmVtb3RhYmxlJzp7XG4vKiBBbGwgcmVtb3RhYmxlcyBhcmUga2V5cy4qL1xucmV0dXJuIHRydWU7XG4gfVxuY2FzZSdlcnJvcic6XG5jYXNlJ3Byb21pc2UnOntcbnJldHVybiBjaGVjayhmYWxzZSxYIGBBICR7cShwYXNzU3R5bGUpfSBjYW5ub3QgYmUgYSBrZXlgKTtcbiB9XG5kZWZhdWx0Ontcbi8qIFVuZXhwZWN0ZWQgdGFncyBhcmUganVzdCBub24ta2V5cywgYnV0IGFuIHVuZXhwZWN0ZWQgcGFzc1N0eWxlKi9cbi8qIGlzIGFsd2F5cyBhbiBlcnJvci4qL1xudGhyb3cgRmFpbCBgdW5leHBlY3RlZCBwYXNzU3R5bGUgJHtxKHBhc3NTdHlsZSl9OiAke3ZhbH1gO1xuIH19XG5cbiB9O1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUHJpbWl0aXZlS2V5IjpbImlzUHJpbWl0aXZlS2V5Il0sImFzc2VydFByaW1pdGl2ZUtleSI6WyJhc3NlcnRQcmltaXRpdmVLZXkiXSwiY2hlY2tTY2FsYXJLZXkiOlsiY2hlY2tTY2FsYXJLZXkiXSwiaXNTY2FsYXJLZXkiOlsiaXNTY2FsYXJLZXkiXSwiYXNzZXJ0U2NhbGFyS2V5IjpbImFzc2VydFNjYWxhcktleSJdLCJjaGVja0tleSI6WyJjaGVja0tleSJdLCJpc0tleSI6WyJpc0tleSJdLCJhc3NlcnRLZXkiOlsiYXNzZXJ0S2V5Il0sImNoZWNrQ29weVNldCI6WyJjaGVja0NvcHlTZXQiXSwiaXNDb3B5U2V0IjpbImlzQ29weVNldCJdLCJhc3NlcnRDb3B5U2V0IjpbImFzc2VydENvcHlTZXQiXSwiZ2V0Q29weVNldEtleXMiOlsiZ2V0Q29weVNldEtleXMiXSwiZXZlcnlDb3B5U2V0S2V5IjpbImV2ZXJ5Q29weVNldEtleSJdLCJtYWtlQ29weVNldCI6WyJtYWtlQ29weVNldCJdLCJjaGVja0NvcHlCYWciOlsiY2hlY2tDb3B5QmFnIl0sImlzQ29weUJhZyI6WyJpc0NvcHlCYWciXSwiYXNzZXJ0Q29weUJhZyI6WyJhc3NlcnRDb3B5QmFnIl0sImdldENvcHlCYWdFbnRyaWVzIjpbImdldENvcHlCYWdFbnRyaWVzIl0sImV2ZXJ5Q29weUJhZ0VudHJ5IjpbImV2ZXJ5Q29weUJhZ0VudHJ5Il0sIm1ha2VDb3B5QmFnIjpbIm1ha2VDb3B5QmFnIl0sIm1ha2VDb3B5QmFnRnJvbUVsZW1lbnRzIjpbIm1ha2VDb3B5QmFnRnJvbUVsZW1lbnRzIl0sImNoZWNrQ29weU1hcCI6WyJjaGVja0NvcHlNYXAiXSwiaXNDb3B5TWFwIjpbImlzQ29weU1hcCJdLCJhc3NlcnRDb3B5TWFwIjpbImFzc2VydENvcHlNYXAiXSwiZ2V0Q29weU1hcEtleXMiOlsiZ2V0Q29weU1hcEtleXMiXSwiZ2V0Q29weU1hcFZhbHVlcyI6WyJnZXRDb3B5TWFwVmFsdWVzIl0sImdldENvcHlNYXBFbnRyaWVzIjpbImdldENvcHlNYXBFbnRyaWVzIl0sImV2ZXJ5Q29weU1hcEtleSI6WyJldmVyeUNvcHlNYXBLZXkiXSwiZXZlcnlDb3B5TWFwVmFsdWUiOlsiZXZlcnlDb3B5TWFwVmFsdWUiXSwiY29weU1hcEtleVNldCI6WyJjb3B5TWFwS2V5U2V0Il0sIm1ha2VDb3B5TWFwIjpbIm1ha2VDb3B5TWFwIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAPfmwlF3GgAAdxoAAC0AAABAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvY29tcGFyZUtleXMuanN7ImltcG9ydHMiOlsiLi9jaGVja0tleS5qcyIsIi4vbWVyZ2UtYmFnLW9wZXJhdG9ycy5qcyIsIi4vbWVyZ2Utc2V0LW9wZXJhdG9ycy5qcyIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJjb21wYXJlS2V5cyIsImtleUVRIiwia2V5R1QiLCJrZXlHVEUiLCJrZXlMVCIsImtleUxURSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBwYXNzU3R5bGVPZixnZXRUYWcsY29tcGFyZVJhbmsscmVjb3JkTmFtZXMscmVjb3JkVmFsdWVzLGFzc2VydEtleSxiYWdDb21wYXJlLHNldENvbXBhcmU7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXSxbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV0sW1wiY29tcGFyZVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVSYW5rID0gJGjigI1fYSldXSxbXCJyZWNvcmROYW1lc1wiLCBbJGjigI1fYSA9PiAocmVjb3JkTmFtZXMgPSAkaOKAjV9hKV1dLFtcInJlY29yZFZhbHVlc1wiLCBbJGjigI1fYSA9PiAocmVjb3JkVmFsdWVzID0gJGjigI1fYSldXV1dLFtcIi4vY2hlY2tLZXkuanNcIiwgW1tcImFzc2VydEtleVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0S2V5ID0gJGjigI1fYSldXV1dLFtcIi4vbWVyZ2UtYmFnLW9wZXJhdG9ycy5qc1wiLCBbW1wiYmFnQ29tcGFyZVwiLCBbJGjigI1fYSA9PiAoYmFnQ29tcGFyZSA9ICRo4oCNX2EpXV1dXSxbXCIuL21lcmdlLXNldC1vcGVyYXRvcnMuanNcIiwgW1tcInNldENvbXBhcmVcIiwgWyRo4oCNX2EgPT4gKHNldENvbXBhcmUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e3F1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGUge1hpbXBvcnQoJy4uL3R5cGVzJykuS2V5Q29tcGFyZX0gKi9cbmNvbnN0ICAgICAgICBjb21wYXJlS2V5cz0obGVmdCxyaWdodCk9PntcbmFzc2VydEtleShsZWZ0KTtcbmFzc2VydEtleShyaWdodCk7XG5jb25zdCBsZWZ0U3R5bGU9cGFzc1N0eWxlT2YobGVmdCk7XG5jb25zdCByaWdodFN0eWxlPXBhc3NTdHlsZU9mKHJpZ2h0KTtcbmlmKGxlZnRTdHlsZSE9PXJpZ2h0U3R5bGUpe1xuLyogRGlmZmVyZW50IHBhc3NTdHlsZXMgYXJlIGluY29tbWVuc3VyYXRlKi9cbnJldHVybiBOYU47XG4gfVxuc3dpdGNoKGxlZnRTdHlsZSl7XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ251bGwnOlxuY2FzZSdib29sZWFuJzpcbmNhc2UnYmlnaW50JzpcbmNhc2Unc3RyaW5nJzpcbmNhc2Unc3ltYm9sJzp7XG4vKiBmb3IgdGhlc2UsIGtleXMgY29tcGFyZSB0aGUgc2FtZSBhcyByYW5rKi9cbnJldHVybiBjb21wYXJlUmFuayhsZWZ0LHJpZ2h0KTtcbiB9XG5jYXNlJ251bWJlcic6e1xuY29uc3QgcmFua0NvbXA9Y29tcGFyZVJhbmsobGVmdCxyaWdodCk7XG5pZihyYW5rQ29tcD09PTApe1xucmV0dXJuIDA7XG4gfVxuaWYoTnVtYmVyLmlzTmFOKGxlZnQpfHxOdW1iZXIuaXNOYU4ocmlnaHQpKXtcbi8qIE5hTiBpcyBlcXVhbCB0byBpdHNlbGYsIGJ1dCBpbmNvbW1lbnN1cmF0ZSB3aXRoIGV2ZXJ5dGhpbmcgZWxzZSovXG5hc3NlcnQoIU51bWJlci5pc05hTihsZWZ0KXx8IU51bWJlci5pc05hTihyaWdodCkpO1xucmV0dXJuIE5hTjtcbiB9XG4vKiBBbW9uZyBub24tTmFOIG51bWJlcnMsIGtleSBvcmRlciBpcyB0aGUgc2FtZSBhcyByYW5rIG9yZGVyLiBOb3RlIHRoYXQqL1xuLyogaW4gYm90aCBvcmRlcnMsIGAtMGAgaXMgaW4gdGhlIHNhbWUgZXF1aXZhbGVuY2UgY2xhc3MgYXMgYDBgLiovXG5yZXR1cm4gcmFua0NvbXA7XG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmlmKGxlZnQ9PT1yaWdodCl7XG5yZXR1cm4gMDtcbiB9XG4vKiBJZiB0d28gcmVtb3RhYmxlcyBhcmUgbm90IGlkZW50aWNhbCwgdGhlbiBhcyBrZXlzIHRoZXkgYXJlKi9cbi8qIGluY29tbWVuc3VyYXRlLiovXG5yZXR1cm4gTmFOO1xuIH1cbmNhc2UnY29weUFycmF5Jzp7XG4vKiBMZXhpY29ncmFwaGljIGJ5IGtleSBvcmRlci4gUmFuayBvcmRlciBvZiBhcnJheXMgaXMgbGV4aWNvZ3JhcGhpYyBieSovXG4vKiByYW5rIG9yZGVyLiovXG4vKiBCZWNhdXNlIHRoZSBpbnZhcmlhbnRzIGFib3ZlIGFwcGx5IHRvIHRoZSBlbGVtZW50cyBvZiB0aGUgYXJyYXksKi9cbi8qIHRoZXkgYXBwbHkgdG8gdGhlIGFycmF5IGFzIGEgd2hvbGUuKi9cbmNvbnN0IGxlbj1NYXRoLm1pbihsZWZ0Lmxlbmd0aCxyaWdodC5sZW5ndGgpO1xuZm9yKGxldCBpPTA7aTxsZW47aSs9MSl7XG5jb25zdCByZXN1bHQ9Y29tcGFyZUtleXMobGVmdFtpXSxyaWdodFtpXSk7XG5pZihyZXN1bHQhPT0wKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbi8qIElmIGFsbCBtYXRjaGluZyBlbGVtZW50cyBhcmUga2V5RVEsIHRoZW4gYWNjb3JkaW5nIHRvIHRoZWlyIGxlbmd0aHMuKi9cbi8qIFRodXMsIGlmIGFycmF5IFggaXMgYSBwcmVmaXggb2YgYXJyYXkgWSwgdGhlbiBYIGlzIHNtYWxsZXIgdGhhbiBZLiovXG5yZXR1cm4gY29tcGFyZVJhbmsobGVmdC5sZW5ndGgscmlnaHQubGVuZ3RoKTtcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbi8qIFBhcmV0byBwYXJ0aWFsIG9yZGVyIGNvbXBhcmlzb24uKi9cbmNvbnN0IGxlZnROYW1lcz1yZWNvcmROYW1lcyhsZWZ0KTtcbmNvbnN0IHJpZ2h0TmFtZXM9cmVjb3JkTmFtZXMocmlnaHQpO1xuXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuaWYoIWtleUVRKGxlZnROYW1lcyxyaWdodE5hbWVzKSl7XG4vKiBJZiB0aGV5IGRvIG5vdCBoYXZlIGV4YWN0bHkgdGhlIHNhbWUgcHJvcGVydGllcywqL1xuLyogdGhleSBhcmUgaW5jb21tZW5zdXJhdGUuKi9cbi8qIE5vdGUgdGhhdCByYW5rIHNvcnRpbmcgb2YgY29weVJlY29yZHMgZ3JvdXBzIGFsbCBjb3B5UmVjb3JkcyB3aXRoKi9cbi8qIHRoZSBzYW1lIGtleXMgdG9nZXRoZXIsIGVuYWJsaW5nIHJhbmdlIHNlYXJjaGluZyBvdmVyIGNvcHlSZWNvcmRzKi9cbi8qIHRvIGF2b2lkIG1vcmUgaXJyZWxldmFudCBvbmVzLiovXG5yZXR1cm4gTmFOO1xuIH1cbmNvbnN0IGxlZnRWYWx1ZXM9cmVjb3JkVmFsdWVzKGxlZnQsbGVmdE5hbWVzKTtcbmNvbnN0IHJpZ2h0VmFsdWVzPXJlY29yZFZhbHVlcyhyaWdodCxyaWdodE5hbWVzKTtcbi8qIFByZXN1bWUgdGhhdCBib3RoIGNvcHlSZWNvcmRzIGhhdmUgdGhlIHNhbWUga2V5IG9yZGVyKi9cbi8qIHVudGlsIGVuY291bnRlcmluZyBhIHByb3BlcnR5IGRpc3Byb3ZpbmcgdGhhdCBoeXBvdGhlc2lzLiovXG5sZXQgcmVzdWx0PTA7XG5mb3IobGV0IGk9MDtpPGxlZnRWYWx1ZXMubGVuZ3RoO2krPTEpe1xuY29uc3QgY29tcD1jb21wYXJlS2V5cyhsZWZ0VmFsdWVzW2ldLHJpZ2h0VmFsdWVzW2ldKTtcbmlmKE51bWJlci5pc05hTihjb21wKSl7XG5yZXR1cm4gTmFOO1xuIH1cbmlmKHJlc3VsdCE9PWNvbXAmJmNvbXAhPT0wKXtcbmlmKHJlc3VsdD09PTApe1xucmVzdWx0PWNvbXA7XG4gfWVsc2V7XG5hc3NlcnQoXG5yZXN1bHQ9PT0tMSYmY29tcD09PTF8fHJlc3VsdD09PTEmJmNvbXA9PT0tMSk7XG5cbnJldHVybiBOYU47XG4gfVxuIH1cbiB9XG4vKiBJZiBjb3B5UmVjb3JkIFggaXMgc21hbGxlciB0aGFuIGNvcHlSZWNvcmQgWSwgdGhlbiB0aGV5IG11c3QgaGF2ZSB0aGUqL1xuLyogc2FtZSBwcm9wZXJ0eSBuYW1lcyBhbmQgZXZlcnkgdmFsdWUgaW4gWCBtdXN0IGJlIHNtYWxsZXIgb3IgZXF1YWwgdG8qL1xuLyogdGhlIGNvcnJlc3BvbmRpbmcgdmFsdWUgaW4gWSAod2l0aCBhdCBsZWFzdCBvbmUgdmFsdWUgc21hbGxlcikuKi9cbi8qIFRoZSByYW5rIG9yZGVyIG9mIFggYW5kIFkgaXMgYmFzZWQgb24gbGV4aWNvZ3JhcGhpYyByYW5rIG9yZGVyIG9mKi9cbi8qIHRoZWlyIHZhbHVlcywgYXMgb3JnYW5pemVkIGJ5IHJldmVyc2UgbGV4aWNvZ3JhcGhpYyBvcmRlciBvZiB0aGVpciovXG4vKiBwcm9wZXJ0eSBuYW1lcy4qL1xuLyogVGh1cyBpZiBjb21wYXJlS2V5cyhYLFkpIDwgMCB0aGVuIGNvbXBhcmVSYW5rKFgsWSkgPCAwLiovXG5yZXR1cm4gcmVzdWx0O1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5jb25zdCBsZWZ0VGFnPWdldFRhZyhsZWZ0KTtcbmNvbnN0IHJpZ2h0VGFnPWdldFRhZyhyaWdodCk7XG5pZihsZWZ0VGFnIT09cmlnaHRUYWcpe1xuLyogZGlmZmVyZW50IHRhZ3MgYXJlIGluY29tbWVuc3VyYXRlKi9cbnJldHVybiBOYU47XG4gfVxuc3dpdGNoKGxlZnRUYWcpe1xuY2FzZSdjb3B5U2V0Jzp7XG4vKiBjb3B5U2V0IFggaXMgc21hbGxlciB0aGFuIGNvcHlTZXQgWSB3aGVuIGV2ZXJ5IGVsZW1lbnQgb2YgWCovXG4vKiBpcyBrZXlFUSB0byBzb21lIGVsZW1lbnQgb2YgWSBhbmQgc29tZSBlbGVtZW50IG9mIFkgaXMqL1xuLyogbm90IGtleUVRIHRvIGFueSBlbGVtZW50IG9mIFguKi9cbnJldHVybiBzZXRDb21wYXJlKGxlZnQscmlnaHQpO1xuIH1cbmNhc2UnY29weUJhZyc6e1xuLyogY29weUJhZyBYIGlzIHNtYWxsZXIgdGhhbiBjb3B5QmFnIFkgd2hlbiBldmVyeSBlbGVtZW50IG9mIFgqL1xuLyogb2NjdXJzIG5vIG1vcmUgdGhhbiB0aGUga2V5RVEgZWxlbWVudCBvZiBZLCBhbmQgc29tZSBlbGVtZW50Ki9cbi8qIG9mIFkgb2NjdXJzIG1vcmUgdGhhbiBzb21lIGVsZW1lbnQgb2YgWCwgd2hlcmUgYmVpbmcgYWJzZW50Ki9cbi8qIGZyb20gWCBjb3VudHMgYXMgb2NjdXJyaW5nIHplcm8gdGltZXMuKi9cbnJldHVybiBiYWdDb21wYXJlKGxlZnQscmlnaHQpO1xuIH1cbmNhc2UnY29weU1hcCc6e1xuLyogVHdvIGNvcHlNYXBzIHRoYXQgaGF2ZSBkaWZmZXJlbnQga2V5cyAoYWNjb3JkaW5nIHRvIGtleUVRKSBhcmUqL1xuLyogaW5jb21tZW5zdXJhdGUuIFRoZSByZXByZXNlbnRhdGlvbiBvZiBjb3B5TWFwcyBpbmNsdWRlcyB0aGUga2V5cyovXG4vKiBmaXJzdCwgaW4gdGhlIHNhbWUgcmV2ZXJzZSByYW5rIG9yZGVyIHVzZWQgYnkgc2V0cy4gVGh1cywgYWxsKi9cbi8qIGNvcHlNYXBzIHdpdGgga2V5cyBvZiB0aGUgc2FtZSByYW5rICh3aGljaCBpcyovXG4vKiBsZXNzIHByZWNpc2UhKSB3aWxsIGJlIGdyb3VwZWQgdG9nZXRoZXIgd2hlbiBjb3B5TWFwcyBhcmUgc29ydGVkKi9cbi8qIGJ5IHJhbmssIG1pbmltaXppbmcgdGhlIG51bWJlciBvZiBtaXNzZXMgd2hlbiByYW5nZSBzZWFyY2hpbmcuKi9cbi8qKi9cbi8qIEFtb25nIGNvcHlNYXBzIHdpdGggdGhlIHNhbWUga2V5cyAoYWNjb3JkaW5nIHRvIGtleUVRKSwgdGhleSovXG4vKiBjb21wYXJlIGJ5IGEgY29ycmVzcG9uZGluZyBjb21wYXJpc29uIG9mIHRoZWlyIHZhbHVlcy4gVGh1cywgYXMqL1xuLyogd2l0aCByZWNvcmRzLCBmb3IgdHdvIGNvcHlNYXBzIFggYW5kIFksIGlmIGBjb21wYXJlS2V5cyhYLFkpIDwqL1xuLyogMGAgdGhlbiwgYmVjYXVzZSB0aGVzZSB2YWx1ZXMgb2JleSB0aGUgYWJvdmUgaW52YXJpYW50cywgbm9uZSBvZiovXG4vKiB0aGUgdmFsdWVzIGluIFggaGF2ZSBhIGxhdGVyIHJhbmsgdGhhbiB0aGUgY29ycmVzcG9uZGluZyB2YWx1ZSovXG4vKiBvZiBZLiBUaHVzLCBgY29tcGFyZVJhbmsoWCxZKSA8PSAwYC4gVE9ETyBpbXBsZW1lbnQqL1xudGhyb3cgRmFpbCBgTWFwIGNvbXBhcmlzb24gbm90IHlldCBpbXBsZW1lbnRlZDogJHtsZWZ0fSB2cyAke3JpZ2h0fWA7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGB1bmV4cGVjdGVkIHRhZyAke3EobGVmdFRhZyl9OiAke2xlZnR9YDtcbiB9fVxuXG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGB1bmV4cGVjdGVkIHBhc3NTdHlsZSAke3EobGVmdFN0eWxlKX06ICR7bGVmdH1gO1xuIH19XG5cbiB9OyRo4oCNX29uY2UuY29tcGFyZUtleXMoY29tcGFyZUtleXMpO1xuaGFyZGVuKGNvbXBhcmVLZXlzKTtcblxuY29uc3QgICAgICAgIGtleUxUPShsZWZ0LHJpZ2h0KT0+Y29tcGFyZUtleXMobGVmdCxyaWdodCk8MDskaOKAjV9vbmNlLmtleUxUKGtleUxUKTtcbmhhcmRlbihrZXlMVCk7XG5cbmNvbnN0ICAgICAgICBrZXlMVEU9KGxlZnQscmlnaHQpPT5jb21wYXJlS2V5cyhsZWZ0LHJpZ2h0KTw9MDskaOKAjV9vbmNlLmtleUxURShrZXlMVEUpO1xuaGFyZGVuKGtleUxURSk7XG5cbmNvbnN0ICAgICAgICBrZXlFUT0obGVmdCxyaWdodCk9PmNvbXBhcmVLZXlzKGxlZnQscmlnaHQpPT09MDskaOKAjV9vbmNlLmtleUVRKGtleUVRKTtcbmhhcmRlbihrZXlFUSk7XG5cbmNvbnN0ICAgICAgICBrZXlHVEU9KGxlZnQscmlnaHQpPT5jb21wYXJlS2V5cyhsZWZ0LHJpZ2h0KT49MDskaOKAjV9vbmNlLmtleUdURShrZXlHVEUpO1xuaGFyZGVuKGtleUdURSk7XG5cbmNvbnN0ICAgICAgICBrZXlHVD0obGVmdCxyaWdodCk9PmNvbXBhcmVLZXlzKGxlZnQscmlnaHQpPjA7JGjigI1fb25jZS5rZXlHVChrZXlHVCk7XG5oYXJkZW4oa2V5R1QpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImNvbXBhcmVLZXlzIjpbImNvbXBhcmVLZXlzIl0sImtleUxUIjpbImtleUxUIl0sImtleUxURSI6WyJrZXlMVEUiXSwia2V5RVEiOlsia2V5RVEiXSwia2V5R1RFIjpbImtleUdURSJdLCJrZXlHVCI6WyJrZXlHVCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABVIML9KhQAACoUAAApAAAAQGVuZG8vcGF0dGVybnMtdjAuMi4yL3NyYy9rZXlzL2NvcHlCYWcuanN7ImltcG9ydHMiOlsiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbImFzc2VydEJhZ0VudHJpZXMiLCJhc3NlcnROb0R1cGxpY2F0ZUtleXMiLCJjaGVja0JhZ0VudHJpZXMiLCJjb2VyY2VUb0JhZ0VudHJpZXMiLCJtYWtlQmFnT2ZFbnRyaWVzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydENoZWNrZXIsbWFrZVRhZ2dlZCxwYXNzU3R5bGVPZixjb21wYXJlQW50aVJhbmssaXNSYW5rU29ydGVkLG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0LHNvcnRCeVJhbms7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjigI1fYSA9PiAobWFrZVRhZ2dlZCA9ICRo4oCNX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXSxbXCJjb21wYXJlQW50aVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVBbnRpUmFuayA9ICRo4oCNX2EpXV0sW1wiaXNSYW5rU29ydGVkXCIsIFskaOKAjV9hID0+IChpc1JhbmtTb3J0ZWQgPSAkaOKAjV9hKV1dLFtcIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0XCIsIFskaOKAjV9hID0+IChtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCA9ICRo4oCNX2EpXV0sW1wic29ydEJ5UmFua1wiLCBbJGjigI1fYSA9PiAoc29ydEJ5UmFuayA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuY29uc3R7ZGV0YWlsczpYfT1hc3NlcnQ7XG5cbi8qKiBAdGVtcGxhdGUge0tleX0gW0s9S2V5XSBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5Db3B5QmFnPEs+fSBDb3B5QmFnICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuS2V5fSBLZXkgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5GdWxsQ29tcGFyZX0gRnVsbENvbXBhcmUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNoZWNrZXJ9IENoZWNrZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1tULGJpZ2ludF1bXX0gYmFnRW50cmllc1xuICogQHBhcmFtIHtGdWxsQ29tcGFyZSB8IHVuZGVmaW5lZH0gZnVsbENvbXBhcmUgSWYgcHJvdmlkZWQgYW5kIGBiYWdFbnRyaWVzYCBpcyBhbHJlYWR5XG4gKiBrbm93biB0byBiZSBzb3J0ZWQgYnkgdGhpcyBgZnVsbENvbXBhcmVgLCB0aGVuIHdlIHNob3VsZCBnZXQgYSBtZW1vIGhpdFxuICogcmF0aGVyIHRoYW4gYSByZXNvcnRpbmcuIEhvd2V2ZXIsIGN1cnJlbnRseSwgd2Ugc3RpbGwgZW51bWVyYXRlIHRoZSBlbnRpcmVcbiAqIGFycmF5IGVhY2ggdGltZS5cbiAqXG4gKiBUT0RPOiBJZiBkb2luZyB0aGlzIHJlZHVudGFudGx5IHR1cm5zIG91dCB0byBiZSBleHBlbnNpdmUsIHdlXG4gKiBjb3VsZCBtZW1vaXplIHRoaXMgbm8tZHVwbGljYXRlLWtleXMgZmluZGluZyBhcyB3ZWxsLCBpbmRlcGVuZGVudFxuICogb2YgdGhlIGBmdWxsT3JkZXJgIHVzZSB0byByZWFjaCB0aGlzIGZpbmRpbmcuXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tOb0R1cGxpY2F0ZUtleXM9KGJhZ0VudHJpZXMsZnVsbENvbXBhcmUsY2hlY2spPT57XG4vKiBUaGlzIGZ1bGxPcmRlciBjb250YWlucyBoaXN0b3J5IGRlcGVuZGVudCBzdGF0ZS4gSXQgaXMgc3BlY2lmaWMqL1xuLyogdG8gdGhpcyBvbmUgY2FsbCBhbmQgZG9lcyBub3Qgc3Vydml2ZSBpdC4qL1xuLyogVE9ETyBPbmNlIGFsbCBvdXIgdG9vbGluZyBpcyByZWFkeSBmb3IgYCYmPWAsIHRoZSBmb2xsb3dpbmcqL1xuLyogbGluZSBzaG91bGQgYmUgcmV3cml0dGVuIHVzaW5nIGl0LiovXG5mdWxsQ29tcGFyZT1mdWxsQ29tcGFyZXx8bWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQoKS5hbnRpQ29tcGFyYXRvcjtcblxuLyogU2luY2UgdGhlIGtleSBpcyBtb3JlIHNpZ25pZmljYW50IHRoYW4gdGhlIHZhbHVlICh0aGUgY291bnQpLCovXG4vKiBzb3J0aW5nIGJ5IGZ1bGxPcmRlciBpcyBndWFyYW50ZWVkIHRvIG1ha2UgZHVwbGljYXRlIGtleXMqL1xuLyogYWRqYWNlbnQgaW5kZXBlbmRlbnQgb2YgdGhlaXIgY291bnRzLiovXG5iYWdFbnRyaWVzPXNvcnRCeVJhbmsoYmFnRW50cmllcyxmdWxsQ29tcGFyZSk7XG5jb25zdHtsZW5ndGh9PWJhZ0VudHJpZXM7XG5mb3IobGV0IGk9MTtpPGxlbmd0aDtpKz0xKXtcbmNvbnN0IGswPWJhZ0VudHJpZXNbaS0xXVswXTtcbmNvbnN0IGsxPWJhZ0VudHJpZXNbaV1bMF07XG5pZihmdWxsQ29tcGFyZShrMCxrMSk9PT0wKXtcbnJldHVybiBjaGVjayhmYWxzZSxYIGB2YWx1ZSBoYXMgZHVwbGljYXRlIGtleXM6ICR7azB9YCk7XG4gfVxuIH1cbnJldHVybiB0cnVlO1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7W1QsYmlnaW50XVtdfSBiYWdFbnRyaWVzXG4gKiBAcGFyYW0ge0Z1bGxDb21wYXJlfSBbZnVsbENvbXBhcmVdXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydE5vRHVwbGljYXRlS2V5cz0oYmFnRW50cmllcyxmdWxsQ29tcGFyZT11bmRlZmluZWQpPT57XG5jaGVja05vRHVwbGljYXRlS2V5cyhiYWdFbnRyaWVzLGZ1bGxDb21wYXJlLGFzc2VydENoZWNrZXIpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtbUGFzc2FibGUsYmlnaW50XVtdfSBiYWdFbnRyaWVzXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqLyRo4oCNX29uY2UuYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzKGFzc2VydE5vRHVwbGljYXRlS2V5cyk7XG5jb25zdCAgICAgICAgY2hlY2tCYWdFbnRyaWVzPShiYWdFbnRyaWVzLGNoZWNrKT0+e1xuaWYocGFzc1N0eWxlT2YoYmFnRW50cmllcykhPT0nY29weUFycmF5Jyl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYFRoZSBlbnRyaWVzIG9mIGEgY29weUJhZyBtdXN0IGJlIGEgY29weUFycmF5OiAke2JhZ0VudHJpZXN9YCk7XG5cbiB9XG5pZighaXNSYW5rU29ydGVkKGJhZ0VudHJpZXMsY29tcGFyZUFudGlSYW5rKSl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYFRoZSBlbnRyaWVzIG9mIGEgY29weUJhZyBtdXN0IGJlIHNvcnRlZCBpbiByZXZlcnNlIHJhbmsgb3JkZXI6ICR7YmFnRW50cmllc31gKTtcblxuIH1cbmZvcihjb25zdCBlbnRyeSBvZiBiYWdFbnRyaWVzKXtcbmlmKFxucGFzc1N0eWxlT2YoZW50cnkpIT09J2NvcHlBcnJheSd8fFxuZW50cnkubGVuZ3RoIT09Mnx8XG50eXBlb2YgZW50cnlbMV0hPT0nYmlnaW50JylcbntcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgRWFjaCBlbnRyeSBvZiBhIGNvcHlCYWcgbXVzdCBiZSBwYWlyIG9mIGEga2V5IGFuZCBhIGJpZ2ludCByZXByZXNlbnRpbmcgYSBjb3VudDogJHtlbnRyeX1gKTtcblxuIH1cbmlmKGVudHJ5WzFdPDEpe1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGBFYWNoIGVudHJ5IG9mIGEgY29weUJhZyBtdXN0IGhhdmUgYSBwb3NpdGl2ZSBjb3VudDogJHtlbnRyeX1gKTtcblxuIH1cbiB9XG5yZXR1cm4gY2hlY2tOb0R1cGxpY2F0ZUtleXMoYmFnRW50cmllcyx1bmRlZmluZWQsY2hlY2spO1xuIH07JGjigI1fb25jZS5jaGVja0JhZ0VudHJpZXMoY2hlY2tCYWdFbnRyaWVzKTtcbmhhcmRlbihjaGVja0JhZ0VudHJpZXMpO1xuXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUganNkb2MvcmVxdWlyZS1yZXR1cm5zLWNoZWNrIC0tIGRvZXNuJ3QgdW5kZXJzdGFuZCBhc3NlcnRzKi9cbi8qKlxuICogQHBhcmFtIHtbUGFzc2FibGUsYmlnaW50XVtdfSBiYWdFbnRyaWVzXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBiYWdFbnRyaWVzIGlzIFtQYXNzYWJsZSxiaWdpbnRdW119XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRCYWdFbnRyaWVzPShiYWdFbnRyaWVzKT0+e1xuY2hlY2tCYWdFbnRyaWVzKGJhZ0VudHJpZXMsYXNzZXJ0Q2hlY2tlcik7XG4gfTskaOKAjV9vbmNlLmFzc2VydEJhZ0VudHJpZXMoYXNzZXJ0QmFnRW50cmllcyk7XG5oYXJkZW4oYXNzZXJ0QmFnRW50cmllcyk7XG5cbmNvbnN0ICAgICAgICBjb2VyY2VUb0JhZ0VudHJpZXM9KGJhZ0VudHJpZXNMaXN0KT0+e1xuY29uc3QgYmFnRW50cmllcz1zb3J0QnlSYW5rKGJhZ0VudHJpZXNMaXN0LGNvbXBhcmVBbnRpUmFuayk7XG5hc3NlcnRCYWdFbnRyaWVzKGJhZ0VudHJpZXMpO1xucmV0dXJuIGJhZ0VudHJpZXM7XG4gfTskaOKAjV9vbmNlLmNvZXJjZVRvQmFnRW50cmllcyhjb2VyY2VUb0JhZ0VudHJpZXMpO1xuaGFyZGVuKGNvZXJjZVRvQmFnRW50cmllcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7SXRlcmFibGU8W0ssIGJpZ2ludF0+fSBiYWdFbnRyeUl0ZXJcbiAqIEByZXR1cm5zIHtDb3B5QmFnPEs+fVxuICovXG5jb25zdCAgICAgICAgbWFrZUJhZ09mRW50cmllcz0oYmFnRW50cnlJdGVyKT0+XG5tYWtlVGFnZ2VkKCdjb3B5QmFnJyxjb2VyY2VUb0JhZ0VudHJpZXMoYmFnRW50cnlJdGVyKSk7JGjigI1fb25jZS5tYWtlQmFnT2ZFbnRyaWVzKG1ha2VCYWdPZkVudHJpZXMpO1xuaGFyZGVuKG1ha2VCYWdPZkVudHJpZXMpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImFzc2VydE5vRHVwbGljYXRlS2V5cyI6WyJhc3NlcnROb0R1cGxpY2F0ZUtleXMiXSwiY2hlY2tCYWdFbnRyaWVzIjpbImNoZWNrQmFnRW50cmllcyJdLCJhc3NlcnRCYWdFbnRyaWVzIjpbImFzc2VydEJhZ0VudHJpZXMiXSwiY29lcmNlVG9CYWdFbnRyaWVzIjpbImNvZXJjZVRvQmFnRW50cmllcyJdLCJtYWtlQmFnT2ZFbnRyaWVzIjpbIm1ha2VCYWdPZkVudHJpZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAACh3+v6MQAACjEAAAKQAAAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMva2V5cy9jb3B5U2V0LmpzeyJpbXBvcnRzIjpbIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJhc3NlcnRFbGVtZW50cyIsImFzc2VydE5vRHVwbGljYXRlcyIsImNoZWNrRWxlbWVudHMiLCJjb2VyY2VUb0VsZW1lbnRzIiwibWFrZVNldE9mRWxlbWVudHMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixtYWtlVGFnZ2VkLHBhc3NTdHlsZU9mLGNvbXBhcmVBbnRpUmFuayxpc1JhbmtTb3J0ZWQsbWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQsc29ydEJ5UmFuazskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaOKAjV9hID0+IChtYWtlVGFnZ2VkID0gJGjigI1fYSldXSxbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcImNvbXBhcmVBbnRpUmFua1wiLCBbJGjigI1fYSA9PiAoY29tcGFyZUFudGlSYW5rID0gJGjigI1fYSldXSxbXCJpc1JhbmtTb3J0ZWRcIiwgWyRo4oCNX2EgPT4gKGlzUmFua1NvcnRlZCA9ICRo4oCNX2EpXV0sW1wibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0ID0gJGjigI1fYSldXSxbXCJzb3J0QnlSYW5rXCIsIFskaOKAjV9hID0+IChzb3J0QnlSYW5rID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG4vKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG5jb25zdHtkZXRhaWxzOlh9PWFzc2VydDtcblxuLyoqIEB0ZW1wbGF0ZSB7S2V5fSBbSz1LZXldIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkNvcHlTZXQ8Sz59IENvcHlTZXQgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXl9IEtleSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkZ1bGxDb21wYXJlfSBGdWxsQ29tcGFyZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUGFzc2FibGV9IFBhc3NhYmxlICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VFtdfSBlbGVtZW50c1xuICogQHBhcmFtIHtGdWxsQ29tcGFyZSB8IHVuZGVmaW5lZH0gZnVsbENvbXBhcmUgSWYgcHJvdmlkZWQgYW5kIGBlbGVtZW50c2AgaXMgYWxyZWFkeSBrbm93blxuICogdG8gYmUgc29ydGVkIGJ5IHRoaXMgYGZ1bGxDb21wYXJlYCwgdGhlbiB3ZSBzaG91bGQgZ2V0IGEgbWVtbyBoaXQgcmF0aGVyXG4gKiB0aGFuIGEgcmVzb3J0aW5nLiBIb3dldmVyLCBjdXJyZW50bHksIHdlIHN0aWxsIGVudW1lcmF0ZSB0aGUgZW50aXJlIGFycmF5XG4gKiBlYWNoIHRpbWUuXG4gKlxuICogVE9ETzogSWYgZG9pbmcgdGhpcyByZWR1bnRhbnRseSB0dXJucyBvdXQgdG8gYmUgZXhwZW5zaXZlLCB3ZVxuICogY291bGQgbWVtb2l6ZSB0aGlzIG5vLWR1cGxpY2F0ZSBmaW5kaW5nIGFzIHdlbGwsIGluZGVwZW5kZW50XG4gKiBvZiB0aGUgYGZ1bGxPcmRlcmAgdXNlIHRvIHJlYWNoIHRoaXMgZmluZGluZy5cbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja05vRHVwbGljYXRlcz0oZWxlbWVudHMsZnVsbENvbXBhcmUsY2hlY2spPT57XG4vKiBUaGlzIGZ1bGxPcmRlciBjb250YWlucyBoaXN0b3J5IGRlcGVuZGVudCBzdGF0ZS4gSXQgaXMgc3BlY2lmaWMqL1xuLyogdG8gdGhpcyBvbmUgY2FsbCBhbmQgZG9lcyBub3Qgc3Vydml2ZSBpdC4qL1xuLyogVE9ETyBPbmNlIGFsbCBvdXIgdG9vbGluZyBpcyByZWFkeSBmb3IgYCYmPWAsIHRoZSBmb2xsb3dpbmcqL1xuLyogbGluZSBzaG91bGQgYmUgcmV3cml0dGVuIHVzaW5nIGl0LiovXG5mdWxsQ29tcGFyZT1mdWxsQ29tcGFyZXx8bWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQoKS5hbnRpQ29tcGFyYXRvcjtcblxuZWxlbWVudHM9c29ydEJ5UmFuayhlbGVtZW50cyxmdWxsQ29tcGFyZSk7XG5jb25zdHtsZW5ndGh9PWVsZW1lbnRzO1xuZm9yKGxldCBpPTE7aTxsZW5ndGg7aSs9MSl7XG5jb25zdCBrMD1lbGVtZW50c1tpLTFdO1xuY29uc3QgazE9ZWxlbWVudHNbaV07XG5pZihmdWxsQ29tcGFyZShrMCxrMSk9PT0wKXtcbnJldHVybiBjaGVjayhmYWxzZSxYIGB2YWx1ZSBoYXMgZHVwbGljYXRlczogJHtrMH1gKTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUW119IGVsZW1lbnRzXG4gKiBAcGFyYW0ge0Z1bGxDb21wYXJlfSBbZnVsbENvbXBhcmVdXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydE5vRHVwbGljYXRlcz0oZWxlbWVudHMsZnVsbENvbXBhcmU9dW5kZWZpbmVkKT0+e1xuY2hlY2tOb0R1cGxpY2F0ZXMoZWxlbWVudHMsZnVsbENvbXBhcmUsYXNzZXJ0Q2hlY2tlcik7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IGVsZW1lbnRzXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqLyRo4oCNX29uY2UuYXNzZXJ0Tm9EdXBsaWNhdGVzKGFzc2VydE5vRHVwbGljYXRlcyk7XG5jb25zdCAgICAgICAgY2hlY2tFbGVtZW50cz0oZWxlbWVudHMsY2hlY2spPT57XG5pZihwYXNzU3R5bGVPZihlbGVtZW50cykhPT0nY29weUFycmF5Jyl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYFRoZSBrZXlzIG9mIGEgY29weVNldCBvciBjb3B5TWFwIG11c3QgYmUgYSBjb3B5QXJyYXk6ICR7ZWxlbWVudHN9YCk7XG5cbiB9XG5pZighaXNSYW5rU29ydGVkKGVsZW1lbnRzLGNvbXBhcmVBbnRpUmFuaykpe1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGBUaGUga2V5cyBvZiBhIGNvcHlTZXQgb3IgY29weU1hcCBtdXN0IGJlIHNvcnRlZCBpbiByZXZlcnNlIHJhbmsgb3JkZXI6ICR7ZWxlbWVudHN9YCk7XG5cbiB9XG5yZXR1cm4gY2hlY2tOb0R1cGxpY2F0ZXMoZWxlbWVudHMsdW5kZWZpbmVkLGNoZWNrKTtcbiB9OyRo4oCNX29uY2UuY2hlY2tFbGVtZW50cyhjaGVja0VsZW1lbnRzKTtcbmhhcmRlbihjaGVja0VsZW1lbnRzKTtcblxuY29uc3QgICAgICAgIGFzc2VydEVsZW1lbnRzPShlbGVtZW50cyk9PntcbmNoZWNrRWxlbWVudHMoZWxlbWVudHMsYXNzZXJ0Q2hlY2tlcik7XG4gfTskaOKAjV9vbmNlLmFzc2VydEVsZW1lbnRzKGFzc2VydEVsZW1lbnRzKTtcbmhhcmRlbihhc3NlcnRFbGVtZW50cyk7XG5cbmNvbnN0ICAgICAgICBjb2VyY2VUb0VsZW1lbnRzPShlbGVtZW50c0xpc3QpPT57XG5jb25zdCBlbGVtZW50cz1zb3J0QnlSYW5rKGVsZW1lbnRzTGlzdCxjb21wYXJlQW50aVJhbmspO1xuYXNzZXJ0RWxlbWVudHMoZWxlbWVudHMpO1xucmV0dXJuIGVsZW1lbnRzO1xuIH07JGjigI1fb25jZS5jb2VyY2VUb0VsZW1lbnRzKGNvZXJjZVRvRWxlbWVudHMpO1xuaGFyZGVuKGNvZXJjZVRvRWxlbWVudHMpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPEs+fSBlbGVtZW50SXRlclxuICogQHJldHVybnMge0NvcHlTZXQ8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlU2V0T2ZFbGVtZW50cz0oZWxlbWVudEl0ZXIpPT5cbm1ha2VUYWdnZWQoJ2NvcHlTZXQnLGNvZXJjZVRvRWxlbWVudHMoZWxlbWVudEl0ZXIpKTskaOKAjV9vbmNlLm1ha2VTZXRPZkVsZW1lbnRzKG1ha2VTZXRPZkVsZW1lbnRzKTtcbmhhcmRlbihtYWtlU2V0T2ZFbGVtZW50cyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiYXNzZXJ0Tm9EdXBsaWNhdGVzIjpbImFzc2VydE5vRHVwbGljYXRlcyJdLCJjaGVja0VsZW1lbnRzIjpbImNoZWNrRWxlbWVudHMiXSwiYXNzZXJ0RWxlbWVudHMiOlsiYXNzZXJ0RWxlbWVudHMiXSwiY29lcmNlVG9FbGVtZW50cyI6WyJjb2VyY2VUb0VsZW1lbnRzIl0sIm1ha2VTZXRPZkVsZW1lbnRzIjpbIm1ha2VTZXRPZkVsZW1lbnRzIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAAsonm15JQAAeSUAADUAAABAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvbWVyZ2UtYmFnLW9wZXJhdG9ycy5qc3siaW1wb3J0cyI6WyIuL2NvcHlCYWcuanMiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiYmFnQ29tcGFyZSIsImJhZ0Rpc2pvaW50U3VidHJhY3QiLCJiYWdJbnRlcnNlY3Rpb24iLCJiYWdJc0Rpc2pvaW50IiwiYmFnSXNTdXBlcmJhZyIsImJhZ1VuaW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydFJhbmtTb3J0ZWQsY29tcGFyZUFudGlSYW5rLG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0LHNvcnRCeVJhbmssYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzLG1ha2VCYWdPZkVudHJpZXM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiYXNzZXJ0UmFua1NvcnRlZFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UmFua1NvcnRlZCA9ICRo4oCNX2EpXV0sW1wiY29tcGFyZUFudGlSYW5rXCIsIFskaOKAjV9hID0+IChjb21wYXJlQW50aVJhbmsgPSAkaOKAjV9hKV1dLFtcIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0XCIsIFskaOKAjV9hID0+IChtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCA9ICRo4oCNX2EpXV0sW1wic29ydEJ5UmFua1wiLCBbJGjigI1fYSA9PiAoc29ydEJ5UmFuayA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvcHlCYWcuanNcIiwgW1tcImFzc2VydE5vRHVwbGljYXRlS2V5c1wiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzID0gJGjigI1fYSldXSxbXCJtYWtlQmFnT2ZFbnRyaWVzXCIsIFskaOKAjV9hID0+IChtYWtlQmFnT2ZFbnRyaWVzID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cbmNvbnN0e3F1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuS2V5Q29tcGFyaXNvbn0gS2V5Q29tcGFyaXNvbiAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkZ1bGxDb21wYXJlfSBGdWxsQ29tcGFyZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuUmFua0NvbXBhcmV9IFJhbmtDb21wYXJlICovXG5cbi8qIEJhc2VkIG9uIG1lcmdlLXNldC1vcGVyYXRvcnMuanMsIGJ1dCBhbHRlcmVkIGZvciB0aGUgYmFnIHJlcHJlc2VudGF0aW9uLiovXG4vKiBUT0RPIHNoYXJlIG1vcmUgY29kZSB3aXRoIG1lcmdlLXNldC1vcGVyYXRvcnMuanMsIHJhdGhlciB0aGFuKi9cbi8qIGR1cGxpY2F0aW5nIHdpdGggY2hhbmdlcy4qL1xuXG4vKipcbiAqIEFzc2VydHMgdGhhdCBgYmFnRW50cmllc2AgaXMgYWxyZWFkeSByYW5rIHNvcnRlZCBieSBgcmFua0NvbXBhcmVgLCB3aGVyZVxuICogdGhlcmVcbiAqIG1heSBiZSBjb250aWd1b3VzIHJlZ2lvbnMgb2YgYmFnRW50cmllcyB3aG9zZSBrZXlzIGFyZSB0aWVkIGZvciB0aGUgc2FtZVxuICogcmFuay5cbiAqIFJldHVybnMgYW4gaXRlcmFibGUgdGhhdCB3aWxsIGVudW1lcmF0ZSBhbGwgdGhlIGJhZ0VudHJpZXMgaW4gb3JkZXJcbiAqIGFjY29yZGluZyB0byBgZnVsbE9yZGVyYCwgd2hpY2ggc2hvdWxkIGRpZmZlciBmcm9tIGByYW5rT3JkZXJgIG9ubHlcbiAqIGJ5IGJlaW5nIG1vcmUgcHJlY2lzZS5cbiAqXG4gKiBUaGlzIHNob3VsZCBiZSBlcXVpdmFsZW50IHRvIHJlc29ydGluZyB0aGUgZW50aXJlIGBiYWdFbnRyaWVzYCBhcnJheVxuICogYWNjb3JkaW5nXG4gKiB0byBgZnVsbE9yZGVyYC4gSG93ZXZlciwgaXQgb3B0aW1pemVzIGZvciB0aGUgY2FzZSB3aGVyZSB0aGVzZSBjb250aWd1b3VzXG4gKiBydW5zIHRoYXQgbmVlZCB0byBiZSByZXNvcnRlZCBhcmUgZWl0aGVyIGFic2VudCBvciBzbWFsbC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtbVCxiaWdpbnRdW119IGJhZ0VudHJpZXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IHJhbmtDb21wYXJlXG4gKiBAcGFyYW0ge0Z1bGxDb21wYXJlfSBmdWxsQ29tcGFyZVxuICogQHJldHVybnMge0l0ZXJhYmxlPFtULGJpZ2ludF0+fVxuICovXG5jb25zdCBiYWdXaW5kb3dSZXNvcnQ9KGJhZ0VudHJpZXMscmFua0NvbXBhcmUsZnVsbENvbXBhcmUpPT57XG5hc3NlcnRSYW5rU29ydGVkKGJhZ0VudHJpZXMscmFua0NvbXBhcmUpO1xuY29uc3R7bGVuZ3RofT1iYWdFbnRyaWVzO1xubGV0IGk9MDtcbmxldCBvcHRJbm5lckl0ZXJhdG9yO1xucmV0dXJuIGhhcmRlbih7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+XG5oYXJkZW4oe1xubmV4dDooKT0+e1xuaWYob3B0SW5uZXJJdGVyYXRvcil7XG5jb25zdCByZXN1bHQ9b3B0SW5uZXJJdGVyYXRvci5uZXh0KCk7XG5pZihyZXN1bHQuZG9uZSl7XG5vcHRJbm5lckl0ZXJhdG9yPXVuZGVmaW5lZDtcbi8qIGZhbGwgdGhyb3VnaCovXG4gfWVsc2V7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG5pZihpPGxlbmd0aCl7XG5jb25zdCBlbnRyeT1iYWdFbnRyaWVzW2ldO1xubGV0IGo9aSsxO1xud2hpbGUoXG5qPGxlbmd0aCYmXG5yYW5rQ29tcGFyZShlbnRyeVswXSxiYWdFbnRyaWVzW2pdWzBdKT09PTApXG57XG5qKz0xO1xuIH1cbmlmKGo9PT1pKzEpe1xuaT1qO1xucmV0dXJuIGhhcmRlbih7ZG9uZTpmYWxzZSx2YWx1ZTplbnRyeX0pO1xuIH1cbmNvbnN0IHNpbWlsYXJSdW49YmFnRW50cmllcy5zbGljZShpLGopO1xuaT1qO1xuY29uc3QgcmVzb3J0ZWQ9c29ydEJ5UmFuayhzaW1pbGFyUnVuLGZ1bGxDb21wYXJlKTtcbi8qIFByb3ZpZGluZyB0aGUgc2FtZSBgZnVsbENvbXBhcmVgIHNob3VsZCBjYXVzZSBhIG1lbW8gaGl0Ki9cbi8qIHdpdGhpbiBgYXNzZXJ0Tm9EdXBsaWNhdGVzYCBlbmFibGluZyBpdCB0byBhdm9pZCBhKi9cbi8qIHJlZHVuZGFudCByZXNvcnRpbmcuKi9cbmFzc2VydE5vRHVwbGljYXRlS2V5cyhyZXNvcnRlZCxmdWxsQ29tcGFyZSk7XG4vKiBUaGlzIGlzIHRoZSByYXcgSlMgYXJyYXkgaXRlcmF0b3Igd2hvc2UgYC5uZXh0KClgIG1ldGhvZCovXG4vKiBkb2VzIG5vdCBoYXJkZW4gdGhlIEl0ZXJhdG9yUmVzdWx0LCBpbiB2aW9sYXRpb24gb2Ygb3VyKi9cbi8qIGNvbnZlbnRpb25zLiBGaXhpbmcgdGhpcyBpcyBleHBlbnNpdmUgYW5kIEknbSBjb25maWRlbnQgdGhlKi9cbi8qIHVuZnJvemVuIHZhbHVlIGRvZXMgbm90IGVzY2FwZSB0aGlzIGZpbGUsIHNvIEknbSBsZWF2aW5nIHRoaXMqL1xuLyogYXMgaXMuKi9cbm9wdElubmVySXRlcmF0b3I9cmVzb3J0ZWRbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIG9wdElubmVySXRlcmF0b3IubmV4dCgpO1xuIH1lbHNle1xucmV0dXJuIGhhcmRlbih7ZG9uZTp0cnVlLHZhbHVlOltudWxsLDBuXX0pO1xuIH1cbiB9fSl9KTtcblxuXG4gfTtcblxuLyoqXG4gKiBSZXR1cm5zIGFuIGl0ZXJhYmxlIHdob3NlIGl0ZXJhdGlvbiByZXN1bHRzIGFyZSBba2V5LCB4Q291bnQsIHlDb3VudF0gdHVwbGVzXG4gKiByZXByZXNlbnRpbmcgdGhlIG5leHQga2V5IGluIHRoZSBsb2NhbCBmdWxsIG9yZGVyLCBhcyB3ZWxsIGFzIGhvdyBtYW55XG4gKiB0aW1lcyBpdCBvY2N1cnJlZCBpbiB0aGUgeCBpbnB1dCBpdGVyYXRvciBhbmQgdGhlIHkgaW5wdXQgaXRlcmF0b3IuXG4gKlxuICogRm9yIHNldHMsIHRoZXNlIGNvdW50cyBhcmUgYWx3YXlzIDAgb3IgMSwgYnV0IHRoaXMgcmVwcmVzZW50YXRpb25cbiAqIGdlbmVyYWxpemVzIG5pY2VseSBmb3IgYmFncy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtbVCxiaWdpbnRdW119IHhiYWdFbnRyaWVzXG4gKiBAcGFyYW0ge1tULGJpZ2ludF1bXX0geWJhZ0VudHJpZXNcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59XG4gKi9cbmNvbnN0IG1lcmdlPSh4YmFnRW50cmllcyx5YmFnRW50cmllcyk9Pntcbi8qIFRoaXMgZnVsbE9yZGVyIGNvbnRhaW5zIGhpc3RvcnkgZGVwZW5kZW50IHN0YXRlLiBJdCBpcyBzcGVjaWZpYyovXG4vKiB0byB0aGlzIG9uZSBgbWVyZ2VgIGNhbGwgYW5kIGRvZXMgbm90IHN1cnZpdmUgaXQuKi9cbmNvbnN0IGZ1bGxDb21wYXJlPW1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KCkuYW50aUNvbXBhcmF0b3I7XG5cbmNvbnN0IHhzPWJhZ1dpbmRvd1Jlc29ydCh4YmFnRW50cmllcyxjb21wYXJlQW50aVJhbmssZnVsbENvbXBhcmUpO1xuY29uc3QgeXM9YmFnV2luZG93UmVzb3J0KHliYWdFbnRyaWVzLGNvbXBhcmVBbnRpUmFuayxmdWxsQ29tcGFyZSk7XG5yZXR1cm4gaGFyZGVuKHtcbltTeW1ib2wuaXRlcmF0b3JdOigpPT57XG4vKiBUaGVzZSBzaXggYGxldGAgdmFyaWFibGVzIGFyZSBidWZmZXJpbmcgb25lIGFoZWFkIGZyb20gdGhlIHVuZGVybHlpbmcqL1xuLyogaXRlcmF0b3JzLiBFYWNoIGl0ZXJhdGlvbiByZXBvcnRzIG9uZSBvciB0aGUgb3RoZXIgb3IgYm90aCwgYW5kKi9cbi8qIHRoZW4gcmVmaWxscyB0aGUgYnVmZmVycyBvZiB0aG9zZSBpdCBhZHZhbmNlZC4qL1xuLyoqIEB0eXBlIHtUfSAqL1xubGV0IHg7XG5sZXQgeGM7XG5sZXQgeERvbmU7XG4vKiogQHR5cGUge1R9ICovXG5sZXQgeTtcbmxldCB5YztcbmxldCB5RG9uZTtcblxuY29uc3QgeGk9eHNbU3ltYm9sLml0ZXJhdG9yXSgpO1xuY29uc3QgbmV4dFg9KCk9PntcbiF4RG9uZXx8RmFpbCBgSW50ZXJuYWw6IG5leHRYIHNob3VsZCBub3QgYmUgY2FsbGVkIG9uY2UgZG9uZWA7XG4oe1xuZG9uZTp4RG9uZSxcbnZhbHVlOlt4LHhjXX09XG54aS5uZXh0KCkpO1xuIH07XG5uZXh0WCgpO1xuXG5jb25zdCB5aT15c1tTeW1ib2wuaXRlcmF0b3JdKCk7XG5jb25zdCBuZXh0WT0oKT0+e1xuIXlEb25lfHxGYWlsIGBJbnRlcm5hbDogbmV4dFkgc2hvdWxkIG5vdCBiZSBjYWxsZWQgb25jZSBkb25lYDtcbih7XG5kb25lOnlEb25lLFxudmFsdWU6W3kseWNdfT1cbnlpLm5leHQoKSk7XG4gfTtcbm5leHRZKCk7XG5cbnJldHVybiBoYXJkZW4oe1xubmV4dDooKT0+e1xuLyoqIEB0eXBlIHtib29sZWFufSAqL1xubGV0IGRvbmU9ZmFsc2U7XG4vKiogQHR5cGUge1tULGJpZ2ludCxiaWdpbnRdfSAqL1xubGV0IHZhbHVlO1xuaWYoeERvbmUmJnlEb25lKXtcbmRvbmU9dHJ1ZTtcbi8qIEB0cy1leHBlY3QtZXJyb3IgQmVjYXVzZSB0aGUgdGVybWluYXRpbmcgdmFsdWUgZG9lcyBub3QgbWF0dGVyKi9cbnZhbHVlPVtudWxsLDBuLDBuXTtcbiB9ZWxzZSBpZih4RG9uZSl7XG4vKiBvbmx5IHlzIGFyZSBsZWZ0Ki9cbnZhbHVlPVt5LDBuLHljXTtcbm5leHRZKCk7XG4gfWVsc2UgaWYoeURvbmUpe1xuLyogb25seSB4cyBhcmUgbGVmdCovXG52YWx1ZT1beCx4Yywwbl07XG5uZXh0WCgpO1xuIH1lbHNle1xuY29uc3QgY29tcD1mdWxsQ29tcGFyZSh4LHkpO1xuaWYoY29tcD09PTApe1xuLyogeCBhbmQgeSBhcmUgZXF1aXZhbGVudCwgc28gcmVwb3J0IGJvdGgqL1xudmFsdWU9W3gseGMseWNdO1xubmV4dFgoKTtcbm5leHRZKCk7XG4gfWVsc2UgaWYoY29tcDwwKXtcbi8qIHggaXMgZWFybGllciwgc28gcmVwb3J0IGl0Ki9cbnZhbHVlPVt4LHhjLDBuXTtcbm5leHRYKCk7XG4gfWVsc2V7XG4vKiB5IGlzIGVhcmxpZXIsIHNvIHJlcG9ydCBpdCovXG5jb21wPjB8fEZhaWwgYEludGVybmFsOiBVbmV4cGVjdGVkIGNvbXAgJHtxKGNvbXApfWA7XG52YWx1ZT1beSwwbix5Y107XG5uZXh0WSgpO1xuIH1cbiB9XG5yZXR1cm4gaGFyZGVuKHtkb25lLHZhbHVlfSk7XG4gfX0pO1xuXG4gfX0pO1xuXG4gfTtcbmhhcmRlbihtZXJnZSk7XG5cbi8qIFdlIHNob3VsZCBiZSBhYmxlIHRvIHVzZSB0aGlzIGZvciBpdGVySXNTdXBlcnNldCBhcyB3ZWxsLiovXG4vKiBUaGUgZ2VuZXJhbGl6YXRpb24gaXMgZnJlZS4qL1xuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGJhZ0l0ZXJJc1N1cGVyYmFnPSh4eWkpPT57XG5mb3IoY29uc3RbX20seGMseWNdb2YgeHlpKXtcbmlmKHhjPHljKXtcbi8qIHNvbWV0aGluZyBpbiB5IGlzIG5vdCBpbiB4LCBzbyB4IGlzIG5vdCBhIHN1cGVyYmFnIG9mIHkqL1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5yZXR1cm4gdHJ1ZTtcbiB9O1xuXG4vKiBXZSBzaG91bGQgYmUgYWJsZSB0byB1c2UgdGhpcyBmb3IgaXRlcklzRGlzam9pbnQgYXMgd2VsbC4qL1xuLyogVGhlIGNvZGUgaXMgaWRlbnRpY2FsLiovXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgYmFnSXRlcklzRGlzam9pbnQ9KHh5aSk9PntcbmZvcihjb25zdFtfbSx4Yyx5Y11vZiB4eWkpe1xuaWYoeGM+PTFuJiZ5Yz49MW4pe1xuLyogU29tZXRoaW5nIGluIGJvdGgsIHNvIG5vdCBkaXNqb2ludCovXG5yZXR1cm4gZmFsc2U7XG4gfVxuIH1cbnJldHVybiB0cnVlO1xuIH07XG5cbi8qIFdlIHNob3VsZCBiZSBhYmxlIHRvIHVzZSB0aGlzIGZvciBpdGVyQ29tcGFyZSBhcyB3ZWxsLiovXG4vKiBUaGUgZ2VuZXJhbGl6YXRpb24gaXMgZnJlZS4qL1xuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge0tleUNvbXBhcmlzb259XG4gKi9cbmNvbnN0IGJhZ0l0ZXJDb21wYXJlPSh4eWkpPT57XG5sZXQgbG9uZVk9ZmFsc2U7XG5sZXQgbG9uZVg9ZmFsc2U7XG5mb3IoY29uc3RbX20seGMseWNdb2YgeHlpKXtcbmlmKHhjPHljKXtcbi8qIHNvbWV0aGluZyBpbiB5IGlzIG5vdCBpbiB4LCBzbyB4IGlzIG5vdCBhIHN1cGVyYmFnIG9mIHkqL1xubG9uZVk9dHJ1ZTtcbiB9XG5pZih4Yz55Yyl7XG4vKiBzb21ldGhpbmcgaW4geCBpcyBub3QgaW4geSwgc28geSBpcyBub3QgYSBzdXBlcmJhZyBvZiB4Ki9cbmxvbmVYPXRydWU7XG4gfVxuaWYobG9uZVgmJmxvbmVZKXtcbnJldHVybiBOYU47XG4gfVxuIH1cbmlmKGxvbmVYKXtcbnJldHVybiAxO1xuIH1lbHNlIGlmKGxvbmVZKXtcbnJldHVybi0xO1xuIH1lbHNle1xuIWxvbmVYJiYhbG9uZVl8fFxuRmFpbCBgSW50ZXJuYWw6IFVuZXhwZWN0ZWQgbG9uZSBwYWlyICR7cShbbG9uZVgsbG9uZVldKX1gO1xucmV0dXJuIDA7XG4gfVxuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7W1QsYmlnaW50LGJpZ2ludF1bXX0geHlpXG4gKiBAcmV0dXJucyB7W1QsYmlnaW50XVtdfVxuICovXG5jb25zdCBiYWdJdGVyVW5pb249KHh5aSk9Pntcbi8qKiBAdHlwZSB7W1QsYmlnaW50XVtdfSAqL1xuY29uc3QgcmVzdWx0PVtdO1xuZm9yKGNvbnN0W20seGMseWNdb2YgeHlpKXtcbnJlc3VsdC5wdXNoKFttLHhjK3ljXSk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7W1QsYmlnaW50XVtdfVxuICovXG5jb25zdCBiYWdJdGVySW50ZXJzZWN0aW9uPSh4eWkpPT57XG4vKiogQHR5cGUge1tULGJpZ2ludF1bXX0gKi9cbmNvbnN0IHJlc3VsdD1bXTtcbmZvcihjb25zdFttLHhjLHljXW9mIHh5aSl7XG5jb25zdCBtYz14Yzw9eWM/eGM6eWM7XG5yZXN1bHQucHVzaChbbSxtY10pO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge1tULGJpZ2ludF1bXX1cbiAqL1xuY29uc3QgYmFnSXRlckRpc2pvaW50U3VidHJhY3Q9KHh5aSk9Pntcbi8qKiBAdHlwZSB7W1QsYmlnaW50XVtdfSAqL1xuY29uc3QgcmVzdWx0PVtdO1xuZm9yKGNvbnN0W20seGMseWNdb2YgeHlpKXtcbmNvbnN0IG1jPXhjLXljO1xubWM+PTBufHxGYWlsIGByaWdodCBlbGVtZW50ICR7bX0gd2FzIG5vdCBpbiBsZWZ0YDtcbmlmKG1jPj0xbil7XG4vKiB0aGUgeCB3YXMgbm90IGluIHkqL1xucmVzdWx0LnB1c2goW20sbWNdKTtcbiB9XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG5jb25zdCBtZXJnZWlmeT0oYmFnSXRlck9wKT0+KHhiYWdFbnRyaWVzLHliYWdFbnRyaWVzKT0+XG5iYWdJdGVyT3AobWVyZ2UoeGJhZ0VudHJpZXMseWJhZ0VudHJpZXMpKTtcblxuY29uc3QgYmFnRW50cmllc0lzU3VwZXJiYWc9bWVyZ2VpZnkoYmFnSXRlcklzU3VwZXJiYWcpO1xuY29uc3QgYmFnRW50cmllc0lzRGlzam9pbnQ9bWVyZ2VpZnkoYmFnSXRlcklzRGlzam9pbnQpO1xuY29uc3QgYmFnRW50cmllc0NvbXBhcmU9bWVyZ2VpZnkoYmFnSXRlckNvbXBhcmUpO1xuY29uc3QgYmFnRW50cmllc1VuaW9uPW1lcmdlaWZ5KGJhZ0l0ZXJVbmlvbik7XG5jb25zdCBiYWdFbnRyaWVzSW50ZXJzZWN0aW9uPW1lcmdlaWZ5KGJhZ0l0ZXJJbnRlcnNlY3Rpb24pO1xuY29uc3QgYmFnRW50cmllc0Rpc2pvaW50U3VidHJhY3Q9bWVyZ2VpZnkoYmFnSXRlckRpc2pvaW50U3VidHJhY3QpO1xuXG5jb25zdCByYXdCYWdpZnk9KGJhZ0VudHJpZXNPcCk9Pih4YmFnLHliYWcpPT5cbmJhZ0VudHJpZXNPcCh4YmFnLnBheWxvYWQseWJhZy5wYXlsb2FkKTtcblxuY29uc3QgYmFnaWZ5PShiYWdFbnRyaWVzT3ApPT4oeGJhZyx5YmFnKT0+XG5tYWtlQmFnT2ZFbnRyaWVzKGJhZ0VudHJpZXNPcCh4YmFnLnBheWxvYWQseWJhZy5wYXlsb2FkKSk7XG5cbmNvbnN0ICAgICAgICBiYWdJc1N1cGVyYmFnPXJhd0JhZ2lmeShiYWdFbnRyaWVzSXNTdXBlcmJhZyk7JGjigI1fb25jZS5iYWdJc1N1cGVyYmFnKGJhZ0lzU3VwZXJiYWcpO1xuY29uc3QgICAgICAgIGJhZ0lzRGlzam9pbnQ9cmF3QmFnaWZ5KGJhZ0VudHJpZXNJc0Rpc2pvaW50KTskaOKAjV9vbmNlLmJhZ0lzRGlzam9pbnQoYmFnSXNEaXNqb2ludCk7XG5jb25zdCAgICAgICAgYmFnQ29tcGFyZT1yYXdCYWdpZnkoYmFnRW50cmllc0NvbXBhcmUpOyRo4oCNX29uY2UuYmFnQ29tcGFyZShiYWdDb21wYXJlKTtcbmNvbnN0ICAgICAgICBiYWdVbmlvbj1iYWdpZnkoYmFnRW50cmllc1VuaW9uKTskaOKAjV9vbmNlLmJhZ1VuaW9uKGJhZ1VuaW9uKTtcbmNvbnN0ICAgICAgICBiYWdJbnRlcnNlY3Rpb249YmFnaWZ5KGJhZ0VudHJpZXNJbnRlcnNlY3Rpb24pOyRo4oCNX29uY2UuYmFnSW50ZXJzZWN0aW9uKGJhZ0ludGVyc2VjdGlvbik7XG5jb25zdCAgICAgICAgYmFnRGlzam9pbnRTdWJ0cmFjdD1iYWdpZnkoYmFnRW50cmllc0Rpc2pvaW50U3VidHJhY3QpOyRo4oCNX29uY2UuYmFnRGlzam9pbnRTdWJ0cmFjdChiYWdEaXNqb2ludFN1YnRyYWN0KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJiYWdJc1N1cGVyYmFnIjpbImJhZ0lzU3VwZXJiYWciXSwiYmFnSXNEaXNqb2ludCI6WyJiYWdJc0Rpc2pvaW50Il0sImJhZ0NvbXBhcmUiOlsiYmFnQ29tcGFyZSJdLCJiYWdVbmlvbiI6WyJiYWdVbmlvbiJdLCJiYWdJbnRlcnNlY3Rpb24iOlsiYmFnSW50ZXJzZWN0aW9uIl0sImJhZ0Rpc2pvaW50U3VidHJhY3QiOlsiYmFnRGlzam9pbnRTdWJ0cmFjdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAi9nVSnigAAJ4oAAA1AAAAQGVuZG8vcGF0dGVybnMtdjAuMi4yL3NyYy9rZXlzL21lcmdlLXNldC1vcGVyYXRvcnMuanN7ImltcG9ydHMiOlsiLi9jb3B5U2V0LmpzIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbImVsZW1lbnRzQ29tcGFyZSIsImVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCIsImVsZW1lbnRzRGlzam9pbnRVbmlvbiIsImVsZW1lbnRzSW50ZXJzZWN0aW9uIiwiZWxlbWVudHNJc0Rpc2pvaW50IiwiZWxlbWVudHNJc1N1cGVyc2V0IiwiZWxlbWVudHNVbmlvbiIsInNldENvbXBhcmUiLCJzZXREaXNqb2ludFN1YnRyYWN0Iiwic2V0RGlzam9pbnRVbmlvbiIsInNldEludGVyc2VjdGlvbiIsInNldElzRGlzam9pbnQiLCJzZXRJc1N1cGVyc2V0Iiwic2V0VW5pb24iXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0UmFua1NvcnRlZCxjb21wYXJlQW50aVJhbmssbWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQsc29ydEJ5UmFuayxhc3NlcnROb0R1cGxpY2F0ZXMsbWFrZVNldE9mRWxlbWVudHM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiYXNzZXJ0UmFua1NvcnRlZFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UmFua1NvcnRlZCA9ICRo4oCNX2EpXV0sW1wiY29tcGFyZUFudGlSYW5rXCIsIFskaOKAjV9hID0+IChjb21wYXJlQW50aVJhbmsgPSAkaOKAjV9hKV1dLFtcIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0XCIsIFskaOKAjV9hID0+IChtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCA9ICRo4oCNX2EpXV0sW1wic29ydEJ5UmFua1wiLCBbJGjigI1fYSA9PiAoc29ydEJ5UmFuayA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvcHlTZXQuanNcIiwgW1tcImFzc2VydE5vRHVwbGljYXRlc1wiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Tm9EdXBsaWNhdGVzID0gJGjigI1fYSldXSxbXCJtYWtlU2V0T2ZFbGVtZW50c1wiLCBbJGjigI1fYSA9PiAobWFrZVNldE9mRWxlbWVudHMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuY29uc3R7cXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXlDb21wYXJpc29ufSBLZXlDb21wYXJpc29uICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuRnVsbENvbXBhcmV9IEZ1bGxDb21wYXJlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5SYW5rQ29tcGFyZX0gUmFua0NvbXBhcmUgKi9cblxuLyoqXG4gKiBBc3NlcnRzIHRoYXQgYGVsZW1lbnRzYCBpcyBhbHJlYWR5IHJhbmsgc29ydGVkIGJ5IGByYW5rQ29tcGFyZWAsIHdoZXJlIHRoZXJlXG4gKiBtYXkgYmUgY29udGlndW91cyByZWdpb25zIG9mIGVsZW1lbnRzIHRpZWQgZm9yIHRoZSBzYW1lIHJhbmsuXG4gKiBSZXR1cm5zIGFuIGl0ZXJhYmxlIHRoYXQgd2lsbCBlbnVtZXJhdGUgYWxsIHRoZSBlbGVtZW50cyBpbiBvcmRlclxuICogYWNjb3JkaW5nIHRvIGBmdWxsT3JkZXJgLCB3aGljaCBzaG91bGQgZGlmZmVyIGZyb20gYHJhbmtPcmRlcmAgb25seVxuICogYnkgYmVpbmcgbW9yZSBwcmVjaXNlLlxuICpcbiAqIFRoaXMgc2hvdWxkIGJlIGVxdWl2YWxlbnQgdG8gcmVzb3J0aW5nIHRoZSBlbnRpcmUgYGVsZW1lbnRzYCBhcnJheSBhY2NvcmRpbmdcbiAqICB0byBgZnVsbE9yZGVyYC4gSG93ZXZlciwgaXQgb3B0aW1pemVzIGZvciB0aGUgY2FzZSB3aGVyZSB0aGVzZSBjb250aWd1b3VzXG4gKiBydW5zIHRoYXQgbmVlZCB0byBiZSByZXNvcnRlZCBhcmUgZWl0aGVyIGFic2VudCBvciBzbWFsbC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUW119IGVsZW1lbnRzXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSByYW5rQ29tcGFyZVxuICogQHBhcmFtIHtGdWxsQ29tcGFyZX0gZnVsbENvbXBhcmVcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxUPn1cbiAqL1xuY29uc3Qgd2luZG93UmVzb3J0PShlbGVtZW50cyxyYW5rQ29tcGFyZSxmdWxsQ29tcGFyZSk9PntcbmFzc2VydFJhbmtTb3J0ZWQoZWxlbWVudHMscmFua0NvbXBhcmUpO1xuY29uc3R7bGVuZ3RofT1lbGVtZW50cztcbmxldCBpPTA7XG5sZXQgb3B0SW5uZXJJdGVyYXRvcjtcbnJldHVybiBoYXJkZW4oe1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PlxuaGFyZGVuKHtcbm5leHQ6KCk9PntcbmlmKG9wdElubmVySXRlcmF0b3Ipe1xuY29uc3QgcmVzdWx0PW9wdElubmVySXRlcmF0b3IubmV4dCgpO1xuaWYocmVzdWx0LmRvbmUpe1xub3B0SW5uZXJJdGVyYXRvcj11bmRlZmluZWQ7XG4vKiBmYWxsIHRocm91Z2gqL1xuIH1lbHNle1xucmV0dXJuIHJlc3VsdDtcbiB9XG4gfVxuaWYoaTxsZW5ndGgpe1xuY29uc3QgdmFsdWU9ZWxlbWVudHNbaV07XG5sZXQgaj1pKzE7XG53aGlsZShqPGxlbmd0aCYmcmFua0NvbXBhcmUodmFsdWUsZWxlbWVudHNbal0pPT09MCl7XG5qKz0xO1xuIH1cbmlmKGo9PT1pKzEpe1xuaT1qO1xucmV0dXJuIGhhcmRlbih7ZG9uZTpmYWxzZSx2YWx1ZX0pO1xuIH1cbmNvbnN0IHNpbWlsYXJSdW49ZWxlbWVudHMuc2xpY2UoaSxqKTtcbmk9ajtcbmNvbnN0IHJlc29ydGVkPXNvcnRCeVJhbmsoc2ltaWxhclJ1bixmdWxsQ29tcGFyZSk7XG4vKiBQcm92aWRpbmcgdGhlIHNhbWUgYGZ1bGxDb21wYXJlYCBzaG91bGQgY2F1c2UgYSBtZW1vIGhpdCovXG4vKiB3aXRoaW4gYGFzc2VydE5vRHVwbGljYXRlc2AgZW5hYmxpbmcgaXQgdG8gYXZvaWQgYSovXG4vKiByZWR1bmRhbnQgcmVzb3J0aW5nLiovXG5hc3NlcnROb0R1cGxpY2F0ZXMocmVzb3J0ZWQsZnVsbENvbXBhcmUpO1xuLyogVGhpcyBpcyB0aGUgcmF3IEpTIGFycmF5IGl0ZXJhdG9yIHdob3NlIGAubmV4dCgpYCBtZXRob2QqL1xuLyogZG9lcyBub3QgaGFyZGVuIHRoZSBJdGVyYXRvclJlc3VsdCwgaW4gdmlvbGF0aW9uIG9mIG91ciovXG4vKiBjb252ZW50aW9ucy4gRml4aW5nIHRoaXMgaXMgZXhwZW5zaXZlIGFuZCBJJ20gY29uZmlkZW50IHRoZSovXG4vKiB1bmZyb3plbiB2YWx1ZSBkb2VzIG5vdCBlc2NhcGUgdGhpcyBmaWxlLCBzbyBJJ20gbGVhdmluZyB0aGlzKi9cbi8qIGFzIGlzLiovXG5vcHRJbm5lckl0ZXJhdG9yPXJlc29ydGVkW1N5bWJvbC5pdGVyYXRvcl0oKTtcbnJldHVybiBvcHRJbm5lckl0ZXJhdG9yLm5leHQoKTtcbiB9ZWxzZXtcbnJldHVybiBoYXJkZW4oe2RvbmU6dHJ1ZSx2YWx1ZTpudWxsfSk7XG4gfVxuIH19KX0pO1xuXG5cbiB9O1xuXG4vKipcbiAqIFJldHVybnMgYW4gaXRlcmFibGUgd2hvc2UgaXRlcmF0aW9uIHJlc3VsdHMgYXJlIFtrZXksIHhDb3VudCwgeUNvdW50XSB0dXBsZXNcbiAqIHJlcHJlc2VudGluZyB0aGUgbmV4dCBrZXkgaW4gdGhlIGxvY2FsIGZ1bGwgb3JkZXIsIGFzIHdlbGwgYXMgaG93IG1hbnlcbiAqIHRpbWVzIGl0IG9jY3VycmVkIGluIHRoZSB4IGlucHV0IGl0ZXJhdG9yIGFuZCB0aGUgeSBpbnB1dCBpdGVyYXRvci5cbiAqXG4gKiBGb3Igc2V0cywgdGhlc2UgY291bnRzIGFyZSBhbHdheXMgMCBvciAxLCBidXQgdGhpcyByZXByZXNlbnRhdGlvblxuICogZ2VuZXJhbGl6ZXMgbmljZWx5IGZvciBiYWdzLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1RbXX0geGVsZW1lbnRzXG4gKiBAcGFyYW0ge1RbXX0geWVsZW1lbnRzXG4gKiBAcmV0dXJucyB7SXRlcmFibGU8W1QsYmlnaW50LGJpZ2ludF0+fVxuICovXG5jb25zdCBtZXJnZT0oeGVsZW1lbnRzLHllbGVtZW50cyk9Pntcbi8qIFRoaXMgZnVsbE9yZGVyIGNvbnRhaW5zIGhpc3RvcnkgZGVwZW5kZW50IHN0YXRlLiBJdCBpcyBzcGVjaWZpYyovXG4vKiB0byB0aGlzIG9uZSBgbWVyZ2VgIGNhbGwgYW5kIGRvZXMgbm90IHN1cnZpdmUgaXQuKi9cbmNvbnN0IGZ1bGxDb21wYXJlPW1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KCkuYW50aUNvbXBhcmF0b3I7XG5cbmNvbnN0IHhzPXdpbmRvd1Jlc29ydCh4ZWxlbWVudHMsY29tcGFyZUFudGlSYW5rLGZ1bGxDb21wYXJlKTtcbmNvbnN0IHlzPXdpbmRvd1Jlc29ydCh5ZWxlbWVudHMsY29tcGFyZUFudGlSYW5rLGZ1bGxDb21wYXJlKTtcbnJldHVybiBoYXJkZW4oe1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9Pntcbi8qIFRoZXNlIGZvdXIgYGxldGAgdmFyaWFibGVzIGFyZSBidWZmZXJpbmcgb25lIGFoZWFkIGZyb20gdGhlIHVuZGVybHlpbmcqL1xuLyogaXRlcmF0b3JzLiBFYWNoIGl0ZXJhdGlvbiByZXBvcnRzIG9uZSBvciB0aGUgb3RoZXIgb3IgYm90aCwgYW5kKi9cbi8qIHRoZW4gcmVmaWxscyB0aGUgYnVmZmVycyBvZiB0aG9zZSBpdCBhZHZhbmNlZC4qL1xuLyoqIEB0eXBlIHtUfSAqL1xubGV0IHg7XG5sZXQgeERvbmU7XG4vKiogQHR5cGUge1R9ICovXG5sZXQgeTtcbmxldCB5RG9uZTtcblxuY29uc3QgeGk9eHNbU3ltYm9sLml0ZXJhdG9yXSgpO1xuY29uc3QgbmV4dFg9KCk9PntcbiF4RG9uZXx8RmFpbCBgSW50ZXJuYWw6IG5leHRYIHNob3VsZCBub3QgYmUgY2FsbGVkIG9uY2UgZG9uZWA7XG4oe2RvbmU6eERvbmUsdmFsdWU6eH09eGkubmV4dCgpKTtcbiB9O1xubmV4dFgoKTtcblxuY29uc3QgeWk9eXNbU3ltYm9sLml0ZXJhdG9yXSgpO1xuY29uc3QgbmV4dFk9KCk9PntcbiF5RG9uZXx8RmFpbCBgSW50ZXJuYWw6IG5leHRZIHNob3VsZCBub3QgYmUgY2FsbGVkIG9uY2UgZG9uZWA7XG4oe2RvbmU6eURvbmUsdmFsdWU6eX09eWkubmV4dCgpKTtcbiB9O1xubmV4dFkoKTtcblxucmV0dXJuIGhhcmRlbih7XG5uZXh0OigpPT57XG4vKiogQHR5cGUge2Jvb2xlYW59ICovXG5sZXQgZG9uZT1mYWxzZTtcbi8qKiBAdHlwZSB7W1QsYmlnaW50LGJpZ2ludF19ICovXG5sZXQgdmFsdWU7XG5pZih4RG9uZSYmeURvbmUpe1xuZG9uZT10cnVlO1xuLyogQHRzLWV4cGVjdC1lcnJvciBCZWNhdXNlIHRoZSB0ZXJtaW5hdGluZyB2YWx1ZSBkb2VzIG5vdCBtYXR0ZXIqL1xudmFsdWU9W251bGwsMG4sMG5dO1xuIH1lbHNlIGlmKHhEb25lKXtcbi8qIG9ubHkgeXMgYXJlIGxlZnQqL1xudmFsdWU9W3ksMG4sMW5dO1xubmV4dFkoKTtcbiB9ZWxzZSBpZih5RG9uZSl7XG4vKiBvbmx5IHhzIGFyZSBsZWZ0Ki9cbnZhbHVlPVt4LDFuLDBuXTtcbm5leHRYKCk7XG4gfWVsc2V7XG5jb25zdCBjb21wPWZ1bGxDb21wYXJlKHgseSk7XG5pZihjb21wPT09MCl7XG4vKiB4IGFuZCB5IGFyZSBlcXVpdmFsZW50LCBzbyByZXBvcnQgYm90aCovXG52YWx1ZT1beCwxbiwxbl07XG5uZXh0WCgpO1xubmV4dFkoKTtcbiB9ZWxzZSBpZihjb21wPDApe1xuLyogeCBpcyBlYXJsaWVyLCBzbyByZXBvcnQgaXQqL1xudmFsdWU9W3gsMW4sMG5dO1xubmV4dFgoKTtcbiB9ZWxzZXtcbi8qIHkgaXMgZWFybGllciwgc28gcmVwb3J0IGl0Ki9cbmNvbXA+MHx8RmFpbCBgSW50ZXJuYWw6IFVuZXhwZWN0ZWQgY29tcCAke3EoY29tcCl9YDtcbnZhbHVlPVt5LDBuLDFuXTtcbm5leHRZKCk7XG4gfVxuIH1cbnJldHVybiBoYXJkZW4oe2RvbmUsdmFsdWV9KTtcbiB9fSk7XG5cbiB9fSk7XG5cbiB9O1xuaGFyZGVuKG1lcmdlKTtcblxuY29uc3QgaXRlcklzU3VwZXJzZXQ9KHh5aSk9PntcbmZvcihjb25zdFtfbSx4YyxfeWNdb2YgeHlpKXtcbmlmKHhjPT09MG4pe1xuLyogc29tZXRoaW5nIGluIHkgaXMgbm90IGluIHgsIHNvIHggaXMgbm90IGEgc3VwZXJzZXQgb2YgeSovXG5yZXR1cm4gZmFsc2U7XG4gfVxuIH1cbnJldHVybiB0cnVlO1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8W1QsYmlnaW50LGJpZ2ludF0+fSB4eWlcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpdGVySXNEaXNqb2ludD0oeHlpKT0+e1xuZm9yKGNvbnN0W19tLHhjLHljXW9mIHh5aSl7XG5pZih4Yz49MW4mJnljPj0xbil7XG4vKiBTb21ldGhpbmcgaW4gYm90aCwgc28gbm90IGRpc2pvaW50Ki9cbnJldHVybiBmYWxzZTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge0tleUNvbXBhcmlzb259XG4gKi9cbmNvbnN0IGl0ZXJDb21wYXJlPSh4eWkpPT57XG5sZXQgbG9uZVk9ZmFsc2U7XG5sZXQgbG9uZVg9ZmFsc2U7XG5mb3IoY29uc3RbX20seGMseWNdb2YgeHlpKXtcbmlmKHhjPT09MG4pe1xuLyogc29tZXRoaW5nIGluIHkgaXMgbm90IGluIHgsIHNvIHggaXMgbm90IGEgc3VwZXJzZXQgb2YgeSovXG5sb25lWT10cnVlO1xuIH1cbmlmKHljPT09MG4pe1xuLyogc29tZXRoaW5nIGluIHggaXMgbm90IGluIHksIHNvIHkgaXMgbm90IGEgc3VwZXJzZXQgb2YgeCovXG5sb25lWD10cnVlO1xuIH1cbmlmKGxvbmVYJiZsb25lWSl7XG5yZXR1cm4gTmFOO1xuIH1cbiB9XG5pZihsb25lWCl7XG5yZXR1cm4gMTtcbiB9ZWxzZSBpZihsb25lWSl7XG5yZXR1cm4tMTtcbiB9ZWxzZXtcbiFsb25lWCYmIWxvbmVZfHxcbkZhaWwgYEludGVybmFsOiBVbmV4cGVjdGVkIGxvbmUgcGFpciAke3EoW2xvbmVYLGxvbmVZXSl9YDtcbnJldHVybiAwO1xuIH1cbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7VFtdfVxuICovXG5jb25zdCBpdGVyVW5pb249KHh5aSk9PntcbmNvbnN0IHJlc3VsdD1bXTtcbmZvcihjb25zdFttLHhjLHljXW9mIHh5aSl7XG5pZih4Yz49MG4pe1xucmVzdWx0LnB1c2gobSk7XG4gfWVsc2V7XG55Yz49MG58fEZhaWwgYEludGVybmFsOiBVbmV4cGVjdGVkIGNvdW50ICR7cSh5Yyl9YDtcbi8qIGlmIHggYW5kIHkgd2VyZSBib3RoIHJlYWR5LCB0aGVuIHRoZXkgd2VyZSBlcXVpdmFsZW50IGFuZCovXG4vKiBhYm92ZSBjbGF1c2UgYWxyZWFkeSB0b29rIGNhcmUgb2YgaXQuIE90aGVyd2lzZSBwdXNoIGhlcmUuKi9cbnJlc3VsdC5wdXNoKG0pO1xuIH1cbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8W1QsYmlnaW50LGJpZ2ludF0+fSB4eWlcbiAqIEByZXR1cm5zIHtUW119XG4gKi9cbmNvbnN0IGl0ZXJEaXNqb2ludFVuaW9uPSh4eWkpPT57XG5jb25zdCByZXN1bHQ9W107XG5mb3IoY29uc3RbbSx4Yyx5Y11vZiB4eWkpe1xueGM9PT0wbnx8eWM9PT0wbnx8RmFpbCBgU2V0cyBtdXN0IG5vdCBoYXZlIGNvbW1vbiBlbGVtZW50czogJHttfWA7XG5pZih4Yz49MW4pe1xucmVzdWx0LnB1c2gobSk7XG4gfWVsc2V7XG55Yz49MW58fEZhaWwgYEludGVybmFsOiBVbmV4cGVjdGVkIGNvdW50ICR7cSh5Yyl9YDtcbnJlc3VsdC5wdXNoKG0pO1xuIH1cbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8W1QsYmlnaW50LGJpZ2ludF0+fSB4eWlcbiAqIEByZXR1cm5zIHtUW119XG4gKi9cbmNvbnN0IGl0ZXJJbnRlcnNlY3Rpb249KHh5aSk9PntcbmNvbnN0IHJlc3VsdD1bXTtcbmZvcihjb25zdFttLHhjLHljXW9mIHh5aSl7XG5pZih4Yz49MW4mJnljPj0xbil7XG4vKiBJZiB0aGV5IGFyZSBib3RoIHByZXNlbnQsIHRoZW4gdGhleSB3ZXJlIGVxdWl2YWxlbnQqL1xucmVzdWx0LnB1c2gobSk7XG4gfVxuIH1cbnJldHVybiByZXN1bHQ7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgaXRlckRpc2pvaW50U3VidHJhY3Q9KHh5aSk9PntcbmNvbnN0IHJlc3VsdD1bXTtcbmZvcihjb25zdFttLHhjLHljXW9mIHh5aSl7XG54Yz49MW58fEZhaWwgYHJpZ2h0IGVsZW1lbnQgJHttfSB3YXMgbm90IGluIGxlZnRgO1xuaWYoeWM9PT0wbil7XG4vKiB0aGUgeCB3YXMgbm90IGluIHkqL1xucmVzdWx0LnB1c2gobSk7XG4gfVxuIH1cbnJldHVybiByZXN1bHQ7XG4gfTtcblxuY29uc3QgbWVyZ2VpZnk9KGl0ZXJPcCk9Pih4ZWxlbWVudHMseWVsZW1lbnRzKT0+XG5pdGVyT3AobWVyZ2UoeGVsZW1lbnRzLHllbGVtZW50cykpO1xuXG5jb25zdCAgICAgICAgZWxlbWVudHNJc1N1cGVyc2V0PW1lcmdlaWZ5KGl0ZXJJc1N1cGVyc2V0KTskaOKAjV9vbmNlLmVsZW1lbnRzSXNTdXBlcnNldChlbGVtZW50c0lzU3VwZXJzZXQpO1xuY29uc3QgICAgICAgIGVsZW1lbnRzSXNEaXNqb2ludD1tZXJnZWlmeShpdGVySXNEaXNqb2ludCk7JGjigI1fb25jZS5lbGVtZW50c0lzRGlzam9pbnQoZWxlbWVudHNJc0Rpc2pvaW50KTtcbmNvbnN0ICAgICAgICBlbGVtZW50c0NvbXBhcmU9bWVyZ2VpZnkoaXRlckNvbXBhcmUpOyRo4oCNX29uY2UuZWxlbWVudHNDb21wYXJlKGVsZW1lbnRzQ29tcGFyZSk7XG5jb25zdCAgICAgICAgZWxlbWVudHNVbmlvbj1tZXJnZWlmeShpdGVyVW5pb24pOyRo4oCNX29uY2UuZWxlbWVudHNVbmlvbihlbGVtZW50c1VuaW9uKTtcbmNvbnN0ICAgICAgICBlbGVtZW50c0Rpc2pvaW50VW5pb249bWVyZ2VpZnkoaXRlckRpc2pvaW50VW5pb24pOyRo4oCNX29uY2UuZWxlbWVudHNEaXNqb2ludFVuaW9uKGVsZW1lbnRzRGlzam9pbnRVbmlvbik7XG5jb25zdCAgICAgICAgZWxlbWVudHNJbnRlcnNlY3Rpb249bWVyZ2VpZnkoaXRlckludGVyc2VjdGlvbik7JGjigI1fb25jZS5lbGVtZW50c0ludGVyc2VjdGlvbihlbGVtZW50c0ludGVyc2VjdGlvbik7XG5jb25zdCAgICAgICAgZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0PW1lcmdlaWZ5KGl0ZXJEaXNqb2ludFN1YnRyYWN0KTskaOKAjV9vbmNlLmVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdChlbGVtZW50c0Rpc2pvaW50U3VidHJhY3QpO1xuXG5jb25zdCByYXdTZXRpZnk9KGVsZW1lbnRzT3ApPT4oeHNldCx5c2V0KT0+XG5lbGVtZW50c09wKHhzZXQucGF5bG9hZCx5c2V0LnBheWxvYWQpO1xuXG5jb25zdCBzZXRpZnk9KGVsZW1lbnRzT3ApPT4oeHNldCx5c2V0KT0+XG5tYWtlU2V0T2ZFbGVtZW50cyhlbGVtZW50c09wKHhzZXQucGF5bG9hZCx5c2V0LnBheWxvYWQpKTtcblxuY29uc3QgICAgICAgIHNldElzU3VwZXJzZXQ9cmF3U2V0aWZ5KGVsZW1lbnRzSXNTdXBlcnNldCk7JGjigI1fb25jZS5zZXRJc1N1cGVyc2V0KHNldElzU3VwZXJzZXQpO1xuY29uc3QgICAgICAgIHNldElzRGlzam9pbnQ9cmF3U2V0aWZ5KGVsZW1lbnRzSXNEaXNqb2ludCk7JGjigI1fb25jZS5zZXRJc0Rpc2pvaW50KHNldElzRGlzam9pbnQpO1xuY29uc3QgICAgICAgIHNldENvbXBhcmU9cmF3U2V0aWZ5KGVsZW1lbnRzQ29tcGFyZSk7JGjigI1fb25jZS5zZXRDb21wYXJlKHNldENvbXBhcmUpO1xuY29uc3QgICAgICAgIHNldFVuaW9uPXNldGlmeShlbGVtZW50c1VuaW9uKTskaOKAjV9vbmNlLnNldFVuaW9uKHNldFVuaW9uKTtcbmNvbnN0ICAgICAgICBzZXREaXNqb2ludFVuaW9uPXNldGlmeShlbGVtZW50c0Rpc2pvaW50VW5pb24pOyRo4oCNX29uY2Uuc2V0RGlzam9pbnRVbmlvbihzZXREaXNqb2ludFVuaW9uKTtcbmNvbnN0ICAgICAgICBzZXRJbnRlcnNlY3Rpb249c2V0aWZ5KGVsZW1lbnRzSW50ZXJzZWN0aW9uKTskaOKAjV9vbmNlLnNldEludGVyc2VjdGlvbihzZXRJbnRlcnNlY3Rpb24pO1xuY29uc3QgICAgICAgIHNldERpc2pvaW50U3VidHJhY3Q9c2V0aWZ5KGVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCk7JGjigI1fb25jZS5zZXREaXNqb2ludFN1YnRyYWN0KHNldERpc2pvaW50U3VidHJhY3QpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImVsZW1lbnRzSXNTdXBlcnNldCI6WyJlbGVtZW50c0lzU3VwZXJzZXQiXSwiZWxlbWVudHNJc0Rpc2pvaW50IjpbImVsZW1lbnRzSXNEaXNqb2ludCJdLCJlbGVtZW50c0NvbXBhcmUiOlsiZWxlbWVudHNDb21wYXJlIl0sImVsZW1lbnRzVW5pb24iOlsiZWxlbWVudHNVbmlvbiJdLCJlbGVtZW50c0Rpc2pvaW50VW5pb24iOlsiZWxlbWVudHNEaXNqb2ludFVuaW9uIl0sImVsZW1lbnRzSW50ZXJzZWN0aW9uIjpbImVsZW1lbnRzSW50ZXJzZWN0aW9uIl0sImVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCI6WyJlbGVtZW50c0Rpc2pvaW50U3VidHJhY3QiXSwic2V0SXNTdXBlcnNldCI6WyJzZXRJc1N1cGVyc2V0Il0sInNldElzRGlzam9pbnQiOlsic2V0SXNEaXNqb2ludCJdLCJzZXRDb21wYXJlIjpbInNldENvbXBhcmUiXSwic2V0VW5pb24iOlsic2V0VW5pb24iXSwic2V0RGlzam9pbnRVbmlvbiI6WyJzZXREaXNqb2ludFVuaW9uIl0sInNldEludGVyc2VjdGlvbiI6WyJzZXRJbnRlcnNlY3Rpb24iXSwic2V0RGlzam9pbnRTdWJ0cmFjdCI6WyJzZXREaXNqb2ludFN1YnRyYWN0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAIkMOwUzwwAAM8MAADUAAABAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL3BhdHRlcm5zL3BhdHRlcm5NYXRjaGVycy5qc3siaW1wb3J0cyI6WyIuLi9rZXlzL2NoZWNrS2V5LmpzIiwiLi4va2V5cy9jb21wYXJlS2V5cy5qcyIsIi4uL3V0aWxzLmpzIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbIk0iLCJhc3NlcnRQYXR0ZXJuIiwiY2hlY2tNYXRjaGVzIiwiZGVmYXVsdExpbWl0cyIsImdldFJhbmtDb3ZlciIsImlzUGF0dGVybiIsIm1hdGNoZXMiLCJtdXN0TWF0Y2giXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixGYXIsZ2V0VGFnLG1ha2VUYWdnZWQscGFzc1N0eWxlT2YsaGFzT3duUHJvcGVydHlPZixuYW1lRm9yUGFzc2FibGVTeW1ib2wsY29tcGFyZVJhbmssZ2V0UGFzc1N0eWxlQ292ZXIsaW50ZXJzZWN0UmFua0NvdmVycyx1bmlvblJhbmtDb3ZlcnMscmVjb3JkTmFtZXMscmVjb3JkVmFsdWVzLGlkZW50Q2hlY2tlcixhcHBseUxhYmVsaW5nRXJyb3IsZnJvbVVuaXF1ZUVudHJpZXMsbGlzdERpZmZlcmVuY2Usa2V5RVEsa2V5R1Qsa2V5R1RFLGtleUxULGtleUxURSxhc3NlcnRLZXksY2hlY2tLZXksaXNLZXksY2hlY2tTY2FsYXJLZXksY2hlY2tDb3B5U2V0LGNoZWNrQ29weU1hcCxjb3B5TWFwS2V5U2V0LGNoZWNrQ29weUJhZzskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV0sW1wiZ2V0VGFnXCIsIFskaOKAjV9hID0+IChnZXRUYWcgPSAkaOKAjV9hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRo4oCNX2EgPT4gKG1ha2VUYWdnZWQgPSAkaOKAjV9hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjigI1fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRo4oCNX2EpXV0sW1wibmFtZUZvclBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaOKAjV9hKV1dLFtcImNvbXBhcmVSYW5rXCIsIFskaOKAjV9hID0+IChjb21wYXJlUmFuayA9ICRo4oCNX2EpXV0sW1wiZ2V0UGFzc1N0eWxlQ292ZXJcIiwgWyRo4oCNX2EgPT4gKGdldFBhc3NTdHlsZUNvdmVyID0gJGjigI1fYSldXSxbXCJpbnRlcnNlY3RSYW5rQ292ZXJzXCIsIFskaOKAjV9hID0+IChpbnRlcnNlY3RSYW5rQ292ZXJzID0gJGjigI1fYSldXSxbXCJ1bmlvblJhbmtDb3ZlcnNcIiwgWyRo4oCNX2EgPT4gKHVuaW9uUmFua0NvdmVycyA9ICRo4oCNX2EpXV0sW1wicmVjb3JkTmFtZXNcIiwgWyRo4oCNX2EgPT4gKHJlY29yZE5hbWVzID0gJGjigI1fYSldXSxbXCJyZWNvcmRWYWx1ZXNcIiwgWyRo4oCNX2EgPT4gKHJlY29yZFZhbHVlcyA9ICRo4oCNX2EpXV1dXSxbXCIuLi91dGlscy5qc1wiLCBbW1wiaWRlbnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChpZGVudENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcImFwcGx5TGFiZWxpbmdFcnJvclwiLCBbJGjigI1fYSA9PiAoYXBwbHlMYWJlbGluZ0Vycm9yID0gJGjigI1fYSldXSxbXCJmcm9tVW5pcXVlRW50cmllc1wiLCBbJGjigI1fYSA9PiAoZnJvbVVuaXF1ZUVudHJpZXMgPSAkaOKAjV9hKV1dLFtcImxpc3REaWZmZXJlbmNlXCIsIFskaOKAjV9hID0+IChsaXN0RGlmZmVyZW5jZSA9ICRo4oCNX2EpXV1dXSxbXCIuLi9rZXlzL2NvbXBhcmVLZXlzLmpzXCIsIFtbXCJrZXlFUVwiLCBbJGjigI1fYSA9PiAoa2V5RVEgPSAkaOKAjV9hKV1dLFtcImtleUdUXCIsIFskaOKAjV9hID0+IChrZXlHVCA9ICRo4oCNX2EpXV0sW1wia2V5R1RFXCIsIFskaOKAjV9hID0+IChrZXlHVEUgPSAkaOKAjV9hKV1dLFtcImtleUxUXCIsIFskaOKAjV9hID0+IChrZXlMVCA9ICRo4oCNX2EpXV0sW1wia2V5TFRFXCIsIFskaOKAjV9hID0+IChrZXlMVEUgPSAkaOKAjV9hKV1dXV0sW1wiLi4va2V5cy9jaGVja0tleS5qc1wiLCBbW1wiYXNzZXJ0S2V5XCIsIFskaOKAjV9hID0+IChhc3NlcnRLZXkgPSAkaOKAjV9hKV1dLFtcImNoZWNrS2V5XCIsIFskaOKAjV9hID0+IChjaGVja0tleSA9ICRo4oCNX2EpXV0sW1wiaXNLZXlcIiwgWyRo4oCNX2EgPT4gKGlzS2V5ID0gJGjigI1fYSldXSxbXCJjaGVja1NjYWxhcktleVwiLCBbJGjigI1fYSA9PiAoY2hlY2tTY2FsYXJLZXkgPSAkaOKAjV9hKV1dLFtcImNoZWNrQ29weVNldFwiLCBbJGjigI1fYSA9PiAoY2hlY2tDb3B5U2V0ID0gJGjigI1fYSldXSxbXCJjaGVja0NvcHlNYXBcIiwgWyRo4oCNX2EgPT4gKGNoZWNrQ29weU1hcCA9ICRo4oCNX2EpXV0sW1wiY29weU1hcEtleVNldFwiLCBbJGjigI1fYSA9PiAoY29weU1hcEtleVNldCA9ICRo4oCNX2EpXV0sW1wiY2hlY2tDb3B5QmFnXCIsIFskaOKAjV9hID0+IChjaGVja0NvcHlCYWcgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbmNvbnN0e3F1b3RlOnEsZGV0YWlsczpYLEZhaWx9PWFzc2VydDtcbmNvbnN0e2VudHJpZXMsdmFsdWVzfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiogQHR5cGUge1dlYWtTZXQ8UGF0dGVybj59ICovXG5jb25zdCBwYXR0ZXJuTWVtbz1uZXcgV2Vha1NldCgpO1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBNYXRjaCBIZWxwZXJzIEhlbHBlcnMgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiogRm9yIGZvcndhcmQgcmVmZXJlbmNlcyB0byBgTWAgKi9cbmxldCBNTTtcblxuLyoqXG4gKiBUaGUgYWN0dWFsIGRlZmF1bHQgdmFsdWVzIGhlcmUgYXJlLCBhdCB0aGUgcHJlc2VudCB0aW1lLCBmYWlybHlcbiAqIGFyYml0cmFyeSBjaG9pY2VzIGFuZCBtYXkgY2hhbmdlIGJlZm9yZSB0aGV5IHNldHRsZSBkb3duLiBPZiBjb3Vyc2VcbiAqIGF0IHNvbWUgcG9pbnQgd2UnbGwgbmVlZCB0byBzdG9wIGNoYW5naW5nIHRoZW0uIEJ1dCB3ZSBzaG91bGQgZmlyc3RcbiAqIHNlZSBob3cgb3VyIHN5c3RlbSBob2xkcyB1cCB3aXRoIHRoZXNlIGNob2ljZXMuIFRoZSBtYWluIGNyaXRlcmlhXG4gKiBpcyB0aGF0IHRoZXkgYmUgYmlnIGVub3VnaCB0aGF0IFwibm9ybWFsXCIgaW5ub2NlbnQgcHJvZ3JhbXMgcmFyZWx5XG4gKiBlbmNvdW50ZXIgdGhlc2UgbGltaXRzLlxuICpcbiAqIEV4cG9ydGVkIHByaW1hcmlseSBmb3IgdGVzdGluZy5cbiAqL1xuY29uc3QgICAgICAgIGRlZmF1bHRMaW1pdHM9aGFyZGVuKHtcbmRlY2ltYWxEaWdpdHNMaW1pdDoxMDAsXG5zdHJpbmdMZW5ndGhMaW1pdDoxMDBfMDAwLFxuc3ltYm9sTmFtZUxlbmd0aExpbWl0OjEwMCxcbm51bVByb3BlcnRpZXNMaW1pdDo4MCxcbnByb3BlcnR5TmFtZUxlbmd0aExpbWl0OjEwMCxcbmFycmF5TGVuZ3RoTGltaXQ6MTBfMDAwLFxubnVtU2V0RWxlbWVudHNMaW1pdDoxMF8wMDAsXG5udW1VbmlxdWVCYWdFbGVtZW50c0xpbWl0OjEwXzAwMCxcbm51bU1hcEVudHJpZXNMaW1pdDo1MDAwfSk7XG5cblxuLyoqXG4gKiBVc2UgdGhlIHJlc3VsdCBvbmx5IHRvIGdldCB0aGUgbGltaXRzIHlvdSBuZWVkIGJ5IGRlc3RydWN0dXJpbmcuXG4gKiBUaHVzLCB0aGUgcmVzdWx0IG9ubHkgbmVlZHMgdG8gc3VwcG9ydCBkZXN0cnVjdHVyaW5nLiBUaGUgY3VycmVudFxuICogaW1wbGVtZW50YXRpb24gdXNlcyBpbmhlcml0YW5jZSBhcyBhIGNoZWFwIGhhY2suXG4gKlxuICogQHBhcmFtIHtMaW1pdHN9IFtsaW1pdHNdXG4gKiBAcmV0dXJucyB7QWxsTGltaXRzfVxuICovJGjigI1fb25jZS5kZWZhdWx0TGltaXRzKGRlZmF1bHRMaW1pdHMpO1xuY29uc3QgbGltaXQ9KGxpbWl0cz17fSk9PlxuLyoqIEB0eXBlIHtBbGxMaW1pdHN9ICovaGFyZGVuKHtfX3Byb3RvX186ZGVmYXVsdExpbWl0cywuLi5saW1pdHN9KTtcblxuY29uc3QgY2hlY2tJc1dlbGxGb3JtZWRXaXRoTGltaXQ9KFxucGF5bG9hZCxcbm1haW5QYXlsb2FkU2hhcGUsXG5jaGVjayxcbmxhYmVsKT0+XG57XG5hc3NlcnQoQXJyYXkuaXNBcnJheShtYWluUGF5bG9hZFNoYXBlKSk7XG5pZighQXJyYXkuaXNBcnJheShwYXlsb2FkKSl7XG5yZXR1cm4gY2hlY2soZmFsc2UsWCBgJHtxKGxhYmVsKX0gcGF5bG9hZCBtdXN0IGJlIGFuIGFycmF5OiAke3BheWxvYWR9YCk7XG4gfVxuXG4vKiBXYXMgdGhlIGZvbGxvd2luZywgYnV0IGl0cyBvdmVydXNlIG9mIHBhdHRlcm5zIGNhdXNlZCBhbiBpbmZpbml0ZSByZWdyZXNzKi9cbi8qIGNvbnN0IHBheWxvYWRMaW1pdFNoYXBlID0gaGFyZGVuKCovXG4vKiBNLnNwbGl0KCovXG4vKiBtYWluUGF5bG9hZFNoYXBlLCovXG4vKiBNLnBhcnRpYWwoaGFyZGVuKFtNLnJlY29yZE9mKE0uc3RyaW5nKCksIE0ubnVtYmVyKCkpXSksIGhhcmRlbihbXSkpLCovXG4vKiApLCovXG4vKiApOyovXG4vKiByZXR1cm4gY2hlY2tNYXRjaGVzKHBheWxvYWQsIHBheWxvYWRMaW1pdFNoYXBlLCBjaGVjaywgbGFiZWwpOyovXG5cbmNvbnN0IG1haW5MZW5ndGg9bWFpblBheWxvYWRTaGFwZS5sZW5ndGg7XG5pZighKHBheWxvYWQubGVuZ3RoPT09bWFpbkxlbmd0aHx8cGF5bG9hZC5sZW5ndGg9PT1tYWluTGVuZ3RoKzEpKXtcbnJldHVybiBjaGVjayhmYWxzZSxYIGAke3EobGFiZWwpfSBwYXlsb2FkIHVuZXhwZWN0ZWQgc2l6ZTogJHtwYXlsb2FkfWApO1xuIH1cbmNvbnN0IGxpbWl0cz1wYXlsb2FkW21haW5MZW5ndGhdO1xucGF5bG9hZD1oYXJkZW4ocGF5bG9hZC5zbGljZSgwLG1haW5MZW5ndGgpKTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZighY2hlY2tNYXRjaGVzKHBheWxvYWQsbWFpblBheWxvYWRTaGFwZSxjaGVjayxsYWJlbCkpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmlmKGxpbWl0cz09PXVuZGVmaW5lZCl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5yZXR1cm4oXG4ocGFzc1N0eWxlT2YobGltaXRzKT09PSdjb3B5UmVjb3JkJ3x8XG5jaGVjayhmYWxzZSxYIGBMaW1pdHMgbXVzdCBiZSBhIHJlY29yZDogJHtxKGxpbWl0cyl9YCkpJiZcbmVudHJpZXMobGltaXRzKS5ldmVyeShcbihba2V5LHZhbHVlXSk9PlxucGFzc1N0eWxlT2YodmFsdWUpPT09J251bWJlcid8fFxuY2hlY2soZmFsc2UsWCBgVmFsdWUgb2YgbGltaXQgJHtxKGtleSl9IGJ1dCBiZSBhIG51bWJlcjogJHtxKHZhbHVlKX1gKSkpO1xuXG5cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7bnVtYmVyfSBkZWNpbWFsRGlnaXRzTGltaXRcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqL1xuY29uc3QgY2hlY2tEZWNpbWFsRGlnaXRzTGltaXQ9KHNwZWNpbWVuLGRlY2ltYWxEaWdpdHNMaW1pdCxjaGVjayk9PntcbmlmKFxuTWF0aC5mbG9vcihNYXRoLmxvZzEwKE1hdGguYWJzKE51bWJlcihzcGVjaW1lbikpKSkrMTw9XG5kZWNpbWFsRGlnaXRzTGltaXQpXG57XG5yZXR1cm4gdHJ1ZTtcbiB9XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYGJpZ2ludCAke3NwZWNpbWVufSBtdXN0IG5vdCBoYXZlIG1vcmUgdGhhbiAke2RlY2ltYWxEaWdpdHNMaW1pdH0gZGlnaXRzYCk7XG5cbiB9O1xuXG4vKipcbiAqIEByZXR1cm5zIHtQYXR0ZXJuS2l0fVxuICovXG5jb25zdCBtYWtlUGF0dGVybktpdD0oKT0+e1xuLyoqXG4gKiBJZiB0aGlzIGlzIGEgcmVjb2duaXplZCBtYXRjaCB0YWcsIHJldHVybiB0aGUgTWF0Y2hIZWxwZXIuXG4gKiBPdGhlcndpc2UgcmVzdWx0IHVuZGVmaW5lZC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcmV0dXJucyB7TWF0Y2hIZWxwZXIgfCB1bmRlZmluZWR9XG4gKi9cbmNvbnN0IG1heWJlTWF0Y2hIZWxwZXI9KHRhZyk9PlxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbkhlbHBlcnNCeU1hdGNoVGFnW3RhZ107XG5cbi8qKlxuICogQHR5cGVkZWYge3N0cmluZ30gS2luZFxuICogSXQgaXMgZWl0aGVyIGEgUGFzc1N0eWxlIG90aGVyIHRoYW4gJ3RhZ2dlZCcsIG9yLCBpZiB0aGUgdW5kZXJseWluZ1xuICogUGFzc1N0eWxlIGlzICd0YWdnZWQnLCB0aGVuIHRoZSBgZ2V0VGFnYCB2YWx1ZSBmb3IgdGFncyB0aGF0IGFyZVxuICogcmVjb2duaXplZCBhdCB0aGUgc3RvcmUgbGV2ZWwgb2YgYWJzdHJhY3Rpb24uIEZvciBlYWNoIG9mIHRob3NlXG4gKiB0YWdzLCBhIHRhZ2dlZCByZWNvcmQgb25seSBoYXMgdGhhdCBraW5kIGlmIGl0IHNhdGlzZmllcyB0aGUgaW52YXJpYW50c1xuICogdGhhdCB0aGUgc3RvcmUgbGV2ZWwgYXNzb2NpYXRlcyB3aXRoIHRoYXQga2luZC5cbiAqL1xuXG4vKipcbiAqIEB0eXBlIHtXZWFrTWFwPENvcHlUYWdnZWQsIEtpbmQ+fVxuICogT25seSBmb3IgdGFnZ2VkIHJlY29yZHMgb2YgcmVjb2duaXplZCBraW5kcyB3aG9zZSBzdG9yZS1sZXZlbCBpbnZhcmlhbnRzXG4gKiBoYXZlIGFscmVhZHkgYmVlbiBjaGVja2VkLlxuICovXG5jb25zdCB0YWdNZW1vPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQ2hlY2tzIG9ubHkgcmVjb2duaXplZCB0YWdzLCBhbmQgb25seSBpZiB0aGUgdGFnZ2VkXG4gKiBwYXNzZXMgdGhlIGludmFyaWFudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgcmVjb2duaXRpb24uXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdGFnZ2VkXG4gKiBAcGFyYW0ge0tpbmR9IHRhZ1xuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrVGFnZ2VkPSh0YWdnZWQsdGFnLGNoZWNrKT0+e1xuY29uc3QgbWF0Y2hIZWxwZXI9bWF5YmVNYXRjaEhlbHBlcih0YWcpO1xuaWYobWF0Y2hIZWxwZXIpe1xuLyogQnVyaWVkIGhlcmUgaXMgdGhlIGltcG9ydGFudCBjYXNlLCB3aGVyZSB3ZSBwcm9jZXNzKi9cbi8qIHRoZSB2YXJpb3VzIHBhdHRlcm5Ob2RlcyovXG5yZXR1cm4gbWF0Y2hIZWxwZXIuY2hlY2tJc1dlbGxGb3JtZWQodGFnZ2VkLnBheWxvYWQsY2hlY2spO1xuIH1cbnN3aXRjaCh0YWcpe1xuY2FzZSdjb3B5U2V0Jzp7XG5yZXR1cm4gY2hlY2tDb3B5U2V0KHRhZ2dlZCxjaGVjayk7XG4gfVxuY2FzZSdjb3B5QmFnJzp7XG5yZXR1cm4gY2hlY2tDb3B5QmFnKHRhZ2dlZCxjaGVjayk7XG4gfVxuY2FzZSdjb3B5TWFwJzp7XG5yZXR1cm4gY2hlY2tDb3B5TWFwKHRhZ2dlZCxjaGVjayk7XG4gfVxuZGVmYXVsdDp7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYGNhbm5vdCBjaGVjayB1bnJlY29nbml6ZWQgdGFnICR7cSh0YWcpfTogJHt0YWdnZWR9YCk7XG5cbiB9fVxuXG4gfTtcblxuLyoqXG4gKiBSZXR1cm5zIG9ubHkgYSByZWNvZ25pemVkIGtpbmQsIGFuZCBvbmx5IGlmIHRoZSBzcGVjaW1lbiBwYXNzZXMgdGhlXG4gKiBpbnZhcmlhbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IHJlY29nbml0aW9uLlxuICogT3RoZXJ3aXNlLCBgY2hlY2soZmFsc2UsIC4uLilgIGFuZCByZXR1cm5zIHVuZGVmaW5lZFxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNwZWNpbWVuXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IFtjaGVja11cbiAqIEByZXR1cm5zIHtLaW5kIHwgdW5kZWZpbmVkfVxuICovXG5jb25zdCBraW5kT2Y9KHNwZWNpbWVuLGNoZWNrPWlkZW50Q2hlY2tlcik9PntcbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihzcGVjaW1lbik7XG5pZihwYXNzU3R5bGUhPT0ndGFnZ2VkJyl7XG5yZXR1cm4gcGFzc1N0eWxlO1xuIH1cbi8qIEF0IHRoaXMgcG9pbnQgd2Uga25vdyB0aGF0IHNwZWNpbWVuIGlzIGEgd2VsbCBmb3JtZWQqL1xuLyogYXMgYSB0YWdnZWQgcmVjb3JkLCB3aGljaCBpcyBkZWZpbmVkIGF0IHRoZSBtYXJzaGFsIGxldmVsIG9mIGFic3RyYWN0aW9uLCovXG4vKiBzaW5jZSBgcGFzc1N0eWxlT2ZgIGNoZWNrcyB0aG9zZSBpbnZhcmlhbnRzLiovXG5pZih0YWdNZW1vLmhhcyhzcGVjaW1lbikpe1xucmV0dXJuIHRhZ01lbW8uZ2V0KHNwZWNpbWVuKTtcbiB9XG5jb25zdCB0YWc9Z2V0VGFnKHNwZWNpbWVuKTtcbmlmKGNoZWNrVGFnZ2VkKHNwZWNpbWVuLHRhZyxjaGVjaykpe1xudGFnTWVtby5zZXQoc3BlY2ltZW4sdGFnKTtcbnJldHVybiB0YWc7XG4gfVxuaWYoY2hlY2shPT1pZGVudENoZWNrZXIpe1xuY2hlY2soZmFsc2UsWCBgY2Fubm90IGNoZWNrIHVucmVjb2duaXplZCB0YWcgJHtxKHRhZyl9YCk7XG4gfVxucmV0dXJuIHVuZGVmaW5lZDtcbiB9O1xuaGFyZGVuKGtpbmRPZik7XG5cbi8qKlxuICogQ2hlY2tzIG9ubHkgcmVjb2duaXplZCBraW5kcywgYW5kIG9ubHkgaWYgdGhlIHNwZWNpbWVuXG4gKiBwYXNzZXMgdGhlIGludmFyaWFudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgcmVjb2duaXRpb24uXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7S2luZH0ga2luZFxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrS2luZD0oc3BlY2ltZW4sa2luZCxjaGVjayk9PntcbmNvbnN0IHJlYWxLaW5kPWtpbmRPZihzcGVjaW1lbixjaGVjayk7XG5pZihraW5kPT09cmVhbEtpbmQpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoY2hlY2shPT1pZGVudENoZWNrZXIpe1xuLyogcXVvdGluZyB3aXRob3V0IHF1b3RlcyovXG5jb25zdCBkZXRhaWxzPVgoWyBgJHtyZWFsS2luZH0gYCxgIC0gTXVzdCBiZSBhICR7a2luZH1gXSxzcGVjaW1lbik7XG5jaGVjayhmYWxzZSxkZXRhaWxzKTtcbiB9XG5yZXR1cm4gZmFsc2U7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBzcGVjaW1lblxuICogQHBhcmFtIHtLZXl9IGtleUFzUGF0dGVyblxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrQXNLZXlQYXR0PShzcGVjaW1lbixrZXlBc1BhdHRlcm4sY2hlY2spPT57XG5pZihrZXlFUShzcGVjaW1lbixrZXlBc1BhdHRlcm4pKXtcbnJldHVybiB0cnVlO1xuIH1cbnJldHVybihcbmNoZWNrIT09aWRlbnRDaGVja2VyJiZcbmNoZWNrKGZhbHNlLFggYCR7c3BlY2ltZW59IC0gTXVzdCBiZTogJHtrZXlBc1BhdHRlcm59YCkpO1xuXG4gfTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gaXNQYXR0ZXJuIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqIEB0eXBlIHtDaGVja1BhdHRlcm59ICovXG5jb25zdCBjaGVja1BhdHRlcm49KHBhdHQsY2hlY2spPT57XG5pZihpc0tleShwYXR0KSl7XG4vKiBBbGwga2V5cyBhcmUgcGF0dGVybnMuIEZvciB0aGVzZSwgdGhlIGtleU1lbW8gd2lsbCBkby4qL1xuLyogQWxsIHByaW1pdGl2ZXMgdGhhdCBhcmUgcGF0dGVybnMgYXJlIGFsc28ga2V5cywgd2hpY2ggdGhpcyovXG4vKiBhbHNvIHRha2VzIGNhcmUgb2Ygd2l0aG91dCBtZW1vLiBUaGUgcmVzdCBvZiBvdXIgY2hlY2tpbmcgbG9naWMqL1xuLyogaXMgb25seSBjb25jZXJuZWQgd2l0aCBub24ta2V5IHBhdHRlcm5zLiovXG5yZXR1cm4gdHJ1ZTtcbiB9XG5pZihwYXR0ZXJuTWVtby5oYXMocGF0dCkpe1xucmV0dXJuIHRydWU7XG4gfVxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbmNvbnN0IHJlc3VsdD1jaGVja1BhdHRlcm5JbnRlcm5hbChwYXR0LGNoZWNrKTtcbmlmKHJlc3VsdCl7XG5wYXR0ZXJuTWVtby5hZGQocGF0dCk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHBhdHQgLSBrbm93biBub3QgdG8gYmUgYSBrZXksIGFuZCB0aGVyZWZvcmUga25vd25cbiAqIG5vdCB0byBiZSBwcmltaXRpdmUuXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tQYXR0ZXJuSW50ZXJuYWw9KHBhdHQsY2hlY2spPT57XG4vKiBQdXJwb3NlbHkgcGFyYWxsZWxzIGNoZWNrS2V5LiBUT0RPIHJldXNlIG1vcmUgbG9naWMgYmV0d2VlbiB0aGVtLiovXG4vKiBNb3N0IG9mIHRoZSB0ZXh0IG9mIHRoZSBzd2l0Y2ggYmVsb3cgbm90IGRlYWxpbmcgd2l0aCBtYXRjaGVycyBpcyovXG4vKiBlc3NlbnRpYWxseSBpZGVudGljYWwuKi9cbmNvbnN0IGNoZWNrSXQ9KGNoaWxkKT0+Y2hlY2tQYXR0ZXJuKGNoaWxkLGNoZWNrKTtcblxuY29uc3Qga2luZD1raW5kT2YocGF0dCxjaGVjayk7XG5zd2l0Y2goa2luZCl7XG5jYXNlIHVuZGVmaW5lZDp7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBBIGNvcHlSZWNvcmQgaXMgYSBwYXR0ZXJuIGlmZiBhbGwgaXRzIGNoaWxkcmVuIGFyZSovXG4vKiBwYXR0ZXJucyovXG5yZXR1cm4gdmFsdWVzKHBhdHQpLmV2ZXJ5KGNoZWNrSXQpO1xuIH1cbmNhc2UnY29weUFycmF5Jzp7XG4vKiBBIGNvcHlBcnJheSBpcyBhIHBhdHRlcm4gaWZmIGFsbCBpdHMgY2hpbGRyZW4gYXJlKi9cbi8qIHBhdHRlcm5zKi9cbnJldHVybiBwYXR0LmV2ZXJ5KGNoZWNrSXQpO1xuIH1cbmNhc2UnY29weU1hcCc6e1xuLyogQSBjb3B5TWFwJ3Mga2V5cyBhcmUga2V5cyBhbmQgdGhlcmVmb3JlIGFscmVhZHkga25vd24gdG8gYmUqL1xuLyogcGF0dGVybnMuKi9cbi8qIEEgY29weU1hcCBpcyBhIHBhdHRlcm4gaWYgaXRzIHZhbHVlcyBhcmUgcGF0dGVybnMuKi9cbnJldHVybiBjaGVja1BhdHRlcm4ocGF0dC52YWx1ZXMsY2hlY2spO1xuIH1cbmNhc2UnZXJyb3InOlxuY2FzZSdwcm9taXNlJzp7XG5yZXR1cm4gY2hlY2soZmFsc2UsWCBgQSAke3Eoa2luZCl9IGNhbm5vdCBiZSBhIHBhdHRlcm5gKTtcbiB9XG5kZWZhdWx0OntcbmlmKG1heWJlTWF0Y2hIZWxwZXIoa2luZCkhPT11bmRlZmluZWQpe1xucmV0dXJuIHRydWU7XG4gfVxucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGBBIHBhc3NhYmxlIG9mIGtpbmQgJHtxKGtpbmQpfSBpcyBub3QgYSBwYXR0ZXJuOiAke3BhdHR9YCk7XG5cbiB9fVxuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBwYXR0XG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgaXNQYXR0ZXJuPShwYXR0KT0+Y2hlY2tQYXR0ZXJuKHBhdHQsaWRlbnRDaGVja2VyKTtcblxuLyoqXG4gKiBAcGFyYW0ge1BhdHRlcm59IHBhdHRcbiAqL1xuY29uc3QgYXNzZXJ0UGF0dGVybj0ocGF0dCk9PntcbmNoZWNrUGF0dGVybihwYXR0LGFzc2VydENoZWNrZXIpO1xuIH07XG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIG1hdGNoZXMgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7UGF0dGVybn0gcGF0dGVyblxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHBhcmFtIHtzdHJpbmd8bnVtYmVyfSBbbGFiZWxdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tNYXRjaGVzPShzcGVjaW1lbixwYXR0ZXJuLGNoZWNrLGxhYmVsPXVuZGVmaW5lZCk9PlxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbmFwcGx5TGFiZWxpbmdFcnJvcihjaGVja01hdGNoZXNJbnRlcm5hbCxbc3BlY2ltZW4scGF0dGVybixjaGVja10sbGFiZWwpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNwZWNpbWVuXG4gKiBAcGFyYW0ge1BhdHRlcm59IHBhdHRcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja01hdGNoZXNJbnRlcm5hbD0oc3BlY2ltZW4scGF0dCxjaGVjayk9Pntcbi8qIFdvcnRoIGJlaW5nIGEgYml0IHZlcmJvc2UgYW5kIHJlcGV0aXRpdmUgaW4gb3JkZXIgdG8gb3B0aW1pemUqL1xuY29uc3QgcGF0dGVybktpbmQ9a2luZE9mKHBhdHQsY2hlY2spO1xuY29uc3Qgc3BlY2ltZW5LaW5kPWtpbmRPZihzcGVjaW1lbik7LyogbWF5IGJlIHVuZGVmaW5lZCovXG5zd2l0Y2gocGF0dGVybktpbmQpe1xuY2FzZSB1bmRlZmluZWQ6e1xucmV0dXJuIEZhaWwgYHBhdHRlcm4gZXhwZWN0ZWQ6ICR7cGF0dH1gO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xucmV0dXJuIEZhaWwgYHByb21pc2VzIGNhbm5vdCBiZSBwYXR0ZXJuczogJHtwYXR0fWA7XG4gfVxuY2FzZSdlcnJvcic6e1xucmV0dXJuIEZhaWwgYGVycm9ycyBjYW5ub3QgYmUgcGF0dGVybnM6ICR7cGF0dH1gO1xuIH1cbmNhc2UndW5kZWZpbmVkJzpcbmNhc2UnbnVsbCc6XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdudW1iZXInOlxuY2FzZSdiaWdpbnQnOlxuY2FzZSdzdHJpbmcnOlxuY2FzZSdzeW1ib2wnOlxuY2FzZSdjb3B5U2V0JzpcbmNhc2UnY29weUJhZyc6XG5jYXNlJ3JlbW90YWJsZSc6e1xuLyogVGhlc2Uga2luZHMgYXJlIG5lY2Vzc2FyaWx5IGtleXMqL1xucmV0dXJuIGNoZWNrQXNLZXlQYXR0KHNwZWNpbWVuLHBhdHQsY2hlY2spO1xuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5pZihpc0tleShwYXR0KSl7XG4vKiBUYWtlcyBjYXJlIG9mIHBhdHRlcm5zIHdoaWNoIGFyZSBrZXlzLCBzbyB0aGUgcmVzdCBvZiB0aGlzKi9cbi8qIGxvZ2ljIGNhbiBhc3N1bWUgcGF0dGVybnMgdGhhdCBhcmUgbm90IGtleXMuKi9cbnJldHVybiBjaGVja0FzS2V5UGF0dChzcGVjaW1lbixwYXR0LGNoZWNrKTtcbiB9XG5pZihzcGVjaW1lbktpbmQhPT0nY29weUFycmF5Jyl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYCR7c3BlY2ltZW59IC0gTXVzdCBiZSBhIGNvcHlBcnJheSB0byBtYXRjaCBhIGNvcHlBcnJheSBwYXR0ZXJuOiAke3BhdHR9YCk7XG5cbiB9XG5jb25zdHtsZW5ndGh9PXBhdHQ7XG5pZihzcGVjaW1lbi5sZW5ndGghPT1sZW5ndGgpe1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGBBcnJheSAke3NwZWNpbWVufSAtIE11c3QgYmUgYXMgbG9uZyBhcyBjb3B5QXJyYXkgcGF0dGVybjogJHtwYXR0fWApO1xuXG4gfVxucmV0dXJuIHBhdHQuZXZlcnkoKHAsaSk9PmNoZWNrTWF0Y2hlcyhzcGVjaW1lbltpXSxwLGNoZWNrLGkpKTtcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbmlmKGlzS2V5KHBhdHQpKXtcbi8qIFRha2VzIGNhcmUgb2YgcGF0dGVybnMgd2hpY2ggYXJlIGtleXMsIHNvIHRoZSByZXN0IG9mIHRoaXMqL1xuLyogbG9naWMgY2FuIGFzc3VtZSBwYXR0ZXJucyB0aGF0IGFyZSBub3Qga2V5cy4qL1xucmV0dXJuIGNoZWNrQXNLZXlQYXR0KHNwZWNpbWVuLHBhdHQsY2hlY2spO1xuIH1cbmlmKHNwZWNpbWVuS2luZCE9PSdjb3B5UmVjb3JkJyl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYCR7c3BlY2ltZW59IC0gTXVzdCBiZSBhIGNvcHlSZWNvcmQgdG8gbWF0Y2ggYSBjb3B5UmVjb3JkIHBhdHRlcm46ICR7cGF0dH1gKTtcblxuIH1cbi8qIFRPRE8gRGV0ZWN0IGFuZCBhY2N1bXVsYXRlIGRpZmZlcmVuY2UgaW4gb25lIHBhc3MuKi9cbi8qIFJhdGhlciB0aGFuIHVzaW5nIHR3byBjYWxscyB0byBgbGlzdERpZmZlcmVuY2VgIHRvIGRldGVjdCBhbmQqL1xuLyogcmVwb3J0IGlmIGFuZCBob3cgdGhlc2UgbGlzdHMgZGlmZmVyLCBzaW5jZSB0aGV5IGFyZSBhbHJlYWR5Ki9cbi8qIGluIHNvcnRlZCBvcmRlciwgd2Ugc2hvdWxkIGluc3RlYWQgdXNlIGFuIGFsZ29yaXRobSBsaWtlKi9cbi8qIGBpdGVyRGlzam9pbnRVbmlvbmAgZnJvbSBtZXJnZS1zb3J0LW9wZXJhdG9ycy5qcyovXG5jb25zdCBzcGVjaW1lbk5hbWVzPXJlY29yZE5hbWVzKHNwZWNpbWVuKTtcbmNvbnN0IHBhdHROYW1lcz1yZWNvcmROYW1lcyhwYXR0KTtcbmNvbnN0IG1pc3Npbmc9bGlzdERpZmZlcmVuY2UocGF0dE5hbWVzLHNwZWNpbWVuTmFtZXMpO1xuaWYobWlzc2luZy5sZW5ndGg+PTEpe1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGAke3NwZWNpbWVufSAtIE11c3QgaGF2ZSBtaXNzaW5nIHByb3BlcnRpZXMgJHtxKG1pc3NpbmcpfWApO1xuXG4gfVxuY29uc3QgdW5leHBlY3RlZD1saXN0RGlmZmVyZW5jZShzcGVjaW1lbk5hbWVzLHBhdHROYW1lcyk7XG5pZih1bmV4cGVjdGVkLmxlbmd0aD49MSl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYCR7c3BlY2ltZW59IC0gTXVzdCBub3QgaGF2ZSB1bmV4cGVjdGVkIHByb3BlcnRpZXM6ICR7cShcbnVuZXhwZWN0ZWQpXG4gfWApO1xuXG4gfVxuY29uc3Qgc3BlY2ltZW5WYWx1ZXM9cmVjb3JkVmFsdWVzKHNwZWNpbWVuLHNwZWNpbWVuTmFtZXMpO1xuY29uc3QgcGF0dFZhbHVlcz1yZWNvcmRWYWx1ZXMocGF0dCxwYXR0TmFtZXMpO1xucmV0dXJuIHBhdHROYW1lcy5ldmVyeSgobGFiZWwsaSk9PlxuY2hlY2tNYXRjaGVzKHNwZWNpbWVuVmFsdWVzW2ldLHBhdHRWYWx1ZXNbaV0sY2hlY2ssbGFiZWwpKTtcblxuIH1cbmNhc2UnY29weU1hcCc6e1xuaWYoaXNLZXkocGF0dCkpe1xuLyogVGFrZXMgY2FyZSBvZiBwYXR0ZXJucyB3aGljaCBhcmUga2V5cywgc28gdGhlIHJlc3Qgb2YgdGhpcyovXG4vKiBsb2dpYyBjYW4gYXNzdW1lIHBhdHRlcm5zIHRoYXQgYXJlIG5vdCBrZXlzLiovXG5yZXR1cm4gY2hlY2tBc0tleVBhdHQoc3BlY2ltZW4scGF0dCxjaGVjayk7XG4gfVxuaWYoc3BlY2ltZW5LaW5kIT09J2NvcHlNYXAnKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGJlIGEgY29weU1hcCB0byBtYXRjaCBhIGNvcHlNYXAgcGF0dGVybjogJHtwYXR0fWApO1xuXG4gfVxuY29uc3R7cGF5bG9hZDpwYXR0UGF5bG9hZH09cGF0dDtcbmNvbnN0e3BheWxvYWQ6c3BlY2ltZW5QYXlsb2FkfT1zcGVjaW1lbjtcbmNvbnN0IHBhdHRLZXlTZXQ9Y29weU1hcEtleVNldChwYXR0UGF5bG9hZCk7XG5jb25zdCBzcGVjaW1lbktleVNldD1jb3B5TWFwS2V5U2V0KHNwZWNpbWVuUGF5bG9hZCk7XG4vKiBDb21wYXJlIGtleXMgYXMgY29weVNldHMqL1xuaWYoIWNoZWNrTWF0Y2hlcyhzcGVjaW1lbktleVNldCxwYXR0S2V5U2V0LGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgcGF0dFZhbHVlcz1wYXR0UGF5bG9hZC52YWx1ZXM7XG5jb25zdCBzcGVjaW1lblZhbHVlcz1zcGVjaW1lblBheWxvYWQudmFsdWVzO1xuLyogY29tcGFyZSB2YWx1ZXMgYXMgY29weUFycmF5cyovXG5yZXR1cm4gY2hlY2tNYXRjaGVzKHNwZWNpbWVuVmFsdWVzLHBhdHRWYWx1ZXMsY2hlY2spO1xuIH1cbmRlZmF1bHQ6e1xuY29uc3QgbWF0Y2hIZWxwZXI9bWF5YmVNYXRjaEhlbHBlcihwYXR0ZXJuS2luZCk7XG5pZihtYXRjaEhlbHBlcil7XG5yZXR1cm4gbWF0Y2hIZWxwZXIuY2hlY2tNYXRjaGVzKHNwZWNpbWVuLHBhdHQucGF5bG9hZCxjaGVjayk7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IHNob3VsZCBoYXZlIHJlY29nbml6ZWQgJHtxKHBhdHRlcm5LaW5kKX0gYDtcbiB9fVxuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBzcGVjaW1lblxuICogQHBhcmFtIHtQYXR0ZXJufSBwYXR0XG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgbWF0Y2hlcz0oc3BlY2ltZW4scGF0dCk9PlxuY2hlY2tNYXRjaGVzKHNwZWNpbWVuLHBhdHQsaWRlbnRDaGVja2VyKTtcblxuLyoqXG4gKiBSZXR1cm5pbmcgbm9ybWFsbHkgaW5kaWNhdGVzIHN1Y2Nlc3MuIE1hdGNoIGZhaWx1cmUgaXMgaW5kaWNhdGVkIGJ5XG4gKiB0aHJvd2luZy5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBzcGVjaW1lblxuICogQHBhcmFtIHtQYXR0ZXJufSBwYXR0XG4gKiBAcGFyYW0ge3N0cmluZ3xudW1iZXJ9IFtsYWJlbF1cbiAqL1xuY29uc3QgbXVzdE1hdGNoPShzcGVjaW1lbixwYXR0LGxhYmVsPXVuZGVmaW5lZCk9PntcbmlmKGNoZWNrTWF0Y2hlcyhzcGVjaW1lbixwYXR0LGlkZW50Q2hlY2tlcixsYWJlbCkpe1xucmV0dXJuO1xuIH1cbi8qIHNob3VsZCBvbmx5IHRocm93Ki9cbmNoZWNrTWF0Y2hlcyhzcGVjaW1lbixwYXR0LGFzc2VydENoZWNrZXIsbGFiZWwpO1xuRmFpbCBgaW50ZXJuYWw6ICR7bGFiZWx9OiBpbmNvbnNpc3RlbnQgcGF0dGVybiBtYXRjaDogJHtxKHBhdHQpfWA7XG4gfTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gZ2V0UmFua0NvdmVyIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqIEB0eXBlIHtHZXRSYW5rQ292ZXJ9ICovXG5jb25zdCBnZXRSYW5rQ292ZXI9KHBhdHQsZW5jb2RlUGFzc2FibGUpPT57XG5pZihpc0tleShwYXR0KSl7XG5jb25zdCBlbmNvZGVkPWVuY29kZVBhc3NhYmxlKHBhdHQpO1xuaWYoZW5jb2RlZCE9PXVuZGVmaW5lZCl7XG5yZXR1cm5bZW5jb2RlZCwgYCR7ZW5jb2RlZH1+YF07XG4gfVxuIH1cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihwYXR0KTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdjb3B5QXJyYXknOntcbi8qIFhYWCB0aGlzIGRvZXNuJ3QgZ2V0IGFsb25nIHdpdGggdGhlIHdvcmxkIG9mIGNvdmVyID09PSBwYWlyIG9mKi9cbi8qIHN0cmluZ3MuIEluIHRoZSBtZWFudGltZSwgZmFsbCB0aHJvdWdoIHRvIHRoZSBkZWZhdWx0IHdoaWNoKi9cbi8qIHJldHVybnMgYSBjb3ZlciB0aGF0IGNvdmVycyBhbGwgY29weUFycmF5cy4qL1xuLyoqL1xuLyogY29uc3QgcmFua0NvdmVycyA9IHBhdHQubWFwKHAgPT4gZ2V0UmFua0NvdmVyKHAsIGVuY29kZVBhc3NhYmxlKSk7Ki9cbi8qIHJldHVybiBoYXJkZW4oWyovXG4vKiByYW5rQ292ZXJzLm1hcCgoW2xlZnQsIF9yaWdodF0pID0+IGxlZnQpLCovXG4vKiByYW5rQ292ZXJzLm1hcCgoW19sZWZ0LCByaWdodF0pID0+IHJpZ2h0KSwqL1xuLyogXSk7Ki9cbmJyZWFrO1xuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuLyogWFhYIHRoaXMgZG9lc24ndCBnZXQgYWxvbmcgd2l0aCB0aGUgd29ybGQgb2YgY292ZXIgPT09IHBhaXIgb2YqL1xuLyogc3RyaW5ncy4gSW4gdGhlIG1lYW50aW1lLCBmYWxsIHRocm91Z2ggdG8gdGhlIGRlZmF1bHQgd2hpY2gqL1xuLyogcmV0dXJucyBhIGNvdmVyIHRoYXQgY292ZXJzIGFsbCBjb3B5UmVjb3Jkcy4qL1xuLyoqL1xuLyogY29uc3QgcGF0dEtleXMgPSBvd25LZXlzKHBhdHQpOyovXG4vKiBjb25zdCBwYXR0RW50cmllcyA9IGhhcmRlbihwYXR0S2V5cy5tYXAoa2V5ID0+IFtrZXksIHBhdHRba2V5XV0pKTsqL1xuLyogY29uc3QgW2xlZnRFbnRyaWVzTGltaXQsIHJpZ2h0RW50cmllc0xpbWl0XSA9Ki9cbi8qIGdldFJhbmtDb3ZlcihwYXR0RW50cmllcyk7Ki9cbi8qIHJldHVybiBoYXJkZW4oWyovXG4vKiBmcm9tVW5pcXVlRW50cmllcyhsZWZ0RW50cmllc0xpbWl0KSwqL1xuLyogZnJvbVVuaXF1ZUVudHJpZXMocmlnaHRFbnRyaWVzTGltaXQpLCovXG4vKiBdKTsqL1xuYnJlYWs7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IHRhZz1nZXRUYWcocGF0dCk7XG5jb25zdCBtYXRjaEhlbHBlcj1tYXliZU1hdGNoSGVscGVyKHRhZyk7XG5pZihtYXRjaEhlbHBlcil7XG4vKiBCdXJpZWQgaGVyZSBpcyB0aGUgaW1wb3J0YW50IGNhc2UsIHdoZXJlIHdlIHByb2Nlc3MqL1xuLyogdGhlIHZhcmlvdXMgcGF0dGVybk5vZGVzKi9cbnJldHVybiBtYXRjaEhlbHBlci5nZXRSYW5rQ292ZXIocGF0dC5wYXlsb2FkLGVuY29kZVBhc3NhYmxlKTtcbiB9XG5zd2l0Y2godGFnKXtcbmNhc2UnY29weVNldCc6e1xuLyogWFhYIHRoaXMgZG9lc24ndCBnZXQgYWxvbmcgd2l0aCB0aGUgd29ybGQgb2YgY292ZXIgPT09IHBhaXIgb2YqL1xuLyogc3RyaW5ncy4gSW4gdGhlIG1lYW50aW1lLCBmYWxsIHRocm91Z2ggdG8gdGhlIGRlZmF1bHQgd2hpY2gqL1xuLyogcmV0dXJucyBhIGNvdmVyIHRoYXQgY292ZXJzIGFsbCBjb3B5U2V0cy4qL1xuLyoqL1xuLyogLy8gU2hvdWxkIGFscmVhZHkgYmUgdmFsaWRhdGVkIGJ5IGNoZWNrUGF0dGVybi4gQnV0IGJlY2F1c2UgdGhpcyovXG4vKiAvLyBpcyBhIGNoZWNrIHRoYXQgbWF5IGxvb3NlbiBvdmVyIHRpbWUsIHdlIGFsc28gYXNzZXJ0Ki9cbi8qIC8vIGV2ZXJ5d2hlcmUgd2Ugc3RpbGwgcmVseSBvbiB0aGUgcmVzdHJpY3Rpb24uKi9cbi8qIGBgYGpzKi9cbi8qIHBhdHQucGF5bG9hZC5sZW5ndGggPT09IDEgfHwqL1xuLyogRmFpbGBOb24tc2luZ2xldG9uIGNvcHlTZXRzIHdpdGggbWF0Y2hlciBub3QgeWV0IGltcGxlbWVudGVkOiAke3BhdHR9YDsqL1xuLyogYGBgKi9cbi8qKi9cbi8qIGNvbnN0IFtsZWZ0RWxlbWVudExpbWl0LCByaWdodEVsZW1lbnRMaW1pdF0gPSBnZXRSYW5rQ292ZXIoKi9cbi8qIHBhdHQucGF5bG9hZFswXSwqL1xuLyogKTsqL1xuLyogcmV0dXJuIGhhcmRlbihbKi9cbi8qIG1ha2VDb3B5U2V0KFtsZWZ0RWxlbWVudExpbWl0XSksKi9cbi8qIG1ha2VDb3B5U2V0KFtyaWdodEVsZW1lbnRMaW1pdF0pLCovXG4vKiBdKTsqL1xuYnJlYWs7XG4gfVxuY2FzZSdjb3B5TWFwJzp7XG4vKiBYWFggdGhpcyBkb2Vzbid0IGdldCBhbG9uZyB3aXRoIHRoZSB3b3JsZCBvZiBjb3ZlciA9PT0gcGFpciBvZiovXG4vKiBzdHJpbmdzLiBJbiB0aGUgbWVhbnRpbWUsIGZhbGwgdGhyb3VnaCB0byB0aGUgZGVmYXVsdCB3aGljaCovXG4vKiByZXR1cm5zIGEgY292ZXIgdGhhdCBjb3ZlcnMgYWxsIGNvcHlNYXBzLiovXG4vKiovXG4vKiAvLyBBIG1hdGNoaW5nIGNvcHlNYXAgbXVzdCBoYXZlIHRoZSBzYW1lIGtleXMsIG9yIGF0IG1vc3Qgb25lKi9cbi8qIC8vIG5vbi1rZXkga2V5IHBhdHRlcm4uIFRodXMgd2UgY2FuIGFzc3VtZSB0aGF0IHZhbHVlIHBvc2l0aW9ucyovXG4vKiAvLyBtYXRjaCAxLXRvLTEuKi9cbi8qIC8vKi9cbi8qIC8vIFRPRE8gSSBtYXkgYmUgb3Zlcmxvb2tpbmcgdGhhdCB0aGUgbGVzcyBwcmVjaXNlIHJhbmtPcmRlciovXG4vKiAvLyBlcXVpdmFsZW5jZSBjbGFzcyBtYXkgY2F1c2UgdmFsdWVzIHRvIGJlIG91dCBvZiBvcmRlciwqL1xuLyogLy8gbWFraW5nIHRoaXMgcmFua0NvdmVyIG5vdCBhY3R1YWxseSBjb3Zlci4gSW4gdGhhdCBjYXNlLCBmb3IqL1xuLyogLy8gYWxsIHRoZSB2YWx1ZXMgZm9yIGtleXMgYXQgdGhlIHNhbWUgcmFuaywgd2Ugc2hvdWxkIHVuaW9uIHRoZWlyKi9cbi8qIC8vIHJhbmsgY292ZXJzLiBUT0RPIFBPU1NJQkxFIFNJTEVOVCBDT1JSRUNUTkVTUyBCVUcqL1xuLyogLy8qL1xuLyogLy8gSWYgdGhpcyBpcyBhIGJ1ZywgaXQgcHJvYmFibHkgYWZmZWN0cyB0aGUgZ2V0UmFua0NvdmVyKi9cbi8qIC8vIGNhc2VzIG9mIG1hdGNoTFRFSGVscGVyIGFuZCBtYXRjaEdURUhlbHBlciBvbiBjb3B5TWFwIGFzKi9cbi8qIC8vIHdlbGwuIFNlZSBtYWtlQ29weU1hcCBmb3IgYW4gaWRlYSBvbiBmaXhpbmcqL1xuLyogLy8gdGhpcyBidWcuKi9cbi8qIGNvbnN0IFtsZWZ0UGF5bG9hZExpbWl0LCByaWdodFBheWxvYWRMaW1pdF0gPSBnZXRSYW5rQ292ZXIoKi9cbi8qIHBhdHQucGF5bG9hZCwqL1xuLyogZW5jb2RlUGFzc2FibGUsKi9cbi8qICk7Ki9cbi8qIHJldHVybiBoYXJkZW4oWyovXG4vKiBtYWtlVGFnZ2VkKCdjb3B5TWFwJywgbGVmdFBheWxvYWRMaW1pdCksKi9cbi8qIG1ha2VUYWdnZWQoJ2NvcHlNYXAnLCByaWdodFBheWxvYWRMaW1pdCksKi9cbi8qIF0pOyovXG5icmVhaztcbiB9XG5kZWZhdWx0OntcbmJyZWFrOy8qIGZhbGwgdGhyb3VnaCB0byBkZWZhdWx0Ki9cbiB9fVxuXG5icmVhazsvKiBmYWxsIHRocm91Z2ggdG8gZGVmYXVsdCovXG4gfVxuZGVmYXVsdDp7XG5icmVhazsvKiBmYWxsIHRocm91Z2ggdG8gZGVmYXVsdCovXG4gfX1cblxucmV0dXJuIGdldFBhc3NTdHlsZUNvdmVyKHBhc3NTdHlsZSk7XG4gfTtcblxuY29uc3QgYXJyYXlFdmVyeU1hdGNoUGF0dGVybj0oYXJyYXkscGF0dCxjaGVjayxsYWJlbFByZWZpeD0nJyk9PntcbmlmKGNoZWNrS2luZChwYXR0LCdtYXRjaDphbnknLGlkZW50Q2hlY2tlcikpe1xuLyogaWYgdGhlIHBhdHRlcm4gaXMgTS5hbnkoKSwgd2Uga25vdyBpdHMgdHJ1ZSovXG5yZXR1cm4gdHJ1ZTtcbiB9XG5yZXR1cm4gYXJyYXkuZXZlcnkoKGVsLGkpPT5cbmNoZWNrTWF0Y2hlcyhlbCxwYXR0LGNoZWNrLCBgJHtsYWJlbFByZWZpeH1bJHtpfV1gKSk7XG5cbiB9O1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBNYXRjaCBIZWxwZXJzIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hBbnlIZWxwZXI9RmFyKCdtYXRjaDphbnkgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KF9zcGVjaW1lbixfbWF0Y2hlclBheWxvYWQsX2NoZWNrKT0+dHJ1ZSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KG1hdGNoZXJQYXlsb2FkLGNoZWNrKT0+XG5tYXRjaGVyUGF5bG9hZD09PXVuZGVmaW5lZHx8XG5jaGVjayhmYWxzZSxYIGBtYXRjaDphbnkgcGF5bG9hZDogJHttYXRjaGVyUGF5bG9hZH0gLSBNdXN0IGJlIHVuZGVmaW5lZGApLFxuXG5nZXRSYW5rQ292ZXI6KF9tYXRjaFBheWxvYWQsX2VuY29kZVBhc3NhYmxlKT0+WycnLCd7J119KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hBbmRIZWxwZXI9RmFyKCdtYXRjaDphbmQgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLHBhdHRzLGNoZWNrKT0+e1xucmV0dXJuIHBhdHRzLmV2ZXJ5KChwYXR0KT0+Y2hlY2tNYXRjaGVzKHNwZWNpbWVuLHBhdHQsY2hlY2spKTtcbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDooYWxsZWdlZFBhdHRzLGNoZWNrKT0+e1xuY29uc3QgY2hlY2tJdD0ocGF0dCk9PmNoZWNrUGF0dGVybihwYXR0LGNoZWNrKTtcbnJldHVybihcbihwYXNzU3R5bGVPZihhbGxlZ2VkUGF0dHMpPT09J2NvcHlBcnJheSd8fFxuY2hlY2soZmFsc2UsWCBgTmVlZHMgYXJyYXkgb2Ygc3ViLXBhdHRlcm5zOiAke2FsbGVnZWRQYXR0c31gKSkmJlxuYWxsZWdlZFBhdHRzLmV2ZXJ5KGNoZWNrSXQpKTtcblxuIH0sXG5cbmdldFJhbmtDb3ZlcjoocGF0dHMsZW5jb2RlUGFzc2FibGUpPT5cbmludGVyc2VjdFJhbmtDb3ZlcnMoXG5jb21wYXJlUmFuayxcbnBhdHRzLm1hcCgocCk9PmdldFJhbmtDb3ZlcihwLGVuY29kZVBhc3NhYmxlKSkpfSk7XG5cblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hPckhlbHBlcj1GYXIoJ21hdGNoOm9yIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixwYXR0cyxjaGVjayk9PntcbmNvbnN0e2xlbmd0aH09cGF0dHM7XG5pZihsZW5ndGg9PT0wKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgJHtzcGVjaW1lbn0gLSBubyBwYXR0ZXJuIGRpc2p1bmN0cyB0byBtYXRjaDogJHtwYXR0c31gKTtcblxuIH1cbmlmKFxucGF0dHMubGVuZ3RoPT09MiYmXG4hbWF0Y2hlcyhzcGVjaW1lbixwYXR0c1swXSkmJlxuY2hlY2tLaW5kKHBhdHRzWzBdLCdtYXRjaDpraW5kJyxpZGVudENoZWNrZXIpJiZcbnBhdHRzWzBdLnBheWxvYWQ9PT0ndW5kZWZpbmVkJylcbntcbi8qIFdvcnRoIHNwZWNpYWwgY2FzaW5nIHRoZSBvcHRpb25hbCBwYXR0ZXJuIGZvciovXG4vKiBiZXR0ZXIgZXJyb3IgbWVzc2FnZXMuKi9cbnJldHVybiBjaGVja01hdGNoZXMoc3BlY2ltZW4scGF0dHNbMV0sY2hlY2spO1xuIH1cbmlmKHBhdHRzLnNvbWUoKHBhdHQpPT5tYXRjaGVzKHNwZWNpbWVuLHBhdHQpKSl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5yZXR1cm4gY2hlY2soZmFsc2UsWCBgJHtzcGVjaW1lbn0gLSBNdXN0IG1hdGNoIG9uZSBvZiAke3BhdHRzfWApO1xuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOm1hdGNoQW5kSGVscGVyLmNoZWNrSXNXZWxsRm9ybWVkLFxuXG5nZXRSYW5rQ292ZXI6KHBhdHRzLGVuY29kZVBhc3NhYmxlKT0+XG51bmlvblJhbmtDb3ZlcnMoXG5jb21wYXJlUmFuayxcbnBhdHRzLm1hcCgocCk9PmdldFJhbmtDb3ZlcihwLGVuY29kZVBhc3NhYmxlKSkpfSk7XG5cblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hOb3RIZWxwZXI9RmFyKCdtYXRjaDpub3QgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLHBhdHQsY2hlY2spPT57XG5pZihtYXRjaGVzKHNwZWNpbWVuLHBhdHQpKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGZhaWwgbmVnYXRlZCBwYXR0ZXJuOiAke3BhdHR9YCk7XG5cbiB9ZWxzZXtcbnJldHVybiB0cnVlO1xuIH1cbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDpjaGVja1BhdHRlcm4sXG5cbmdldFJhbmtDb3ZlcjooX3BhdHQsX2VuY29kZVBhc3NhYmxlKT0+WycnLCd7J119KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hTY2FsYXJIZWxwZXI9RmFyKCdtYXRjaDpzY2FsYXIgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLF9tYXRjaGVyUGF5bG9hZCxjaGVjayk9PlxuY2hlY2tTY2FsYXJLZXkoc3BlY2ltZW4sY2hlY2spLFxuXG5jaGVja0lzV2VsbEZvcm1lZDptYXRjaEFueUhlbHBlci5jaGVja0lzV2VsbEZvcm1lZCxcblxuZ2V0UmFua0NvdmVyOihfbWF0Y2hQYXlsb2FkLF9lbmNvZGVQYXNzYWJsZSk9PlsnYScsJ3p+J119KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hLZXlIZWxwZXI9RmFyKCdtYXRjaDprZXkgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLF9tYXRjaGVyUGF5bG9hZCxjaGVjayk9PlxuY2hlY2tLZXkoc3BlY2ltZW4sY2hlY2spLFxuXG5jaGVja0lzV2VsbEZvcm1lZDptYXRjaEFueUhlbHBlci5jaGVja0lzV2VsbEZvcm1lZCxcblxuZ2V0UmFua0NvdmVyOihfbWF0Y2hQYXlsb2FkLF9lbmNvZGVQYXNzYWJsZSk9PlsnYScsJ3p+J119KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hQYXR0ZXJuSGVscGVyPUZhcignbWF0Y2g6cGF0dGVybiBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sX21hdGNoZXJQYXlsb2FkLGNoZWNrKT0+XG5jaGVja1BhdHRlcm4oc3BlY2ltZW4sY2hlY2spLFxuXG5jaGVja0lzV2VsbEZvcm1lZDptYXRjaEFueUhlbHBlci5jaGVja0lzV2VsbEZvcm1lZCxcblxuZ2V0UmFua0NvdmVyOihfbWF0Y2hQYXlsb2FkLF9lbmNvZGVQYXNzYWJsZSk9PlsnYScsJ3p+J119KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hLaW5kSGVscGVyPUZhcignbWF0Y2g6a2luZCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczpjaGVja0tpbmQsXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihhbGxlZ2VkS2V5S2luZCxjaGVjayk9PlxudHlwZW9mIGFsbGVnZWRLZXlLaW5kPT09J3N0cmluZyd8fFxuY2hlY2soXG5mYWxzZSxcblggYG1hdGNoOmtpbmQ6IHBheWxvYWQ6ICR7YWxsZWdlZEtleUtpbmR9IC0gQSBraW5kIG5hbWUgbXVzdCBiZSBhIHN0cmluZ2ApLFxuXG5cbmdldFJhbmtDb3Zlcjooa2luZCxfZW5jb2RlUGFzc2FibGUpPT57XG5sZXQgc3R5bGU7XG5zd2l0Y2goa2luZCl7XG5jYXNlJ2NvcHlTZXQnOlxuY2FzZSdjb3B5TWFwJzp7XG5zdHlsZT0ndGFnZ2VkJztcbmJyZWFrO1xuIH1cbmRlZmF1bHQ6e1xuc3R5bGU9a2luZDtcbmJyZWFrO1xuIH19XG5cbnJldHVybiBnZXRQYXNzU3R5bGVDb3ZlcihzdHlsZSk7XG4gfX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEJpZ2ludEhlbHBlcj1GYXIoJ21hdGNoOmJpZ2ludCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sW2xpbWl0cz11bmRlZmluZWRdLGNoZWNrKT0+e1xuY29uc3R7ZGVjaW1hbERpZ2l0c0xpbWl0fT1saW1pdChsaW1pdHMpO1xucmV0dXJuKFxuY2hlY2tLaW5kKHNwZWNpbWVuLCdiaWdpbnQnLGNoZWNrKSYmXG5jaGVja0RlY2ltYWxEaWdpdHNMaW1pdChzcGVjaW1lbixkZWNpbWFsRGlnaXRzTGltaXQsY2hlY2spKTtcblxuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihwYXlsb2FkLGNoZWNrKT0+XG5jaGVja0lzV2VsbEZvcm1lZFdpdGhMaW1pdChcbnBheWxvYWQsXG5oYXJkZW4oW10pLFxuY2hlY2ssXG4nbWF0Y2g6YmlnaW50IHBheWxvYWQnKSxcblxuXG5nZXRSYW5rQ292ZXI6KF9tYXRjaFBheWxvYWQsX2VuY29kZVBhc3NhYmxlKT0+XG5nZXRQYXNzU3R5bGVDb3ZlcignYmlnaW50Jyl9KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hOYXRIZWxwZXI9RmFyKCdtYXRjaDpuYXQgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLFtsaW1pdHM9dW5kZWZpbmVkXSxjaGVjayk9PntcbmNvbnN0e2RlY2ltYWxEaWdpdHNMaW1pdH09bGltaXQobGltaXRzKTtcbnJldHVybihcbmNoZWNrS2luZChzcGVjaW1lbiwnYmlnaW50JyxjaGVjaykmJlxuY2hlY2soXG4vKiogQHR5cGUge2JpZ2ludH0gKi9zcGVjaW1lbj49MG4sXG5YIGAke3NwZWNpbWVufSAtIE11c3QgYmUgbm9uLW5lZ2F0aXZlYCkmJlxuXG5jaGVja0RlY2ltYWxEaWdpdHNMaW1pdChzcGVjaW1lbixkZWNpbWFsRGlnaXRzTGltaXQsY2hlY2spKTtcblxuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihwYXlsb2FkLGNoZWNrKT0+XG5jaGVja0lzV2VsbEZvcm1lZFdpdGhMaW1pdChcbnBheWxvYWQsXG5oYXJkZW4oW10pLFxuY2hlY2ssXG4nbWF0Y2g6bmF0IHBheWxvYWQnKSxcblxuXG5nZXRSYW5rQ292ZXI6KF9tYXRjaFBheWxvYWQsX2VuY29kZVBhc3NhYmxlKT0+XG4vKiBUT0RPIENvdWxkIGJlIG1vcmUgcHJlY2lzZSovXG5nZXRQYXNzU3R5bGVDb3ZlcignYmlnaW50Jyl9KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hTdHJpbmdIZWxwZXI9RmFyKCdtYXRjaDpzdHJpbmcgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLFtsaW1pdHM9dW5kZWZpbmVkXSxjaGVjayk9PntcbmNvbnN0e3N0cmluZ0xlbmd0aExpbWl0fT1saW1pdChsaW1pdHMpO1xuLyogcHJldHRpZXItaWdub3JlKi9cbnJldHVybihcbmNoZWNrS2luZChzcGVjaW1lbiwnc3RyaW5nJyxjaGVjaykmJihcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAZW5kby9yZXN0cmljdC1jb21wYXJpc29uLW9wZXJhbmRzKi9cbi8qKiBAdHlwZSB7c3RyaW5nfSAqL3NwZWNpbWVuLmxlbmd0aDw9c3RyaW5nTGVuZ3RoTGltaXR8fFxuY2hlY2soXG5mYWxzZSxcblggYHN0cmluZyAke3NwZWNpbWVufSBtdXN0IG5vdCBiZSBiaWdnZXIgdGhhbiAke3N0cmluZ0xlbmd0aExpbWl0fWApKSk7XG5cblxuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihwYXlsb2FkLGNoZWNrKT0+XG5jaGVja0lzV2VsbEZvcm1lZFdpdGhMaW1pdChcbnBheWxvYWQsXG5oYXJkZW4oW10pLFxuY2hlY2ssXG4nbWF0Y2g6c3RyaW5nIHBheWxvYWQnKSxcblxuXG5nZXRSYW5rQ292ZXI6KF9tYXRjaFBheWxvYWQsX2VuY29kZVBhc3NhYmxlKT0+XG5nZXRQYXNzU3R5bGVDb3Zlcignc3RyaW5nJyl9KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hTeW1ib2xIZWxwZXI9RmFyKCdtYXRjaDpzeW1ib2wgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLFtsaW1pdHM9dW5kZWZpbmVkXSxjaGVjayk9PntcbmNvbnN0e3N5bWJvbE5hbWVMZW5ndGhMaW1pdH09bGltaXQobGltaXRzKTtcbmlmKCFjaGVja0tpbmQoc3BlY2ltZW4sJ3N5bWJvbCcsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdCBzeW1ib2xOYW1lPW5hbWVGb3JQYXNzYWJsZVN5bWJvbChzcGVjaW1lbik7XG5cbmlmKHR5cGVvZiBzeW1ib2xOYW1lIT09J3N0cmluZycpe1xudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFBhc3NhYmxlIHN5bWJvbCAke3NwZWNpbWVufSBtdXN0IGhhdmUgYSBwYXNzYWJsZSBuYW1lYDtcbiB9XG5yZXR1cm4gY2hlY2soXG5zeW1ib2xOYW1lLmxlbmd0aDw9c3ltYm9sTmFtZUxlbmd0aExpbWl0LFxuWCBgU3ltYm9sIG5hbWUgJHtxKFxuc3ltYm9sTmFtZSlcbiB9IG11c3Qgbm90IGJlIGJpZ2dlciB0aGFuICR7c3ltYm9sTmFtZUxlbmd0aExpbWl0fWApO1xuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbXSksXG5jaGVjayxcbidtYXRjaDpzeW1ib2wgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooX21hdGNoUGF5bG9hZCxfZW5jb2RlUGFzc2FibGUpPT5cbmdldFBhc3NTdHlsZUNvdmVyKCdzeW1ib2wnKX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFJlbW90YWJsZUhlbHBlcj1GYXIoJ21hdGNoOnJlbW90YWJsZSBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4scmVtb3RhYmxlRGVzYyxjaGVjayk9Pntcbi8qIFVuZm9ydHVuYXRlIGR1cGxpY2F0aW9uIG9mIGNoZWNrS2luZCBsb2dpYywgYnV0IG5vIGJldHRlciBjaG9pY2VzLiovXG5pZihjaGVja0tpbmQoc3BlY2ltZW4sJ3JlbW90YWJsZScsaWRlbnRDaGVja2VyKSl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5pZihjaGVjaz09PWlkZW50Q2hlY2tlcil7XG5yZXR1cm4gZmFsc2U7XG4gfVxubGV0IHNwZWNpbWVuS2luZD1wYXNzU3R5bGVPZihzcGVjaW1lbik7XG5pZihzcGVjaW1lbktpbmQ9PT0ndGFnZ2VkJyl7XG5zcGVjaW1lbktpbmQ9Z2V0VGFnKHNwZWNpbWVuKTtcbiB9XG5jb25zdHtsYWJlbH09cmVtb3RhYmxlRGVzYztcblxuLyogcXVvdGluZyB3aXRob3V0IHF1b3RlcyovXG5jb25zdCBkZXRhaWxzPVgoXG5bIGAke3NwZWNpbWVuS2luZH0gYCxgIC0gTXVzdCBiZSBhIHJlbW90YWJsZSAoJHtsYWJlbH0pYF0sXG5zcGVjaW1lbik7XG5cbnJldHVybiBjaGVjayhmYWxzZSxkZXRhaWxzKTtcbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDooYWxsZWdlZFJlbW90YWJsZURlc2MsY2hlY2spPT5cbmNoZWNrTWF0Y2hlcyhcbmFsbGVnZWRSZW1vdGFibGVEZXNjLFxuaGFyZGVuKHtsYWJlbDpNTS5zdHJpbmcoKX0pLFxuY2hlY2ssXG4nbWF0Y2g6cmVtb3RhYmxlIHBheWxvYWQnKSxcblxuXG5nZXRSYW5rQ292ZXI6KF9yZW1vdGFibGVEZXNjLF9lbmNvZGVQYXNzYWJsZSk9PlxuZ2V0UGFzc1N0eWxlQ292ZXIoJ3JlbW90YWJsZScpfSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoTFRFSGVscGVyPUZhcignbWF0Y2g6bHRlIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixyaWdodE9wZXJhbmQsY2hlY2spPT5cbmtleUxURShzcGVjaW1lbixyaWdodE9wZXJhbmQpfHxcbmNoZWNrKGZhbHNlLFggYCR7c3BlY2ltZW59IC0gTXVzdCBiZSA8PSAke3JpZ2h0T3BlcmFuZH1gKSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6Y2hlY2tLZXksXG5cbmdldFJhbmtDb3ZlcjoocmlnaHRPcGVyYW5kLGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHJpZ2h0T3BlcmFuZCk7XG4vKiBUaGUgcHJlZmVyLWNvbnN0IG1ha2VzIG5vIHNlbnNlIHdoZW4gc29tZSBvZiB0aGUgdmFyaWFibGVzIG5lZWQqL1xuLyogdG8gYmUgYGxldGAqL1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIHByZWZlci1jb25zdCovXG5sZXRbbGVmdEJvdW5kLHJpZ2h0Qm91bmRdPWdldFBhc3NTdHlsZUNvdmVyKHBhc3NTdHlsZSk7XG5jb25zdCBuZXdSaWdodEJvdW5kPSBgJHtlbmNvZGVQYXNzYWJsZShyaWdodE9wZXJhbmQpfX5gO1xuaWYobmV3UmlnaHRCb3VuZCE9PXVuZGVmaW5lZCl7XG5yaWdodEJvdW5kPW5ld1JpZ2h0Qm91bmQ7XG4gfVxucmV0dXJuW2xlZnRCb3VuZCxyaWdodEJvdW5kXTtcbiB9fSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoTFRIZWxwZXI9RmFyKCdtYXRjaDpsdCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4scmlnaHRPcGVyYW5kLGNoZWNrKT0+XG5rZXlMVChzcGVjaW1lbixyaWdodE9wZXJhbmQpfHxcbmNoZWNrKGZhbHNlLFggYCR7c3BlY2ltZW59IC0gTXVzdCBiZSA8ICR7cmlnaHRPcGVyYW5kfWApLFxuXG5jaGVja0lzV2VsbEZvcm1lZDpjaGVja0tleSxcblxuZ2V0UmFua0NvdmVyOm1hdGNoTFRFSGVscGVyLmdldFJhbmtDb3Zlcn0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEdURUhlbHBlcj1GYXIoJ21hdGNoOmd0ZSBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4scmlnaHRPcGVyYW5kLGNoZWNrKT0+XG5rZXlHVEUoc3BlY2ltZW4scmlnaHRPcGVyYW5kKXx8XG5jaGVjayhmYWxzZSxYIGAke3NwZWNpbWVufSAtIE11c3QgYmUgPj0gJHtyaWdodE9wZXJhbmR9YCksXG5cbmNoZWNrSXNXZWxsRm9ybWVkOmNoZWNrS2V5LFxuXG5nZXRSYW5rQ292ZXI6KHJpZ2h0T3BlcmFuZCxlbmNvZGVQYXNzYWJsZSk9PntcbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZihyaWdodE9wZXJhbmQpO1xuLyogVGhlIHByZWZlci1jb25zdCBtYWtlcyBubyBzZW5zZSB3aGVuIHNvbWUgb2YgdGhlIHZhcmlhYmxlcyBuZWVkKi9cbi8qIHRvIGJlIGBsZXRgKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBwcmVmZXItY29uc3QqL1xubGV0W2xlZnRCb3VuZCxyaWdodEJvdW5kXT1nZXRQYXNzU3R5bGVDb3ZlcihwYXNzU3R5bGUpO1xuY29uc3QgbmV3TGVmdEJvdW5kPWVuY29kZVBhc3NhYmxlKHJpZ2h0T3BlcmFuZCk7XG5pZihuZXdMZWZ0Qm91bmQhPT11bmRlZmluZWQpe1xubGVmdEJvdW5kPW5ld0xlZnRCb3VuZDtcbiB9XG5yZXR1cm5bbGVmdEJvdW5kLHJpZ2h0Qm91bmRdO1xuIH19KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hHVEhlbHBlcj1GYXIoJ21hdGNoOmd0IGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixyaWdodE9wZXJhbmQsY2hlY2spPT5cbmtleUdUKHNwZWNpbWVuLHJpZ2h0T3BlcmFuZCl8fFxuY2hlY2soZmFsc2UsWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGJlID4gJHtyaWdodE9wZXJhbmR9YCksXG5cbmNoZWNrSXNXZWxsRm9ybWVkOmNoZWNrS2V5LFxuXG5nZXRSYW5rQ292ZXI6bWF0Y2hHVEVIZWxwZXIuZ2V0UmFua0NvdmVyfSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoUmVjb3JkT2ZIZWxwZXI9RmFyKCdtYXRjaDpyZWNvcmRPZiBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooXG5zcGVjaW1lbixcbltrZXlQYXR0LHZhbHVlUGF0dCxsaW1pdHM9dW5kZWZpbmVkXSxcbmNoZWNrKT0+XG57XG5jb25zdHtudW1Qcm9wZXJ0aWVzTGltaXQscHJvcGVydHlOYW1lTGVuZ3RoTGltaXR9PWxpbWl0KGxpbWl0cyk7XG5yZXR1cm4oXG5jaGVja0tpbmQoc3BlY2ltZW4sJ2NvcHlSZWNvcmQnLGNoZWNrKSYmXG5jaGVjayhcbm93bktleXMoc3BlY2ltZW4pLmxlbmd0aDw9bnVtUHJvcGVydGllc0xpbWl0LFxuWCBgTXVzdCBub3QgaGF2ZSBtb3JlIHRoYW4gJHtxKFxubnVtUHJvcGVydGllc0xpbWl0KVxuIH0gcHJvcGVydGllczogJHtzcGVjaW1lbn1gKSYmXG5cbmVudHJpZXMoc3BlY2ltZW4pLmV2ZXJ5KFxuKFtrZXksdmFsdWVdKT0+XG5hcHBseUxhYmVsaW5nRXJyb3IoXG5jaGVjayxcbltcbmtleS5sZW5ndGg8PXByb3BlcnR5TmFtZUxlbmd0aExpbWl0LFxuWCBgUHJvcGVydHkgbmFtZSBtdXN0IG5vdCBiZSBsb25nZXIgdGhhbiAke3EoXG5wcm9wZXJ0eU5hbWVMZW5ndGhMaW1pdClcbiB9YF0sXG5cbmtleSkmJlxuXG5jaGVja01hdGNoZXMoXG5oYXJkZW4oW2tleSx2YWx1ZV0pLFxuaGFyZGVuKFtrZXlQYXR0LHZhbHVlUGF0dF0pLFxuY2hlY2ssXG5rZXkpKSk7XG5cblxuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbTU0ucGF0dGVybigpLE1NLnBhdHRlcm4oKV0pLFxuY2hlY2ssXG4nbWF0Y2g6cmVjb3JkT2YgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooX2VudHJ5UGF0dCk9PmdldFBhc3NTdHlsZUNvdmVyKCdjb3B5UmVjb3JkJyl9KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hBcnJheU9mSGVscGVyPUZhcignbWF0Y2g6YXJyYXlPZiBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sW3N1YlBhdHQsbGltaXRzPXVuZGVmaW5lZF0sY2hlY2spPT57XG5jb25zdHthcnJheUxlbmd0aExpbWl0fT1saW1pdChsaW1pdHMpO1xuLyogcHJldHRpZXItaWdub3JlKi9cbnJldHVybihcbmNoZWNrS2luZChzcGVjaW1lbiwnY29weUFycmF5JyxjaGVjaykmJihcbi8qKiBAdHlwZSB7QXJyYXl9ICovc3BlY2ltZW4ubGVuZ3RoPD1hcnJheUxlbmd0aExpbWl0fHxcbmNoZWNrKFxuZmFsc2UsXG5YIGBBcnJheSBsZW5ndGggJHtzcGVjaW1lbi5sZW5ndGh9IG11c3QgYmUgPD0gbGltaXQgJHthcnJheUxlbmd0aExpbWl0fWApKSYmXG5cbmFycmF5RXZlcnlNYXRjaFBhdHRlcm4oc3BlY2ltZW4sc3ViUGF0dCxjaGVjaykpO1xuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbTU0ucGF0dGVybigpXSksXG5jaGVjayxcbidtYXRjaDphcnJheU9mIHBheWxvYWQnKSxcblxuXG5nZXRSYW5rQ292ZXI6KCk9PmdldFBhc3NTdHlsZUNvdmVyKCdjb3B5QXJyYXknKX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFNldE9mSGVscGVyPUZhcignbWF0Y2g6c2V0T2YgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLFtrZXlQYXR0LGxpbWl0cz11bmRlZmluZWRdLGNoZWNrKT0+e1xuY29uc3R7bnVtU2V0RWxlbWVudHNMaW1pdH09bGltaXQobGltaXRzKTtcbnJldHVybihcbmNoZWNrS2luZChzcGVjaW1lbiwnY29weVNldCcsY2hlY2spJiZcbmNoZWNrKFxuLyoqIEB0eXBlIHtBcnJheX0gKi9zcGVjaW1lbi5wYXlsb2FkLmxlbmd0aDxudW1TZXRFbGVtZW50c0xpbWl0LFxuWCBgU2V0IG11c3Qgbm90IGhhdmUgbW9yZSB0aGFuICR7cShudW1TZXRFbGVtZW50c0xpbWl0KX0gZWxlbWVudHM6ICR7XG5zcGVjaW1lbi5wYXlsb2FkLmxlbmd0aFxuIH1gKSYmXG5cbmFycmF5RXZlcnlNYXRjaFBhdHRlcm4oc3BlY2ltZW4ucGF5bG9hZCxrZXlQYXR0LGNoZWNrLCdzZXQgZWxlbWVudHMnKSk7XG5cbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDoocGF5bG9hZCxjaGVjayk9PlxuY2hlY2tJc1dlbGxGb3JtZWRXaXRoTGltaXQoXG5wYXlsb2FkLFxuaGFyZGVuKFtNTS5wYXR0ZXJuKCldKSxcbmNoZWNrLFxuJ21hdGNoOnNldE9mIHBheWxvYWQnKSxcblxuXG5nZXRSYW5rQ292ZXI6KCk9PmdldFBhc3NTdHlsZUNvdmVyKCd0YWdnZWQnKX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEJhZ09mSGVscGVyPUZhcignbWF0Y2g6YmFnT2YgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KFxuc3BlY2ltZW4sXG5ba2V5UGF0dCxjb3VudFBhdHQsbGltaXRzPXVuZGVmaW5lZF0sXG5jaGVjayk9Plxue1xuY29uc3R7bnVtVW5pcXVlQmFnRWxlbWVudHNMaW1pdCxkZWNpbWFsRGlnaXRzTGltaXR9PWxpbWl0KGxpbWl0cyk7XG5yZXR1cm4oXG5jaGVja0tpbmQoc3BlY2ltZW4sJ2NvcHlCYWcnLGNoZWNrKSYmXG5jaGVjayhcbi8qKiBAdHlwZSB7QXJyYXl9ICovc3BlY2ltZW4ucGF5bG9hZC5sZW5ndGg8PVxubnVtVW5pcXVlQmFnRWxlbWVudHNMaW1pdCxcblggYEJhZyBtdXN0IG5vdCBoYXZlIG1vcmUgdGhhbiAke3EoXG5udW1VbmlxdWVCYWdFbGVtZW50c0xpbWl0KVxuIH0gdW5pcXVlIGVsZW1lbnRzOiAke3NwZWNpbWVufWApJiZcblxuc3BlY2ltZW4ucGF5bG9hZC5ldmVyeShcbihba2V5LGNvdW50XSxpKT0+XG5jaGVja01hdGNoZXMoa2V5LGtleVBhdHQsY2hlY2ssIGBiYWcga2V5c1ske2l9XWApJiZcbmFwcGx5TGFiZWxpbmdFcnJvcihcbmNoZWNrRGVjaW1hbERpZ2l0c0xpbWl0LFxuW2NvdW50LGRlY2ltYWxEaWdpdHNMaW1pdCxjaGVja10sXG4gYGJhZyBjb3VudHNbJHtpfV1gKSYmXG5cbmNoZWNrTWF0Y2hlcyhjb3VudCxjb3VudFBhdHQsY2hlY2ssIGBiYWcgY291bnRzWyR7aX1dYCkpKTtcblxuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbTU0ucGF0dGVybigpLE1NLnBhdHRlcm4oKV0pLFxuY2hlY2ssXG4nbWF0Y2g6YmFnT2YgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooKT0+Z2V0UGFzc1N0eWxlQ292ZXIoJ3RhZ2dlZCcpfSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoTWFwT2ZIZWxwZXI9RmFyKCdtYXRjaDptYXBPZiBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooXG5zcGVjaW1lbixcbltrZXlQYXR0LHZhbHVlUGF0dCxsaW1pdHM9dW5kZWZpbmVkXSxcbmNoZWNrKT0+XG57XG5jb25zdHtudW1NYXBFbnRyaWVzTGltaXR9PWxpbWl0KGxpbWl0cyk7XG5yZXR1cm4oXG5jaGVja0tpbmQoc3BlY2ltZW4sJ2NvcHlNYXAnLGNoZWNrKSYmXG5jaGVjayhcbi8qKiBAdHlwZSB7QXJyYXl9ICovc3BlY2ltZW4ucGF5bG9hZC5rZXlzLmxlbmd0aDw9XG5udW1NYXBFbnRyaWVzTGltaXQsXG5YIGBDb3B5TWFwIG11c3QgaGF2ZSBubyBtb3JlIHRoYW4gJHtxKFxubnVtTWFwRW50cmllc0xpbWl0KVxuIH0gZW50cmllczogJHtzcGVjaW1lbn1gKSYmXG5cbmFycmF5RXZlcnlNYXRjaFBhdHRlcm4oXG5zcGVjaW1lbi5wYXlsb2FkLmtleXMsXG5rZXlQYXR0LFxuY2hlY2ssXG4nbWFwIGtleXMnKSYmXG5cbmFycmF5RXZlcnlNYXRjaFBhdHRlcm4oXG5zcGVjaW1lbi5wYXlsb2FkLnZhbHVlcyxcbnZhbHVlUGF0dCxcbmNoZWNrLFxuJ21hcCB2YWx1ZXMnKSk7XG5cblxuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihwYXlsb2FkLGNoZWNrKT0+XG5jaGVja0lzV2VsbEZvcm1lZFdpdGhMaW1pdChcbnBheWxvYWQsXG5oYXJkZW4oW01NLnBhdHRlcm4oKSxNTS5wYXR0ZXJuKCldKSxcbmNoZWNrLFxuJ21hdGNoOm1hcE9mIHBheWxvYWQnKSxcblxuXG5nZXRSYW5rQ292ZXI6KF9lbnRyeVBhdHQpPT5nZXRQYXNzU3R5bGVDb3ZlcigndGFnZ2VkJyl9KTtcblxuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7UGF0dGVybltdfSByZXF1aXJlZFBhdHRcbiAqIEBwYXJhbSB7UGF0dGVybltdfSBvcHRpb25hbFBhdHRcbiAqIEByZXR1cm5zIHt7XG4gKiAgIHJlcXVpcmVkU3BlY2ltZW46IFBhc3NhYmxlW10sXG4gKiAgIG9wdGlvbmFsU3BlY2ltZW46IFBhc3NhYmxlW10sXG4gKiAgIHJlc3RTcGVjaW1lbjogUGFzc2FibGVbXVxuICogfX1cbiAqL1xuY29uc3Qgc3BsaXRBcnJheVBhcnRzPShzcGVjaW1lbixyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0KT0+e1xuY29uc3QgbnVtUmVxdWlyZWQ9cmVxdWlyZWRQYXR0Lmxlbmd0aDtcbmNvbnN0IG51bU9wdGlvbmFsPW9wdGlvbmFsUGF0dC5sZW5ndGg7XG5jb25zdCByZXF1aXJlZFNwZWNpbWVuPXNwZWNpbWVuLnNsaWNlKDAsbnVtUmVxdWlyZWQpO1xuY29uc3Qgb3B0aW9uYWxTcGVjaW1lbj1zcGVjaW1lbi5zbGljZShcbm51bVJlcXVpcmVkLFxubnVtUmVxdWlyZWQrbnVtT3B0aW9uYWwpO1xuXG5jb25zdCByZXN0U3BlY2ltZW49c3BlY2ltZW4uc2xpY2UobnVtUmVxdWlyZWQrbnVtT3B0aW9uYWwpO1xucmV0dXJuIGhhcmRlbih7cmVxdWlyZWRTcGVjaW1lbixvcHRpb25hbFNwZWNpbWVuLHJlc3RTcGVjaW1lbn0pO1xuIH07XG5cbi8qKlxuICogT3B0aW9uYWwgc3BlY2ltZW4gZWxlbWVudHMgd2hpY2ggYXJlIGB1bmRlZmluZWRgIHBhc3MgdW5jb25kaXRpb25hbGx5LlxuICogV2UgZW5jb2RlIHRoaXMgd2l0aCB0aGUgYE0ub3JgIHBhdHRlcm4gc28gaXQgYWxzbyBwcm9kdWNlcyBhIGdvb2RcbiAqIGNvbXByZXNzaW9uIGRpc3Rpbmd1aXNoaW5nIGB1bmRlZmluZWRgIGZyb20gYWJzZW5jZS5cbiAqXG4gKiBAcGFyYW0ge1BhdHRlcm5bXX0gb3B0aW9uYWxQYXR0XG4gKiBAcGFyYW0ge251bWJlcn0gbGVuZ3RoXG4gKiBAcmV0dXJucyB7UGF0dGVybltdfSBUaGUgcGFydGlhbFBhdHRcbiAqL1xuY29uc3QgYWRhcHRBcnJheVBhdHRlcm49KG9wdGlvbmFsUGF0dCxsZW5ndGgpPT5cbmhhcmRlbihvcHRpb25hbFBhdHQuc2xpY2UoMCxsZW5ndGgpLm1hcCgocGF0dCk9Pk1NLm9wdChwYXR0KSkpO1xuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hTcGxpdEFycmF5SGVscGVyPUZhcignbWF0Y2g6c3BsaXRBcnJheSBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooXG5zcGVjaW1lbixcbltyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0PVtdLHJlc3RQYXR0PU1NLmFueSgpXSxcbmNoZWNrKT0+XG57XG5pZighY2hlY2tLaW5kKHNwZWNpbWVuLCdjb3B5QXJyYXknLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3R7cmVxdWlyZWRTcGVjaW1lbixvcHRpb25hbFNwZWNpbWVuLHJlc3RTcGVjaW1lbn09XG5zcGxpdEFycmF5UGFydHMoc3BlY2ltZW4scmVxdWlyZWRQYXR0LG9wdGlvbmFsUGF0dCk7XG5jb25zdCBwYXJ0aWFsUGF0dD1hZGFwdEFycmF5UGF0dGVybihcbm9wdGlvbmFsUGF0dCxcbm9wdGlvbmFsU3BlY2ltZW4ubGVuZ3RoKTtcblxubGV0IGFyZ051bT0wO1xucmV0dXJuKFxuKHJlcXVpcmVkU3BlY2ltZW4ubGVuZ3RoPT09cmVxdWlyZWRQYXR0Lmxlbmd0aHx8XG5jaGVjayhcbmZhbHNlLFxuWCBgRXhwZWN0ZWQgYXQgbGVhc3QgJHtxKFxucmVxdWlyZWRQYXR0Lmxlbmd0aClcbiB9IGFyZ3VtZW50czogJHtzcGVjaW1lbn1gKSkmJlxuXG5yZXF1aXJlZFBhdHQuZXZlcnkoKHAsaSk9PlxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXBsdXNwbHVzKi9cbmNoZWNrTWF0Y2hlcyhyZXF1aXJlZFNwZWNpbWVuW2ldLHAsY2hlY2ssIGBhcmcgJHthcmdOdW0rK31gKSkmJlxuXG5wYXJ0aWFsUGF0dC5ldmVyeSgocCxpKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tcGx1c3BsdXMqL1xuY2hlY2tNYXRjaGVzKG9wdGlvbmFsU3BlY2ltZW5baV0scCxjaGVjaywgYGFyZyAke2FyZ051bSsrfT9gKSkmJlxuXG5jaGVja01hdGNoZXMocmVzdFNwZWNpbWVuLHJlc3RQYXR0LGNoZWNrLCcuLi5yZXN0JykpO1xuXG4gfSxcblxuLyoqXG4gKiBAcGFyYW0ge0FycmF5fSBzcGxpdEFycmF5XG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKi9cbmNoZWNrSXNXZWxsRm9ybWVkOihzcGxpdEFycmF5LGNoZWNrKT0+e1xuaWYoXG5wYXNzU3R5bGVPZihzcGxpdEFycmF5KT09PSdjb3B5QXJyYXknJiYoXG5zcGxpdEFycmF5Lmxlbmd0aD49MXx8c3BsaXRBcnJheS5sZW5ndGg8PTMpKVxue1xuY29uc3RbcmVxdWlyZWRQYXR0LG9wdGlvbmFsUGF0dD11bmRlZmluZWQscmVzdFBhdHQ9dW5kZWZpbmVkXT1cbnNwbGl0QXJyYXk7XG5pZihcbmlzUGF0dGVybihyZXF1aXJlZFBhdHQpJiZcbnBhc3NTdHlsZU9mKHJlcXVpcmVkUGF0dCk9PT0nY29weUFycmF5JyYmKFxub3B0aW9uYWxQYXR0PT09dW5kZWZpbmVkfHxcbmlzUGF0dGVybihvcHRpb25hbFBhdHQpJiZcbnBhc3NTdHlsZU9mKG9wdGlvbmFsUGF0dCk9PT0nY29weUFycmF5JykmJihcbnJlc3RQYXR0PT09dW5kZWZpbmVkfHxpc1BhdHRlcm4ocmVzdFBhdHQpKSlcbntcbnJldHVybiB0cnVlO1xuIH1cbiB9XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYE11c3QgYmUgYW4gYXJyYXkgb2YgYSByZXF1aXJlZFBhdHQgYXJyYXksIGFuIG9wdGlvbmFsIG9wdGlvbmFsUGF0dCBhcnJheSwgYW5kIGFuIG9wdGlvbmFsIHJlc3RQYXR0OiAke3EoXG5zcGxpdEFycmF5KVxuIH1gKTtcblxuIH0sXG5cbmdldFJhbmtDb3ZlcjooW1xuX3JlcXVpcmVkUGF0dCxcbl9vcHRpb25hbFBhdHQ9dW5kZWZpbmVkLFxuX3Jlc3RQYXR0PXVuZGVmaW5lZF0pPT5cbmdldFBhc3NTdHlsZUNvdmVyKCdjb3B5QXJyYXknKX0pO1xuXG5cbi8qKlxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFBhc3NhYmxlPn0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7Q29weVJlY29yZDxQYXR0ZXJuPn0gcmVxdWlyZWRQYXR0XG4gKiBAcGFyYW0ge0NvcHlSZWNvcmQ8UGF0dGVybj59IG9wdGlvbmFsUGF0dFxuICogQHJldHVybnMge3tcbiAqICAgcmVxdWlyZWRTcGVjaW1lbjogQ29weVJlY29yZDxQYXNzYWJsZT4sXG4gKiAgIG9wdGlvbmFsU3BlY2ltZW46IENvcHlSZWNvcmQ8UGFzc2FibGU+LFxuICogICByZXN0U3BlY2ltZW46IENvcHlSZWNvcmQ8UGFzc2FibGU+XG4gKiB9fVxuICovXG5jb25zdCBzcGxpdFJlY29yZFBhcnRzPShzcGVjaW1lbixyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0KT0+e1xuLyogTm90IGZyb3plbiEgTXV0YXRlZCBpbiBwbGFjZSovXG4vKiogQHR5cGUge1tzdHJpbmcsIFBhc3NhYmxlXVtdfSAqL1xuY29uc3QgcmVxdWlyZWRFbnRyaWVzPVtdO1xuLyoqIEB0eXBlIHtbc3RyaW5nLCBQYXNzYWJsZV1bXX0gKi9cbmNvbnN0IG9wdGlvbmFsRW50cmllcz1bXTtcbi8qKiBAdHlwZSB7W3N0cmluZywgUGFzc2FibGVdW119ICovXG5jb25zdCByZXN0RW50cmllcz1bXTtcbmZvcihjb25zdFtuYW1lLHZhbHVlXW9mIGVudHJpZXMoc3BlY2ltZW4pKXtcbmlmKGhhc093blByb3BlcnR5T2YocmVxdWlyZWRQYXR0LG5hbWUpKXtcbnJlcXVpcmVkRW50cmllcy5wdXNoKFtuYW1lLHZhbHVlXSk7XG4gfWVsc2UgaWYoaGFzT3duUHJvcGVydHlPZihvcHRpb25hbFBhdHQsbmFtZSkpe1xub3B0aW9uYWxFbnRyaWVzLnB1c2goW25hbWUsdmFsdWVdKTtcbiB9ZWxzZXtcbnJlc3RFbnRyaWVzLnB1c2goW25hbWUsdmFsdWVdKTtcbiB9XG4gfVxucmV0dXJuIGhhcmRlbih7XG5yZXF1aXJlZFNwZWNpbWVuOmZyb21VbmlxdWVFbnRyaWVzKHJlcXVpcmVkRW50cmllcyksXG5vcHRpb25hbFNwZWNpbWVuOmZyb21VbmlxdWVFbnRyaWVzKG9wdGlvbmFsRW50cmllcyksXG5yZXN0U3BlY2ltZW46ZnJvbVVuaXF1ZUVudHJpZXMocmVzdEVudHJpZXMpfSk7XG5cbiB9O1xuXG4vKipcbiAqIE9wdGlvbmFsIHNwZWNpbWVuIHZhbHVlcyB3aGljaCBhcmUgYHVuZGVmaW5lZGAgcGFzcyB1bmNvbmRpdGlvbmFsbHkuXG4gKiBXZSBlbmNvZGUgdGhpcyB3aXRoIHRoZSBgTS5vcmAgcGF0dGVybiBzbyBpdCBhbHNvIHByb2R1Y2VzIGEgZ29vZFxuICogY29tcHJlc3Npb24gZGlzdGluZ3Vpc2hpbmcgYHVuZGVmaW5lZGAgZnJvbSBhYnNlbmNlLlxuICpcbiAqIEBwYXJhbSB7Q29weVJlY29yZDxQYXR0ZXJuPn0gb3B0aW9uYWxQYXR0XG4gKiBAcGFyYW0ge3N0cmluZ1tdfSBuYW1lc1xuICogQHJldHVybnMge0NvcHlSZWNvcmQ8UGF0dGVybj59IFRoZSBwYXJ0aWFsUGF0dFxuICovXG5jb25zdCBhZGFwdFJlY29yZFBhdHRlcm49KG9wdGlvbmFsUGF0dCxuYW1lcyk9PlxuZnJvbVVuaXF1ZUVudHJpZXMobmFtZXMubWFwKChuYW1lKT0+W25hbWUsTU0ub3B0KG9wdGlvbmFsUGF0dFtuYW1lXSldKSk7XG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFNwbGl0UmVjb3JkSGVscGVyPUZhcignbWF0Y2g6c3BsaXRSZWNvcmQgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KFxuc3BlY2ltZW4sXG5bcmVxdWlyZWRQYXR0LG9wdGlvbmFsUGF0dD17fSxyZXN0UGF0dD1NTS5hbnkoKV0sXG5jaGVjayk9Plxue1xuaWYoIWNoZWNrS2luZChzcGVjaW1lbiwnY29weVJlY29yZCcsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdHtyZXF1aXJlZFNwZWNpbWVuLG9wdGlvbmFsU3BlY2ltZW4scmVzdFNwZWNpbWVufT1cbnNwbGl0UmVjb3JkUGFydHMoc3BlY2ltZW4scmVxdWlyZWRQYXR0LG9wdGlvbmFsUGF0dCk7XG5cbmNvbnN0IHBhcnRpYWxOYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMob3B0aW9uYWxTcGVjaW1lbik7XG5jb25zdCBwYXJ0aWFsUGF0dD1hZGFwdFJlY29yZFBhdHRlcm4ob3B0aW9uYWxQYXR0LHBhcnRpYWxOYW1lcyk7XG5yZXR1cm4oXG5jaGVja01hdGNoZXMocmVxdWlyZWRTcGVjaW1lbixyZXF1aXJlZFBhdHQsY2hlY2spJiZcbnBhcnRpYWxOYW1lcy5ldmVyeSgobmFtZSk9PlxuY2hlY2tNYXRjaGVzKFxub3B0aW9uYWxTcGVjaW1lbltuYW1lXSxcbnBhcnRpYWxQYXR0W25hbWVdLFxuY2hlY2ssXG4gYCR7bmFtZX0/YCkpJiZcblxuXG5jaGVja01hdGNoZXMocmVzdFNwZWNpbWVuLHJlc3RQYXR0LGNoZWNrLCcuLi5yZXN0JykpO1xuXG4gfSxcblxuLyoqXG4gKiBAcGFyYW0ge0FycmF5fSBzcGxpdEFycmF5XG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKi9cbmNoZWNrSXNXZWxsRm9ybWVkOihzcGxpdEFycmF5LGNoZWNrKT0+e1xuaWYoXG5wYXNzU3R5bGVPZihzcGxpdEFycmF5KT09PSdjb3B5QXJyYXknJiYoXG5zcGxpdEFycmF5Lmxlbmd0aD49MXx8c3BsaXRBcnJheS5sZW5ndGg8PTMpKVxue1xuY29uc3RbcmVxdWlyZWRQYXR0LG9wdGlvbmFsUGF0dD11bmRlZmluZWQscmVzdFBhdHQ9dW5kZWZpbmVkXT1cbnNwbGl0QXJyYXk7XG5pZihcbmlzUGF0dGVybihyZXF1aXJlZFBhdHQpJiZcbnBhc3NTdHlsZU9mKHJlcXVpcmVkUGF0dCk9PT0nY29weVJlY29yZCcmJihcbm9wdGlvbmFsUGF0dD09PXVuZGVmaW5lZHx8XG5pc1BhdHRlcm4ob3B0aW9uYWxQYXR0KSYmXG5wYXNzU3R5bGVPZihvcHRpb25hbFBhdHQpPT09J2NvcHlSZWNvcmQnKSYmKFxucmVzdFBhdHQ9PT11bmRlZmluZWR8fGlzUGF0dGVybihyZXN0UGF0dCkpKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgTXVzdCBiZSBhbiBhcnJheSBvZiBhIHJlcXVpcmVkUGF0dCByZWNvcmQsIGFuIG9wdGlvbmFsIG9wdGlvbmFsUGF0dCByZWNvcmQsIGFuZCBhbiBvcHRpb25hbCByZXN0UGF0dDogJHtxKFxuc3BsaXRBcnJheSlcbiB9YCk7XG5cbiB9LFxuXG5nZXRSYW5rQ292ZXI6KFtcbnJlcXVpcmVkUGF0dCxcbl9vcHRpb25hbFBhdHQ9dW5kZWZpbmVkLFxuX3Jlc3RQYXR0PXVuZGVmaW5lZF0pPT5cbmdldFBhc3NTdHlsZUNvdmVyKHBhc3NTdHlsZU9mKHJlcXVpcmVkUGF0dCkpfSk7XG5cblxuLyoqIEB0eXBlIHtSZWNvcmQ8c3RyaW5nLCBNYXRjaEhlbHBlcj59ICovXG5jb25zdCBIZWxwZXJzQnlNYXRjaFRhZz1oYXJkZW4oe1xuJ21hdGNoOmFueSc6bWF0Y2hBbnlIZWxwZXIsXG4nbWF0Y2g6YW5kJzptYXRjaEFuZEhlbHBlcixcbidtYXRjaDpvcic6bWF0Y2hPckhlbHBlcixcbidtYXRjaDpub3QnOm1hdGNoTm90SGVscGVyLFxuXG4nbWF0Y2g6c2NhbGFyJzptYXRjaFNjYWxhckhlbHBlcixcbidtYXRjaDprZXknOm1hdGNoS2V5SGVscGVyLFxuJ21hdGNoOnBhdHRlcm4nOm1hdGNoUGF0dGVybkhlbHBlcixcbidtYXRjaDpraW5kJzptYXRjaEtpbmRIZWxwZXIsXG4nbWF0Y2g6YmlnaW50JzptYXRjaEJpZ2ludEhlbHBlcixcbidtYXRjaDpuYXQnOm1hdGNoTmF0SGVscGVyLFxuJ21hdGNoOnN0cmluZyc6bWF0Y2hTdHJpbmdIZWxwZXIsXG4nbWF0Y2g6c3ltYm9sJzptYXRjaFN5bWJvbEhlbHBlcixcbidtYXRjaDpyZW1vdGFibGUnOm1hdGNoUmVtb3RhYmxlSGVscGVyLFxuXG4nbWF0Y2g6bHQnOm1hdGNoTFRIZWxwZXIsXG4nbWF0Y2g6bHRlJzptYXRjaExURUhlbHBlcixcbidtYXRjaDpndGUnOm1hdGNoR1RFSGVscGVyLFxuJ21hdGNoOmd0JzptYXRjaEdUSGVscGVyLFxuXG4nbWF0Y2g6YXJyYXlPZic6bWF0Y2hBcnJheU9mSGVscGVyLFxuJ21hdGNoOnJlY29yZE9mJzptYXRjaFJlY29yZE9mSGVscGVyLFxuJ21hdGNoOnNldE9mJzptYXRjaFNldE9mSGVscGVyLFxuJ21hdGNoOmJhZ09mJzptYXRjaEJhZ09mSGVscGVyLFxuJ21hdGNoOm1hcE9mJzptYXRjaE1hcE9mSGVscGVyLFxuJ21hdGNoOnNwbGl0QXJyYXknOm1hdGNoU3BsaXRBcnJheUhlbHBlcixcbidtYXRjaDpzcGxpdFJlY29yZCc6bWF0Y2hTcGxpdFJlY29yZEhlbHBlcn0pO1xuXG5cbmNvbnN0IG1ha2VNYXRjaGVyPSh0YWcscGF5bG9hZCk9PntcbmNvbnN0IG1hdGNoZXI9bWFrZVRhZ2dlZCh0YWcscGF5bG9hZCk7XG5hc3NlcnRQYXR0ZXJuKG1hdGNoZXIpO1xucmV0dXJuIG1hdGNoZXI7XG4gfTtcblxuY29uc3QgbWFrZUtpbmRNYXRjaGVyPShraW5kKT0+bWFrZU1hdGNoZXIoJ21hdGNoOmtpbmQnLGtpbmQpO1xuXG5jb25zdCBBbnlTaGFwZT1tYWtlTWF0Y2hlcignbWF0Y2g6YW55Jyx1bmRlZmluZWQpO1xuY29uc3QgU2NhbGFyU2hhcGU9bWFrZU1hdGNoZXIoJ21hdGNoOnNjYWxhcicsdW5kZWZpbmVkKTtcbmNvbnN0IEtleVNoYXBlPW1ha2VNYXRjaGVyKCdtYXRjaDprZXknLHVuZGVmaW5lZCk7XG5jb25zdCBQYXR0ZXJuU2hhcGU9bWFrZU1hdGNoZXIoJ21hdGNoOnBhdHRlcm4nLHVuZGVmaW5lZCk7XG5jb25zdCBCb29sZWFuU2hhcGU9bWFrZUtpbmRNYXRjaGVyKCdib29sZWFuJyk7XG5jb25zdCBOdW1iZXJTaGFwZT1tYWtlS2luZE1hdGNoZXIoJ251bWJlcicpO1xuY29uc3QgQmlnSW50U2hhcGU9bWFrZVRhZ2dlZCgnbWF0Y2g6YmlnaW50JyxbXSk7XG5jb25zdCBOYXRTaGFwZT1tYWtlVGFnZ2VkKCdtYXRjaDpuYXQnLFtdKTtcbmNvbnN0IFN0cmluZ1NoYXBlPW1ha2VUYWdnZWQoJ21hdGNoOnN0cmluZycsW10pO1xuY29uc3QgU3ltYm9sU2hhcGU9bWFrZVRhZ2dlZCgnbWF0Y2g6c3ltYm9sJyxbXSk7XG5jb25zdCBSZWNvcmRTaGFwZT1tYWtlVGFnZ2VkKCdtYXRjaDpyZWNvcmRPZicsW0FueVNoYXBlLEFueVNoYXBlXSk7XG5jb25zdCBBcnJheVNoYXBlPW1ha2VUYWdnZWQoJ21hdGNoOmFycmF5T2YnLFtBbnlTaGFwZV0pO1xuY29uc3QgU2V0U2hhcGU9bWFrZVRhZ2dlZCgnbWF0Y2g6c2V0T2YnLFtBbnlTaGFwZV0pO1xuY29uc3QgQmFnU2hhcGU9bWFrZVRhZ2dlZCgnbWF0Y2g6YmFnT2YnLFtBbnlTaGFwZSxBbnlTaGFwZV0pO1xuY29uc3QgTWFwU2hhcGU9bWFrZVRhZ2dlZCgnbWF0Y2g6bWFwT2YnLFtBbnlTaGFwZSxBbnlTaGFwZV0pO1xuY29uc3QgUmVtb3RhYmxlU2hhcGU9bWFrZUtpbmRNYXRjaGVyKCdyZW1vdGFibGUnKTtcbmNvbnN0IEVycm9yU2hhcGU9bWFrZUtpbmRNYXRjaGVyKCdlcnJvcicpO1xuY29uc3QgUHJvbWlzZVNoYXBlPW1ha2VLaW5kTWF0Y2hlcigncHJvbWlzZScpO1xuY29uc3QgVW5kZWZpbmVkU2hhcGU9bWFrZUtpbmRNYXRjaGVyKCd1bmRlZmluZWQnKTtcblxuLyoqXG4gKiBGb3Igd2hlbiB0aGUgbGFzdCBlbGVtZW50IG9mIHRoZSBwYXlsb2FkIGlzIHRoZSBvcHRpb25hbCBsaW1pdHMsXG4gKiBzbyB0aGF0IHdoZW4gaXQgaXMgYHVuZGVmaW5lZGAgaXQgaXMgZHJvcHBlZCBmcm9tIHRoZSBlbmQgb2YgdGhlXG4gKiBwYXlsb2FkcyBhcnJheS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcGFyYW0ge1Bhc3NhYmxlW119IHBheWxvYWRcbiAqL1xuY29uc3QgbWFrZUxpbWl0c01hdGNoZXI9KHRhZyxwYXlsb2FkKT0+e1xuaWYocGF5bG9hZFtwYXlsb2FkLmxlbmd0aC0xXT09PXVuZGVmaW5lZCl7XG5wYXlsb2FkPWhhcmRlbihwYXlsb2FkLnNsaWNlKDAscGF5bG9hZC5sZW5ndGgtMSkpO1xuIH1cbnJldHVybiBtYWtlTWF0Y2hlcih0YWcscGF5bG9hZCk7XG4gfTtcblxuY29uc3QgbWFrZVJlbW90YWJsZU1hdGNoZXI9KGxhYmVsPXVuZGVmaW5lZCk9PlxubGFiZWw9PT11bmRlZmluZWQ/XG5SZW1vdGFibGVTaGFwZTpcbm1ha2VNYXRjaGVyKCdtYXRjaDpyZW1vdGFibGUnLGhhcmRlbih7bGFiZWx9KSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VH0gZW1wdHlcbiAqIEBwYXJhbSB7VH0gYmFzZVxuICogQHBhcmFtIHtUfSBbb3B0aW9uYWxdXG4gKiBAcGFyYW0ge1R9IFtyZXN0XVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgbWFrZVNwbGl0UGF5bG9hZD0oXG5lbXB0eSxcbmJhc2UsXG5vcHRpb25hbD11bmRlZmluZWQsXG5yZXN0PXVuZGVmaW5lZCk9Plxue1xuaWYocmVzdCl7XG5yZXR1cm5bYmFzZSxvcHRpb25hbHx8ZW1wdHkscmVzdF07XG4gfVxuaWYob3B0aW9uYWwpe1xucmV0dXJuW2Jhc2Usb3B0aW9uYWxdO1xuIH1cbnJldHVybltiYXNlXTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7J3N5bmMnfCdhc3luYyd9IGNhbGxLaW5kXG4gKiBAcGFyYW0ge0FyZ0d1YXJkW119IGFyZ0d1YXJkc1xuICogQHBhcmFtIHtBcmdHdWFyZFtdfSBbb3B0aW9uYWxBcmdHdWFyZHNdXG4gKiBAcGFyYW0ge0FyZ0d1YXJkfSBbcmVzdEFyZ0d1YXJkXVxuICogQHJldHVybnMge01ldGhvZEd1YXJkTWFrZXJ9XG4gKi9cbmNvbnN0IG1ha2VNZXRob2RHdWFyZE1ha2VyPShcbmNhbGxLaW5kLFxuYXJnR3VhcmRzLFxub3B0aW9uYWxBcmdHdWFyZHM9dW5kZWZpbmVkLFxucmVzdEFyZ0d1YXJkPXVuZGVmaW5lZCk9PlxuXG5oYXJkZW4oe1xub3B0aW9uYWw6KC4uLm9wdEFyZ0d1YXJkcyk9Pntcbm9wdGlvbmFsQXJnR3VhcmRzPT09dW5kZWZpbmVkfHxcbkZhaWwgYENhbiBvbmx5IGhhdmUgb25lIHNldCBvZiBvcHRpb25hbCBndWFyZHNgO1xucmVzdEFyZ0d1YXJkPT09dW5kZWZpbmVkfHxcbkZhaWwgYG9wdGlvbmFsIGFyZyBndWFyZHMgbXVzdCBjb21lIGJlZm9yZSByZXN0IGFyZ2A7XG5yZXR1cm4gbWFrZU1ldGhvZEd1YXJkTWFrZXIoY2FsbEtpbmQsYXJnR3VhcmRzLG9wdEFyZ0d1YXJkcyk7XG4gfSxcbnJlc3Q6KHJBcmdHdWFyZCk9PntcbnJlc3RBcmdHdWFyZD09PXVuZGVmaW5lZHx8RmFpbCBgQ2FuIG9ubHkgaGF2ZSBvbmUgcmVzdCBhcmdgO1xucmV0dXJuIG1ha2VNZXRob2RHdWFyZE1ha2VyKFxuY2FsbEtpbmQsXG5hcmdHdWFyZHMsXG5vcHRpb25hbEFyZ0d1YXJkcyxcbnJBcmdHdWFyZCk7XG5cbiB9LFxucmV0dXJuczoocmV0dXJuR3VhcmQ9VW5kZWZpbmVkU2hhcGUpPT5cbmhhcmRlbih7XG5rbGFzczonbWV0aG9kR3VhcmQnLFxuY2FsbEtpbmQsXG5hcmdHdWFyZHMsXG5vcHRpb25hbEFyZ0d1YXJkcyxcbnJlc3RBcmdHdWFyZCxcbnJldHVybkd1YXJkfSl9KTtcblxuXG5cbmNvbnN0IG1ha2VBd2FpdEFyZ0d1YXJkPShhcmdHdWFyZCk9PlxuaGFyZGVuKHtcbmtsYXNzOidhd2FpdEFyZycsXG5hcmdHdWFyZH0pO1xuXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKiBAdHlwZSB7TWF0Y2hlck5hbWVzcGFjZX0gKi9cbmNvbnN0IE09aGFyZGVuKHtcbmFueTooKT0+QW55U2hhcGUsXG5hbmQ6KC4uLnBhdHRzKT0+bWFrZU1hdGNoZXIoJ21hdGNoOmFuZCcscGF0dHMpLFxub3I6KC4uLnBhdHRzKT0+bWFrZU1hdGNoZXIoJ21hdGNoOm9yJyxwYXR0cyksXG5ub3Q6KHN1YlBhdHQpPT5tYWtlTWF0Y2hlcignbWF0Y2g6bm90JyxzdWJQYXR0KSxcblxuc2NhbGFyOigpPT5TY2FsYXJTaGFwZSxcbmtleTooKT0+S2V5U2hhcGUsXG5wYXR0ZXJuOigpPT5QYXR0ZXJuU2hhcGUsXG5raW5kOm1ha2VLaW5kTWF0Y2hlcixcbmJvb2xlYW46KCk9PkJvb2xlYW5TaGFwZSxcbm51bWJlcjooKT0+TnVtYmVyU2hhcGUsXG5iaWdpbnQ6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9tYWtlTGltaXRzTWF0Y2hlcignbWF0Y2g6YmlnaW50JyxbbGltaXRzXSk6QmlnSW50U2hhcGUsXG5uYXQ6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9tYWtlTGltaXRzTWF0Y2hlcignbWF0Y2g6bmF0JyxbbGltaXRzXSk6TmF0U2hhcGUsXG5zdHJpbmc6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9tYWtlTGltaXRzTWF0Y2hlcignbWF0Y2g6c3RyaW5nJyxbbGltaXRzXSk6U3RyaW5nU2hhcGUsXG5zeW1ib2w6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9tYWtlTGltaXRzTWF0Y2hlcignbWF0Y2g6c3ltYm9sJyxbbGltaXRzXSk6U3ltYm9sU2hhcGUsXG5yZWNvcmQ6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9NLnJlY29yZE9mKE0uYW55KCksTS5hbnkoKSxsaW1pdHMpOlJlY29yZFNoYXBlLFxuYXJyYXk6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9NLmFycmF5T2YoTS5hbnkoKSxsaW1pdHMpOkFycmF5U2hhcGUsXG5zZXQ6KGxpbWl0cz11bmRlZmluZWQpPT5saW1pdHM/TS5zZXRPZihNLmFueSgpLGxpbWl0cyk6U2V0U2hhcGUsXG5iYWc6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9NLmJhZ09mKE0uYW55KCksTS5hbnkoKSxsaW1pdHMpOkJhZ1NoYXBlLFxubWFwOihsaW1pdHM9dW5kZWZpbmVkKT0+XG5saW1pdHM/TS5tYXBPZihNLmFueSgpLE0uYW55KCksbGltaXRzKTpNYXBTaGFwZSxcbnJlbW90YWJsZTptYWtlUmVtb3RhYmxlTWF0Y2hlcixcbmVycm9yOigpPT5FcnJvclNoYXBlLFxucHJvbWlzZTooKT0+UHJvbWlzZVNoYXBlLFxudW5kZWZpbmVkOigpPT5VbmRlZmluZWRTaGFwZSxcbm51bGw6KCk9Pm51bGwsXG5cbmx0OihyaWdodE9wZXJhbmQpPT5tYWtlTWF0Y2hlcignbWF0Y2g6bHQnLHJpZ2h0T3BlcmFuZCksXG5sdGU6KHJpZ2h0T3BlcmFuZCk9Pm1ha2VNYXRjaGVyKCdtYXRjaDpsdGUnLHJpZ2h0T3BlcmFuZCksXG5lcTooa2V5KT0+e1xuYXNzZXJ0S2V5KGtleSk7XG5yZXR1cm4ga2V5PT09dW5kZWZpbmVkP00udW5kZWZpbmVkKCk6a2V5O1xuIH0sXG5uZXE6KGtleSk9Pk0ubm90KE0uZXEoa2V5KSksXG5ndGU6KHJpZ2h0T3BlcmFuZCk9Pm1ha2VNYXRjaGVyKCdtYXRjaDpndGUnLHJpZ2h0T3BlcmFuZCksXG5ndDoocmlnaHRPcGVyYW5kKT0+bWFrZU1hdGNoZXIoJ21hdGNoOmd0JyxyaWdodE9wZXJhbmQpLFxuXG5yZWNvcmRPZjooa2V5UGF0dD1NLmFueSgpLHZhbHVlUGF0dD1NLmFueSgpLGxpbWl0cz11bmRlZmluZWQpPT5cbm1ha2VMaW1pdHNNYXRjaGVyKCdtYXRjaDpyZWNvcmRPZicsW2tleVBhdHQsdmFsdWVQYXR0LGxpbWl0c10pLFxuYXJyYXlPZjooc3ViUGF0dD1NLmFueSgpLGxpbWl0cz11bmRlZmluZWQpPT5cbm1ha2VMaW1pdHNNYXRjaGVyKCdtYXRjaDphcnJheU9mJyxbc3ViUGF0dCxsaW1pdHNdKSxcbnNldE9mOihrZXlQYXR0PU0uYW55KCksbGltaXRzPXVuZGVmaW5lZCk9PlxubWFrZUxpbWl0c01hdGNoZXIoJ21hdGNoOnNldE9mJyxba2V5UGF0dCxsaW1pdHNdKSxcbmJhZ09mOihrZXlQYXR0PU0uYW55KCksY291bnRQYXR0PU0uYW55KCksbGltaXRzPXVuZGVmaW5lZCk9PlxubWFrZUxpbWl0c01hdGNoZXIoJ21hdGNoOmJhZ09mJyxba2V5UGF0dCxjb3VudFBhdHQsbGltaXRzXSksXG5tYXBPZjooa2V5UGF0dD1NLmFueSgpLHZhbHVlUGF0dD1NLmFueSgpLGxpbWl0cz11bmRlZmluZWQpPT5cbm1ha2VMaW1pdHNNYXRjaGVyKCdtYXRjaDptYXBPZicsW2tleVBhdHQsdmFsdWVQYXR0LGxpbWl0c10pLFxuc3BsaXRBcnJheTooYmFzZSxvcHRpb25hbD11bmRlZmluZWQscmVzdD11bmRlZmluZWQpPT5cbm1ha2VNYXRjaGVyKFxuJ21hdGNoOnNwbGl0QXJyYXknLFxubWFrZVNwbGl0UGF5bG9hZChbXSxiYXNlLG9wdGlvbmFsLHJlc3QpKSxcblxuc3BsaXRSZWNvcmQ6KGJhc2Usb3B0aW9uYWw9dW5kZWZpbmVkLHJlc3Q9dW5kZWZpbmVkKT0+XG5tYWtlTWF0Y2hlcihcbidtYXRjaDpzcGxpdFJlY29yZCcsXG5tYWtlU3BsaXRQYXlsb2FkKHt9LGJhc2Usb3B0aW9uYWwscmVzdCkpLFxuXG5zcGxpdDooYmFzZSxyZXN0PXVuZGVmaW5lZCk9PntcbmlmKHBhc3NTdHlsZU9mKGhhcmRlbihiYXNlKSk9PT0nY29weUFycmF5Jyl7XG4vKiBAdHMtZXhwZWN0LWVycm9yIFdlIGtub3cgaXQgc2hvdWxkIGJlIGFuIGFycmF5Ki9cbnJldHVybiBNLnNwbGl0QXJyYXkoYmFzZSxyZXN0JiZbXSxyZXN0KTtcbiB9ZWxzZXtcbnJldHVybiBNLnNwbGl0UmVjb3JkKGJhc2UscmVzdCYme30scmVzdCk7XG4gfVxuIH0sXG5wYXJ0aWFsOihiYXNlLHJlc3Q9dW5kZWZpbmVkKT0+e1xuaWYocGFzc1N0eWxlT2YoaGFyZGVuKGJhc2UpKT09PSdjb3B5QXJyYXknKXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgV2Uga25vdyBpdCBzaG91bGQgYmUgYW4gYXJyYXkqL1xucmV0dXJuIE0uc3BsaXRBcnJheShbXSxiYXNlLHJlc3QpO1xuIH1lbHNle1xucmV0dXJuIE0uc3BsaXRSZWNvcmQoe30sYmFzZSxyZXN0KTtcbiB9XG4gfSxcblxuZXJlZjoodCk9Pk0ub3IodCxNLnByb21pc2UoKSksXG5vcHQ6KHQpPT5NLm9yKE0udW5kZWZpbmVkKCksdCksXG5cbmludGVyZmFjZTooaW50ZXJmYWNlTmFtZSxtZXRob2RHdWFyZHMse3Nsb3BweT1mYWxzZX09e30pPT57XG5mb3IoY29uc3RbXyxtZXRob2RHdWFyZF1vZiBlbnRyaWVzKG1ldGhvZEd1YXJkcykpe1xubWV0aG9kR3VhcmQua2xhc3M9PT0nbWV0aG9kR3VhcmQnfHxcbkZhaWwgYHVucmVjb2duaXplIG1ldGhvZCBndWFyZCAke21ldGhvZEd1YXJkfWA7XG4gfVxucmV0dXJuIGhhcmRlbih7XG5rbGFzczonSW50ZXJmYWNlJyxcbmludGVyZmFjZU5hbWUsXG5tZXRob2RHdWFyZHMsXG5zbG9wcHl9KTtcblxuIH0sXG5jYWxsOiguLi5hcmdHdWFyZHMpPT5tYWtlTWV0aG9kR3VhcmRNYWtlcignc3luYycsYXJnR3VhcmRzKSxcbmNhbGxXaGVuOiguLi5hcmdHdWFyZHMpPT5tYWtlTWV0aG9kR3VhcmRNYWtlcignYXN5bmMnLGFyZ0d1YXJkcyksXG5cbmF3YWl0OihhcmdHdWFyZCk9Pm1ha2VBd2FpdEFyZ0d1YXJkKGFyZ0d1YXJkKX0pO1xuXG5cbnJldHVybiBoYXJkZW4oe1xuY2hlY2tNYXRjaGVzLFxubWF0Y2hlcyxcbm11c3RNYXRjaCxcbmFzc2VydFBhdHRlcm4sXG5pc1BhdHRlcm4sXG5nZXRSYW5rQ292ZXIsXG5NfSk7XG5cbiB9O1xuXG4vKiBPbmx5IGluY2x1ZGUgdGhvc2Ugd2hvc2UgbWVhbmluZyBpcyBpbmRlcGVuZGVudCBvZiBhbiBpbXB1dGVkIHNvcnQgb3JkZXIqL1xuLyogb2YgcmVtb3RhYmxlcywgb3Igb2YgZW5jb2Rpbmcgb2YgcGFzc2FibGUgYXMgc29ydGFibGUgc3RyaW5ncy4gVGh1cywqL1xuLyogZ2V0UmFua0NvdmVyIGlzIG9taXR0ZWQuIFRvIGdldCBvbmUsIHlvdSdkIG5lZWQgdG8gaW5zdGFudGlhdGUqL1xuLyogYG1ha2VQYXR0ZXJuS2l0KClgIHlvdXJzZWxmLiBTaW5jZSB0aGVyZSBhcmUgY3VycmVudGx5IG5vIGV4dGVybmFsKi9cbi8qIHVzZXMgb2YgYGdldFJhbmtDb3ZlcmAsIGZvciBjbGFyaXR5IGR1cmluZyBkZXZlbG9wbWVudCwgYG1ha2VQYXR0ZXJuS2l0YCovXG4vKiBpcyBub3QgY3VycmVudGx5IGV4cG9ydGVkLiovXG5jb25zdCAgICAgICB7XG5jaGVja01hdGNoZXMsXG5tYXRjaGVzLFxubXVzdE1hdGNoLFxuYXNzZXJ0UGF0dGVybixcbmlzUGF0dGVybixcbmdldFJhbmtDb3Zlcixcbk19PVxubWFrZVBhdHRlcm5LaXQoKTskaOKAjV9vbmNlLmNoZWNrTWF0Y2hlcyhjaGVja01hdGNoZXMpOyRo4oCNX29uY2UubWF0Y2hlcyhtYXRjaGVzKTskaOKAjV9vbmNlLm11c3RNYXRjaChtdXN0TWF0Y2gpOyRo4oCNX29uY2UuYXNzZXJ0UGF0dGVybihhc3NlcnRQYXR0ZXJuKTskaOKAjV9vbmNlLmlzUGF0dGVybihpc1BhdHRlcm4pOyRo4oCNX29uY2UuZ2V0UmFua0NvdmVyKGdldFJhbmtDb3Zlcik7JGjigI1fb25jZS5NKE0pO1xuXG5NTT1NO1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5Db3B5VGFnZ2VkfSBDb3B5VGFnZ2VkICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5Db3B5UmVjb3JkPFQ+fSBDb3B5UmVjb3JkICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5Db3B5QXJyYXk8VD59IENvcHlBcnJheSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuUmFua0NvbXBhcmV9IFJhbmtDb21wYXJlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5SYW5rQ292ZXJ9IFJhbmtDb3ZlciAqL1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuQXJnR3VhcmR9IEFyZ0d1YXJkICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuTWV0aG9kR3VhcmRNYWtlcn0gTWV0aG9kR3VhcmRNYWtlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLk1hdGNoZXJOYW1lc3BhY2V9IE1hdGNoZXJOYW1lc3BhY2UgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXl9IEtleSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLlBhdHRlcm59IFBhdHRlcm4gKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5QYXR0ZXJuS2l0fSBQYXR0ZXJuS2l0ICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuQ2hlY2tQYXR0ZXJufSBDaGVja1BhdHRlcm4gKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5MaW1pdHN9IExpbWl0cyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkFsbExpbWl0c30gQWxsTGltaXRzICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuR2V0UmFua0NvdmVyfSBHZXRSYW5rQ292ZXIgKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBNYXRjaEhlbHBlclxuICogVGhpcyBmYWN0b3JzIG91dCBvbmx5IHRoZSBwYXJ0cyBzcGVjaWZpYyB0byBlYWNoIGtpbmQgb2YgTWF0Y2hlci4gSXQgaXNcbiAqIGVuY2Fwc3VsYXRlZCwgYW5kIGl0cyBtZXRob2RzIGNhbiBtYWtlIHRoZSBzdGF0ZWQgdW5jaGVja2VyIGFzc3VtcHRpb25zXG4gKiBlbmZvcmNlZCBieSB0aGUgY29tbW9uIGNhbGxpbmcgbG9naWMuXG4gKlxuICogQHByb3BlcnR5IHsoYWxsZWdlZFBheWxvYWQ6IFBhc3NhYmxlLFxuICogICAgICAgICAgICAgY2hlY2s6IENoZWNrZXJcbiAqICkgPT4gYm9vbGVhbn0gY2hlY2tJc1dlbGxGb3JtZWRcbiAqIFJlcG9ydHMgd2hldGhlciBgYWxsZWdlZFBheWxvYWRgIGlzIHZhbGlkIGFzIHRoZSBwYXlsb2FkIG9mIGEgQ29weVRhZ2dlZFxuICogd2hvc2UgdGFnIGNvcnJlc3BvbmRzIHdpdGggdGhpcyBNYXRjaEhlbHBlcidzIE1hdGNoZXJzLlxuICpcbiAqIEBwcm9wZXJ0eSB7KHNwZWNpbWVuOiBQYXNzYWJsZSxcbiAqICAgICAgICAgICAgIG1hdGNoZXJQYXlsb2FkOiBQYXNzYWJsZSxcbiAqICAgICAgICAgICAgIGNoZWNrOiBDaGVja2VyLFxuICogKSA9PiBib29sZWFufSBjaGVja01hdGNoZXNcbiAqIEFzc3VtaW5nIHZhbGlkaXR5IG9mIGBtYXRjaGVyUGF5bG9hZGAgYXMgdGhlIHBheWxvYWQgb2YgYSBNYXRjaGVyIGNvcnJlc3BvbmRpbmdcbiAqIHdpdGggdGhpcyBNYXRjaEhlbHBlciwgcmVwb3J0cyB3aGV0aGVyIGBzcGVjaW1lbmAgaXMgbWF0Y2hlZCBieSB0aGF0IE1hdGNoZXIuXG4gKlxuICogQHByb3BlcnR5IHtYaW1wb3J0KCcuLi90eXBlcycpLkdldFJhbmtDb3Zlcn0gZ2V0UmFua0NvdmVyXG4gKiBBc3N1bWVzIHRoaXMgaXMgdGhlIHBheWxvYWQgb2YgYSBDb3B5VGFnZ2VkIHdpdGggdGhlIGNvcnJlc3BvbmRpbmdcbiAqIG1hdGNoVGFnLiBSZXR1cm4gYSBSYW5rQ292ZXIgdG8gYm91bmQgZnJvbSBiZWxvdyBhbmQgYWJvdmUsXG4gKiBpbiByYW5rIG9yZGVyLCBhbGwgcG9zc2libGUgUGFzc2FibGVzIHRoYXQgd291bGQgbWF0Y2ggdGhpcyBNYXRjaGVyLlxuICogVGhlIGxlZnQgZWxlbWVudCBtdXN0IGJlIGJlZm9yZSBvciB0aGUgc2FtZSByYW5rIGFzIGFueSBwb3NzaWJsZVxuICogbWF0Y2hpbmcgc3BlY2ltZW4uIFRoZSByaWdodCBlbGVtZW50IG11c3QgYmUgYWZ0ZXIgb3IgdGhlIHNhbWVcbiAqIHJhbmsgYXMgYW55IHBvc3NpYmxlIG1hdGNoaW5nIHNwZWNpbWVuLlxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVmYXVsdExpbWl0cyI6WyJkZWZhdWx0TGltaXRzIl0sImNoZWNrTWF0Y2hlcyI6WyJjaGVja01hdGNoZXMiXSwibWF0Y2hlcyI6WyJtYXRjaGVzIl0sIm11c3RNYXRjaCI6WyJtdXN0TWF0Y2giXSwiYXNzZXJ0UGF0dGVybiI6WyJhc3NlcnRQYXR0ZXJuIl0sImlzUGF0dGVybiI6WyJpc1BhdHRlcm4iXSwiZ2V0UmFua0NvdmVyIjpbImdldFJhbmtDb3ZlciJdLCJNIjpbIk0iXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAmBk7szQBAAA0AQAAIgAAAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAlh73x+oaAADqGgAAIgAAAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMvdXRpbHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL3Byb21pc2Uta2l0Il0sImV4cG9ydHMiOlsiYXBwbHlMYWJlbGluZ0Vycm9yIiwiZnJvbVVuaXF1ZUVudHJpZXMiLCJpZGVudENoZWNrZXIiLCJsaXN0RGlmZmVyZW5jZSIsIm9iamVjdE1hcCIsInRocm93TGFiZWxlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLGlzUHJvbWlzZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJpc1Byb21pc2VcIiwgWyRo4oCNX2EgPT4gKGlzUHJvbWlzZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuXG5jb25zdHtmcm9tRW50cmllcyxlbnRyaWVzfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG5jb25zdHtkZXRhaWxzOlgscXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5cbi8qIFRPRE8gbWlncmF0ZSB0byBwcm9wZXIgaG9tZSovXG4vKiBGcm9tIHRoZSBgYWdvcmljLXNka2AgbW9ub3JlcG8uIE1vdmVkIGhlcmUgdGVtcG9yYXJpbHkgYmVjYXVzZSB0aGUgcGF0dGVybiovXG4vKiBjb2RlIGlzIG1pZ3JhdGVkIGZyb20gYEBhZ29yaWMvc3RvcmVgIHRvIGBAZW5kby9wYXR0ZXJuc2AsIGFuZCBkZXBlbmRzIG9uKi9cbi8qIHRoZSBmdW5jdGlvbmFsaXR5IGluIHRoaXMgZmlsZSwgd2hpY2ggaXMgb3RoZXJ3aXNlIGF2YWlsYWJsZSBvbmx5Ki9cbi8qIHdpdGhpbiB0aGUgYGFnb3JpYy1zZGtgIG1vbm9yZXBvLiovXG5cbi8qKlxuICogVE9ETyBhcyBsb25nIGFzIGBAZW5kby9wYXNzLXN0eWxlYCByZW1haW5zIHRoZSBwcm9wZXIgaG9tZSBvZiB0aGVcbiAqIGBDaGVja2VyYCB0eXBlLCBpdCBwcm9iYWJseSBtYWtlcyBtb3N0IHNlbnNlIHRvIG1vdmUgYGlkZW50Q2hlY2tlcmBcbiAqIGludG8gYEBlbmRvL3Bhc3Mtc3R5bGVgIGFzIHdlbGwuXG4gKlxuICogSW4gdGhlIGBhc3NlcnRGb29gL2Bpc0Zvb2AvYGNoZWNrRm9vYCBwYXR0ZXJuLCBgY2hlY2tGb29gIGhhcyBhIGBjaGVja2BcbiAqIHBhcmFtZXRlciBvZiB0eXBlIGBDaGVja2VyYC4gYGFzc2VydEZvb2AgY2FsbHMgYGNoZWNrRm9vYCBwYXNzZXNcbiAqIGBhc3NlcnRDaGVja2VyYCBhcyB0aGUgYGNoZWNrYCBhcmd1bWVudC4gYGlzRm9vYCBwYXNzZXMgYGlkZW50Q2hlY2tlcmBcbiAqIGFzIHRoZSBgY2hlY2tgIGFyZ3VtZW50LiBgaWRlbnRDaGVja2VyYCBhY3RzIHByZWNpc2VseSBsaWtlIGFuXG4gKiBpZGVudGl0eSBmdW5jdGlvbiwgYnV0IGlzIHR5cGVkIGFzIGEgYENoZWNrZXJgIHRvIGluZGljYXRlIGl0c1xuICogaW50ZW5kZWQgdXNlLlxuICpcbiAqIEB0eXBlIHtDaGVja2VyfVxuICovXG5jb25zdCAgICAgICAgaWRlbnRDaGVja2VyPShjb25kLF9kZXRhaWxzKT0+Y29uZDskaOKAjV9vbmNlLmlkZW50Q2hlY2tlcihpZGVudENoZWNrZXIpO1xuaGFyZGVuKGlkZW50Q2hlY2tlcik7XG5cbi8qKlxuICogVGhyb3dzIGlmIG11bHRpcGxlIGVudHJpZXMgdXNlIHRoZSBzYW1lIHByb3BlcnR5IG5hbWUuIE90aGVyd2lzZSBhY3RzXG4gKiBsaWtlIGBPYmplY3QuZnJvbUVudHJpZXNgIGJ1dCBoYXJkZW5zIHRoZSByZXN1bHQuXG4gKiBVc2UgaXQgdG8gcHJvdGVjdCBmcm9tIHByb3BlcnR5IG5hbWVzIGNvbXB1dGVkIGZyb20gdXNlci1wcm92aWRlZCBkYXRhLlxuICpcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEBwYXJhbSB7SXRlcmFibGU8W0ssVl0+fSBhbGxFbnRyaWVzXG4gKiBAcmV0dXJucyB7e1trOiBLXTogVn19XG4gKi9cbmNvbnN0ICAgICAgICBmcm9tVW5pcXVlRW50cmllcz0oYWxsRW50cmllcyk9PntcbmNvbnN0IGVudHJpZXNBcnJheT1bLi4uYWxsRW50cmllc107XG5jb25zdCByZXN1bHQ9aGFyZGVuKGZyb21FbnRyaWVzKGVudHJpZXNBcnJheSkpO1xuaWYob3duS2V5cyhyZXN1bHQpLmxlbmd0aD09PWVudHJpZXNBcnJheS5sZW5ndGgpe1xucmV0dXJuIHJlc3VsdDtcbiB9XG5jb25zdCBuYW1lcz1uZXcgU2V0KCk7XG5mb3IoY29uc3RbbmFtZSxfXW9mIGVudHJpZXNBcnJheSl7XG5pZihuYW1lcy5oYXMobmFtZSkpe1xuRmFpbCBgY29sbGlzaW9uIG9uIHByb3BlcnR5IG5hbWUgJHtxKG5hbWUpfTogJHtlbnRyaWVzQXJyYXl9YDtcbiB9XG5uYW1lcy5hZGQobmFtZSk7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IGZhaWxlZCB0byBjcmVhdGUgb2JqZWN0IGZyb20gdW5pcXVlIGVudHJpZXNgO1xuIH07JGjigI1fb25jZS5mcm9tVW5pcXVlRW50cmllcyhmcm9tVW5pcXVlRW50cmllcyk7XG5oYXJkZW4oZnJvbVVuaXF1ZUVudHJpZXMpO1xuXG4vKipcbiAqIEJ5IGFuYWxvZ3kgd2l0aCBob3cgYEFycmF5LnByb3RvdHlwZS5tYXBgIHdpbGwgbWFwIHRoZSBlbGVtZW50cyBvZlxuICogYW4gYXJyYXkgdG8gdHJhbnNmb3JtZWQgZWxlbWVudHMgb2YgYW4gYXJyYXkgb2YgdGhlIHNhbWUgc2hhcGUsXG4gKiBgb2JqZWN0TWFwYCB3aWxsIGRvIGxpa2V3aXNlIGZvciB0aGUgc3RyaW5nLW5hbWVkIG93biBlbnVtZXJhYmxlXG4gKiBwcm9wZXJ0aWVzIG9mIGFuIG9iamVjdC5cbiAqXG4gKiBUeXBpY2FsIHVzYWdlIGFwcGxpZXMgYG9iamVjdE1hcGAgdG8gYSBDb3B5UmVjb3JkLCBpLmUuLFxuICogYW4gb2JqZWN0IGZvciB3aGljaCBgcGFzc1N0eWxlT2Yob3JpZ2luYWwpID09PSAnY29weVJlY29yZCdgLiBGb3IgdGhlc2UsXG4gKiBub25lIG9mIHRoZSBmb2xsb3dpbmcgZWRnZSBjYXNlcyBhcmlzZS4gVGhlIHJlc3VsdCB3aWxsIGJlIGEgQ29weVJlY29yZFxuICogd2l0aCBleGFjdGx5IHRoZSBzYW1lIHByb3BlcnR5IG5hbWVzLCB3aG9zZSB2YWx1ZXMgYXJlIHRoZSBtYXBwZWQgZm9ybSBvZlxuICogdGhlIG9yaWdpbmFsJ3MgdmFsdWVzLlxuICpcbiAqIFdoZW4gdGhlIG9yaWdpbmFsIGlzIG5vdCBhIENvcHlSZWNvcmQsIHNvbWUgZWRnZSBjYXNlcyB0byBiZSBhd2FyZSBvZlxuICogICAgKiBObyBtYXR0ZXIgaG93IG11dGFibGUgdGhlIG9yaWdpbmFsIG9iamVjdCwgdGhlIHJldHVybmVkIG9iamVjdCBpc1xuICogICAgICBoYXJkZW5lZC5cbiAqICAgICogT25seSB0aGUgc3RyaW5nLW5hbWVkIGVudW1lcmFibGUgb3duIHByb3BlcnRpZXMgb2YgdGhlIG9yaWdpbmFsXG4gKiAgICAgIGFyZSBtYXBwZWQuIEFsbCBvdGhlciBwcm9wZXJ0aWVzIGFyZSBpZ25vcmVkLlxuICogICAgKiBJZiBhbnkgb2YgdGhlIG9yaWdpbmFsIHByb3BlcnRpZXMgd2VyZSBhY2Nlc3NvcnMsIGBPYmplY3QuZW50cmllc2BcbiAqICAgICAgd2lsbCBjYXVzZSBpdHMgYGdldHRlcmAgdG8gYmUgY2FsbGVkIGFuZCB3aWxsIHVzZSB0aGUgcmVzdWx0aW5nXG4gKiAgICAgIHZhbHVlLlxuICogICAgKiBObyBtYXR0ZXIgd2hldGhlciB0aGUgb3JpZ2luYWwgcHJvcGVydHkgd2FzIGFuIGFjY2Vzc29yLCB3cml0YWJsZSxcbiAqICAgICAgb3IgY29uZmlndXJhYmxlLCBhbGwgdGhlIHByb3BlcnRpZXMgb2YgdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGJlXG4gKiAgICAgIG5vbi13cml0YWJsZSwgbm9uLWNvbmZpZ3VyYWJsZSwgZGF0YSBwcm9wZXJ0aWVzLlxuICogICAgKiBObyBtYXR0ZXIgd2hhdCB0aGUgb3JpZ2luYWwgb2JqZWN0IG1heSBoYXZlIGluaGVyaXRlZCBmcm9tLCBhbmRcbiAqICAgICAgbm8gbWF0dGVyIHdoZXRoZXIgaXQgd2FzIGEgc3BlY2lhbCBraW5kIG9mIG9iamVjdCBzdWNoIGFzIGFuIGFycmF5LFxuICogICAgICB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYWx3YXlzIGJlIGEgcGxhaW4gb2JqZWN0IGluaGVyaXRpbmcgZGlyZWN0bHlcbiAqICAgICAgZnJvbSBgT2JqZWN0LnByb3RvdHlwZWAgYW5kIHdob3NlIHN0YXRlIGlzIG9ubHkgdGhlc2UgbmV3IG1hcHBlZFxuICogICAgICBvd24gcHJvcGVydGllcy5cbiAqXG4gKiBXaXRoIHRoZXNlIGRpZmZlcmVuY2VzLCBldmVuIGlmIHRoZSBvcmlnaW5hbCBvYmplY3Qgd2FzIG5vdCBhIENvcHlSZWNvcmQsXG4gKiBpZiBhbGwgdGhlIG1hcHBlZCB2YWx1ZXMgYXJlIFBhc3NhYmxlLCB0aGVuIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBiZVxuICogYSBDb3B5UmVjb3JkLlxuICpcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgYW55Pn0gT1xuICogQHBhcmFtIHtPfSBvcmlnaW5hbFxuICogQHRlbXBsYXRlIFIgbWFwIHJlc3VsdFxuICogQHBhcmFtIHsodmFsdWU6IE9ba2V5b2YgT10sIGtleToga2V5b2YgTykgPT4gUn0gbWFwRm5cbiAqIEByZXR1cm5zIHt7IFtQIGluIGtleW9mIE9dOiBSfX1cbiAqL1xuY29uc3QgICAgICAgIG9iamVjdE1hcD0ob3JpZ2luYWwsbWFwRm4pPT57XG5jb25zdCBlbnRzPWVudHJpZXMob3JpZ2luYWwpO1xuY29uc3QgbWFwRW50cz1lbnRzLm1hcCgoW2ssdl0pPT5bayxtYXBGbih2LGspXSk7XG5yZXR1cm4gaGFyZGVuKGZyb21FbnRyaWVzKG1hcEVudHMpKTtcbiB9OyRo4oCNX29uY2Uub2JqZWN0TWFwKG9iamVjdE1hcCk7XG5oYXJkZW4ob2JqZWN0TWFwKTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHtBcnJheTxzdHJpbmcgfCBzeW1ib2w+fSBsZWZ0TmFtZXNcbiAqIEBwYXJhbSB7QXJyYXk8c3RyaW5nIHwgc3ltYm9sPn0gcmlnaHROYW1lc1xuICovXG5jb25zdCAgICAgICAgbGlzdERpZmZlcmVuY2U9KGxlZnROYW1lcyxyaWdodE5hbWVzKT0+e1xuY29uc3QgcmlnaHRTZXQ9bmV3IFNldChyaWdodE5hbWVzKTtcbnJldHVybiBsZWZ0TmFtZXMuZmlsdGVyKChuYW1lKT0+IXJpZ2h0U2V0LmhhcyhuYW1lKSk7XG4gfTskaOKAjV9vbmNlLmxpc3REaWZmZXJlbmNlKGxpc3REaWZmZXJlbmNlKTtcbmhhcmRlbihsaXN0RGlmZmVyZW5jZSk7XG5cbi8qKlxuICogQHBhcmFtIHtFcnJvcn0gaW5uZXJFcnJcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcn0gbGFiZWxcbiAqIEBwYXJhbSB7RXJyb3JDb25zdHJ1Y3Rvcj19IEVycm9yQ29uc3RydWN0b3JcbiAqIEByZXR1cm5zIHtuZXZlcn1cbiAqL1xuXG4vKiBFdmFkZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vaXNzdWVzLzE0NTAgdXNpbmcgYmxhbmsgbGluZSovXG5jb25zdCAgICAgICAgdGhyb3dMYWJlbGVkPShpbm5lckVycixsYWJlbCxFcnJvckNvbnN0cnVjdG9yPXVuZGVmaW5lZCk9PntcbmlmKHR5cGVvZiBsYWJlbD09PSdudW1iZXInKXtcbmxhYmVsPSBgWyR7bGFiZWx9XWA7XG4gfVxuY29uc3Qgb3V0ZXJFcnI9YXNzZXJ0LmVycm9yKFxuIGAke2xhYmVsfTogJHtpbm5lckVyci5tZXNzYWdlfWAsXG5FcnJvckNvbnN0cnVjdG9yKTtcblxuYXNzZXJ0Lm5vdGUob3V0ZXJFcnIsWCBgQ2F1c2VkIGJ5ICR7aW5uZXJFcnJ9YCk7XG50aHJvdyBvdXRlckVycjtcbiB9OyRo4oCNX29uY2UudGhyb3dMYWJlbGVkKHRocm93TGFiZWxlZCk7XG5oYXJkZW4odGhyb3dMYWJlbGVkKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgQSxSXG4gKiBAcGFyYW0geyguLi5hcmdzOiBBW10pID0+IFJ9IGZ1bmNcbiAqIEBwYXJhbSB7QVtdfSBhcmdzXG4gKiBAcGFyYW0ge3N0cmluZ3xudW1iZXJ9IFtsYWJlbF1cbiAqIEByZXR1cm5zIHtSfVxuICovXG5jb25zdCAgICAgICAgYXBwbHlMYWJlbGluZ0Vycm9yPShmdW5jLGFyZ3MsbGFiZWw9dW5kZWZpbmVkKT0+e1xuaWYobGFiZWw9PT11bmRlZmluZWQpe1xucmV0dXJuIGZ1bmMoLi4uYXJncyk7XG4gfVxubGV0IHJlc3VsdDtcbnRyeXtcbnJlc3VsdD1mdW5jKC4uLmFyZ3MpO1xuIH1jYXRjaChlcnIpe1xudGhyb3dMYWJlbGVkKGVycixsYWJlbCk7XG4gfVxuaWYoaXNQcm9taXNlKHJlc3VsdCkpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBJZiByZXN1bHQgaXMgYSByZWplY3RlZCBwcm9taXNlLCB0aGlzIHdpbGwqL1xuLyogcmV0dXJuIGEgcHJvbWlzZSB3aXRoIGEgZGlmZmVyZW50IHJlamVjdGlvbiByZWFzb24uIEJ1dCB0aGlzKi9cbi8qIGNvbmZ1c2VzIFR5cGVTY3JpcHQgYmVjYXVzZSBpdCB0eXBlcyB0aGF0IGNhc2UgYXMgYFByb21pc2U8bmV2ZXI+YCovXG4vKiB3aGljaCBpcyBjb29sIGZvciBhIHByb21pc2UgdGhhdCB3aWxsIG5ldmVyIGZ1bGZsbC4qL1xuLyogQnV0IFR5cGVTY3JpcHQgZG9lc24ndCB1bmRlcnN0YW5kIHRoYXQgdGhpcyB3aWxsIG9ubHkgaGFwcGVuKi9cbi8qIHdoZW4gYHJlc3VsdGAgd2FzIGEgcmVqZWN0ZWQgcHJvbWlzZS4gSW4gb25seSB0aGlzIGNhc2UgYFJgKi9cbi8qIHNob3VsZCBhbHJlYWR5IGFsbG93IGBQcm9taXNlPG5ldmVyPmAgYXMgYSBzdWJ0eXBlLiovXG5yZXR1cm4gRS53aGVuKHJlc3VsdCx1bmRlZmluZWQsKHJlYXNvbik9PnRocm93TGFiZWxlZChyZWFzb24sbGFiZWwpKTtcbiB9ZWxzZXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH07JGjigI1fb25jZS5hcHBseUxhYmVsaW5nRXJyb3IoYXBwbHlMYWJlbGluZ0Vycm9yKTtcbmhhcmRlbihhcHBseUxhYmVsaW5nRXJyb3IpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlkZW50Q2hlY2tlciI6WyJpZGVudENoZWNrZXIiXSwiZnJvbVVuaXF1ZUVudHJpZXMiOlsiZnJvbVVuaXF1ZUVudHJpZXMiXSwib2JqZWN0TWFwIjpbIm9iamVjdE1hcCJdLCJsaXN0RGlmZmVyZW5jZSI6WyJsaXN0RGlmZmVyZW5jZSJdLCJ0aHJvd0xhYmVsZWQiOlsidGhyb3dMYWJlbGVkIl0sImFwcGx5TGFiZWxpbmdFcnJvciI6WyJhcHBseUxhYmVsaW5nRXJyb3IiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAClK+n3AJAABwCQAAIgAAAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvaXMtcHJvbWlzZS5qcyIsIi4vc3JjL21lbW8tcmFjZS5qcyIsIi4vc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiZXhwb3J0cyI6WyJtYWtlUHJvbWlzZUtpdCIsInJhY2VQcm9taXNlcyJdLCJyZWV4cG9ydHMiOlsiLi9zcmMvaXMtcHJvbWlzZS5qcyIsIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCxtZW1vUmFjZTskaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc1wiLCBbW1wibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0XCIsIFskaOKAjV9hID0+IChtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQgPSAkaOKAjV9hKV1dXV0sW1wiLi9zcmMvbWVtby1yYWNlLmpzXCIsIFtbXCJtZW1vUmFjZVwiLCBbJGjigI1fYSA9PiAobWVtb1JhY2UgPSAkaOKAjV9hKV1dXV0sW1wiLi9zcmMvaXMtcHJvbWlzZS5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VQcm9taXNlS2l0LCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlUHJvbWlzZUtpdFwifSk7JGjigI1fb25jZS5tYWtlUHJvbWlzZUtpdChtYWtlUHJvbWlzZUtpdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KHJhY2VQcm9taXNlcywgJ25hbWUnLCB7dmFsdWU6IFwicmFjZVByb21pc2VzXCJ9KTskaOKAjV9vbmNlLnJhY2VQcm9taXNlcyhyYWNlUHJvbWlzZXMpOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGUge1Byb21pc2VDb25zdHJ1Y3Rvcn0gKi9cbmNvbnN0IEJlc3RQaXBlbGluYWJsZVByb21pc2U9Z2xvYmFsVGhpcy5IYW5kbGVkUHJvbWlzZXx8UHJvbWlzZTtcblxuLyoqXG4gKiBtYWtlUHJvbWlzZUtpdCgpIGJ1aWxkcyBhIFByb21pc2Ugb2JqZWN0LCBhbmQgcmV0dXJucyBhIHJlY29yZFxuICogY29udGFpbmluZyB0aGUgcHJvbWlzZSBpdHNlbGYsIGFzIHdlbGwgYXMgc2VwYXJhdGUgZmFjZXRzIGZvciByZXNvbHZpbmdcbiAqIGFuZCByZWplY3RpbmcgaXQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEByZXR1cm5zIHtYaW1wb3J0KCcuL3NyYy90eXBlcy5qcycpLlByb21pc2VLaXQ8VD59XG4gKi9cbmZ1bmN0aW9uICAgICAgICBtYWtlUHJvbWlzZUtpdCgpe1xuY29uc3R7cmVzb2x2ZSxyZWplY3QsZXhlY3V0b3J9PW1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCgpO1xuXG5jb25zdCBwcm9taXNlPW5ldyBCZXN0UGlwZWxpbmFibGVQcm9taXNlKGV4ZWN1dG9yKTtcblxucmV0dXJuIGhhcmRlbih7cHJvbWlzZSxyZXNvbHZlLHJlamVjdH0pO1xuIH1cbmhhcmRlbihtYWtlUHJvbWlzZUtpdCk7XG5cbi8qIE5COiBBbm90aGVyIGltcGxlbWVudGF0aW9uIGZvciBQcm9taXNlLnJhY2Ugd291bGQgYmUgdG8gdXNlIHRoZSByZWxlYXNpbmcgZXhlY3V0b3IsKi9cbi8qIEhvd2V2ZXIgd2hpbGUgaXQgd291bGQgbm8gbG9uZ2VyIGxlYWsgdGhlIHJhY2VkIHByb21pc2Ugb2JqZWN0cyB0aGVtc2VsdmVzLCBpdCB3b3VsZCovXG4vKiBzdGlsbCBsZWFrIHJlYWN0aW9ucyBvbiB0aGUgbm9uLXJlc29sdmVkIHByb21pc2VzIGNvbnRlbmRpbmcgZm9yIHRoZSByYWNlLiovXG5cbi8qKlxuICogQ3JlYXRlcyBhIFByb21pc2UgdGhhdCBpcyByZXNvbHZlZCBvciByZWplY3RlZCB3aGVuIGFueSBvZiB0aGUgcHJvdmlkZWQgUHJvbWlzZXMgYXJlIHJlc29sdmVkXG4gKiBvciByZWplY3RlZC5cbiAqXG4gKiBVbmxpa2UgYFByb21pc2UucmFjZWAgaXQgY2xlYW5zIHVwIGFmdGVyIGl0c2VsZiBzbyBhIG5vbi1yZXNvbHZlZCB2YWx1ZSBkb2Vzbid0IGhvbGQgb250b1xuICogdGhlIHJlc3VsdCBwcm9taXNlLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFQ+fSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFQ+Pn0gQSBuZXcgUHJvbWlzZS5cbiAqL1xuZnVuY3Rpb24gICAgICAgIHJhY2VQcm9taXNlcyh2YWx1ZXMpe1xucmV0dXJuIGhhcmRlbihtZW1vUmFjZS5jYWxsKEJlc3RQaXBlbGluYWJsZVByb21pc2UsdmFsdWVzKSk7XG4gfVxuaGFyZGVuKHJhY2VQcm9taXNlcyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVByb21pc2VLaXQiOlsibWFrZVByb21pc2VLaXQiXSwicmFjZVByb21pc2VzIjpbInJhY2VQcm9taXNlcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACIfYGs3wIAAN8CAAArAAAAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41Ni9zcmMvaXMtcHJvbWlzZS5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiaXNQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KGlzUHJvbWlzZSwgJ25hbWUnLCB7dmFsdWU6IFwiaXNQcm9taXNlXCJ9KTskaOKAjV9vbmNlLmlzUHJvbWlzZShpc1Byb21pc2UpOyAgIC8qKlxuICogRGV0ZXJtaW5lIGlmIHRoZSBhcmd1bWVudCBpcyBhIFByb21pc2UuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBtYXliZVByb21pc2UgVGhlIHZhbHVlIHRvIGV4YW1pbmVcbiAqIEByZXR1cm5zIHttYXliZVByb21pc2UgaXMgUHJvbWlzZX0gV2hldGhlciBpdCBpcyBhIHByb21pc2VcbiAqL1xuZnVuY3Rpb24gICAgICAgIGlzUHJvbWlzZShtYXliZVByb21pc2Upe1xucmV0dXJuIFByb21pc2UucmVzb2x2ZShtYXliZVByb21pc2UpPT09bWF5YmVQcm9taXNlO1xuIH1cbmhhcmRlbihpc1Byb21pc2UpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzUHJvbWlzZSI6WyJpc1Byb21pc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAHadN674SAAC+EgAAKgAAAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYvc3JjL21lbW8tcmFjZS5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsibWVtb1JhY2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBJbml0aWFsIHZlcnNpb24gYXV0aG9yZWQgYnkgQnJpYW4gS2ltOlxuaHR0cHM6Ly9naXRodWIuY29tL25vZGVqcy9ub2RlL2lzc3Vlcy8xNzQ2OSNpc3N1ZWNvbW1lbnQtNjg1MjE2Nzc3XG4gVGhpcyBpcyBmcmVlIGFuZCB1bmVuY3VtYmVyZWQgc29mdHdhcmUgcmVsZWFzZWQgaW50byB0aGUgcHVibGljIGRvbWFpbi5cbiBBbnlvbmUgaXMgZnJlZSB0byBjb3B5LCBtb2RpZnksIHB1Ymxpc2gsIHVzZSwgY29tcGlsZSwgc2VsbCwgb3JcbmRpc3RyaWJ1dGUgdGhpcyBzb2Z0d2FyZSwgZWl0aGVyIGluIHNvdXJjZSBjb2RlIGZvcm0gb3IgYXMgYSBjb21waWxlZFxuYmluYXJ5LCBmb3IgYW55IHB1cnBvc2UsIGNvbW1lcmNpYWwgb3Igbm9uLWNvbW1lcmNpYWwsIGFuZCBieSBhbnlcbm1lYW5zLlxuIEluIGp1cmlzZGljdGlvbnMgdGhhdCByZWNvZ25pemUgY29weXJpZ2h0IGxhd3MsIHRoZSBhdXRob3Igb3IgYXV0aG9yc1xub2YgdGhpcyBzb2Z0d2FyZSBkZWRpY2F0ZSBhbnkgYW5kIGFsbCBjb3B5cmlnaHQgaW50ZXJlc3QgaW4gdGhlXG5zb2Z0d2FyZSB0byB0aGUgcHVibGljIGRvbWFpbi4gV2UgbWFrZSB0aGlzIGRlZGljYXRpb24gZm9yIHRoZSBiZW5lZml0XG5vZiB0aGUgcHVibGljIGF0IGxhcmdlIGFuZCB0byB0aGUgZGV0cmltZW50IG9mIG91ciBoZWlycyBhbmRcbnN1Y2Nlc3NvcnMuIFdlIGludGVuZCB0aGlzIGRlZGljYXRpb24gdG8gYmUgYW4gb3ZlcnQgYWN0IG9mXG5yZWxpbnF1aXNobWVudCBpbiBwZXJwZXR1aXR5IG9mIGFsbCBwcmVzZW50IGFuZCBmdXR1cmUgcmlnaHRzIHRvIHRoaXNcbnNvZnR3YXJlIHVuZGVyIGNvcHlyaWdodCBsYXcuXG4gVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEIFwiQVMgSVNcIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCxcbkVYUFJFU1MgT1IgSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRlxuTUVSQ0hBTlRBQklMSVRZLCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULlxuSU4gTk8gRVZFTlQgU0hBTEwgVEhFIEFVVEhPUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1Jcbk9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLFxuQVJJU0lORyBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SXG5PVEhFUiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuXG4gRm9yIG1vcmUgaW5mb3JtYXRpb24sIHBsZWFzZSByZWZlciB0byA8aHR0cDovL3VubGljZW5zZS5vcmcvPlxuKi9cblxuXG5cblxuXG5cblxuY29uc3QgaXNPYmplY3Q9KHZhbHVlKT0+T2JqZWN0KHZhbHVlKT09PXZhbHVlO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBbVD1hbnldXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWZlcnJlZFxuICogQHByb3BlcnR5IHsodmFsdWU/OiBYaW1wb3J0KFwiLi90eXBlcy5qc1wiKS5FUmVmPFQ+ICkgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHByb3BlcnR5IHsoZXJyPzogYW55ICkgPT4gdm9pZH0gcmVqZWN0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IG5ldmVyXG4gKiAgfCB7c2V0dGxlZDogZmFsc2UsIGRlZmVycmVkczogU2V0PERlZmVycmVkPn1cbiAqICB8IHtzZXR0bGVkOiB0cnVlLCBkZWZlcnJlZHM/OiB1bmRlZmluZWR9XG4gKiB9IFByb21pc2VNZW1vUmVjb3JkXG4gKi9cblxuLyogS2V5cyBhcmUgdGhlIHZhbHVlcyBwYXNzZWQgdG8gcmFjZSwgdmFsdWVzIGFyZSBhIHJlY29yZCBvZiBkYXRhIGNvbnRhaW5pbmcgYSovXG4vKiBzZXQgb2YgZGVmZXJyZWRzIGFuZCB3aGV0aGVyIHRoZSB2YWx1ZSBoYXMgc2V0dGxlZC4qL1xuLyoqIEB0eXBlIHtXZWFrTWFwPG9iamVjdCwgUHJvbWlzZU1lbW9SZWNvcmQ+fSAqL1xuY29uc3Qga25vd25Qcm9taXNlcz1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UHJvbWlzZU1lbW9SZWNvcmQgfCB1bmRlZmluZWR9IHJlY29yZFxuICogQHJldHVybnMge1NldDxEZWZlcnJlZD59XG4gKi9cbmNvbnN0IG1hcmtTZXR0bGVkPShyZWNvcmQpPT57XG5pZighcmVjb3JkfHxyZWNvcmQuc2V0dGxlZCl7XG5yZXR1cm4gbmV3IFNldCgpO1xuIH1cblxuY29uc3R7ZGVmZXJyZWRzfT1yZWNvcmQ7XG5PYmplY3QuYXNzaWduKHJlY29yZCx7XG5kZWZlcnJlZHM6dW5kZWZpbmVkLFxuc2V0dGxlZDp0cnVlfSk7XG5cbk9iamVjdC5mcmVlemUocmVjb3JkKTtcbnJldHVybiBkZWZlcnJlZHM7XG4gfTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHthbnl9IHZhbHVlXG4gKiBAcmV0dXJucyB7UHJvbWlzZU1lbW9SZWNvcmR9XG4gKi9cbmNvbnN0IGdldE1lbW9SZWNvcmQ9KHZhbHVlKT0+e1xuaWYoIWlzT2JqZWN0KHZhbHVlKSl7XG4vKiBJZiB0aGUgY29udGVuZGVyIGlzIGEgcHJpbWl0aXZlLCBhdHRlbXB0aW5nIHRvIHVzZSBpdCBhcyBhIGtleSBpbiB0aGUqL1xuLyogd2Vha21hcCB3b3VsZCB0aHJvdyBhbiBlcnJvci4gTHVja2lseSwgaXQgaXMgc2FmZSB0byBjYWxsKi9cbi8qIGBQcm9taXNlLnJlc29sdmUoY29udGVuZGVyKS50aGVuYCBvbiBhIHByaW1pdGl2ZSB2YWx1ZSBtdWx0aXBsZSB0aW1lcyovXG4vKiBiZWNhdXNlIHRoZSBwcm9taXNlIGZ1bGZpbGxzIGltbWVkaWF0ZWx5LiBTbyB3ZSBmYWtlIGEgc2V0dGxlZCByZWNvcmQuKi9cbnJldHVybiBoYXJkZW4oe3NldHRsZWQ6dHJ1ZX0pO1xuIH1cblxubGV0IHJlY29yZD1rbm93blByb21pc2VzLmdldCh2YWx1ZSk7XG5cbmlmKCFyZWNvcmQpe1xucmVjb3JkPXtkZWZlcnJlZHM6bmV3IFNldCgpLHNldHRsZWQ6ZmFsc2V9O1xua25vd25Qcm9taXNlcy5zZXQodmFsdWUscmVjb3JkKTtcbi8qIFRoaXMgY2FsbCB0byBgdGhlbmAgaGFwcGVucyBvbmNlIGZvciB0aGUgbGlmZXRpbWUgb2YgdGhlIHZhbHVlLiovXG5Qcm9taXNlLnJlc29sdmUodmFsdWUpLnRoZW4oXG4odmFsKT0+e1xuZm9yKGNvbnN0e3Jlc29sdmV9b2YgbWFya1NldHRsZWQocmVjb3JkKSl7XG5yZXNvbHZlKHZhbCk7XG4gfVxuIH0sXG4oZXJyKT0+e1xuZm9yKGNvbnN0e3JlamVjdH1vZiBtYXJrU2V0dGxlZChyZWNvcmQpKXtcbnJlamVjdChlcnIpO1xuIH1cbiB9KTtcblxuIH1cbnJldHVybiByZWNvcmQ7XG4gfTtcblxuY29uc3R7cmFjZX09e1xuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0ZW1wbGF0ZSB7UHJvbWlzZUNvbnN0cnVjdG9yfSBbUD1Qcm9taXNlQ29uc3RydWN0b3JdXG4gKiBAdGhpcyB7UH1cbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IHZhbHVlcyBBbiBpdGVyYWJsZSBvZiBQcm9taXNlcy5cbiAqIEByZXR1cm5zIHtQcm9taXNlPEF3YWl0ZWQ8VD4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5yYWNlKHZhbHVlcyl7XG5sZXQgZGVmZXJyZWQ7XG4vKiogQHR5cGUge1RbXX0gKi9cbmNvbnN0IGNhY2hlZFZhbHVlcz1bXTtcbmNvbnN0IEM9dGhpcztcbmNvbnN0IHJlc3VsdD1uZXcgQygocmVzb2x2ZSxyZWplY3QpPT57XG5kZWZlcnJlZD17cmVzb2x2ZSxyZWplY3R9O1xuZm9yKGNvbnN0IHZhbHVlIG9mIHZhbHVlcyl7XG5jYWNoZWRWYWx1ZXMucHVzaCh2YWx1ZSk7XG5jb25zdHtzZXR0bGVkLGRlZmVycmVkc309Z2V0TWVtb1JlY29yZCh2YWx1ZSk7XG5pZihzZXR0bGVkKXtcbi8qIElmIHRoZSBjb250ZW5kZXIgaXMgc2V0dGxlZCAoaW5jbHVkaW5nIHByaW1pdGl2ZXMpLCBpdCBpcyBzYWZlKi9cbi8qIHRvIGNhbGwgYFByb21pc2UucmVzb2x2ZSh2YWx1ZSkudGhlbmAgb24gaXQuKi9cbkMucmVzb2x2ZSh2YWx1ZSkudGhlbihyZXNvbHZlLHJlamVjdCk7XG4gfWVsc2V7XG5kZWZlcnJlZHMuYWRkKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuXG4vKiBUaGUgZmluYWxseSBjYWxsYmFjayBleGVjdXRlcyB3aGVuIGFueSB2YWx1ZSBzZXR0bGVzLCBwcmV2ZW50aW5nIGFueSBvZiovXG4vKiB0aGUgdW5yZXNvbHZlZCB2YWx1ZXMgZnJvbSByZXRhaW5pbmcgYSByZWZlcmVuY2UgdG8gdGhlIHJlc29sdmVkIHZhbHVlLiovXG5yZXR1cm4gcmVzdWx0LmZpbmFsbHkoKCk9PntcbmZvcihjb25zdCB2YWx1ZSBvZiBjYWNoZWRWYWx1ZXMpe1xuY29uc3R7ZGVmZXJyZWRzfT1nZXRNZW1vUmVjb3JkKHZhbHVlKTtcbmlmKGRlZmVycmVkcyl7XG5kZWZlcnJlZHMuZGVsZXRlKGRlZmVycmVkKTtcbiB9XG4gfVxuIH0pO1xuIH19OyRo4oCNX29uY2UucmFjZShyYWNlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtZW1vUmFjZSI6WyJyYWNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAANNDsO5pBwAAaQcAADUAAABAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQGNhbGxiYWNrIFByb21pc2VFeGVjdXRvciBUaGUgcHJvbWlzZSBleGVjdXRvclxuICogQHBhcmFtIHsodmFsdWU6IFhpbXBvcnQoJy4vdHlwZXMuanMnKS5FUmVmPFQ+KSA9PiB2b2lkfSByZXNvbHZlXG4gKiBAcGFyYW0geyhyZWFzb246IGFueSkgPT4gdm9pZH0gcmVqZWN0XG4gKi9cblxuLyoqXG4gKiBtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQoKSBidWlsZHMgcmVzb2x2ZS9yZWplY3QgZnVuY3Rpb25zIHdoaWNoIGRyb3AgcmVmZXJlbmNlc1xuICogdG8gdGhlIHJlc29sdmUvcmVqZWN0IGZ1bmN0aW9ucyBnYXRoZXJlZCBmcm9tIGFuIGV4ZWN1dG9yIHRvIGJlIHVzZWQgd2l0aCBhXG4gKiBwcm9taXNlIGNvbnN0cnVjdG9yLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcmV0dXJucyB7UGljazxYaW1wb3J0KCcuL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPiwgJ3Jlc29sdmUnIHwgJ3JlamVjdCc+ICYgeyBleGVjdXRvcjogUHJvbWlzZUV4ZWN1dG9yPFQ+fX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdD0oKT0+e1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKCh2YWx1ZTogWGltcG9ydCgnLi90eXBlcy5qcycpLkVSZWY8VD4pID0+IHZvaWQpfSAqL1xubGV0IGludGVybmFsUmVzb2x2ZTtcbi8qKiBAdHlwZSB7bnVsbCB8IHVuZGVmaW5lZCB8ICgocmVhc29uOiB1bmtub3duKSA9PiB2b2lkKX0gKi9cbmxldCBpbnRlcm5hbFJlamVjdDtcblxuLyoqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLkVSZWY8VD59IHZhbHVlICovXG5jb25zdCByZXNvbHZlPSh2YWx1ZSk9PntcbmlmKGludGVybmFsUmVzb2x2ZSl7XG5pbnRlcm5hbFJlc29sdmUodmFsdWUpO1xuaW50ZXJuYWxSZXNvbHZlPW51bGw7XG5pbnRlcm5hbFJlamVjdD1udWxsO1xuIH1lbHNle1xuYXNzZXJ0KGludGVybmFsUmVzb2x2ZT09PW51bGwpO1xuIH1cbiB9O1xuXG4vKiogQHBhcmFtIHt1bmtub3dufSByZWFzb24gKi9cbmNvbnN0IHJlamVjdD0ocmVhc29uKT0+e1xuaWYoaW50ZXJuYWxSZWplY3Qpe1xuaW50ZXJuYWxSZWplY3QocmVhc29uKTtcbmludGVybmFsUmVzb2x2ZT1udWxsO1xuaW50ZXJuYWxSZWplY3Q9bnVsbDtcbiB9ZWxzZXtcbmFzc2VydChpbnRlcm5hbFJlamVjdD09PW51bGwpO1xuIH1cbiB9O1xuXG5jb25zdCBleGVjdXRvcj0ocmVzLHJlaik9PntcbmFzc2VydChpbnRlcm5hbFJlc29sdmU9PT11bmRlZmluZWQmJmludGVybmFsUmVqZWN0PT09dW5kZWZpbmVkKTtcbmludGVybmFsUmVzb2x2ZT1yZXM7XG5pbnRlcm5hbFJlamVjdD1yZWo7XG4gfTtcblxucmV0dXJuIGhhcmRlbih7cmVzb2x2ZSxyZWplY3QsZXhlY3V0b3J9KTtcbiB9OyRo4oCNX29uY2UubWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCk7XG5oYXJkZW4obWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQiOlsibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJgZO7M0AQAANAEAACYAAABAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAMriXk9BgAAPQYAAAdAAAAQGVuZG8vc3RyZWFtLXYwLjMuMjUvaW5kZXguanN7ImltcG9ydHMiOlsiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL3Byb21pc2Uta2l0Il0sImV4cG9ydHMiOlsibWFrZVBpcGUiLCJtYWtlUXVldWUiLCJtYWtlU3RyZWFtIiwibWFwUmVhZGVyIiwibWFwV3JpdGVyIiwicHJpbWUiLCJwdW1wIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsbWFrZVByb21pc2VLaXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wcm9taXNlLWtpdFwiLCBbW1wibWFrZVByb21pc2VLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VQcm9taXNlS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7e1xuICogICByZXNvbHZlKHZhbHVlPzogVCB8IFByb21pc2U8VD4pOiB2b2lkLFxuICogICByZWplY3QoZXJyb3I6IEVycm9yKTogdm9pZCxcbiAqICAgcHJvbWlzZTogUHJvbWlzZTxUPlxuICogfX0gUHJvbWlzZUtpdFxuICovXG5cbi8qIFR5cGVTY3JpcHQgUmVhZE9ubHkgc2VtYW50aWNzIGFyZSBub3Qgc3VmZmljaWVudGx5IGV4cHJlc3NpdmUgdG8gZGlzdGluZ3Vpc2gqL1xuLyogYSB2YWx1ZSBvbmUgcHJvbWlzZXMgbm90IHRvIGFsdGVyIGZyb20gYSB2YWx1ZSBvbmUgbXVzdCBub3QgYWx0ZXIsKi9cbi8qIG1ha2luZyBpdCB1c2VsZXNzLiovXG5jb25zdCBmcmVlemU9LyoqIEB0eXBlIHs8VD4odjogVCB8IFJlYWRvbmx5PFQ+KSA9PiBUfSAqL09iamVjdC5mcmVlemU7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEByZXR1cm5zIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQXN5bmNRdWV1ZTxUPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VRdWV1ZT0oKT0+e1xubGV0e3Byb21pc2U6dGFpbFByb21pc2UscmVzb2x2ZTp0YWlsUmVzb2x2ZX09bWFrZVByb21pc2VLaXQoKTtcbnJldHVybntcbnB1dCh2YWx1ZSl7XG5jb25zdHtyZXNvbHZlLHByb21pc2V9PW1ha2VQcm9taXNlS2l0KCk7XG50YWlsUmVzb2x2ZShmcmVlemUoe3ZhbHVlLHByb21pc2V9KSk7XG50YWlsUmVzb2x2ZT1yZXNvbHZlO1xuIH0sXG5nZXQoKXtcbmNvbnN0IHByb21pc2U9dGFpbFByb21pc2UudGhlbigobmV4dCk9Pm5leHQudmFsdWUpO1xudGFpbFByb21pc2U9dGFpbFByb21pc2UudGhlbigobmV4dCk9Pm5leHQucHJvbWlzZSk7XG5yZXR1cm4gaGFyZGVuKHByb21pc2UpO1xuIH19O1xuXG4gfTskaOKAjV9vbmNlLm1ha2VRdWV1ZShtYWtlUXVldWUpO1xuaGFyZGVuKG1ha2VRdWV1ZSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRSZWFkXG4gKiBAdGVtcGxhdGUgVFdyaXRlXG4gKiBAdGVtcGxhdGUgVFJlYWRSZXR1cm5cbiAqIEB0ZW1wbGF0ZSBUV3JpdGVSZXR1cm5cbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLkFzeW5jUXVldWU8SXRlcmF0b3JSZXN1bHQ8VFJlYWQsIFRSZWFkUmV0dXJuPj59IGFja3NcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLkFzeW5jUXVldWU8SXRlcmF0b3JSZXN1bHQ8VFdyaXRlLCBUV3JpdGVSZXR1cm4+Pn0gZGF0YVxuICovXG5jb25zdCAgICAgICAgbWFrZVN0cmVhbT0oYWNrcyxkYXRhKT0+e1xuY29uc3Qgc3RyZWFtPWhhcmRlbih7XG4vKipcbiAqIEBwYXJhbSB7VFdyaXRlfSB2YWx1ZVxuICovXG5uZXh0KHZhbHVlKXtcbi8qIE5vdGUgdGhlIHNoYWxsb3cgZnJlZXplIHNpbmNlIHZhbHVlIGlzIG5vdCBndWFyYW50ZWVkIHRvIGJlIGZyZWV6YWJsZSovXG4vKiAodHlwZWQgYXJyYXlzIGFyZSBub3QpLiovXG5kYXRhLnB1dChmcmVlemUoe3ZhbHVlLGRvbmU6ZmFsc2V9KSk7XG5yZXR1cm4gYWNrcy5nZXQoKTtcbiB9LFxuLyoqXG4gKiBAcGFyYW0ge1RXcml0ZVJldHVybn0gdmFsdWVcbiAqL1xucmV0dXJuKHZhbHVlKXtcbmRhdGEucHV0KGZyZWV6ZSh7dmFsdWUsZG9uZTp0cnVlfSkpO1xucmV0dXJuIGFja3MuZ2V0KCk7XG4gfSxcbi8qKlxuICogQHBhcmFtIHtFcnJvcn0gZXJyb3JcbiAqL1xudGhyb3coZXJyb3Ipe1xuZGF0YS5wdXQoaGFyZGVuKFByb21pc2UucmVqZWN0KGVycm9yKSkpO1xucmV0dXJuIGFja3MuZ2V0KCk7XG4gfSxcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKXtcbnJldHVybiBzdHJlYW07XG4gfX0pO1xuXG5yZXR1cm4gc3RyZWFtO1xuIH07JGjigI1fb25jZS5tYWtlU3RyZWFtKG1ha2VTdHJlYW0pO1xuaGFyZGVuKG1ha2VTdHJlYW0pO1xuXG4vKiBKU0RvYyBUeXBlU2NyaXB0IHNlZW1zIHVuYWJsZSB0byBleHByZXNzIHRoaXMgcGFydGljdWxhciBmdW5jdGlvbidzKi9cbi8qIGVudGFuZ2xlbWVudCBvZiBxdWV1ZXMsIGJ1dCB0aGUgZGVmaW5pdGlvbiBpbiB0eXBlcy5kLnRzIHdvcmtzIGZvciB0aGUgZW5kKi9cbi8qIHVzZXIuKi9cbmNvbnN0ICAgICAgICBtYWtlUGlwZT0oKT0+e1xuY29uc3QgZGF0YT1tYWtlUXVldWUoKTtcbmNvbnN0IGFja3M9bWFrZVF1ZXVlKCk7XG5jb25zdCByZWFkZXI9bWFrZVN0cmVhbShhY2tzLGRhdGEpO1xuY29uc3Qgd3JpdGVyPW1ha2VTdHJlYW0oZGF0YSxhY2tzKTtcbnJldHVybiBoYXJkZW4oW3dyaXRlcixyZWFkZXJdKTtcbiB9OyRo4oCNX29uY2UubWFrZVBpcGUobWFrZVBpcGUpO1xuaGFyZGVuKG1ha2VQaXBlKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFJlYWRcbiAqIEB0ZW1wbGF0ZSBUV3JpdGVcbiAqIEB0ZW1wbGF0ZSBUUmVhZFJldHVyblxuICogQHRlbXBsYXRlIFRXcml0ZVJldHVyblxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuU3RyZWFtPFRXcml0ZSwgVFJlYWQsIFRXcml0ZVJldHVybiwgVFJlYWRSZXR1cm4+fSB3cml0ZXJcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlN0cmVhbTxUUmVhZCwgVFdyaXRlLCBUUmVhZFJldHVybiwgVFdyaXRlUmV0dXJuPn0gcmVhZGVyXG4gKiBAcGFyYW0ge1RXcml0ZX0gcHJpbWVyXG4gKi9cbmNvbnN0ICAgICAgICBwdW1wPWFzeW5jKHdyaXRlcixyZWFkZXIscHJpbWVyKT0+e1xuLyoqIEBwYXJhbSB7UHJvbWlzZTxJdGVyYXRvclJlc3VsdDxUUmVhZCwgVFJlYWRSZXR1cm4+Pn0gcHJvbWlzZSAqL1xuY29uc3QgdGljaz0ocHJvbWlzZSk9PlxuRS53aGVuKFxucHJvbWlzZSxcbihyZXN1bHQpPT57XG5pZihyZXN1bHQuZG9uZSl7XG5yZXR1cm4gd3JpdGVyLnJldHVybihyZXN1bHQudmFsdWUpO1xuIH1lbHNle1xuLyogQmVob2xkOiBtdXR1YWwgcmVjdXJzaW9uLiovXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIHRvY2sod3JpdGVyLm5leHQocmVzdWx0LnZhbHVlKSk7XG4gfVxuIH0sXG4oLyoqIEB0eXBlIHtFcnJvcn0gKi9lcnJvcik9PntcbnJldHVybiB3cml0ZXIudGhyb3coZXJyb3IpO1xuIH0pO1xuXG4vKiogQHBhcmFtIHtQcm9taXNlPEl0ZXJhdG9yUmVzdWx0PFRXcml0ZSwgVFdyaXRlUmV0dXJuPj59IHByb21pc2UgKi9cbmNvbnN0IHRvY2s9KHByb21pc2UpPT5cbkUud2hlbihcbnByb21pc2UsXG4ocmVzdWx0KT0+e1xuaWYocmVzdWx0LmRvbmUpe1xucmV0dXJuIHJlYWRlci5yZXR1cm4ocmVzdWx0LnZhbHVlKTtcbiB9ZWxzZXtcbnJldHVybiB0aWNrKHJlYWRlci5uZXh0KHJlc3VsdC52YWx1ZSkpO1xuIH1cbiB9LFxuKC8qKiBAdHlwZSB7RXJyb3J9ICovZXJyb3IpPT57XG5yZXR1cm4gcmVhZGVyLnRocm93KGVycm9yKTtcbiB9KTtcblxuYXdhaXQgdGljayhyZWFkZXIubmV4dChwcmltZXIpKTtcbnJldHVybiB1bmRlZmluZWQ7XG4gfTskaOKAjV9vbmNlLnB1bXAocHVtcCk7XG5oYXJkZW4ocHVtcCk7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRSZWFkXG4gKiBAdGVtcGxhdGUgVFdyaXRlXG4gKiBAdGVtcGxhdGUgVFJldHVyblxuICogQHBhcmFtIHtBc3luY0dlbmVyYXRvcjxUUmVhZCwgVFJldHVybiwgVFdyaXRlPn0gZ2VuZXJhdG9yXG4gKiBAcGFyYW0ge1RXcml0ZX0gcHJpbWVyXG4gKi9cbmNvbnN0ICAgICAgICBwcmltZT0oZ2VuZXJhdG9yLHByaW1lcik9Pntcbi8qIFdlIGNhcHR1cmUgdGhlIGZpcnN0IHJldHVybmVkIHByb21pc2UuKi9cbmNvbnN0IGZpcnN0PWdlbmVyYXRvci5uZXh0KHByaW1lcik7XG4vKiogQHR5cGUge0l0ZXJhdG9yUmVzdWx0PFRSZWFkLCBUUmV0dXJuPj19ICovXG5sZXQgcmVzdWx0O1xuY29uc3QgcHJpbWVkPWhhcmRlbih7XG4vKiogQHBhcmFtIHtUV3JpdGV9IHZhbHVlICovXG4gICAgICBhc3luYyBuZXh0KHZhbHVlKXtcbmlmKHJlc3VsdD09PXVuZGVmaW5lZCl7XG5yZXN1bHQ9YXdhaXQgZmlyc3Q7XG5pZihyZXN1bHQuZG9uZSl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG5yZXR1cm4gZ2VuZXJhdG9yLm5leHQodmFsdWUpO1xuIH0sXG4vKiogQHBhcmFtIHtUUmV0dXJufSB2YWx1ZSAqL1xuICAgICAgYXN5bmMgcmV0dXJuKHZhbHVlKXtcbmlmKHJlc3VsdD09PXVuZGVmaW5lZCl7XG5yZXN1bHQ9YXdhaXQgZmlyc3Q7XG5pZihyZXN1bHQuZG9uZSl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG5yZXR1cm4gZ2VuZXJhdG9yLnJldHVybih2YWx1ZSk7XG4gfSxcbi8qKiBAcGFyYW0ge0Vycm9yfSBlcnJvciAqL1xuICAgICAgYXN5bmMgdGhyb3coZXJyb3Ipe1xuaWYocmVzdWx0PT09dW5kZWZpbmVkKXtcbnJlc3VsdD1hd2FpdCBmaXJzdDtcbmlmKHJlc3VsdC5kb25lKXtcbnRocm93IGVycm9yO1xuIH1cbiB9XG5yZXR1cm4gZ2VuZXJhdG9yLnRocm93KGVycm9yKTtcbiB9fSk7XG5cbnJldHVybiBwcmltZWQ7XG4gfTskaOKAjV9vbmNlLnByaW1lKHByaW1lKTtcbmhhcmRlbihwcmltZSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRJblxuICogQHRlbXBsYXRlIFRPdXRcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlYWRlcjxUSW4+fSByZWFkZXJcbiAqIEBwYXJhbSB7KHZhbHVlOiBUSW4pID0+IFRPdXR9IHRyYW5zZm9ybVxuICogQHJldHVybnMge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZWFkZXI8VE91dD59XG4gKi9cbmNvbnN0ICAgICAgICBtYXBSZWFkZXI9KHJlYWRlcix0cmFuc2Zvcm0pPT57XG5hc3luYyBmdW5jdGlvbip0cmFuc2Zvcm1HZW5lcmF0b3IoKXtcbmZvciBhd2FpdChjb25zdCB2YWx1ZSBvZiByZWFkZXIpe1xueWllbGQgdHJhbnNmb3JtKHZhbHVlKTtcbiB9XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbnJldHVybiBoYXJkZW4odHJhbnNmb3JtR2VuZXJhdG9yKCkpO1xuIH07JGjigI1fb25jZS5tYXBSZWFkZXIobWFwUmVhZGVyKTtcbmhhcmRlbihtYXBSZWFkZXIpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUSW5cbiAqIEB0ZW1wbGF0ZSBUT3V0XG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Xcml0ZXI8VE91dD59IHdyaXRlclxuICogQHBhcmFtIHsodmFsdWU6IFRJbikgPT4gVE91dH0gdHJhbnNmb3JtXG4gKiBAcmV0dXJucyB7WGltcG9ydCgnLi90eXBlcy5qcycpLldyaXRlcjxUSW4+fVxuICovXG5jb25zdCAgICAgICAgbWFwV3JpdGVyPSh3cml0ZXIsdHJhbnNmb3JtKT0+e1xuY29uc3QgdHJhbnNmb3JtZWRXcml0ZXI9aGFyZGVuKHtcbi8qKlxuICogQHBhcmFtIHtUSW59IHZhbHVlXG4gKi9cbiAgICAgIGFzeW5jIG5leHQodmFsdWUpe1xucmV0dXJuIHdyaXRlci5uZXh0KHRyYW5zZm9ybSh2YWx1ZSkpO1xuIH0sXG4vKipcbiAqIEBwYXJhbSB7RXJyb3J9IGVycm9yXG4gKi9cbiAgICAgIGFzeW5jIHRocm93KGVycm9yKXtcbnJldHVybiB3cml0ZXIudGhyb3coZXJyb3IpO1xuIH0sXG4vKipcbiAqIEBwYXJhbSB7dW5kZWZpbmVkfSB2YWx1ZVxuICovXG4gICAgICBhc3luYyByZXR1cm4odmFsdWUpe1xucmV0dXJuIHdyaXRlci5yZXR1cm4odmFsdWUpO1xuIH0sXG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCl7XG5yZXR1cm4gdHJhbnNmb3JtZWRXcml0ZXI7XG4gfX0pO1xuXG5yZXR1cm4gdHJhbnNmb3JtZWRXcml0ZXI7XG4gfTskaOKAjV9vbmNlLm1hcFdyaXRlcihtYXBXcml0ZXIpO1xuaGFyZGVuKG1hcFdyaXRlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVF1ZXVlIjpbIm1ha2VRdWV1ZSJdLCJtYWtlU3RyZWFtIjpbIm1ha2VTdHJlYW0iXSwibWFrZVBpcGUiOlsibWFrZVBpcGUiXSwicHVtcCI6WyJwdW1wIl0sInByaW1lIjpbInByaW1lIl0sIm1hcFJlYWRlciI6WyJtYXBSZWFkZXIiXSwibWFwV3JpdGVyIjpbIm1hcFdyaXRlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACIAPtlSxMAAEsTAAAuAAAAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL2NyYWJibGVHb3Zlcm5vci5qc3siaW1wb3J0cyI6WyJAYWdvcmljL2dvdmVybmFuY2Uvc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qcyIsIkBhZ29yaWMvZ292ZXJuYW5jZS9zcmMvY29udHJhY3RHb3Zlcm5vcktpdC5qcyIsIkBhZ29yaWMvaW50ZXJuYWwiLCJAYWdvcmljL3RpbWUiLCJAYWdvcmljL3ZhdC1kYXRhIiwiQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCJdLCJleHBvcnRzIjpbInN0YXJ0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsbWFrZVRyYWNlcixwcm92aWRlU2luZ2xldG9uLENPTlRSQUNUX0VMRUNUT1JBVEUscHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQsTSxwcmVwYXJlRXhvLFRpbWVzdGFtcFNoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9pbnRlcm5hbFwiLCBbW1wibWFrZVRyYWNlclwiLCBbJGjigI1fYSA9PiAobWFrZVRyYWNlciA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L2R1cmFiaWxpdHkuanNcIiwgW1tcInByb3ZpZGVTaW5nbGV0b25cIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVTaW5nbGV0b24gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9nb3Zlcm5hbmNlL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanNcIiwgW1tcIkNPTlRSQUNUX0VMRUNUT1JBVEVcIiwgWyRo4oCNX2EgPT4gKENPTlRSQUNUX0VMRUNUT1JBVEUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9nb3Zlcm5hbmNlL3NyYy9jb250cmFjdEdvdmVybm9yS2l0LmpzXCIsIFtbXCJwcmVwYXJlQ29udHJhY3RHb3Zlcm5vcktpdFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV0sW1wicHJlcGFyZUV4b1wiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4byA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3RpbWVcIiwgW1tcIlRpbWVzdGFtcFNoYXBlXCIsIFskaOKAjV9hID0+IChUaW1lc3RhbXBTaGFwZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuY29uc3QgdHJhY2U9bWFrZVRyYWNlcignQ3JhYmJsZUdvdmVybmFuY2UnLGZhbHNlKTtcbmNvbnN0ICAgICAgICBzdGFydD1hc3luYyh6Y2YscHJpdmF0ZUFyZ3MsYmFnZ2FnZSk9PntcbnRyYWNlKCdzdGFydCcpO1xuY29uc3Qgem9lPXpjZi5nZXRab2VTZXJ2aWNlKCk7XG50cmFjZSgnZ2V0VGVybXMnLHpjZi5nZXRUZXJtcygpKTtcbmNvbnN0e1xuZ292ZXJuZWRDb250cmFjdEluc3RhbGxhdGlvbixcbmdvdmVybmVkOntcbmlzc3VlcktleXdvcmRSZWNvcmQ6Z292ZXJuZWRJc3N1ZXJLZXl3b3JkUmVjb3JkLFxudGVybXM6Y29udHJhY3RUZXJtcyxcbmxhYmVsOmdvdmVybmVkQ29udHJhY3RMYWJlbH0sXG5cbmJpbmFyeVZvdGVDb3VudGVySW5zdGFsbGF0aW9uOmNvdW50ZXJ9PVxuemNmLmdldFRlcm1zKCk7XG5jb25zdHtcbmdvdmVybmVkOnt0aW1lcn19PVxucHJpdmF0ZUFyZ3M7XG50cmFjZSgnY29udHJhY3RUZXJtcycsY29udHJhY3RUZXJtcyk7XG5jb250cmFjdFRlcm1zLmdvdmVybmVkUGFyYW1zW0NPTlRSQUNUX0VMRUNUT1JBVEVdfHxcbkZhaWwgYENvbnRyYWN0IG11c3QgZGVjbGFyZSAke0NPTlRSQUNUX0VMRUNUT1JBVEV9IGFzIGEgZ292ZXJuZWQgcGFyYW1ldGVyYDtcblxuY29uc3QgbWFrZUNvbnRyYWN0R292ZXJub3JLaXQ9cHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQoYmFnZ2FnZSx7XG50aW1lcixcbnpvZX0pO1xuXG5cbnRyYWNlKCdhd2FpdGluZyBwcm92aWRlU2luZ2xldG9uKCknKTtcbmNvbnN0IGdvdmVybm9yS2l0PWF3YWl0IHByb3ZpZGVTaW5nbGV0b24oXG5iYWdnYWdlLFxuJ2NvbnRyYWN0R292ZXJub3JLaXQnLFxuYXN5bmMoKT0+e1xuY29uc3QgYXVnbWVudGVkVGVybXM9aGFyZGVuKHtcbi4uLmNvbnRyYWN0VGVybXMsXG5lbGVjdGlvbk1hbmFnZXI6emNmLmdldEluc3RhbmNlKCl9KTtcblxuXG50cmFjZSgnc3RhcnRpbmcgZ292ZXJuZWRDb250cmFjdEluc3RhbGxhdGlvbiBvZicsZ292ZXJuZWRDb250cmFjdExhYmVsKTtcbmNvbnN0IHN0YXJ0ZWRJbnN0YW5jZUtpdD1hd2FpdCBFKHpvZSkuc3RhcnRJbnN0YW5jZShcbmdvdmVybmVkQ29udHJhY3RJbnN0YWxsYXRpb24sXG5nb3Zlcm5lZElzc3VlcktleXdvcmRSZWNvcmQsXG5hdWdtZW50ZWRUZXJtcyxcbnByaXZhdGVBcmdzLmdvdmVybmVkLFxuZ292ZXJuZWRDb250cmFjdExhYmVsKTtcblxudHJhY2UoJ2F3YWl0aW5nIHJlbW90ZSBsaW1pdGVkQ3JlYXRvckZhY2V0Jyk7XG5jb25zdCBsaW1pdGVkQ3JlYXRvckZhY2V0PWF3YWl0IEUoXG5zdGFydGVkSW5zdGFuY2VLaXQuY3JlYXRvckZhY2V0KS5cbmdldExpbWl0ZWRDcmVhdG9yRmFjZXQoKTtcblxucmV0dXJuIG1ha2VDb250cmFjdEdvdmVybm9yS2l0KHN0YXJ0ZWRJbnN0YW5jZUtpdCxsaW1pdGVkQ3JlYXRvckZhY2V0KTtcbiB9KTtcblxuXG5jb25zdCBtYWtlT2ZmZXJGaWx0ZXJJbnZpdGF0aW9uPShzdHJpbmdzLGRlYWRsaW5lKT0+e1xuY29uc3Qgdm90ZU9uT2ZmZXJGaWx0ZXJIYW5kbGVyPShzZWF0KT0+e1xuc2VhdC5leGl0KCk7XG5yZXR1cm4gRShnb3Zlcm5vcktpdC5jcmVhdG9yKS52b3RlT25PZmZlckZpbHRlcihcbmNvdW50ZXIsXG5kZWFkbGluZSxcbnN0cmluZ3MpO1xuXG4gfTtcblxucmV0dXJuIHpjZi5tYWtlSW52aXRhdGlvbih2b3RlT25PZmZlckZpbHRlckhhbmRsZXIsJ3ZvdGUgb24gb2ZmZXIgZmlsdGVyJyk7XG4gfTtcblxuY29uc3QgbWFrZVZvdGVPbkFwaUludm9jYXRpb25JbnZpdGF0aW9uPShcbmFwaU1ldGhvZE5hbWUsXG5tZXRob2RBcmdzLFxuZGVhZGxpbmUpPT5cbntcbmNvbnN0IHZvdGVPbkFwaUludm9jYXRpb25IYW5kbGVyPShzZWF0KT0+e1xuc2VhdC5leGl0KCk7XG5yZXR1cm4gRShnb3Zlcm5vcktpdC5jcmVhdG9yKS52b3RlT25BcGlJbnZvY2F0aW9uKFxuYXBpTWV0aG9kTmFtZSxcbm1ldGhvZEFyZ3MsXG5jb3VudGVyLFxuZGVhZGxpbmUpO1xuXG4gfTtcblxucmV0dXJuIHpjZi5tYWtlSW52aXRhdGlvbihcbnZvdGVPbkFwaUludm9jYXRpb25IYW5kbGVyLFxuJ3ZvdGUgb24gb2ZmZXIgZmlsdGVyJyk7XG5cbiB9O1xuXG5jb25zdCBpbnZpdGF0aW9uTWFrZXJzPXByZXBhcmVFeG8oXG5iYWdnYWdlLFxuJ0NyYWJibGUgR292ZXJuYW5jZSBJbnZpdGF0aW9uIE1ha2VycycsXG5NLmludGVyZmFjZSgnQ3JhYmJsZUdvdmVybm9yIC0gSW52aXRhdGlvbk1ha2VyJyx7XG5Wb3RlT25QYXVzZU9mZmVyczpNLmNhbGwoTS5hcnJheU9mKE0uc3RyaW5nKCkpLFRpbWVzdGFtcFNoYXBlKS5yZXR1cm5zKFxuTS5wcm9taXNlKCkpLFxuXG5Wb3RlT25BcGlJbnZvY2F0aW9uOk0uY2FsbChcbk0uc3RyaW5nKCksXG5NLmFycmF5KCksXG5UaW1lc3RhbXBTaGFwZSkuXG5yZXR1cm5zKE0ucHJvbWlzZSgpKX0pLFxuXG57XG5Wb3RlT25QYXVzZU9mZmVyczptYWtlT2ZmZXJGaWx0ZXJJbnZpdGF0aW9uLFxuVm90ZU9uQXBpSW52b2NhdGlvbjptYWtlVm90ZU9uQXBpSW52b2NhdGlvbkludml0YXRpb259KTtcblxuXG5cbmNvbnN0IGNyZWF0b3JGYWNldD1wcmVwYXJlRXhvKFxuYmFnZ2FnZSxcbidDcmFiYmxlIEdvdmVybmFuY2UgQ3JlYXRvciBGYWNldCcsXG5NLmludGVyZmFjZSgnQ3JhYmJsZSBHb3Zlcm5hbmNlIENyZWF0b3IgRmFjZXQnLHtcbm1ha2VDb21taXR0ZWVNZW1iZXJJbnZpdGF0aW9uOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0UHVibGljRmFjZXQ6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRJbnN0YW5jZTpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmdldEFkbWluRmFjZXQ6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRDcmVhdG9yRmFjZXQ6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSl9KSxcblxue1xubWFrZUNvbW1pdHRlZU1lbWJlckludml0YXRpb24oKXtcbmNvbnN0IGdvdk1lbWJlckhhbmRsZXI9KHNlYXQpPT57XG5zZWF0LmV4aXQoKTtcbnJldHVybiBoYXJkZW4oe2ludml0YXRpb25NYWtlcnN9KTtcbiB9O1xuXG5yZXR1cm4gemNmLm1ha2VJbnZpdGF0aW9uKFxuZ292TWVtYmVySGFuZGxlcixcbidDcmFiYmxlIEdvdmVybmFuY2UgSW52aXRhdGlvbiBIYW5kbGVyJyk7XG5cbiB9LFxuZ2V0UHVibGljRmFjZXQoKXtcbnJldHVybiBFKGdvdmVybm9yS2l0LmNyZWF0b3IpLmdldFB1YmxpY0ZhY2V0KCk7XG4gfSxcbmdldEluc3RhbmNlKCl7XG5yZXR1cm4gRShnb3Zlcm5vcktpdC5jcmVhdG9yKS5nZXRJbnN0YW5jZSgpO1xuIH0sXG5nZXRBZG1pbkZhY2V0KCl7XG5yZXR1cm4gRShnb3Zlcm5vcktpdC5jcmVhdG9yKS5nZXRBZG1pbkZhY2V0KCk7XG4gfSxcbmdldENyZWF0b3JGYWNldCgpe1xucmV0dXJuIEUoZ292ZXJub3JLaXQuY3JlYXRvcikuZ2V0Q3JlYXRvckZhY2V0KCk7XG4gfX0pO1xuXG5cblxucmV0dXJue2NyZWF0b3JGYWNldCxwdWJsaWNGYWNldDpnb3Zlcm5vcktpdC5wdWJsaWN9O1xuIH07JGjigI1fb25jZS5zdGFydChzdGFydCk7XG5oYXJkZW4oc3RhcnQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InN0YXJ0IjpbInN0YXJ0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAIu6h5KtAQAArQEAABwAAABqZXNzaWUuanMtdjAuMy4yL3NyYy9tYWluLmpzeyJpbXBvcnRzIjpbIi4vcmluZzAvbWFpbi5qcyIsIi4vcmluZzEvbWFpbi5qcyJdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbIi4vcmluZzAvbWFpbi5qcyIsIi4vcmluZzEvbWFpbi5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vcmluZzAvbWFpbi5qc1wiLCBbXV0sW1wiLi9yaW5nMS9tYWluLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACdzxOJXQEAAF0BAAAfAAAAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzAvRS5qc3siaW1wb3J0cyI6WyJAZW5kby9mYXIiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyJAZW5kby9mYXIiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9mYXJcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAPi0yb+pAwAAqQMAACwAAABqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMC9hc3luYy1nZW5lcmF0ZS5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiYXN5bmNHZW5lcmF0ZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qIEB0cy1jaGVjayovXG5cbi8qKlxuICogUmV0dXJuIGFuIGFzeW5jIGl0ZXJhYmxlIHRoYXQgcHJvZHVjZXMgaXRlcmF0b3IgcmVzdWx0cyB2aWEgYG5leHRgLlxuICpcbiAqIFRoaXMgd29ya3MgYXJvdW5kIEplc3NpZSdzIGZvcmJpZGRhbmNlIG9mIFN5bWJvbC5cbiAqXG4gKiBAdGVtcGxhdGUgVCxUUmV0dXJuXG4gKiBAcGFyYW0geygpID0+IEl0ZXJhdG9yUmVzdWx0PFQsIFRSZXR1cm4+IHxcbiAqICAgICAgICAgICAgICAgUHJvbWlzZTxJdGVyYXRvclJlc3VsdDxULCBUUmV0dXJuPj5cbiAqIH0gbmV4dCBwcm9kdWNlIGEgc2luZ2xlLXN0ZXAgaXRlcmF0b3IgcmVzdWx0XG4gKiBAcmV0dXJucyB7QXN5bmNJdGVyYWJsZTxUPn1cbiAqL1xuY29uc3QgICAgICAgIGFzeW5jR2VuZXJhdGU9KG5leHQpPT57XG5yZXR1cm4gaGFyZGVuKHtcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06KCk9PntcbnJldHVybiBoYXJkZW4oe1xubmV4dDphc3luYygpPT5oYXJkZW4obmV4dCgpKX0pO1xuXG4gfX0pO1xuXG4gfTskaOKAjV9vbmNlLmFzeW5jR2VuZXJhdGUoYXN5bmNHZW5lcmF0ZSk7XG5oYXJkZW4oYXN5bmNHZW5lcmF0ZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiYXN5bmNHZW5lcmF0ZSI6WyJhc3luY0dlbmVyYXRlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJfXVO3QAQAA0AEAACIAAABqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMC9tYWluLmpzeyJpbXBvcnRzIjpbIi4vRS5qcyIsIi4vYXN5bmMtZ2VuZXJhdGUuanMiLCIuL21ha2Vycy5qcyJdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbIi4vRS5qcyIsIi4vYXN5bmMtZ2VuZXJhdGUuanMiLCIuL21ha2Vycy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vRS5qc1wiLCBbXV0sW1wiLi9tYWtlcnMuanNcIiwgW11dLFtcIi4vYXN5bmMtZ2VuZXJhdGUuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG+be2LjCAAA4wgAACQAAABqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMC9tYWtlcnMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbIm1ha2VNYXAiLCJtYWtlUHJvbWlzZSIsIm1ha2VTZXQiLCJtYWtlV2Vha01hcCIsIm1ha2VXZWFrU2V0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQHRzLWNoZWNrKi9cbi8qIFRoZXNlIHdvcmsgYXJvdW5kIEplc3NpZSdzIGZvcmJpZGRhbmNlIG9mIGBuZXdgLiovXG4vKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiIC8+Ki9cblxuLyoqIEB0eXBlIHs8VD4oZXhlY3V0b3I6IChyZXNvbHZlOiAodmFsdWU6IFQpID0+IHZvaWQsIHJlamVjdDogKHJlYXNvbj86IGFueSkgPT5cbiAqIHZvaWQpID0+IHZvaWQpID0+IFByb21pc2U8VD59ICovXG5jb25zdCAgICAgICAgbWFrZVByb21pc2U9KGV4ZWN1dG9yKT0+aGFyZGVuKG5ldyBQcm9taXNlKGV4ZWN1dG9yKSk7JGjigI1fb25jZS5tYWtlUHJvbWlzZShtYWtlUHJvbWlzZSk7XG5oYXJkZW4obWFrZVByb21pc2UpO1xuXG4vKiogQHR5cGVkZWYgezxLLCBWPihlbnRyaWVzPzogcmVhZG9ubHkgKHJlYWRvbmx5IFtLLCBWXSlbXSkgPT4gTWFwPEssIFY+fSBNYXBGcm9tRW50cmllcyAqL1xuLyoqIEB0eXBlZGVmIHs8SywgVj4oaXRlcmFibGU6IEl0ZXJhYmxlPHJlYWRvbmx5IFtLLCBWXT4pID0+IE1hcDxLLCBWPn0gTWFwRnJvbUl0ZXJhYmxlICovXG5cbi8qKiBAdHlwZSB7TWFwRnJvbUVudHJpZXMgJiBNYXBGcm9tSXRlcmFibGV9ICovXG5jb25zdCAgICAgICAgbWFrZU1hcD0oZW50cmllc09ySXRlcmFibGUpPT5oYXJkZW4obmV3IE1hcChlbnRyaWVzT3JJdGVyYWJsZSkpOyRo4oCNX29uY2UubWFrZU1hcChtYWtlTWFwKTtcbmhhcmRlbihtYWtlTWFwKTtcblxuLyoqIEB0eXBlZGVmIHs8VD4odmFsdWVzPzogcmVhZG9ubHkgVFtdKSA9PiBTZXQ8VD59IFNldEZyb21WYWx1ZXMgKi9cbi8qKiBAdHlwZWRlZiB7PFQ+KGl0ZXJhYmxlOiBJdGVyYWJsZTxUPikgPT4gU2V0PFQ+fSBTZXRGcm9tSXRlcmFibGUgKi9cbi8qKiBAdHlwZSB7U2V0RnJvbVZhbHVlcyAmIFNldEZyb21JdGVyYWJsZX0gKi9cbmNvbnN0ICAgICAgICBtYWtlU2V0PSh2YWx1ZXMpPT5oYXJkZW4obmV3IFNldCh2YWx1ZXMpKTskaOKAjV9vbmNlLm1ha2VTZXQobWFrZVNldCk7XG5oYXJkZW4obWFrZVNldCk7XG5cbi8qKiBAdHlwZWRlZiB7PEsgZXh0ZW5kcyB7fSwgViA9IGFueT4oZW50cmllcz86IHJlYWRvbmx5IFtLLCBWXVtdIHwgbnVsbCkgPT4gV2Vha01hcDxLLCBWPn0gV2Vha01hcEZyb21FbnRyaWVzICovXG4vKiogQHR5cGVkZWYgezxLIGV4dGVuZHMge30sIFY+KGl0ZXJhYmxlOiBJdGVyYWJsZTxbSywgVl0+KSA9PiBXZWFrTWFwPEssIFY+fSBXZWFrTWFwRnJvbUl0ZXJhYmxlICovXG4vKiogQHR5cGUge1dlYWtNYXBGcm9tRW50cmllcyAmIFdlYWtNYXBGcm9tSXRlcmFibGV9ICovXG5jb25zdCAgICAgICAgbWFrZVdlYWtNYXA9KGVudHJpZXMpPT5oYXJkZW4obmV3IFdlYWtNYXAoZW50cmllcykpOyRo4oCNX29uY2UubWFrZVdlYWtNYXAobWFrZVdlYWtNYXApO1xuaGFyZGVuKG1ha2VXZWFrTWFwKTtcblxuLyoqIEB0eXBlZGVmIHs8VCBleHRlbmRzIHt9Pih2YWx1ZXM/OiByZWFkb25seSBUW10pID0+IFdlYWtTZXQ8VD59IFdlYWtTZXRGcm9tVmFsdWVzICovXG4vKiogQHR5cGVkZWYgezxUIGV4dGVuZHMge30+KGl0ZXJhYmxlOiBJdGVyYWJsZTxUPikgPT4gV2Vha1NldDxUPn0gV2Vha1NldEZyb21JdGVyYWJsZSAqL1xuLyoqIEB0eXBlIHtXZWFrU2V0RnJvbVZhbHVlcyAmIFdlYWtTZXRGcm9tSXRlcmFibGV9ICovXG5jb25zdCAgICAgICAgbWFrZVdlYWtTZXQ9KHZhbHVlcyk9PmhhcmRlbihuZXcgV2Vha1NldCh2YWx1ZXMpKTskaOKAjV9vbmNlLm1ha2VXZWFrU2V0KG1ha2VXZWFrU2V0KTtcbmhhcmRlbihtYWtlV2Vha1NldCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVByb21pc2UiOlsibWFrZVByb21pc2UiXSwibWFrZU1hcCI6WyJtYWtlTWFwIl0sIm1ha2VTZXQiOlsibWFrZVNldCJdLCJtYWtlV2Vha01hcCI6WyJtYWtlV2Vha01hcCJdLCJtYWtlV2Vha1NldCI6WyJtYWtlV2Vha1NldCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAC0LPWY/gQAAP4EAAApAAAAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzEvYXN5bmMtdG9vbHMuanN7ImltcG9ydHMiOlsiLi4vcmluZzAvbWFpbi5qcyJdLCJleHBvcnRzIjpbImFzeW5jRG9XaGlsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlUHJvbWlzZTskaOKAjV9pbXBvcnRzKFtbXCIuLi9yaW5nMC9tYWluLmpzXCIsIFtbXCJtYWtlUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAobWFrZVByb21pc2UgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cbi8qKlxuICogUmVzb2x2ZSByZXR1cm5lZCBwcm9taXNlIHdpdGggdW5kZWZpbmVkIHdoZW4gYGJvZHlgIHJldHVybnMgZmFsc3kuXG4gKlxuICogVGhpcyB3b3JrcyBhcm91bmQgSmVzc2llJ3MgZm9yYmlkZGFuY2Ugb2YgYGF3YWl0YCBub3QgYXQgdGhlIGZ1bmN0aW9uLWxldmVsLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0geygpID0+IFQgfCBQcm9taXNlPFQ+fSBib2R5IHBlcmZvcm0gc2lkZS1lZmZlY3RzLCBhbmQgcmV0dXJuIHRydXRoeSBpZlxuICogd2Ugc2hvdWxkIHJ1biBhZ2FpblxuICogQHJldHVybnMge1Byb21pc2U8dm9pZD59XG4gKi9cbmNvbnN0ICAgICAgICBhc3luY0RvV2hpbGU9KGJvZHkpPT57XG5jb25zdCBsb29wPWFzeW5jKHJlc29sdmUscmVqZWN0KT0+e1xuY29uc3QgZG9Db250aW51ZT1hd2FpdCBib2R5KCk7XG5pZighZG9Db250aW51ZSl7XG4vKiBSZXNvbHZlIHRoZSBvdXRlcm1vc3QgcHJvbWlzZS4qL1xucmVzb2x2ZSh1bmRlZmluZWQpO1xucmV0dXJuO1xuIH1cblxuLyogRG8gdGhlIGxvb3AgYWdhaW4uICBXZSBhcmUgY2FyZWZ1bCBub3QgdG8gYXdhaXQgc28gdGhhdCB3ZSBkb24ndCBjcmVhdGUgYSovXG4vKiBwcm9taXNlIGNoYWluLiovXG5sb29wKHJlc29sdmUscmVqZWN0KS5jYXRjaChyZWplY3QpO1xuIH07XG5cbnJldHVybiBtYWtlUHJvbWlzZSgocmVzb2x2ZSxyZWplY3QpPT5sb29wKHJlc29sdmUscmVqZWN0KS5jYXRjaChyZWplY3QpKTtcbiB9OyRo4oCNX29uY2UuYXN5bmNEb1doaWxlKGFzeW5jRG9XaGlsZSk7XG5oYXJkZW4oYXN5bmNEb1doaWxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3luY0RvV2hpbGUiOlsiYXN5bmNEb1doaWxlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJYTQrJyAQAAcgEAACIAAABqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMS9tYWluLmpzeyJpbXBvcnRzIjpbIi4vYXN5bmMtdG9vbHMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL2FzeW5jLXRvb2xzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9hc3luYy10b29scy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAQIeAwoAAAAAAAAAAACUChBb/gsBAP4LAQAUAAAAAAAAAAAAAACkgQAAAABjb21wYXJ0bWVudC1tYXAuanNvblBLAQIeAwoAAAAAAAAAAAA5ilYCOwsAADsLAAAjAAAAAAAAAAAAAACkgTAMAQBAYWdvcmljL2Fzc2VydC12MC42LjAvc3JjL2Fzc2VydC5qc1BLAQIeAwoAAAAAAAAAAAAFuYfs2i4AANouAAAiAAAAAAAAAAAAAACkgawXAQBAYWdvcmljL2Fzc2VydC12MC42LjAvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAFP1hb9GNwAARjcAACwAAAAAAAAAAAAAAKSBxkYBAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9hbW91bnRNYXRoLmpzUEsBAh4DCgAAAAAAAAAAAEqUAO3VBQAA1QUAAC0AAAAAAAAAAAAAAKSBVn4BAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9kaXNwbGF5SW5mby5qc1BLAQIeAwoAAAAAAAAAAABDMHvc6AEAAOgBAAAnAAAAAAAAAAAAAACkgXaEAQBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAANV3BKJggAACYIAAAKwAAAAAAAAAAAAAApIGjhgEAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL2lzc3VlcktpdC5qc1BLAQIeAwoAAAAAAAAAAACAyG7uswUAALMFAABAAAAAAAAAAAAAAACkgYSnAQBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvbWF0aEhlbHBlcnMvY29weUJhZ01hdGhIZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAAHHnYj3HBQAAxwUAAEAAAAAAAAAAAAAAAKSBla0BAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9tYXRoSGVscGVycy9jb3B5U2V0TWF0aEhlbHBlcnMuanNQSwECHgMKAAAAAAAAAAAA/9yw+yoGAAAqBgAAPAAAAAAAAAAAAAAApIG6swEAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL25hdE1hdGhIZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAACaZmC+fBwAAnwcAADwAAAAAAAAAAAAAAKSBProBAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9tYXRoSGVscGVycy9zZXRNYXRoSGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAACwOKgfpQQAAKUEAAApAAAAAAAAAAAAAACkgTfCAQBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvcGF5bWVudC5qc1BLAQIeAwoAAAAAAAAAAAAP1+ju6zEAAOsxAAAvAAAAAAAAAAAAAACkgSPHAQBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvcGF5bWVudExlZGdlci5qc1BLAQIeAwoAAAAAAAAAAACiRUVCwA8AAMAPAAAnAAAAAAAAAAAAAACkgVv5AQBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvcHVyc2UuanNQSwECHgMKAAAAAAAAAAAALkljqRQGAAAUBgAAMwAAAAAAAAAAAAAApIFgCQIAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL3RyYW5zaWVudE5vdGlmaWVyLmpzUEsBAh4DCgAAAAAAAAAAACjunj4SJwAAEicAACwAAAAAAAAAAAAAAKSBxQ8CAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy90eXBlR3VhcmRzLmpzUEsBAh4DCgAAAAAAAAAAACzPqVFwPwAAcD8AAC8AAAAAAAAAAAAAAKSBITcCAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy90eXBlcy1hbWJpZW50LmpzUEsBAh4DCgAAAAAAAAAAAKIjQPJ1EQAAdREAAEQAAAAAAAAAAAAAAKSB3nYCAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuQXBpLmpzUEsBAh4DCgAAAAAAAAAAABvtXsqrDwAAqw8AAEcAAAAAAAAAAAAAAKSBtYgCAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuRmlsdGVyLmpzUEsBAh4DCgAAAAAAAAAAAEYPijVIFgAASBYAAEYAAAAAAAAAAAAAAKSBxZgCAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanNQSwECHgMKAAAAAAAAAAAAa2BKrnsdAAB7HQAAOwAAAAAAAAAAAAAApIFxrwIAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJub3JLaXQuanNQSwECHgMKAAAAAAAAAAAAWbdv2KcPAACnDwAAMAAAAAAAAAAAAAAApIFFzQIAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL3F1ZXN0aW9uLmpzUEsBAh4DCgAAAAAAAAAAAJ7Q0hMoOwAAKDsAADIAAAAAAAAAAAAAAKSBOt0CAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy90eXBlR3VhcmRzLmpzUEsBAh4DCgAAAAAAAAAAAG3bYQpeKAAAXigAAC0AAAAAAAAAAAAAAKSBshgDAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy9jYWxsYmFjay5qc1BLAQIeAwoAAAAAAAAAAACqj91GIgYAACIGAAArAAAAAAAAAAAAAACkgVtBAwBAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvY29uZmlnLmpzUEsBAh4DCgAAAAAAAAAAABfJM4DIBAAAyAQAACoAAAAAAAAAAAAAAKSBxkcDAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy9kZWJ1Zy5qc1BLAQIeAwoAAAAAAAAAAABuFZifQwIAAEMCAAAqAAAAAAAAAAAAAACkgdZMAwBAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAbco46wkuAAAJLgAANQAAAAAAAAAAAAAApIFhTwMAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL2xpYi1jaGFpblN0b3JhZ2UuanNQSwECHgMKAAAAAAAAAAAAafLEQCcPAAAnDwAAMQAAAAAAAAAAAAAApIG9fQMAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL21ldGhvZC10b29scy5qc1BLAQIeAwoAAAAAAAAAAABUOfoRLQIAAC0CAAAvAAAAAAAAAAAAAACkgTONAwBAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvdHlwZUd1YXJkcy5qc1BLAQIeAwoAAAAAAAAAAADexqKMKwcAACsHAAAwAAAAAAAAAAAAAACkga2PAwBAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvdXBncmFkZS1hcGkuanNQSwECHgMKAAAAAAAAAAAAoumxkuM8AADjPAAAKgAAAAAAAAAAAAAApIEmlwMAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL3V0aWxzLmpzUEsBAh4DCgAAAAAAAAAAAGfQxYrVEgAA1RIAADkAAAAAAAAAAAAAAKSBUdQDAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9hc3luY0l0ZXJhYmxlQWRhcHRvci5qc1BLAQIeAwoAAAAAAAAAAACwvi9PHAcAABwHAAAqAAAAAAAAAAAAAACkgX3nAwBAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAA8rAIZVoYAABaGAAALQAAAAAAAAAAAAAApIHh7gMAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL25vdGlmaWVyLmpzUEsBAh4DCgAAAAAAAAAAAFZ/h0h+OAAAfjgAADAAAAAAAAAAAAAAAKSBhgcEAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9wdWJsaXNoLWtpdC5qc1BLAQIeAwoAAAAAAAAAAAC+ATAkgwoAAIMKAAA0AAAAAAAAAAAAAACkgVJABABAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvc3RvcmVkLW5vdGlmaWVyLmpzUEsBAh4DCgAAAAAAAAAAAOs+VGqwIgAAsCIAAC0AAAAAAAAAAAAAAKSBJ0sEAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9zdG9yZXN1Yi5qc1BLAQIeAwoAAAAAAAAAAAB1YuMobiQAAG4kAAAuAAAAAAAAAAAAAACkgSJuBABAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvc3Vic2NyaWJlLmpzUEsBAh4DCgAAAAAAAAAAACeyOyPFCwAAxQsAAC8AAAAAAAAAAAAAAKSB3JIEAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9zdWJzY3JpYmVyLmpzUEsBAh4DCgAAAAAAAAAAACGBFnIMBgAADAYAACoAAAAAAAAAAAAAAKSB7p4EAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy90b3BpYy5qc1BLAQIeAwoAAAAAAAAAAAD4UQ8TPzAAAD8wAAAyAAAAAAAAAAAAAACkgUKlBABAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvdHlwZXMtYW1iaWVudC5qc1BLAQIeAwoAAAAAAAAAAAA+Ylw2XAEAAFwBAAAmAAAAAAAAAAAAAACkgdHVBABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9leHBvcnRlZC5qc1BLAQIeAwoAAAAAAAAAAABqgKjv3AsAANwLAAAnAAAAAAAAAAAAAACkgXHXBABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAA4q+AfUYLAABGCwAAMgAAAAAAAAAAAAAApIGS4wQAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL2xlZ2FjeS9sZWdhY3lNYXAuanNQSwECHgMKAAAAAAAAAAAApoNNtMIGAADCBgAANgAAAAAAAAAAAAAApIEo7wQAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL2xlZ2FjeS9sZWdhY3lXZWFrTWFwLmpzUEsBAh4DCgAAAAAAAAAAAJoDutcWFgAAFhYAADcAAAAAAAAAAAAAAKSBPvYEAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy9zdG9yZXMvc2NhbGFyTWFwU3RvcmUuanNQSwECHgMKAAAAAAAAAAAAnQOWIEEPAABBDwAANwAAAAAAAAAAAAAApIGpDAUAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qc1BLAQIeAwoAAAAAAAAAAAAZQWnY4xIAAOMSAAA7AAAAAAAAAAAAAACkgT8cBQBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qc1BLAQIeAwoAAAAAAAAAAABtrD+9hA4AAIQOAAA7AAAAAAAAAAAAAACkgXsvBQBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3NjYWxhcldlYWtTZXRTdG9yZS5qc1BLAQIeAwoAAAAAAAAAAACy12MInRkAAJ0ZAAA0AAAAAAAAAAAAAACkgVg+BQBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3N0b3JlLXV0aWxzLmpzUEsBAh4DCgAAAAAAAAAAAMUArIJYKgAAWCoAACcAAAAAAAAAAAAAAKSBR1gFAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAAhmCHYvwEAAL8BAAAiAAAAAAAAAAAAAACkgeSCBQBAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAMBAN+aoIgAAqCIAACkAAAAAAAAAAAAAAKSB44QFAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3RpbWVNYXRoLmpzUEsBAh4DCgAAAAAAAAAAAG6zHqqnBwAApwcAACsAAAAAAAAAAAAAAKSB0qcFAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3R5cGVHdWFyZHMuanNQSwECHgMKAAAAAAAAAAAAvtREY2MoAABjKAAALgAAAAAAAAAAAAAApIHCrwUAQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAvc3JjL2V4by11dGlscy5qc1BLAQIeAwoAAAAAAAAAAAA74z2IkggAAJIIAAAqAAAAAAAAAAAAAACkgXHYBQBAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAA3vSPIFMoAABTKAAANgAAAAAAAAAAAAAApIFL4QUAQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAvc3JjL3ZhdC1kYXRhLWJpbmRpbmdzLmpzUEsBAh4DCgAAAAAAAAAAALLT47GtEgAArRIAADsAAAAAAAAAAAAAAKSB8gkGAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzUEsBAh4DCgAAAAAAAAAAAKCkFjVWCAAAVggAACsAAAAAAAAAAAAAAKSB+BwGAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL21ha2VIYW5kbGUuanNQSwECHgMKAAAAAAAAAAAA5bEJzNtDAADbQwAAKwAAAAAAAAAAAAAApIGXJQYAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvdHlwZUd1YXJkcy5qc1BLAQIeAwoAAAAAAAAAAAC3wrx74gYAAOIGAAAlAAAAAAAAAAAAAACkgbtpBgBAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wL3NyYy9oZWFwLmpzUEsBAh4DCgAAAAAAAAAAANj0GTCPCQAAjwkAACYAAAAAAAAAAAAAAKSB4HAGAEBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAvc3JjL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAM7dsT6QCwAAkAsAACQAAAAAAAAAAAAAAKSBs3oGAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTQuOC9zcmMvRS5qc1BLAQIeAwoAAAAAAAAAAABpSisBHQIAAB0CAAAqAAAAAAAAAAAAAACkgYWGBgBAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE0Ljgvc3JjL25vLXNoaW0uanNQSwECHgMKAAAAAAAAAAAA6330t3sMAAB7DAAALgAAAAAAAAAAAAAApIHqiAYAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44L3NyYy90cmFjay10dXJucy5qc1BLAQIeAwoAAAAAAAAAAAB+JG4t0hEAANIRAAAkAAAAAAAAAAAAAACkgbGVBgBAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIvc3JjL0UuanNQSwECHgMKAAAAAAAAAAAANwvtTx8CAAAfAgAAKgAAAAAAAAAAAAAApIHFpwYAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yL3NyYy9uby1zaGltLmpzUEsBAh4DCgAAAAAAAAAAAKFYIz+PEAAAjxAAAC4AAAAAAAAAAAAAAKSBLKoGAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMi9zcmMvdHJhY2stdHVybnMuanNQSwECHgMKAAAAAAAAAAAAOlKtTRwCAAAcAgAAGQAAAAAAAAAAAAAApIEHuwYAQGVuZG8vZXhvLXYwLjIuMi9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAADGt+tWYxgAAGMYAAAiAAAAAAAAAAAAAACkgVq9BgBAZW5kby9leG8tdjAuMi4yL3NyYy9leG8tbWFrZXJzLmpzUEsBAh4DCgAAAAAAAAAAADGwrfJxJgAAcSYAACEAAAAAAAAAAAAAAKSB/dUGAEBlbmRvL2V4by12MC4yLjIvc3JjL2V4by10b29scy5qc1BLAQIeAwoAAAAAAAAAAABBDDOUQAIAAEACAAAeAAAAAAAAAAAAAACkga38BgBAZW5kby9mYXItdjAuMi4xOC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAApY8690oHAABKBwAAHQAAAAAAAAAAAAAApIEp/wYAQGVuZG8vbWFyc2hhbC12MC44LjUvaW5kZXguanNQSwECHgMKAAAAAAAAAAAADQgme5QNAACUDQAAKwAAAAAAAAAAAAAApIGuBgcAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL2RlZXBseUZ1bGZpbGxlZC5qc1BLAQIeAwoAAAAAAAAAAAA7cs+A5D8AAOQ/AAAqAAAAAAAAAAAAAACkgYsUBwBAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvZW5jb2RlUGFzc2FibGUuanNQSwECHgMKAAAAAAAAAAAAxFOn8Pw/AAD8PwAAKwAAAAAAAAAAAAAApIG3VAcAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL2VuY29kZVRvQ2FwRGF0YS5qc1BLAQIeAwoAAAAAAAAAAACzXvdrxTsAAMU7AAAtAAAAAAAAAAAAAACkgfyUBwBAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvZW5jb2RlVG9TbWFsbGNhcHMuanNQSwECHgMKAAAAAAAAAAAACEKS/awqAACsKgAAKgAAAAAAAAAAAAAApIEM0QcAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL21hcnNoYWwtanVzdGluLmpzUEsBAh4DCgAAAAAAAAAAABPT1RvcBgAA3AYAAC0AAAAAAAAAAAAAAKSBAPwHAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qc1BLAQIeAwoAAAAAAAAAAAC+nmlK7DIAAOwyAAAjAAAAAAAAAAAAAACkgScDCABAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvbWFyc2hhbC5qc1BLAQIeAwoAAAAAAAAAAABXRGQKfkAAAH5AAAAlAAAAAAAAAAAAAACkgVQ2CABAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvcmFua09yZGVyLmpzUEsBAh4DCgAAAAAAAAAAAJgZO7M0AQAANAEAACEAAAAAAAAAAAAAAKSBFXcIAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAAlHpu9zwsAAM8LAAAeAAAAAAAAAAAAAACkgYh4CABAZW5kby9uYXQtdjQuMS4yNy9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAZfKMGnwIAAB8CAAAIAAAAAAAAAAAAAAApIGThAgAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAA3ka2qpMHAACTBwAAKAAAAAAAAAAAAAAApIFNjQgAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2NvcHlBcnJheS5qc1BLAQIeAwoAAAAAAAAAAACD9dsszwcAAM8HAAApAAAAAAAAAAAAAACkgSaVCABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvY29weVJlY29yZC5qc1BLAQIeAwoAAAAAAAAAAADToDhxnREAAJ0RAAAkAAAAAAAAAAAAAACkgTydCABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvZXJyb3IuanNQSwECHgMKAAAAAAAAAAAASjtmg1UIAABVCAAAKwAAAAAAAAAAAAAApIEbrwgAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2l0ZXItaGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAABiTWcDThoAAE4aAAAnAAAAAAAAAAAAAACkgbm3CABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvbWFrZS1mYXIuanNQSwECHgMKAAAAAAAAAAAAApF75R0EAAAdBAAAKQAAAAAAAAAAAAAApIFM0ggAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL21ha2VUYWdnZWQuanNQSwECHgMKAAAAAAAAAAAAGUAoxvUZAAD1GQAAMAAAAAAAAAAAAAAApIGw1ggAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAAC5usQ2DGwAAgxsAACoAAAAAAAAAAAAAAKSB8/AIAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9wYXNzU3R5bGVPZi5qc1BLAQIeAwoAAAAAAAAAAAAUsaJ9wyEAAMMhAAAoAAAAAAAAAAAAAACkgb4MCQBAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvcmVtb3RhYmxlLmpzUEsBAh4DCgAAAAAAAAAAADXiToqaDwAAmg8AACsAAAAAAAAAAAAAAKSBxy4JAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9zYWZlLXByb21pc2UuanNQSwECHgMKAAAAAAAAAAAAxx/VUEcSAABHEgAAJQAAAAAAAAAAAAAApIGqPgkAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3N5bWJvbC5qc1BLAQIeAwoAAAAAAAAAAAAlvFz7/QcAAP0HAAAlAAAAAAAAAAAAAACkgTRRCQBAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvdGFnZ2VkLmpzUEsBAh4DCgAAAAAAAAAAAHqgfmgSDQAAEg0AACkAAAAAAAAAAAAAAKSBdFkJAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy90eXBlR3VhcmRzLmpzUEsBAh4DCgAAAAAAAAAAAJgZO7M0AQAANAEAACQAAAAAAAAAAAAAAKSBzWYJAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAACwnEJ+4goAAOIKAAAeAAAAAAAAAAAAAACkgUNoCQBAZW5kby9wYXR0ZXJucy12MC4yLjIvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAyxcZ4KRGAACkRgAAKgAAAAAAAAAAAAAApIFhcwkAQGVuZG8vcGF0dGVybnMtdjAuMi4yL3NyYy9rZXlzL2NoZWNrS2V5LmpzUEsBAh4DCgAAAAAAAAAAAPfmwlF3GgAAdxoAAC0AAAAAAAAAAAAAAKSBTboJAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMva2V5cy9jb21wYXJlS2V5cy5qc1BLAQIeAwoAAAAAAAAAAABVIML9KhQAACoUAAApAAAAAAAAAAAAAACkgQ/VCQBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvY29weUJhZy5qc1BLAQIeAwoAAAAAAAAAAAAKHf6/oxAAAKMQAAApAAAAAAAAAAAAAACkgYDpCQBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvY29weVNldC5qc1BLAQIeAwoAAAAAAAAAAAALKJ5teSUAAHklAAA1AAAAAAAAAAAAAACkgWr6CQBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvbWVyZ2UtYmFnLW9wZXJhdG9ycy5qc1BLAQIeAwoAAAAAAAAAAAAi9nVSnigAAJ4oAAA1AAAAAAAAAAAAAACkgTYgCgBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvbWVyZ2Utc2V0LW9wZXJhdG9ycy5qc1BLAQIeAwoAAAAAAAAAAACJDDsFM8MAADPDAAA1AAAAAAAAAAAAAACkgSdJCgBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL3BhdHRlcm5zL3BhdHRlcm5NYXRjaGVycy5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAiAAAAAAAAAAAAAACkga0MCwBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAJYe98fqGgAA6hoAACIAAAAAAAAAAAAAAKSBIQ4LAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMvdXRpbHMuanNQSwECHgMKAAAAAAAAAAAAClK+n3AJAABwCQAAIgAAAAAAAAAAAAAApIFLKQsAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41Ni9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAACIfYGs3wIAAN8CAAArAAAAAAAAAAAAAACkgfsyCwBAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy9pcy1wcm9taXNlLmpzUEsBAh4DCgAAAAAAAAAAAB2nTeu+EgAAvhIAACoAAAAAAAAAAAAAAKSBIzYLAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYvc3JjL21lbW8tcmFjZS5qc1BLAQIeAwoAAAAAAAAAAADTQ7DuaQcAAGkHAAA1AAAAAAAAAAAAAACkgSlJCwBAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAmAAAAAAAAAAAAAACkgeVQCwBAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAAMriXk9BgAAPQYAAAdAAAAAAAAAAAAAACkgV1SCwBAZW5kby9zdHJlYW0tdjAuMy4yNS9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAACIAPtlSxMAAEsTAAAuAAAAAAAAAAAAAACkgYxrCwBjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvY3JhYmJsZUdvdmVybm9yLmpzUEsBAh4DCgAAAAAAAAAAAIu6h5KtAQAArQEAABwAAAAAAAAAAAAAAKSBI38LAGplc3NpZS5qcy12MC4zLjIvc3JjL21haW4uanNQSwECHgMKAAAAAAAAAAAAnc8TiV0BAABdAQAAHwAAAAAAAAAAAAAApIEKgQsAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzAvRS5qc1BLAQIeAwoAAAAAAAAAAAD4tMm/qQMAAKkDAAAsAAAAAAAAAAAAAACkgaSCCwBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMC9hc3luYy1nZW5lcmF0ZS5qc1BLAQIeAwoAAAAAAAAAAACX11Tt0AEAANABAAAiAAAAAAAAAAAAAACkgZeGCwBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMC9tYWluLmpzUEsBAh4DCgAAAAAAAAAAAG+be2LjCAAA4wgAACQAAAAAAAAAAAAAAKSBp4gLAGplc3NpZS5qcy12MC4zLjIvc3JjL3JpbmcwL21ha2Vycy5qc1BLAQIeAwoAAAAAAAAAAAC0LPWY/gQAAP4EAAApAAAAAAAAAAAAAACkgcyRCwBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMS9hc3luYy10b29scy5qc1BLAQIeAwoAAAAAAAAAAACWE0KycgEAAHIBAAAiAAAAAAAAAAAAAACkgRGXCwBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMS9tYWluLmpzUEsFBgAAAAB7AHsABysAAMOYCwAAAA==","endoZipBase64Sha512":"cf4a0089e2d715a5c4460760cdb054d72f74b8fd330fece0bfd5e8fd82190c3c16e37eb1c31aab9734df81de9277721ce1d3dc7f5c8c7513349f5355e948978c"} diff --git a/proposals/64:crabble-start/assets/core-eval.js b/proposals/64:crabble-start/assets/core-eval.js new file mode 100644 index 00000000..6f86212c --- /dev/null +++ b/proposals/64:crabble-start/assets/core-eval.js @@ -0,0 +1,232 @@ +/* eslint-disable no-undef */ +const startCrabble = async ({ + consume: { + board, + zoe, + chainStorage: chainStorageP, + chainTimerService, + agoricNamesAdmin, + agoricNames: agoricNamesP, + namesByAddressAdmin: namesByAddressAdminP, + contractKits: contractKitsP, + governedContractKits, + diagnostics, + }, +}) => { + const logger = (log) => { + console.log('[CRABBLE_CORE_EVAL]', log); + }; + // vars = [crabble, governor] + const vars = ["9ef6df6021cabaece3a53065bbc4e1f68f0e109498861b814e26077422c89a5c1f7a6717875f7c9b35197cb36ba87dd424d927ef9230c9227bb7fdf4dcd0cdf0", "cf4a0089e2d715a5c4460760cdb054d72f74b8fd330fece0bfd5e8fd82190c3c16e37eb1c31aab9734df81de9277721ce1d3dc7f5c8c7513349f5355e948978c"]; + const members = ["agoric1kupk4yyvnl3h80j753705nfm2nfxff5vktvd3z", "agoric10xh9n8qzjsxg9k5txdmvtj5kfr3092j8mptr7g", "agoric1890064p6j3xhzzdf8daknd6kpvhw766ds8flgw"]; + + logger('Settling privileges...'); + const [ + namesByAddressAdmin, + chainStorage, + agoricNames, + contractKits, + timerBrand, + ] = await Promise.all([ + namesByAddressAdminP, + chainStorageP, + agoricNamesP, + contractKitsP, + E(chainTimerService).getTimerBrand(), + ]); + + logger({ namesByAddressAdmin, chainStorage, agoricNames, contractKits }); + + const crabbleNode = await E(chainStorage).makeChildNode('crabble'); + + logger('Getting nameHubs...'); + const mem1NameHub = E( + E(namesByAddressAdmin).lookupAdmin(members[0]), + ).readonly(); + const mem2NameHub = E( + E(namesByAddressAdmin).lookupAdmin(members[1]), + ).readonly(); + const mem3NameHub = E( + E(namesByAddressAdmin).lookupAdmin(members[2]), + ).readonly(); + + const [mem1DepositFacet, mem2DepositFacet, mem3DepositFacet] = + await Promise.all([ + E(mem1NameHub).lookup('depositFacet'), + E(mem2NameHub).lookup('depositFacet'), + E(mem3NameHub).lookup('depositFacet'), + ]); + + logger('Gathering info...'); + const [ + contractInstallation, + governorInstallation, + binaryVoteCounterInstallation, + committeeInstallation, + marshaller, + committeeNode, + timer, + ] = await Promise.all([ + E(zoe).installBundleID(`b1-${vars[0]}`), + E(zoe).installBundleID(`b1-${vars[1]}`), + E(agoricNames).lookup('installation', 'binaryVoteCounter'), + E(agoricNames).lookup('installation', 'committee'), + E(board).getPublishingMarshaller(), + E(crabbleNode).makeChildNode('committee'), + chainTimerService, + ]).catch((err) => logger(err)); + + logger({ + contractInstallation, + governorInstallation, + binaryVoteCounterInstallation, + committeeInstallation, + marshaller, + crabbleNode, + committeeNode, + }); + + const instanceAdminP = E(agoricNamesAdmin).lookupAdmin('instance'); + + logger('Starting committee...'); + const committeeKit = await E(zoe).startInstance( + committeeInstallation, + {}, + { + committeeSize: 3, + committeeName: 'Crabble Committee', + }, + { + storageNode: committeeNode, + marshaller, + }, + ); + logger({ committeeKit }); + + logger('Getting poser invitation...'); + const initialPoserInvitation = await E( + committeeKit.creatorFacet, + ).getPoserInvitation(); + const initialPoserInvitationAmount = await E( + E(zoe).getInvitationIssuer(), + ).getAmountOf(initialPoserInvitation); + + logger({ initialPoserInvitation, initialPoserInvitationAmount }); + + logger('---Starting Crabble with governor---'); + const crabbleTerms = { + governedParams: { + Electorate: { + type: 'invitation', + value: initialPoserInvitationAmount, + }, + }, + agoricNames, + }; + + const crabblePrivateArgs = { + storageNode: crabbleNode, + marshaller, + timer, + initialPoserInvitation, + }; + + logger({ + crabbleTerms, + crabblePrivateArgs, + }); + + logger('Deeply fulfill governorTerms...'); + const governorTerms = harden({ + timerBrand, + governedContractInstallation: contractInstallation, + governed: { + terms: crabbleTerms, + issuerKeywordRecord: {}, + label: 'Crabble', + }, + binaryVoteCounterInstallation, + }); + + logger({ + governorTerms, + }); + + logger('Starting governor...'); + const governorKit = await E(zoe).startInstance( + governorInstallation, + {}, + governorTerms, + harden({ + governed: crabblePrivateArgs, + }), + 'Crabble', + ); + + logger({ + governorKit, + }); + + logger('Getting crabbleKit...'); + const [instance, publicFacet, creatorFacet, adminFacet] = await Promise.all([ + E(governorKit.creatorFacet).getInstance(), + E(governorKit.creatorFacet).getPublicFacet(), + E(governorKit.creatorFacet).getCreatorFacet(), + E(governorKit.creatorFacet).getAdminFacet(), + ]); + + const kit = harden({ + instance, + publicFacet, + creatorFacet, + adminFacet, + governor: governorKit.instance, + governorCreatorFacet: governorKit.creatorFacet, + governorAdminFacet: governorKit.adminFacet, + label: 'GovernedCrabble', + }); + + logger('Updating agoricNames with instances...'); + await Promise.all([ + E(instanceAdminP).update('Crabble', instance), + E(instanceAdminP).update('CrabbleGovernor', governorKit.instance), + E(instanceAdminP).update('CrabbleCommittee', committeeKit.instance), + ]); + + logger('Updating diagnostics...'); + await E(diagnostics).savePrivateArgs(instance, crabblePrivateArgs); + await E(diagnostics).savePrivateArgs(governorKit.instance, { + economicCommitteeCreatorFacet: committeeKit.creatorFacet, + }); + + logger('Getting the member and voter invitations...'); + const [voterInvitations, mem1Invite, mem2Invite, mem3Invite] = + await Promise.all([ + E(committeeKit.creatorFacet).getVoterInvitations(), + E(governorKit.creatorFacet).makeCommitteeMemberInvitation(), + E(governorKit.creatorFacet).makeCommitteeMemberInvitation(), + E(governorKit.creatorFacet).makeCommitteeMemberInvitation(), + ]); + + logger('Updating contractKits...'); + await Promise.all([ + E(governedContractKits).init(instance, kit), + E(contractKits).init(committeeKit.instance, committeeKit), + ]); + + logger('Sending invitations...'); + await Promise.all([ + E(mem1DepositFacet).receive(voterInvitations[0]), + E(mem1DepositFacet).receive(mem1Invite), + E(mem2DepositFacet).receive(voterInvitations[1]), + E(mem2DepositFacet).receive(mem2Invite), + E(mem3DepositFacet).receive(voterInvitations[2]), + E(mem3DepositFacet).receive(mem3Invite), + ]); + + logger('Done.'); +}; + +harden(startCrabble); + +startCrabble; diff --git a/proposals/64:crabble-start/assets/deployAssets.js b/proposals/64:crabble-start/assets/deployAssets.js new file mode 100644 index 00000000..2f69fc96 --- /dev/null +++ b/proposals/64:crabble-start/assets/deployAssets.js @@ -0,0 +1,87 @@ +import bundleMintHolder from '@agoric/vats/bundles/bundle-mintHolder.js'; +import { E } from '@endo/far'; +import { AssetKind } from '@agoric/ertp'; +import fs from 'fs/promises'; + +const deployAssets = async (homeP, { pathResolve }) => { + const { zoe, board, scratch } = E.get(homeP); + + console.log('Installing mintHolder bundle...'); + const mintHolderInstallation = await E(zoe).install(bundleMintHolder); + + const collateralTerms = { + keyword: 'Collateral', + assetKind: AssetKind.NAT, + displayInfo: { decimalPlaces: 6 }, + }; + + const rentalFeeTerms = { + keyword: 'RentalFee', + assetKind: AssetKind.NAT, + displayInfo: { decimalPlaces: 6 }, + }; + + const utilityTerms = { + keyword: 'Utility', + assetKind: AssetKind.SET, + }; + + console.log('Starting instances...'); + const [collateralKit, rentalFeeKit, utilityKit] = await Promise.all([ + E(zoe).startInstance(mintHolderInstallation, undefined, collateralTerms), + E(zoe).startInstance(mintHolderInstallation, undefined, rentalFeeTerms), + E(zoe).startInstance(mintHolderInstallation, undefined, utilityTerms), + ]); + + console.log('Putting the mint objects to scratch...'); + await Promise.all([ + E(scratch).set('collateral-mint', collateralKit.creatorFacet), + E(scratch).set('rentalFee-mint', rentalFeeKit.creatorFacet), + E(scratch).set('utility-mint', utilityKit.creatorFacet), + ]); + + const [collateralBrand, rentalFeeBrand, utilityBrand] = await Promise.all([ + E(collateralKit.publicFacet).getBrand(), + E(rentalFeeKit.publicFacet).getBrand(), + E(utilityKit.publicFacet).getBrand(), + ]); + + console.log('Putting the issuers to board...'); + const [ + collateralIssuerBoardId, + collateralBrandBoardId, + rentalFeeIssuerBoardId, + rentalFeeBrandBoardId, + utilityIssuerBoardId, + utilityBrandBoardId, + ] = await Promise.all([ + E(board).getId(collateralKit.publicFacet), + E(board).getId(collateralBrand), + E(board).getId(rentalFeeKit.publicFacet), + E(board).getId(rentalFeeBrand), + E(board).getId(utilityKit.publicFacet), + E(board).getId(utilityBrand), + ]); + + console.log('Writing to file...'); + const dappConstants = { + COLLATERAL_ISSUER_BOARD_ID: collateralIssuerBoardId, + COLLATERAL_BRAND_BOARD_ID: collateralBrandBoardId, + RENTAL_FEE_ISSUER_BOARD_ID: rentalFeeIssuerBoardId, + RENTAL_FEE_BRAND_BOARD_ID: rentalFeeBrandBoardId, + UTILITY_ISSUER_BOARD_ID: utilityIssuerBoardId, + UTILITY_BRAND_BOARD_ID: utilityBrandBoardId, + }; + const defaultsFolder = pathResolve(`../../../generated`); + const defaultsFile = pathResolve( + `../../../generated/installationConstants.json`, + ); + console.log('writing', defaultsFile); + const defaultsContents = JSON.stringify(dappConstants, undefined, 2); + await fs.mkdir(defaultsFolder, { recursive: true }); + await fs.writeFile(defaultsFile, defaultsContents); + + console.log('Done.'); +}; + +export default deployAssets; diff --git a/proposals/64:crabble-start/assets/proposal-permit.json b/proposals/64:crabble-start/assets/proposal-permit.json new file mode 100644 index 00000000..c5a208b9 --- /dev/null +++ b/proposals/64:crabble-start/assets/proposal-permit.json @@ -0,0 +1,15 @@ +{ + "consume": { + "board": true, + "chainStorage": true, + "chainTimerService": "timer", + "zoe": true, + "agoricNamesAdmin": true, + "agoricNames": true, + "namesByAddressAdmin": true, + "contractKits": true, + "governedContractKits": true, + "diagnostics": true, + "instancePrivateArgs": true + } +} diff --git a/proposals/64:crabble-start/assets/upgrade-core-eval.js b/proposals/64:crabble-start/assets/upgrade-core-eval.js new file mode 100644 index 00000000..e27fdbab --- /dev/null +++ b/proposals/64:crabble-start/assets/upgrade-core-eval.js @@ -0,0 +1,39 @@ +/* eslint-disable no-undef */ +const upgradeCrabble = async ({ + consume: { + agoricNames, + governedContractKits: governedContractKitsP, + instancePrivateArgs: instancePrivateArgsP, + }, +}) => { + const logger = (log) => { + console.log('[UPGRADE_CRABBLE_CORE_EVAL]', log); + }; + + const crabbleV2 = + '041f3c030f3a93166304411a3fbe1b54cb2acc7f7124e4b963cd4a43d7ea2ad1c4a2bcc64491799f30eadee31104bf2b10bac4e3a158afff234a4c0e37707651'; + const [governedContractKits, instancePrivateArgs, crabbleInstance] = + await Promise.all([ + governedContractKitsP, + instancePrivateArgsP, + E(agoricNames).lookup('instance', 'Crabble'), + ]); + + logger('Getting Crabble Info...'); + const [crabbleKit, crabblePrivateArgs] = await Promise.all([ + E(governedContractKits).get(crabbleInstance), + E(instancePrivateArgs).get(crabbleInstance), + ]); + + logger('CRABBLE_INFO'); + logger({ crabbleKit, crabblePrivateArgs }); + + const upgradeResult = await E(crabbleKit.adminFacet).upgradeContract( + `b1-${crabbleV2}`, + crabblePrivateArgs, + ); + logger({ upgradeResult }); +}; + +harden(upgradeCrabble); +upgradeCrabble; diff --git a/proposals/64:crabble-start/test-crabble-start.js b/proposals/64:crabble-start/test-crabble-start.js new file mode 100644 index 00000000..30273d59 --- /dev/null +++ b/proposals/64:crabble-start/test-crabble-start.js @@ -0,0 +1,437 @@ +// @ts-check + +// NOTE: This ava test() style is based on earlier working code. +// TODO: consider ordinary script style. + +/** + * @file mainnet-2 contract start test for KREAd + * + * Proposal info is fetched from a release. + * + * @typedef {{ + * bundles: string[], + * evals: { permit: string; script: string }[], + * }} ProposalInfo + */ + +import anyTest from 'ava'; +import * as cpAmbient from 'child_process'; // TODO: use execa +import * as fspAmbient from 'fs/promises'; +import { tmpName as tmpNameAmbient } from 'tmp'; +import * as pathAmbient from 'path'; +import * as processAmbient from 'process'; +import dbOpenAmbient from 'better-sqlite3'; + +// TODO: factor out ambient authority from these +// or at least allow caller to supply authority. +import { + agoric, + wellKnownIdentities, +} from '../../upgrade-test-scripts/lib/cliHelper.js'; +import { + provisionSmartWallet, + voteLatestProposalAndWait, + waitForBlock, +} from '../../upgrade-test-scripts/lib/commonUpgradeHelpers.js'; + +import { makeAgd } from '../../upgrade-test-scripts/lib/agd-lib.js'; +import { dbTool } from '../../upgrade-test-scripts/lib/vat-status.js'; +import { + makeFileRd, + makeFileRW, +} from '../../upgrade-test-scripts/lib/webAsset.js'; +import { + ensureISTForInstall, + flags, + getContractInfo, + loadedBundleIds, + testIncludes, + txAbbr, +} from './core-eval-support.js'; + +/** @typedef {Awaited>} TestContext */ +/** @type {import('ava').TestFn}} */ +const test = anyTest; + +const assetInfo = { + /** @type {Record} */ + buildAssets: { + crabbleCoreEvalInfo: { + evals: [{ permit: 'proposal-permit.json', script: 'core-eval.js' }], + bundles: [ + 'bundle-crabble.json', + 'bundle-crabbleGovernor.json', + ], + }, + }, +}; + +const dappAPI = { + instance: 'crabble', // agoricNames.instance key + vstorageNode: 'crabble', +}; + +const staticConfig = { + deposit: '10000000ubld', // 10 BLD. XXX mainnet was 5000 at the time + installer: 'user1', // as in: agd keys show gov1 + proposer: 'validator', + collateralPrice: 6, // conservatively low price. TODO: look up + swingstorePath: '~/.agoric/data/agoric/swingstore.sqlite', + buildInfo: Object.values(assetInfo.buildAssets), + initialCoins: `20000000ubld`, // enough to provision a smartWallet + accounts: { + mem1: { + impersonate: 'agoric1kupk4yyvnl3h80j753705nfm2nfxff5vktvd3z', + address: 'agoric1s32tu4wtkqc5440p0uf0hk508nerfmunr65vtl', + mnemonic: + 'rival find chest wall myself guess fat hint frozen shed cake theme harbor physical bleak tube large desk cream increase scrap virus top bulb', + }, + mem2: { + impersonate: 'agoric10xh9n8qzjsxg9k5txdmvtj5kfr3092j8mptr7g', + address: 'agoric1xdu48rxgakk5us7m3wud04pf92kzjmhwllzdef', + mnemonic: + 'orient tag produce jar expect travel consider zero flight pause rebuild rent blanket yellow siege ivory hidden loop unlock dream priority prevent horn load', + }, + mem3: { + impersonate: 'agoric1890064p6j3xhzzdf8daknd6kpvhw766ds8flgw', + address: 'agoric1hmdue96vs0p6zj42aa26x6zrqlythpxnvgsgpr', + mnemonic: + 'seven regular giggle castle universe find secret like inquiry round write pumpkin risk exhaust dress grab host message carbon student put kind gold treat', + }, + }, + ...dappAPI, +}; + +/** + * id: 'b1-{hash}' + * endoZipBase64Sha512: hash + * fileName: bundleName + */ +const bundleDetail = async (src, bundleName) => { + const file = src.join(bundleName); + const [content, absPath] = await Promise.all([ + file.readText(), + file.toString(), + ]); + const { endoZipBase64Sha512 } = JSON.parse(content); + return { + id: `b1-${endoZipBase64Sha512}`, + fileName: bundleName, + endoZipBase64Sha512, + absPath, + }; +}; + +/** + * Provide access to the outside world via t.context. + * @param {Object} io + */ +const makeTestContext = async (io = {}) => { + const { + process: { env, cwd } = processAmbient, + child_process: { execFileSync } = cpAmbient, + dbOpen = dbOpenAmbient, + fsp = fspAmbient, + path = pathAmbient, + tmpName = tmpNameAmbient, + } = io; + + const src = makeFileRd(`${cwd()}/assets`, { fsp, path }); + const tmpNameP = prefix => + new Promise((resolve, reject) => + tmpName({ prefix }, (err, x) => (err ? reject(err) : resolve(x))), + ); + + const config = { + chainId: 'agoriclocal', + ...staticConfig, + }; + + // This agd API is based on experience "productizing" + // the inter bid CLI in #7939 + const agd = makeAgd({ execFileSync: execFileSync }).withOpts({ + keyringBackend: 'test', + }); + + const dbPath = staticConfig.swingstorePath.replace(/^~/, env.HOME); + const swingstore = dbTool(dbOpen(dbPath, { readonly: true })); + + /* @param {string} baseName */ + const mkTempRW = async baseName => + makeFileRW(await tmpNameP(baseName), { fsp, path }); + return { agd, agoric, swingstore, config, mkTempRW, src }; +}; + +test.before(async t => (t.context = await makeTestContext())); + +test('initial', async t => { + const { src } = t.context; + const assetFaucet = src.join('bundle-assetsFaucet.json'); + const stat = assetFaucet.stat(); + const path = assetFaucet.toString(); + console.log({ + stat, + path, + }); + t.pass(); +}); + +test.serial(`pre-flight: not in agoricNames.instance`, async t => { + const { config, agoric } = t.context; + const { instance: target } = config; + console.log({ config, agoric }) + const { instance } = await wellKnownIdentities({ agoric }); + testIncludes(t, target, Object.keys(instance), 'instance keys', false); +}); + +test.serial('bundles not yet installed', async t => { + const { swingstore, src } = t.context; + const loaded = loadedBundleIds(swingstore); + const info = staticConfig.buildInfo; + for await (const { bundles, evals } of info) { + t.log(evals[0].script, evals.length, 'eval', bundles.length, 'bundles'); + for await (const bundle of bundles) { + const detail = await bundleDetail(src, bundle); + console.log({ detail }); + const { id } = detail; + testIncludes(t, id, loaded, 'loaded bundles', false); + } + } +}); + +/** @param {number[]} xs */ +const sum = xs => xs.reduce((a, b) => a + b, 0); + +const getFileSize = async (src, fileName) => { + const file = src.join(fileName); + const { size } = await file.stat(); + return size; +}; + +/** @param {import('./lib/webAsset.js').FileRd} src */ +const readBundleSizes = async src => { + const info = staticConfig.buildInfo; + const bundleSizes = await Promise.all( + info + .map(({ bundles }) => + bundles.map(bundleName => getFileSize(src, bundleName)), + ) + .flat(), + ); + const totalSize = sum(bundleSizes); + return { bundleSizes, totalSize }; +}; + +test.serial('ensure enough IST to install bundles', async t => { + const { agd, config, src } = t.context; + const { totalSize, bundleSizes } = await readBundleSizes(src); + console.log({ totalSize, bundleSizes }); + await ensureISTForInstall(agd, config, totalSize, { + log: t.log, + }); + t.pass(); +}); + +test.serial('ensure bundles installed', async t => { + const { agd, swingstore, agoric, config, io, src } = t.context; + const { chainId } = config; + const loaded = loadedBundleIds(swingstore); + const from = agd.lookup(config.installer); + + let todo = 0; + let done = 0; + for await (const { bundles } of staticConfig.buildInfo) { + todo += bundles.length; + for await (const bundle of bundles) { + const { id, endoZipBase64Sha512, absPath } = await bundleDetail( + src, + bundle, + ); + if (loaded.includes(id)) { + t.log('bundle already installed', id); + done += 1; + continue; + } + + const result = await agd.tx( + ['swingset', 'install-bundle', `@${absPath}`, '--gas', 'auto'], + { from, chainId, yes: true }, + ); + t.log(txAbbr(result)); + t.is(result.code, 0); + + const info = await getContractInfo('bundles', { agoric, prefix: '' }); + t.log(info); + done += 1; + t.deepEqual(info, { + endoZipBase64Sha512, + error: null, + installed: true, + }); + } + } + t.is(todo, done); +}); + +test.serial('core eval prereqs: provision royalty, gov, ...', async t => { + const { agd, config } = t.context; + const { entries } = Object; + + for (const [name, { address, mnemonic }] of entries(config.accounts)) { + try { + agd.lookup(address); + t.log(name, 'key already added'); + continue; + } catch (_e) {} + t.log('add key', name); + agd.keys.add(name, mnemonic); + } + + for (const [name, { address }] of entries(config.accounts)) { + const walletPath = `published.wallet.${address}`; + const data = await agd.query(['vstorage', 'data', walletPath]); + if (data.value.length > 0) { + t.log(name, 'wallet already provisioned'); + continue; + } + await provisionSmartWallet(address, config.initialCoins); + } + + t.pass(); +}); + +/** + * @param {string} text + * @param {string} fileName + */ +const acctSub = (text, fileName) => { + let out = text; + for (const [name, detail] of Object.entries(staticConfig.accounts)) { + if (out.includes(detail.impersonate)) { + console.log('impersonating', name, 'in', fileName); + out = out.replace(detail.impersonate, detail.address); + } + } + return out; +}; + +test.serial('core eval proposal passes', async t => { + const { agd, swingstore, config, mkTempRW, src } = t.context; + const from = agd.lookup(config.proposer); + const { chainId, deposit, instance } = config; + const info = { title: instance, description: `start ${instance}` }; + t.log('submit proposal', instance); + + // double-check that bundles are loaded + const loaded = loadedBundleIds(swingstore); + const { buildInfo } = staticConfig; + for (const { bundles } of buildInfo) { + for (const bundle of bundles) { + const { id } = await bundleDetail(src, bundle); + testIncludes(t, id, loaded, 'loaded bundles'); + } + } + + /** @param {string} script */ + const withKnownKeys = async script => { + const file = src.join(script); + const text = await file.readText(); + const text2 = acctSub(text, script); + const out = await mkTempRW(script); + await out.writeText(text2); + return out.toString(); + }; + + const evalNames = buildInfo + .map(({ evals }) => evals) + .flat() + .map(e => [e.permit, e.script]) + .flat(); + const evalPaths = await Promise.all(evalNames.map(withKnownKeys)); + t.log(evalPaths); + console.log('await tx', evalPaths); + const result = await agd.tx( + [ + 'gov', + 'submit-proposal', + 'swingset-core-eval', + ...evalPaths, + ...flags({ ...info, deposit }), + ...flags({ gas: 'auto', 'gas-adjustment': '1.2' }), + ], + { from, chainId, yes: true }, + ); + t.log(txAbbr(result)); + t.is(result.code, 0); + + console.log('await voteLatestProposalAndWait', evalPaths); + const detail = await voteLatestProposalAndWait(); + t.log(detail.proposal_id, detail.voting_end_time, detail.status); + + // TODO: how long is long enough? poll? + await waitForBlock(5); + + t.is(detail.status, 'PROPOSAL_STATUS_PASSED'); +}); + +test.serial('vstorage published.CHILD is present', async t => { + const { agd, config } = t.context; + const { vstorageNode } = config; + const { children } = await agd.query(['vstorage', 'children', 'published']); + testIncludes(t, vstorageNode, children, 'published children'); +}); + +test.serial(`agoricNames.instance is populated`, async t => { + const { config, agoric, agd } = t.context; + const { instance: target } = config; + + /** + * @param {() => Promise} check + */ + const poll = async (check, maxTries) => { + for (let tries = 0; tries < maxTries; tries += 1) { + const ok = await check(); + if (ok) return; + await waitForBlock(); + } + throw Error(`tried ${maxTries} times without success`); + }; + + const checkForInstance = async () => { + + const { instance } = await wellKnownIdentities({ agoric }); + const present = Object.keys(instance); + return present.includes(target); + }; + + // contract initialization took ~10min in mainnet + const minute = 60 / 1; // block time is ~1sec + poll(checkForInstance, 15 * minute); + t.pass(); +}); + +// // needs 2 brand names +// test.todo(`agoricNames.brand is populated`); +// test.todo('boardAux is populated'); +// +// // KREAd specific below here +// // TODO refactor this test for re-use across MN2 scripts +// +// // TODO test this more robustly with the pausing feature +// // This doesn't work with mainline KREAd becaues they don't have anything +// // to write upon contract start. The pausing test will ensure there's +// // a latestQuestion node published. +test.serial('crabble governance is present', async t => { + const { agd } = t.context; + const { children } = await agd.query([ + 'vstorage', + 'children', + 'published.crabble', + ]); + console.log({ children }) + testIncludes(t, 'governance', children, 'crabble committee'); +}); +// +// test.todo('test contract features- mint character'); +// test.todo('test contract governance - pause'); +// test.todo('test contract governance - API'); From 2fcdd4353b9d4d27cc0474ba332799ae1133ba77 Mon Sep 17 00:00:00 2001 From: anilhelvaci Date: Tue, 12 Dec 2023 12:30:59 +0300 Subject: [PATCH 2/4] Code run in #1 --- proposals/64:crabble-start/.yarnrc.yml | 1 + .../assets/assets-core-eval.js | 186 -- .../assets/bundle-assetsFaucet-json-meta.json | 122 - .../assets/bundle-assetsFaucet.json | 1 - .../assets/bundle-contract.json | 1 + .../assets/bundle-crabble-json-meta.json | 814 ------ .../assets/bundle-crabble.json | 1 - .../bundle-crabbleGovernor-json-meta.json | 498 ---- .../assets/bundle-crabbleGovernor.json | 1 - .../assets/bundle-governor.json | 1 + .../64:crabble-start/assets/core-eval.js | 232 -- .../assets/crabble-permit.json | 24 + .../assets/crabbleCoreEval.js | 250 ++ .../64:crabble-start/assets/deployAssets.js | 87 - .../64:crabble-start/assets/gov-permit.json | 11 + .../64:crabble-start/assets/govStarting.js | 216 ++ .../assets/proposal-permit.json | 15 - .../assets/upgrade-core-eval.js | 39 - .../64:crabble-start/core-eval-support.js | 151 ++ proposals/64:crabble-start/eval.sh | 12 + proposals/64:crabble-start/package.json | 21 + .../64:crabble-start/test-crabble-start.js | 38 +- proposals/64:crabble-start/test.sh | 7 + proposals/64:crabble-start/use.sh | 8 + proposals/64:crabble-start/yarn.lock | 2349 +++++++++++++++++ 25 files changed, 3073 insertions(+), 2013 deletions(-) create mode 100644 proposals/64:crabble-start/.yarnrc.yml delete mode 100644 proposals/64:crabble-start/assets/assets-core-eval.js delete mode 100644 proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json delete mode 100644 proposals/64:crabble-start/assets/bundle-assetsFaucet.json create mode 100644 proposals/64:crabble-start/assets/bundle-contract.json delete mode 100644 proposals/64:crabble-start/assets/bundle-crabble-json-meta.json delete mode 100644 proposals/64:crabble-start/assets/bundle-crabble.json delete mode 100644 proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json delete mode 100644 proposals/64:crabble-start/assets/bundle-crabbleGovernor.json create mode 100644 proposals/64:crabble-start/assets/bundle-governor.json delete mode 100644 proposals/64:crabble-start/assets/core-eval.js create mode 100644 proposals/64:crabble-start/assets/crabble-permit.json create mode 100644 proposals/64:crabble-start/assets/crabbleCoreEval.js delete mode 100644 proposals/64:crabble-start/assets/deployAssets.js create mode 100644 proposals/64:crabble-start/assets/gov-permit.json create mode 100644 proposals/64:crabble-start/assets/govStarting.js delete mode 100644 proposals/64:crabble-start/assets/proposal-permit.json delete mode 100644 proposals/64:crabble-start/assets/upgrade-core-eval.js create mode 100644 proposals/64:crabble-start/core-eval-support.js create mode 100755 proposals/64:crabble-start/eval.sh create mode 100644 proposals/64:crabble-start/package.json create mode 100644 proposals/64:crabble-start/test.sh create mode 100644 proposals/64:crabble-start/use.sh create mode 100644 proposals/64:crabble-start/yarn.lock diff --git a/proposals/64:crabble-start/.yarnrc.yml b/proposals/64:crabble-start/.yarnrc.yml new file mode 100644 index 00000000..3186f3f0 --- /dev/null +++ b/proposals/64:crabble-start/.yarnrc.yml @@ -0,0 +1 @@ +nodeLinker: node-modules diff --git a/proposals/64:crabble-start/assets/assets-core-eval.js b/proposals/64:crabble-start/assets/assets-core-eval.js deleted file mode 100644 index c8b79d9e..00000000 --- a/proposals/64:crabble-start/assets/assets-core-eval.js +++ /dev/null @@ -1,186 +0,0 @@ -/* eslint-disable no-undef */ -const startAssetsFaucet = async ({ - consume: { zoe, agoricNamesAdmin, contractKits, board, chainStorage }, -}) => { - const boardAux = E(chainStorage).makeChildNode('boardAux'); - - const logger = (log) => { - console.log('[ASSET_CRABBLE_CORE_EVAL]', log); - }; - - const publishBrandInfo = async (brand, marshaller) => { - const [id, displayInfo, allegedName] = await Promise.all([ - E(board).getId(brand), - E(brand).getDisplayInfo(), - E(brand).getAllegedName(), - ]); - const node = E(boardAux).makeChildNode(id); - const aux = await E(marshaller).toCapData( - harden({ allegedName, displayInfo }), - ); - await E(node).setValue(JSON.stringify(aux)); - }; - - const assetsFaucetBundleID = 'ddc23eddf3926ed5b0a6f861c794ffd8fb80ca49f1c9dbf0656b5642060e0c6567ef2d131968b29792a7651fe68eec07ac2ed519650f888a587bc95f72674628'; - - const crabbleIstTerms = { - keyword: 'CrabbleIST', - assetKind: 'nat', - displayInfo: { decimalPlaces: 6 }, - }; - - const chainboardCollectionTerms = { - keyword: 'ChainboardCollection', - assetKind: 'set', - }; - - const crabbleCollectionTerms = { - keyword: 'CrabbleCollection', - assetKind: 'set', - }; - - logger('Get faucet contract installation'); - const assetsFaucetInstallation = await E(zoe).installBundleID( - `b1-${assetsFaucetBundleID}`, - ); - - logger({ - assetsFaucetInstallation, - }); - - logger('Get agoricNamesAdmin'); - const issuerAdminP = E(agoricNamesAdmin).lookupAdmin('issuer'); - const brandAdminP = E(agoricNamesAdmin).lookupAdmin('brand'); - const instanceAdminP = E(agoricNamesAdmin).lookupAdmin('instance'); - - logger('Starting Faucet contracts'); - const { - creatorFacet: crabbleIstCreatorFacet, - publicFacet: crabbleIstPublicFacet, - instance: crabbleIstInstance, - } = await E(zoe).startInstance( - assetsFaucetInstallation, - {}, - crabbleIstTerms, - {}, - 'CrabbleISTFaucet', - ); - - const { - creatorFacet: chainboardCollectionCreatorFacet, - publicFacet: chainboardCollectionPublicFacet, - instance: chainboardCollectionInstance, - } = await E(zoe).startInstance( - assetsFaucetInstallation, - {}, - chainboardCollectionTerms, - {}, - 'ChainboardCollectionFaucet', - ); - - const { - creatorFacet: crabbleCollectionCreatorFacet, - publicFacet: crabbleCollectionPublicFacet, - instance: crabbleCollectionInstance, - } = await E(zoe).startInstance( - assetsFaucetInstallation, - {}, - crabbleCollectionTerms, - {}, - 'CrabbleCollectionFaucet', - ); - - logger({ - crabbleIstCreatorFacet, - crabbleIstPublicFacet, - crabbleIstInstance, - chainboardCollectionCreatorFacet, - chainboardCollectionPublicFacet, - chainboardCollectionInstance, - crabbleCollectionCreatorFacet, - crabbleCollectionPublicFacet, - crabbleCollectionInstance, - }); - - logger('Updating agoricNames with assets issuers and brands'); - const crabbleIstIssuerP = E(crabbleIstPublicFacet).getIssuer(); - const chainboardCollectionIssuerP = E( - chainboardCollectionPublicFacet, - ).getIssuer(); - const crabbleCollectionIssuerP = E(crabbleCollectionPublicFacet).getIssuer(); - - const [ - crabbleIstIssuer, - crabbleIstBrand, - chainboardCollectionIssuer, - chainboardCollectionBrand, - crabbleCollectionIssuer, - crabbleCollectionBrand, - ] = await Promise.all([ - crabbleIstIssuerP, - E(crabbleIstIssuerP).getBrand(), - chainboardCollectionIssuerP, - E(chainboardCollectionIssuerP).getBrand(), - crabbleCollectionIssuerP, - E(crabbleCollectionIssuerP).getBrand(), - ]); - await Promise.all([ - E(issuerAdminP).update('CrabbleIST', crabbleIstIssuer), - E(brandAdminP).update('CrabbleIST', crabbleIstBrand), - E(issuerAdminP).update('ChainboardCollection', chainboardCollectionIssuer), - E(brandAdminP).update('ChainboardCollection', chainboardCollectionBrand), - E(issuerAdminP).update('CrabbleCollection', crabbleCollectionIssuer), - E(brandAdminP).update('CrabbleCollection', crabbleCollectionBrand), - ]); - - logger('Updating agoricNames with contract instances'); - await Promise.all([ - E(instanceAdminP).update('CrabbleISTFaucet', crabbleIstInstance), - E(instanceAdminP).update( - 'ChainboardCollectionFaucet', - chainboardCollectionInstance, - ), - E(instanceAdminP).update( - 'CrabbleCollectionFaucet', - crabbleCollectionInstance, - ), - ]); - - logger('Publishing brand info to boardAux...'); - const marshaller = await E(board).getPublishingMarshaller(); - await Promise.all([ - publishBrandInfo(crabbleIstBrand, marshaller), - publishBrandInfo(chainboardCollectionBrand, marshaller), - publishBrandInfo(crabbleCollectionBrand, marshaller), - ]); - - logger('Record faucet contracts kits on contractKits'); - const crabbleIstKit = { - crabbleIstCreatorFacet, - crabbleIstPublicFacet, - crabbleIstInstance, - }; - - const chainboardCollectionKit = { - chainboardCollectionCreatorFacet, - chainboardCollectionPublicFacet, - chainboardCollectionInstance, - }; - - const crabbleCollectionKit = { - crabbleCollectionCreatorFacet, - crabbleCollectionPublicFacet, - crabbleCollectionInstance, - }; - - await Promise.all([ - E(contractKits).init(crabbleIstInstance, crabbleIstKit), - E(contractKits).init(chainboardCollectionInstance, chainboardCollectionKit), - E(contractKits).init(crabbleCollectionInstance, crabbleCollectionKit), - ]); - - logger('Completed'); -}; - -harden(startAssetsFaucet); -startAssetsFaucet; diff --git a/proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json b/proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json deleted file mode 100644 index 1e56b02d..00000000 --- a/proposals/64:crabble-start/assets/bundle-assetsFaucet-json-meta.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "bundleFileName": "bundle-assetsFaucet.json", - "bundleTime": "2023-12-04T09:21:55.049Z", - "moduleSource": { - "relative": "../../assetsFaucet/src/assetsFaucet.js", - "absolute": "/Users/anil/WebstormProjects/agoric-samples/crabbleProtocol/source_code/assetsFaucet/src/assetsFaucet.js" - }, - "contents": [ - { - "relativePath": "", - "mtime": "2023-12-04T07:39:35.034Z" - }, - { - "relativePath": "../../../node_modules/@endo/far/src/index.js", - "mtime": "2023-11-07T14:22:41.230Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/no-shim.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/index.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/E.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/exports.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/error.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/iter-helpers.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/make-far.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/makeTagged.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/passStyle-helpers.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/passStyleOf.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/remotable.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/symbol.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/typeGuards.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/types.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/track-turns.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/copyArray.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/copyRecord.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/safe-promise.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/tagged.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/index.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/env-options/index.js", - "mtime": "2023-11-07T14:22:43.206Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/is-promise.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/memo-race.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/promise-executor-kit.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/types.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/env-options/src/env-options.js", - "mtime": "2023-11-07T14:22:43.206Z" - } - ] -} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-assetsFaucet.json b/proposals/64:crabble-start/assets/bundle-assetsFaucet.json deleted file mode 100644 index db099ea3..00000000 --- a/proposals/64:crabble-start/assets/bundle-assetsFaucet.json +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"ddc23eddf3926ed5b0a6f861c794ffd8fb80ca49f1c9dbf0656b5642060e0c6567ef2d131968b29792a7651fe68eec07ac2ed519650f888a587bc95f72674628"} diff --git a/proposals/64:crabble-start/assets/bundle-contract.json b/proposals/64:crabble-start/assets/bundle-contract.json new file mode 100644 index 00000000..d1dc9b49 --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-contract.json @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"46f82a8b8348f7c2dcae1ddc1ace085f5f489d493f7df24ce8f2334199b21eeb9ed848de5e2814f200ba47470ff3bd83b08d74055da2a454f94c2a0c565bf557"} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-crabble-json-meta.json b/proposals/64:crabble-start/assets/bundle-crabble-json-meta.json deleted file mode 100644 index 5eae2451..00000000 --- a/proposals/64:crabble-start/assets/bundle-crabble-json-meta.json +++ /dev/null @@ -1,814 +0,0 @@ -{ - "bundleFileName": "bundle-crabble.json", - "bundleTime": "2023-12-04T09:21:52.263Z", - "moduleSource": { - "relative": "../../contract/src/crabble.js", - "absolute": "/Users/anil/WebstormProjects/agoric-samples/crabbleProtocol/source_code/contract/src/crabble.js" - }, - "contents": [ - { - "relativePath": "", - "mtime": "2023-12-04T07:53:53.636Z" - }, - { - "relativePath": "../assertionHelpers.js", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../catalog.js", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../rental.js", - "mtime": "2023-12-04T07:39:35.036Z" - }, - { - "relativePath": "../utils.js", - "mtime": "2023-12-04T07:39:35.036Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/index.js", - "mtime": "2023-09-29T12:47:53.776Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/index.js", - "mtime": "2023-09-29T12:48:23.825Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/index.js", - "mtime": "2023-09-29T12:48:23.873Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/index.js", - "mtime": "2023-09-29T12:47:53.967Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/recorder.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../../../node_modules/@endo/far/src/index.js", - "mtime": "2023-11-07T14:22:41.230Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/safeMath.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../bidsManager.js", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../bidKit.js", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../constants.js", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../leaseKit.js", - "mtime": "2023-12-04T07:39:35.036Z" - }, - { - "relativePath": "../rentalKit.js", - "mtime": "2023-12-04T07:39:35.036Z" - }, - { - "relativePath": "../typeGuards.js", - "mtime": "2023-12-04T07:39:35.036Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/time/index.js", - "mtime": "2023-09-29T12:47:53.942Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/exported.js", - "mtime": "2023-09-29T12:48:23.893Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/atomicTransfer.js", - "mtime": "2023-09-29T12:48:23.894Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/topics.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/makeHandle.js", - "mtime": "2023-09-29T12:47:53.972Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/exo-utils.js", - "mtime": "2023-09-29T12:48:23.872Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/vat-data-bindings.js", - "mtime": "2023-09-29T12:48:23.873Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/index.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/constants.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governParam.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/paramManager.js", - "mtime": "2023-09-29T12:48:23.824Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/typedParamManager.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernor.js", - "mtime": "2023-09-29T12:48:23.824Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractHelper.js", - "mtime": "2023-09-29T12:48:23.824Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/question.js", - "mtime": "2023-09-29T12:47:53.875Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/types-ambient.js", - "mtime": "2023-09-29T12:48:23.825Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/validators.js", - "mtime": "2023-09-29T12:48:23.825Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/exported.js", - "mtime": "2023-09-29T12:47:53.775Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/SwingSet/src/vats/network/types.js", - "mtime": "2023-09-29T12:48:23.791Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/amountMath.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/issuerKit.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.781Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/bondingCurves.js", - "mtime": "2023-09-29T12:48:23.894Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/durability.js", - "mtime": "2023-09-29T12:48:23.894Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/priceAuthority.js", - "mtime": "2023-09-29T12:48:23.894Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/priceQuote.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/ratio.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/stateMachine.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/statistics.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/zoeHelpers.js", - "mtime": "2023-09-29T12:48:23.895Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/no-shim.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/index.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/assert/src/assert.js", - "mtime": "2023-09-29T12:47:53.836Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/index.js", - "mtime": "2023-09-29T12:47:53.895Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/index.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/tools/testSupports.js", - "mtime": "2023-09-29T12:47:53.902Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/no-shim.js", - "mtime": "2023-09-29T07:30:46.568Z" - }, - { - "relativePath": "../leaseHolder.js", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../bidHolder.js", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/nat/src/index.js", - "mtime": "2023-09-29T07:30:52.810Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.897Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/far/src/index.js", - "mtime": "2023-09-29T07:30:45.835Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractFacet/types.js", - "mtime": "2023-09-29T12:48:23.893Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/types.js", - "mtime": "2023-09-29T12:47:53.968Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/exported.js", - "mtime": "2023-09-29T12:47:53.970Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/types.js", - "mtime": "2023-09-29T12:47:53.972Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/zoeService/types.js", - "mtime": "2023-09-29T12:47:53.973Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/tools/types-ambient.js", - "mtime": "2023-09-29T12:47:53.986Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/exported.js", - "mtime": "2023-09-29T12:47:53.899Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/exported.js", - "mtime": "2023-09-29T12:47:53.911Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/SwingSet/exported.js", - "mtime": "2023-09-29T12:47:53.792Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractFacet/rightsConservation.js", - "mtime": "2023-09-29T12:47:53.966Z" - }, - { - "relativePath": "../rentalHolder.js", - "mtime": "2023-12-04T07:39:35.036Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/time/src/timeMath.js", - "mtime": "2023-09-29T12:48:23.869Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/time/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.869Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyMap.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyWeakMap.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarMapStore.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarSetStore.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakMapStore.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakSetStore.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/store-utils.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/index.js", - "mtime": "2023-09-29T07:31:07.143Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/index.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/assertions.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/cleanProposal.js", - "mtime": "2023-09-29T12:48:23.893Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/index.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/typeGuards.js", - "mtime": "2023-09-29T12:47:53.875Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernorKit.js", - "mtime": "2023-09-29T12:48:23.824Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/displayInfo.js", - "mtime": "2023-09-29T12:47:53.775Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/paymentLedger.js", - "mtime": "2023-09-29T12:48:23.781Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/types-ambient.js", - "mtime": "2023-09-29T12:48:23.781Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copyBagMathHelpers.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copySetMathHelpers.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/natMathHelpers.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/setMathHelpers.js", - "mtime": "2023-09-29T12:47:53.776Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/index.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractFacet/offerSafety.js", - "mtime": "2023-09-29T12:47:53.966Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/E.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/exports.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/config.js", - "mtime": "2023-09-29T12:47:53.895Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/debug.js", - "mtime": "2023-09-29T12:47:53.895Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/method-tools.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/utils.js", - "mtime": "2023-09-29T12:47:53.897Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/error.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/iter-helpers.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/make-far.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/makeTagged.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/passStyle-helpers.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/passStyleOf.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/remotable.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/symbol.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/typeGuards.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/types.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/E.js", - "mtime": "2023-09-29T07:30:46.568Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/assert/src/types.js", - "mtime": "2023-09-29T12:47:53.836Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/asyncIterableAdaptor.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/notifier.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/publish-kit.js", - "mtime": "2023-09-29T12:48:23.846Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/stored-notifier.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/storesub.js", - "mtime": "2023-09-29T12:48:23.846Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscribe.js", - "mtime": "2023-09-29T12:48:23.846Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscriber.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/types-ambient.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/testing-utils.js", - "mtime": "2023-09-29T12:47:53.896Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/index.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/callSpread/types.js", - "mtime": "2023-09-29T12:47:53.970Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/loan/types.js", - "mtime": "2023-09-29T12:48:23.896Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contracts/types.js", - "mtime": "2023-09-29T12:47:53.971Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/types.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/internal-types.js", - "mtime": "2023-09-29T12:48:23.897Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-makers.js", - "mtime": "2023-09-29T07:31:07.143Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/checkKey.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/compareKeys.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copyBag.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copySet.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-bag-operators.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-set-operators.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/patterns/patternMatchers.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/types.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/utils.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/objArrayConversion.js", - "mtime": "2023-09-29T12:47:53.972Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/deeplyFulfilled.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodePassable.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToCapData.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-justin.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-stringify.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/rankOrder.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/types.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governFilter.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governApi.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/payment.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/purse.js", - "mtime": "2023-09-29T12:47:53.776Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/is-promise.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/promise-executor-kit.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/memo-race.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/types.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../node_modules/@endo/eventual-send/src/track-turns.js", - "mtime": "2023-11-07T14:22:39.358Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/stream/index.js", - "mtime": "2023-09-29T07:30:53.746Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/main.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/copyArray.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/copyRecord.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/safe-promise.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/pass-style/src/tagged.js", - "mtime": "2023-11-07T14:22:43.840Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/index.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/track-turns.js", - "mtime": "2023-09-29T07:30:46.568Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/lib-chainStorage.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/upgrade-api.js", - "mtime": "2023-09-29T12:47:53.897Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/topic.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/error.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/iter-helpers.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/make-far.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/makeTagged.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyle-helpers.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyleOf.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/remotable.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/symbol.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/typeGuards.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/types.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-tools.js", - "mtime": "2023-09-29T07:31:07.143Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToSmallcaps.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/main.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/main.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/transientNotifier.js", - "mtime": "2023-09-29T12:47:53.776Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/callback.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zone/src/index.js", - "mtime": "2023-09-29T12:48:23.911Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/is-promise.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/memo-race.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/promise-executor-kit.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/promise-kit/src/types.js", - "mtime": "2023-11-07T14:22:40.138Z" - }, - { - "relativePath": "../../../node_modules/@endo/env-options/index.js", - "mtime": "2023-11-07T14:22:43.206Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyArray.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyRecord.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/safe-promise.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/tagged.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/E.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/async-generate.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/makers.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/async-tools.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zone/src/heap.js", - "mtime": "2023-09-29T12:48:23.911Z" - }, - { - "relativePath": "../../../node_modules/@endo/env-options/src/env-options.js", - "mtime": "2023-11-07T14:22:43.206Z" - } - ] -} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-crabble.json b/proposals/64:crabble-start/assets/bundle-crabble.json deleted file mode 100644 index 4d2fec6f..00000000 --- a/proposals/64:crabble-start/assets/bundle-crabble.json +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"9ef6df6021cabaece3a53065bbc4e1f68f0e109498861b814e26077422c89a5c1f7a6717875f7c9b35197cb36ba87dd424d927ef9230c9227bb7fdf4dcd0cdf0"} diff --git a/proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json b/proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json deleted file mode 100644 index b68e5ce2..00000000 --- a/proposals/64:crabble-start/assets/bundle-crabbleGovernor-json-meta.json +++ /dev/null @@ -1,498 +0,0 @@ -{ - "bundleFileName": "bundle-crabbleGovernor.json", - "bundleTime": "2023-12-04T09:21:53.975Z", - "moduleSource": { - "relative": "../../contract/src/crabbleGovernor.js", - "absolute": "/Users/anil/WebstormProjects/agoric-samples/crabbleProtocol/source_code/contract/src/crabbleGovernor.js" - }, - "contents": [ - { - "relativePath": "", - "mtime": "2023-12-04T07:39:35.035Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governParam.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernorKit.js", - "mtime": "2023-09-29T12:48:23.824Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/index.js", - "mtime": "2023-09-29T12:47:53.895Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/time/index.js", - "mtime": "2023-09-29T12:47:53.942Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/index.js", - "mtime": "2023-09-29T12:48:23.873Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/contractSupport/durability.js", - "mtime": "2023-09-29T12:48:23.894Z" - }, - { - "relativePath": "../../node_modules/@endo/eventual-send/src/no-shim.js", - "mtime": "2023-11-07T14:22:46.391Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/question.js", - "mtime": "2023-09-29T12:47:53.875Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/typeGuards.js", - "mtime": "2023-09-29T12:47:53.875Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/index.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/no-shim.js", - "mtime": "2023-09-29T07:30:46.568Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/index.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/time/src/timeMath.js", - "mtime": "2023-09-29T12:48:23.869Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/time/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.869Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/config.js", - "mtime": "2023-09-29T12:47:53.895Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/debug.js", - "mtime": "2023-09-29T12:47:53.895Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/method-tools.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/utils.js", - "mtime": "2023-09-29T12:47:53.897Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governApi.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/governance/src/contractGovernance/governFilter.js", - "mtime": "2023-09-29T12:47:53.874Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/assert/src/assert.js", - "mtime": "2023-09-29T12:47:53.836Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/exo-utils.js", - "mtime": "2023-09-29T12:48:23.872Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/vat-data/src/vat-data-bindings.js", - "mtime": "2023-09-29T12:48:23.873Z" - }, - { - "relativePath": "../../node_modules/@endo/eventual-send/src/E.js", - "mtime": "2023-11-07T14:22:46.391Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/makeHandle.js", - "mtime": "2023-09-29T12:47:53.972Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyMap.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/legacy/legacyWeakMap.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarMapStore.js", - "mtime": "2023-09-29T12:48:23.855Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarSetStore.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakMapStore.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/scalarWeakSetStore.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/stores/store-utils.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/index.js", - "mtime": "2023-09-29T07:31:07.143Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/index.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/index.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zoe/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.897Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/nat/src/index.js", - "mtime": "2023-09-29T07:30:52.810Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/deeplyFulfilled.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodePassable.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToCapData.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-justin.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal-stringify.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/marshal.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/rankOrder.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/types.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/index.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/E.js", - "mtime": "2023-09-29T07:30:46.568Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/far/src/index.js", - "mtime": "2023-09-29T07:30:45.835Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/index.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/stream/index.js", - "mtime": "2023-09-29T07:30:53.746Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/main.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/assert/src/types.js", - "mtime": "2023-09-29T12:47:53.836Z" - }, - { - "relativePath": "../../node_modules/@endo/eventual-send/src/track-turns.js", - "mtime": "2023-11-07T14:22:46.391Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/src/types.js", - "mtime": "2023-09-29T12:48:23.856Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-makers.js", - "mtime": "2023-09-29T07:31:07.143Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/index.js", - "mtime": "2023-09-29T12:47:53.776Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/asyncIterableAdaptor.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/notifier.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/publish-kit.js", - "mtime": "2023-09-29T12:48:23.846Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/stored-notifier.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/storesub.js", - "mtime": "2023-09-29T12:48:23.846Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscribe.js", - "mtime": "2023-09-29T12:48:23.846Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/subscriber.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/checkKey.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/compareKeys.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copyBag.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/copySet.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-bag-operators.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/keys/merge-set-operators.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/patterns/patternMatchers.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/types.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/patterns/src/utils.js", - "mtime": "2023-09-29T07:30:53.579Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/marshal/src/encodeToSmallcaps.js", - "mtime": "2023-09-29T07:30:46.169Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/iter-helpers.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/error.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/make-far.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/makeTagged.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyle-helpers.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/passStyleOf.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/remotable.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/symbol.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/typeGuards.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/types.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/eventual-send/src/track-turns.js", - "mtime": "2023-09-29T07:30:46.568Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/is-promise.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/memo-race.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/promise-executor-kit.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/promise-kit/src/types.js", - "mtime": "2023-09-29T07:30:49.638Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/main.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/main.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/exo/src/exo-tools.js", - "mtime": "2023-09-29T07:31:07.143Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/types-ambient.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/amountMath.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/issuerKit.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/typeGuards.js", - "mtime": "2023-09-29T12:48:23.781Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/lib-chainStorage.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/notifier/src/topic.js", - "mtime": "2023-09-29T12:47:53.900Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/upgrade-api.js", - "mtime": "2023-09-29T12:47:53.897Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyArray.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/copyRecord.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/safe-promise.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/@endo/pass-style/src/tagged.js", - "mtime": "2023-09-29T07:30:52.015Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/E.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/async-generate.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring0/makers.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/node_modules/jessie.js/src/ring1/async-tools.js", - "mtime": "2023-09-29T11:16:36.561Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copyBagMathHelpers.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/copySetMathHelpers.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/natMathHelpers.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/mathHelpers/setMathHelpers.js", - "mtime": "2023-09-29T12:47:53.776Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/displayInfo.js", - "mtime": "2023-09-29T12:47:53.775Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/paymentLedger.js", - "mtime": "2023-09-29T12:48:23.781Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/types-ambient.js", - "mtime": "2023-09-29T12:48:23.781Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/internal/src/callback.js", - "mtime": "2023-09-29T12:48:23.844Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zone/src/index.js", - "mtime": "2023-09-29T12:48:23.911Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/payment.js", - "mtime": "2023-09-29T12:48:23.780Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/purse.js", - "mtime": "2023-09-29T12:47:53.776Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/store/exported.js", - "mtime": "2023-09-29T12:47:53.911Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/zone/src/heap.js", - "mtime": "2023-09-29T12:48:23.911Z" - }, - { - "relativePath": "../../../../../agoric-11-wf/packages/ERTP/src/transientNotifier.js", - "mtime": "2023-09-29T12:47:53.776Z" - } - ] -} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-crabbleGovernor.json b/proposals/64:crabble-start/assets/bundle-crabbleGovernor.json deleted file mode 100644 index ede76b87..00000000 --- a/proposals/64:crabble-start/assets/bundle-crabbleGovernor.json +++ /dev/null @@ -1 +0,0 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"cf4a0089e2d715a5c4460760cdb054d72f74b8fd330fece0bfd5e8fd82190c3c16e37eb1c31aab9734df81de9277721ce1d3dc7f5c8c7513349f5355e948978c"} diff --git a/proposals/64:crabble-start/assets/bundle-governor.json b/proposals/64:crabble-start/assets/bundle-governor.json new file mode 100644 index 00000000..314918b1 --- /dev/null +++ b/proposals/64:crabble-start/assets/bundle-governor.json @@ -0,0 +1 @@ +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"bde789b8f6623f2352dc2d4a781f39066bbb63366602ac3c70943760418a9c7e63b8d9cfad6c8601e418ec5dfd29f1b62b2419bd2cd7f5907f59a62aff37e332"} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/core-eval.js b/proposals/64:crabble-start/assets/core-eval.js deleted file mode 100644 index 6f86212c..00000000 --- a/proposals/64:crabble-start/assets/core-eval.js +++ /dev/null @@ -1,232 +0,0 @@ -/* eslint-disable no-undef */ -const startCrabble = async ({ - consume: { - board, - zoe, - chainStorage: chainStorageP, - chainTimerService, - agoricNamesAdmin, - agoricNames: agoricNamesP, - namesByAddressAdmin: namesByAddressAdminP, - contractKits: contractKitsP, - governedContractKits, - diagnostics, - }, -}) => { - const logger = (log) => { - console.log('[CRABBLE_CORE_EVAL]', log); - }; - // vars = [crabble, governor] - const vars = ["9ef6df6021cabaece3a53065bbc4e1f68f0e109498861b814e26077422c89a5c1f7a6717875f7c9b35197cb36ba87dd424d927ef9230c9227bb7fdf4dcd0cdf0", "cf4a0089e2d715a5c4460760cdb054d72f74b8fd330fece0bfd5e8fd82190c3c16e37eb1c31aab9734df81de9277721ce1d3dc7f5c8c7513349f5355e948978c"]; - const members = ["agoric1kupk4yyvnl3h80j753705nfm2nfxff5vktvd3z", "agoric10xh9n8qzjsxg9k5txdmvtj5kfr3092j8mptr7g", "agoric1890064p6j3xhzzdf8daknd6kpvhw766ds8flgw"]; - - logger('Settling privileges...'); - const [ - namesByAddressAdmin, - chainStorage, - agoricNames, - contractKits, - timerBrand, - ] = await Promise.all([ - namesByAddressAdminP, - chainStorageP, - agoricNamesP, - contractKitsP, - E(chainTimerService).getTimerBrand(), - ]); - - logger({ namesByAddressAdmin, chainStorage, agoricNames, contractKits }); - - const crabbleNode = await E(chainStorage).makeChildNode('crabble'); - - logger('Getting nameHubs...'); - const mem1NameHub = E( - E(namesByAddressAdmin).lookupAdmin(members[0]), - ).readonly(); - const mem2NameHub = E( - E(namesByAddressAdmin).lookupAdmin(members[1]), - ).readonly(); - const mem3NameHub = E( - E(namesByAddressAdmin).lookupAdmin(members[2]), - ).readonly(); - - const [mem1DepositFacet, mem2DepositFacet, mem3DepositFacet] = - await Promise.all([ - E(mem1NameHub).lookup('depositFacet'), - E(mem2NameHub).lookup('depositFacet'), - E(mem3NameHub).lookup('depositFacet'), - ]); - - logger('Gathering info...'); - const [ - contractInstallation, - governorInstallation, - binaryVoteCounterInstallation, - committeeInstallation, - marshaller, - committeeNode, - timer, - ] = await Promise.all([ - E(zoe).installBundleID(`b1-${vars[0]}`), - E(zoe).installBundleID(`b1-${vars[1]}`), - E(agoricNames).lookup('installation', 'binaryVoteCounter'), - E(agoricNames).lookup('installation', 'committee'), - E(board).getPublishingMarshaller(), - E(crabbleNode).makeChildNode('committee'), - chainTimerService, - ]).catch((err) => logger(err)); - - logger({ - contractInstallation, - governorInstallation, - binaryVoteCounterInstallation, - committeeInstallation, - marshaller, - crabbleNode, - committeeNode, - }); - - const instanceAdminP = E(agoricNamesAdmin).lookupAdmin('instance'); - - logger('Starting committee...'); - const committeeKit = await E(zoe).startInstance( - committeeInstallation, - {}, - { - committeeSize: 3, - committeeName: 'Crabble Committee', - }, - { - storageNode: committeeNode, - marshaller, - }, - ); - logger({ committeeKit }); - - logger('Getting poser invitation...'); - const initialPoserInvitation = await E( - committeeKit.creatorFacet, - ).getPoserInvitation(); - const initialPoserInvitationAmount = await E( - E(zoe).getInvitationIssuer(), - ).getAmountOf(initialPoserInvitation); - - logger({ initialPoserInvitation, initialPoserInvitationAmount }); - - logger('---Starting Crabble with governor---'); - const crabbleTerms = { - governedParams: { - Electorate: { - type: 'invitation', - value: initialPoserInvitationAmount, - }, - }, - agoricNames, - }; - - const crabblePrivateArgs = { - storageNode: crabbleNode, - marshaller, - timer, - initialPoserInvitation, - }; - - logger({ - crabbleTerms, - crabblePrivateArgs, - }); - - logger('Deeply fulfill governorTerms...'); - const governorTerms = harden({ - timerBrand, - governedContractInstallation: contractInstallation, - governed: { - terms: crabbleTerms, - issuerKeywordRecord: {}, - label: 'Crabble', - }, - binaryVoteCounterInstallation, - }); - - logger({ - governorTerms, - }); - - logger('Starting governor...'); - const governorKit = await E(zoe).startInstance( - governorInstallation, - {}, - governorTerms, - harden({ - governed: crabblePrivateArgs, - }), - 'Crabble', - ); - - logger({ - governorKit, - }); - - logger('Getting crabbleKit...'); - const [instance, publicFacet, creatorFacet, adminFacet] = await Promise.all([ - E(governorKit.creatorFacet).getInstance(), - E(governorKit.creatorFacet).getPublicFacet(), - E(governorKit.creatorFacet).getCreatorFacet(), - E(governorKit.creatorFacet).getAdminFacet(), - ]); - - const kit = harden({ - instance, - publicFacet, - creatorFacet, - adminFacet, - governor: governorKit.instance, - governorCreatorFacet: governorKit.creatorFacet, - governorAdminFacet: governorKit.adminFacet, - label: 'GovernedCrabble', - }); - - logger('Updating agoricNames with instances...'); - await Promise.all([ - E(instanceAdminP).update('Crabble', instance), - E(instanceAdminP).update('CrabbleGovernor', governorKit.instance), - E(instanceAdminP).update('CrabbleCommittee', committeeKit.instance), - ]); - - logger('Updating diagnostics...'); - await E(diagnostics).savePrivateArgs(instance, crabblePrivateArgs); - await E(diagnostics).savePrivateArgs(governorKit.instance, { - economicCommitteeCreatorFacet: committeeKit.creatorFacet, - }); - - logger('Getting the member and voter invitations...'); - const [voterInvitations, mem1Invite, mem2Invite, mem3Invite] = - await Promise.all([ - E(committeeKit.creatorFacet).getVoterInvitations(), - E(governorKit.creatorFacet).makeCommitteeMemberInvitation(), - E(governorKit.creatorFacet).makeCommitteeMemberInvitation(), - E(governorKit.creatorFacet).makeCommitteeMemberInvitation(), - ]); - - logger('Updating contractKits...'); - await Promise.all([ - E(governedContractKits).init(instance, kit), - E(contractKits).init(committeeKit.instance, committeeKit), - ]); - - logger('Sending invitations...'); - await Promise.all([ - E(mem1DepositFacet).receive(voterInvitations[0]), - E(mem1DepositFacet).receive(mem1Invite), - E(mem2DepositFacet).receive(voterInvitations[1]), - E(mem2DepositFacet).receive(mem2Invite), - E(mem3DepositFacet).receive(voterInvitations[2]), - E(mem3DepositFacet).receive(mem3Invite), - ]); - - logger('Done.'); -}; - -harden(startCrabble); - -startCrabble; diff --git a/proposals/64:crabble-start/assets/crabble-permit.json b/proposals/64:crabble-start/assets/crabble-permit.json new file mode 100644 index 00000000..2ac5ccc0 --- /dev/null +++ b/proposals/64:crabble-start/assets/crabble-permit.json @@ -0,0 +1,24 @@ +{ + "consume": { + "board": true, + "chainStorage": true, + "chainTimerService": true, + "agoricNames": true, + "zoe": true, + "namesByAddressAdmin": true, + "startMyGovernedUpgradable": true, + "startUpgradable": true + }, + "installation": { + "consume": { + "committee": true + } + }, + "instance": { + "produce": { + "Crabble": true, + "CrabbleCommittee": true, + "CrabbleGovernor": true + } + } +} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/crabbleCoreEval.js b/proposals/64:crabble-start/assets/crabbleCoreEval.js new file mode 100644 index 00000000..c0ac0d3d --- /dev/null +++ b/proposals/64:crabble-start/assets/crabbleCoreEval.js @@ -0,0 +1,250 @@ +// @ts-check +// XMPORT: { E } from '@endo/far'; + +const fail = (msg) => { + throw Error(msg); +}; + +const { fromEntries, keys, values } = Object; + +/** @type {(xs: X[], ys: Y[]) => [X, Y][]} */ +const zip = (xs, ys) => harden(xs.map((x, i) => [x, ys[+i]])); + +/** + * @type {>>( + * obj: T, + * ) => Promise<{ [K in keyof T]: Awaited }>} + */ +const allValues = async (obj) => { + const resolved = await Promise.all(values(obj)); + // @ts-expect-error cast + return harden(fromEntries(zip(keys(obj), resolved))); +}; + +const logger = (...args) => { + console.log('[CRABBLE_CORE_EVAL]', ...args); +}; + +/** + * @template T + * @typedef {{ + * resolve: (v: ERef) => void; + * reject: (r: unknown) => void; + * reset: (reason?: unknown) => void; + * }} ProducerX + */ + +/** + * @param {{ + * consume: { + * agoricNames: ERef; + * board: ERef; + * startUpgradable: Promise; + * namesByAddressAdmin: ERef; + * }; + * instance: { produce: Record<'CrabbleCommittee', ProducerX> } + * }} powers + * @param {*} config + * @param {ERef} crabbleNode + */ +const startCommittee = async ( + { + consume: { + board, + // namesByAddress should suffice, but... + // https://github.com/Agoric/agoric-sdk/issues/8113 + namesByAddressAdmin, + startUpgradable, + }, + installation: { consume: { committee: committeeInstallationP } }, + instance: { produce: produceInstance }, + }, + config, + crabbleNode, +) => { + const committeeSize = 3; + const committeeName = "CrabbleCommittee"; + const members = ["agoric1ag5a8lhn00h4u9h2shpfpjpaq6v4kku54zk69m","agoric140y0mqnq7ng5vvxxwpfe67988e5vqar9whg309","agoric1wqfu6hu5q2qtey9jtjapaae4df9zd492z4448k"]; + + logger('Getting nameHubs, depositFacets...'); + const getDepositFacet = async (address) => { + const hub = E(E(namesByAddressAdmin).lookupAdmin(address)).readonly(); + return E(hub).lookup('depositFacet'); + }; + const memberDeposits = await Promise.all(members.map(getDepositFacet)); + + logger('Gathering info...'); + const { committeeInstallation, marshaller, committeeNode } = await allValues({ + committeeInstallation: committeeInstallationP, + marshaller: E(board).getPublishingMarshaller(), + committeeNode: E(crabbleNode).makeChildNode('committee'), + }); + + logger('Starting committee...'); + const committeeKit = await E(startUpgradable)({ + installation: committeeInstallation, + terms: { committeeSize, committeeName }, + privateArgs: { storageNode: committeeNode, marshaller }, + label: committeeName, + }); + logger({ committeeKit }); + + logger('Updating agoricNames with committee instance...'); + produceInstance.CrabbleCommittee.resolve(committeeKit.instance); + + logger('Getting the member and voter invitations...'); + const voterInvitations = await E( + committeeKit.creatorFacet, + ).getVoterInvitations(); + + logger('Sending committeeinvitations...'); + await Promise.all( + zip(memberDeposits, voterInvitations).map(([depositFacet, invitation]) => + E(depositFacet).receive(invitation), + ), + ); + + logger('Done.'); + return { committeeCreatorFacet: committeeKit.creatorFacet, memberDeposits }; +}; + +/** + * + * @param {{ + * consume: { + * zoe: Promise; + * board: ERef, + * startMyGovernedUpgradable: Promise, + * chainTimerService: ERef; + * agoricNames: ERef; + * }, + * instance: { produce: Record<'Crabble' | 'CrabbleGovernor', ProducerX>} + * }} powers + * @param {*} config + * @param {ERef} crabbleNode + * @param {Promise<{ + * committeeCreatorFacet: ERef; + * memberDeposits: ERef[] + * }>} committeeInfoP + */ +const startCrabble = async (powers, config, crabbleNode, committeeInfoP) => { + // eslint-disable-next-line + const contractBundleID = "b1-46f82a8b8348f7c2dcae1ddc1ace085f5f489d493f7df24ce8f2334199b21eeb9ed848de5e2814f200ba47470ff3bd83b08d74055da2a454f94c2a0c565bf557"; + // eslint-disable-next-line + const governorBundleID = "b1-bde789b8f6623f2352dc2d4a781f39066bbb63366602ac3c70943760418a9c7e63b8d9cfad6c8601e418ec5dfd29f1b62b2419bd2cd7f5907f59a62aff37e332"; + + const { + consume: { + board, + startMyGovernedUpgradable, + zoe: zoeI, // only used for installation, not for startInstance + chainTimerService, + agoricNames: agoricNamesP, + }, + instance: { produce: produceInstance }, + } = powers; + logger('Gathering info...'); + const { + contractInstallation, + governorInstallation, + binaryVoteCounterInstallation, + committeeInstallation, + marshaller, + timer, + info: { committeeCreatorFacet, memberDeposits }, + agoricNames, + } = await allValues({ + contractInstallation: E(zoeI).installBundleID(contractBundleID), + governorInstallation: E(zoeI).installBundleID(governorBundleID), + binaryVoteCounterInstallation: E(agoricNamesP).lookup( + 'installation', + 'binaryVoteCounter', + ), + committeeInstallation: E(agoricNamesP).lookup('installation', 'committee'), + marshaller: E(board).getPublishingMarshaller(), + timer: chainTimerService, + info: committeeInfoP, + agoricNames: agoricNamesP, + }); + + logger({ + contractInstallation, + binaryVoteCounterInstallation, + committeeInstallation, + marshaller, + crabbleNode, + }); + + logger('---Starting Crabble with governor---'); + const crabbleTerms = { + agoricNames, + }; + + const crabblePrivateArgs = { + storageNode: crabbleNode, + marshaller, + timer, + }; + + logger({ + crabbleTerms, + crabblePrivateArgs, + }); + + logger('Deeply fulfill governorTerms...'); + const governorTerms = harden({ + timer, // ISSUE: TIMER IN TERMS + governedContractInstallation: contractInstallation, + binaryVoteCounterInstallation, + }); + + logger({ + governorTerms, + }); + + logger('Starting governor, governed...'); + const kit = await E(startMyGovernedUpgradable)({ + installation: contractInstallation, + committeeCreatorFacet, + contractGovernor: governorInstallation, + governorTerms, + terms: crabbleTerms, + privateArgs: crabblePrivateArgs, + label: 'Crabble', + }); + + logger({ + kit, + }); + + logger('Updating agoricNames with instances...'); + produceInstance.Crabble.resolve(kit.instance); + produceInstance.CrabbleGovernor.resolve(kit.governor); + + logger('Sending member invitations...'); + await Promise.all( + memberDeposits.map(async (df) => { + const inv = await E( + kit.governorCreatorFacet, + ).makeCommitteeMemberInvitation(); + return E(df).receive(inv); + }), + ); + + logger('Done.'); +}; + +harden(startCrabble); + +const start = async (powers, config) => { + const { + consume: { chainStorage }, + } = powers; + const crabbleNode = await E(chainStorage).makeChildNode('crabble'); + + const committeeInfo = startCommittee(powers, config, crabbleNode); + await startCrabble(powers, config, crabbleNode, committeeInfo); +}; +harden(start); + +start; diff --git a/proposals/64:crabble-start/assets/deployAssets.js b/proposals/64:crabble-start/assets/deployAssets.js deleted file mode 100644 index 2f69fc96..00000000 --- a/proposals/64:crabble-start/assets/deployAssets.js +++ /dev/null @@ -1,87 +0,0 @@ -import bundleMintHolder from '@agoric/vats/bundles/bundle-mintHolder.js'; -import { E } from '@endo/far'; -import { AssetKind } from '@agoric/ertp'; -import fs from 'fs/promises'; - -const deployAssets = async (homeP, { pathResolve }) => { - const { zoe, board, scratch } = E.get(homeP); - - console.log('Installing mintHolder bundle...'); - const mintHolderInstallation = await E(zoe).install(bundleMintHolder); - - const collateralTerms = { - keyword: 'Collateral', - assetKind: AssetKind.NAT, - displayInfo: { decimalPlaces: 6 }, - }; - - const rentalFeeTerms = { - keyword: 'RentalFee', - assetKind: AssetKind.NAT, - displayInfo: { decimalPlaces: 6 }, - }; - - const utilityTerms = { - keyword: 'Utility', - assetKind: AssetKind.SET, - }; - - console.log('Starting instances...'); - const [collateralKit, rentalFeeKit, utilityKit] = await Promise.all([ - E(zoe).startInstance(mintHolderInstallation, undefined, collateralTerms), - E(zoe).startInstance(mintHolderInstallation, undefined, rentalFeeTerms), - E(zoe).startInstance(mintHolderInstallation, undefined, utilityTerms), - ]); - - console.log('Putting the mint objects to scratch...'); - await Promise.all([ - E(scratch).set('collateral-mint', collateralKit.creatorFacet), - E(scratch).set('rentalFee-mint', rentalFeeKit.creatorFacet), - E(scratch).set('utility-mint', utilityKit.creatorFacet), - ]); - - const [collateralBrand, rentalFeeBrand, utilityBrand] = await Promise.all([ - E(collateralKit.publicFacet).getBrand(), - E(rentalFeeKit.publicFacet).getBrand(), - E(utilityKit.publicFacet).getBrand(), - ]); - - console.log('Putting the issuers to board...'); - const [ - collateralIssuerBoardId, - collateralBrandBoardId, - rentalFeeIssuerBoardId, - rentalFeeBrandBoardId, - utilityIssuerBoardId, - utilityBrandBoardId, - ] = await Promise.all([ - E(board).getId(collateralKit.publicFacet), - E(board).getId(collateralBrand), - E(board).getId(rentalFeeKit.publicFacet), - E(board).getId(rentalFeeBrand), - E(board).getId(utilityKit.publicFacet), - E(board).getId(utilityBrand), - ]); - - console.log('Writing to file...'); - const dappConstants = { - COLLATERAL_ISSUER_BOARD_ID: collateralIssuerBoardId, - COLLATERAL_BRAND_BOARD_ID: collateralBrandBoardId, - RENTAL_FEE_ISSUER_BOARD_ID: rentalFeeIssuerBoardId, - RENTAL_FEE_BRAND_BOARD_ID: rentalFeeBrandBoardId, - UTILITY_ISSUER_BOARD_ID: utilityIssuerBoardId, - UTILITY_BRAND_BOARD_ID: utilityBrandBoardId, - }; - const defaultsFolder = pathResolve(`../../../generated`); - const defaultsFile = pathResolve( - `../../../generated/installationConstants.json`, - ); - console.log('writing', defaultsFile); - const defaultsContents = JSON.stringify(dappConstants, undefined, 2); - await fs.mkdir(defaultsFolder, { recursive: true }); - await fs.writeFile(defaultsFile, defaultsContents); - - console.log('Done.'); -}; - -export default deployAssets; diff --git a/proposals/64:crabble-start/assets/gov-permit.json b/proposals/64:crabble-start/assets/gov-permit.json new file mode 100644 index 00000000..c5f9edd9 --- /dev/null +++ b/proposals/64:crabble-start/assets/gov-permit.json @@ -0,0 +1,11 @@ +{ + "consume": { + "chainTimerService": true, + "governedContractKits": true, + "diagnostics": true, + "zoe": true + }, + "produce": { + "startMyGovernedUpgradable": true + } +} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/govStarting.js b/proposals/64:crabble-start/assets/govStarting.js new file mode 100644 index 00000000..dde650cf --- /dev/null +++ b/proposals/64:crabble-start/assets/govStarting.js @@ -0,0 +1,216 @@ +/* eslint-disable no-shadow */ +/** + * @file Add support for starting governed contracts to the Agoric bootstrap / + * CoreEval "promise space". + */ + +// @ts-check +// XMPORT: { E } from '@endo/far'; + +// XMPORT { CONTRACT_ELECTORATE, ParamTypes } from '@agoric/governance'; +const CONTRACT_ELECTORATE = 'Electorate'; +const ParamTypes = /** @type {const} */ ({ + INVITATION: 'invitation', +}); + +const { fromEntries, entries } = Object; + +/** @type { >>(obj: T) => Promise<{ [K in keyof T]: Awaited}> } */ +const allValues = async obj => { + const es = await Promise.all( + entries(obj).map(async ([k, v]) => [k, await v]), + ); + return fromEntries(es); +}; + +const logger = (message) => { + console.log('[PRODUCE_UPGRADABLE_STARTER]', message); +}; + +/** + * @template SF @typedef + * {XMPORT('@agoric/zoe/src/zoeService/utils').StartResult} + * StartResult + */ +/** + * @typedef {StartResult< + * typeof XMPORT('@agoric/governance/src/committee.js').start + * >} CommitteeStart + */ + +/** + * Like startGovernedInstance but with parameterized committeeCreatorFacet + * + * @template {GovernableStartFn} SF + * @param {{ + * zoe: ERef; + * governedContractInstallation: ERef>; + * issuerKeywordRecord?: IssuerKeywordRecord; + * terms: Record; + * privateArgs: any; // TODO: connect with Installation type + * label: string; + * }} zoeArgs + * @param {{ + * governedParams: Record; + * timer: ERef; + * contractGovernor: ERef; + * governorTerms: Record; + * committeeCreatorFacet: CommitteeStart['creatorFacet']; + * }} govArgs + * @returns {Promise>} + */ +const startMyGovernedInstance = async ( + { + zoe, + governedContractInstallation, + issuerKeywordRecord, + terms, + privateArgs, + label, + }, + { + governedParams, + timer, + contractGovernor, + governorTerms, + committeeCreatorFacet, + }, +) => { + const logger = (message) => { + console.log('[START_GOVERNED_INSTANCE]', message); + }; + + logger('Getting poser invitation...'); + const poserInvitationP = E(committeeCreatorFacet).getPoserInvitation(); + const [initialPoserInvitation, electorateInvitationAmount] = + await Promise.all([ + poserInvitationP, + E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP), + ]); + + logger('Fulfilling governor terms...'); + const fullGovernorTerms = await allValues({ + timer, + governedContractInstallation, + governed: { + terms: { + ...terms, + governedParams: { + [CONTRACT_ELECTORATE]: { + type: ParamTypes.INVITATION, + value: electorateInvitationAmount, + }, + ...governedParams, + }, + }, + issuerKeywordRecord, + label, + }, + ...governorTerms, + }); + + logger('Starting governor...'); + const governorFacets = await E(zoe).startInstance( + contractGovernor, + {}, + fullGovernorTerms, + harden({ + economicCommitteeCreatorFacet: committeeCreatorFacet, + governed: await allValues({ + ...privateArgs, + initialPoserInvitation, + }), + }), + `${label}-governor`, + ); + + logger('Getting facets...'); + const [instance, publicFacet, creatorFacet, adminFacet] = await Promise.all([ + E(governorFacets.creatorFacet).getInstance(), + E(governorFacets.creatorFacet).getPublicFacet(), + E(governorFacets.creatorFacet).getCreatorFacet(), + E(governorFacets.creatorFacet).getAdminFacet(), + ]); + /** @type {GovernanceFacetKit} */ + const facets = harden({ + instance, + publicFacet, + governor: governorFacets.instance, + creatorFacet, + adminFacet, + governorCreatorFacet: governorFacets.creatorFacet, + governorAdminFacet: governorFacets.adminFacet, + }); + return facets; +}; + +/** + * @param {BootstrapSpace & { + * produce: { + * startMyGovernedUpgradable: Producer; + * }; + * }} powers + */ +const produceStartMyGovernedUpgradable = async ({ + consume: { chainTimerService, governedContractKits, diagnostics, zoe }, + produce, // startMyGovernedUpgradable +}) => { + logger('Producing governed upgradable...'); + /** + * @template {GovernableStartFn} SF + * @param {StartGovernedUpgradableOpts & { + * committeeCreatorFacet: CommitteeStart['creatorFacet']; + * contractGovernor: ERef; + * governorTerms: Record; + * }} opts + */ + const startGovernedUpgradable = async ({ + installation, + issuerKeywordRecord, + committeeCreatorFacet, + contractGovernor, + governorTerms, + governedParams, + terms, + privateArgs, + label, + }) => { + const contractKits = await governedContractKits; + logger('Init startMyGovernedInstance...'); + const facets = await startMyGovernedInstance( + { + zoe, + governedContractInstallation: installation, + issuerKeywordRecord, + terms, + privateArgs, + label, + }, + { + governedParams, + timer: chainTimerService, + contractGovernor, + committeeCreatorFacet, + governorTerms, + }, + ); + logger('Updating contractKits...'); + const kit = harden({ ...facets, label }); + contractKits.init(facets.instance, kit); + + logger('Updating diagnostics...'); + await E(diagnostics).savePrivateArgs(kit.instance, privateArgs); + await E(diagnostics).savePrivateArgs(kit.governor, { + committeeCreatorFacet: await committeeCreatorFacet, + }); + + return facets; + }; + + produce.startMyGovernedUpgradable.resolve(harden(startGovernedUpgradable)); + logger('Done.'); +}; +harden(produceStartMyGovernedUpgradable); + +// script completion value +produceStartMyGovernedUpgradable; diff --git a/proposals/64:crabble-start/assets/proposal-permit.json b/proposals/64:crabble-start/assets/proposal-permit.json deleted file mode 100644 index c5a208b9..00000000 --- a/proposals/64:crabble-start/assets/proposal-permit.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "consume": { - "board": true, - "chainStorage": true, - "chainTimerService": "timer", - "zoe": true, - "agoricNamesAdmin": true, - "agoricNames": true, - "namesByAddressAdmin": true, - "contractKits": true, - "governedContractKits": true, - "diagnostics": true, - "instancePrivateArgs": true - } -} diff --git a/proposals/64:crabble-start/assets/upgrade-core-eval.js b/proposals/64:crabble-start/assets/upgrade-core-eval.js deleted file mode 100644 index e27fdbab..00000000 --- a/proposals/64:crabble-start/assets/upgrade-core-eval.js +++ /dev/null @@ -1,39 +0,0 @@ -/* eslint-disable no-undef */ -const upgradeCrabble = async ({ - consume: { - agoricNames, - governedContractKits: governedContractKitsP, - instancePrivateArgs: instancePrivateArgsP, - }, -}) => { - const logger = (log) => { - console.log('[UPGRADE_CRABBLE_CORE_EVAL]', log); - }; - - const crabbleV2 = - '041f3c030f3a93166304411a3fbe1b54cb2acc7f7124e4b963cd4a43d7ea2ad1c4a2bcc64491799f30eadee31104bf2b10bac4e3a158afff234a4c0e37707651'; - const [governedContractKits, instancePrivateArgs, crabbleInstance] = - await Promise.all([ - governedContractKitsP, - instancePrivateArgsP, - E(agoricNames).lookup('instance', 'Crabble'), - ]); - - logger('Getting Crabble Info...'); - const [crabbleKit, crabblePrivateArgs] = await Promise.all([ - E(governedContractKits).get(crabbleInstance), - E(instancePrivateArgs).get(crabbleInstance), - ]); - - logger('CRABBLE_INFO'); - logger({ crabbleKit, crabblePrivateArgs }); - - const upgradeResult = await E(crabbleKit.adminFacet).upgradeContract( - `b1-${crabbleV2}`, - crabblePrivateArgs, - ); - logger({ upgradeResult }); -}; - -harden(upgradeCrabble); -upgradeCrabble; diff --git a/proposals/64:crabble-start/core-eval-support.js b/proposals/64:crabble-start/core-eval-support.js new file mode 100644 index 00000000..d27d76e5 --- /dev/null +++ b/proposals/64:crabble-start/core-eval-support.js @@ -0,0 +1,151 @@ +// @ts-check +import { + Far, + makeMarshal, + makeTranslationTable, +} from '../../upgrade-test-scripts/lib/unmarshal.js'; +import { Fail, NonNullish } from '../../upgrade-test-scripts/lib/assert.js'; + +// TODO: factor out ambient authority from these +// or at least allow caller to supply authority. +import { mintIST } from '../../upgrade-test-scripts/lib/econHelpers.js'; +import { agoric } from '../../upgrade-test-scripts/lib/cliHelper.js'; + +// move to unmarshal.js? +const makeBoardUnmarshal = () => { + const synthesizeRemotable = (_slot, iface) => + Far(iface.replace(/^Alleged: /, ''), {}); + + const { convertValToSlot, convertSlotToVal } = makeTranslationTable( + slot => Fail`unknown id: ${slot}`, + synthesizeRemotable, + ); + + return makeMarshal(convertValToSlot, convertSlotToVal); +}; + +export const getContractInfo = async (path, io = {}) => { + const m = makeBoardUnmarshal(); + const { + agoric: { follow = agoric.follow }, + prefix = 'published.', + } = io; + console.log('@@TODO: prevent agoric follow hang', prefix, path); + const txt = await follow('-lF', `:${prefix}${path}`, '-o', 'text'); + const { body, slots } = JSON.parse(txt); + return m.fromCapData({ body, slots }); +}; + +/** + * Asserts that `haystack` includes `needle` (or when `sense` is false, that it + * does not), providing pretty output in the case of failure. + * + * @param {import('ava').ExecutionContext} t + * @param {unknown} needle + * @param {unknown[]} haystack + * @param {string} label + * @param {boolean} [sense] true to assert inclusion; false for exclusion + * @returns {void} + */ +export const testIncludes = (t, needle, haystack, label, sense = true) => { + const matches = haystack.filter(c => Object.is(c, needle)); + t.deepEqual(matches, sense ? [needle] : [], label); +}; + +/** + * @param {Record} record - e.g. { color: 'blue' } + * @returns {string[]} - e.g. ['--color', 'blue'] + */ +export const flags = record => { + return Object.entries(record) + .map(([k, v]) => [`--${k}`, v]) + .flat(); +}; + +export const txAbbr = tx => { + const { txhash, code, height, gas_used } = tx; + return { txhash, code, height, gas_used }; +}; + +export const loadedBundleIds = swingstore => { + const ids = swingstore`SELECT bundleID FROM bundles`.map(r => r.bundleID); + return ids; +}; + +/** + * @param {string} cacheFn - e.g. /home/me.agoric/cache/b1-DEADBEEF.json + */ +export const bundleDetail = cacheFn => { + const fileName = NonNullish(cacheFn.split('/').at(-1)); + const id = fileName.replace(/\.json$/, ''); + const hash = id.replace(/^b1-/, ''); + return { fileName, endoZipBase64Sha512: hash, id }; +}; + +const importBundleCost = (bytes, price = 0.002) => { + return bytes * price; +}; + +/** + * @typedef {{ + * bundles: string[], + * evals: { permit: string; script: string }[], + * }} ProposalInfo + */ + +const myISTBalance = async (agd, addr, denom = 'uist', unit = 1_000_000) => { + const coins = await agd.query(['bank', 'balances', addr]); + const coin = coins.balances.find(a => a.denom === denom); + return Number(coin.amount) / unit; +}; + +/** + * @param {number} myIST + * @param {number} cost + * @param {{ + * unit?: number, padding?: number, minInitialDebt?: number, + * collateralPrice: number, + * }} opts + * @returns + */ +const mintCalc = (myIST, cost, opts) => { + const { + unit = 1_000_000, + padding = 1, + minInitialDebt = 6, + collateralPrice, + } = opts; + const { round, max } = Math; + const wantMinted = max(round(cost - myIST + padding), minInitialDebt); + const giveCollateral = round(wantMinted / collateralPrice) + 1; + const sendValue = round(giveCollateral * unit); + return { wantMinted, giveCollateral, sendValue }; +}; + +/** + * + * @param {ReturnType} agd + * @param {*} config + * @param {number} bytes total bytes + * @param {{ log: (...args: any[]) => void }} io + * @returns + */ +export const ensureISTForInstall = async (agd, config, bytes, { log }) => { + const cost = importBundleCost(bytes); + log({ totalSize: bytes, cost }); + const { installer } = config; + const addr = agd.lookup(installer); + const istBalance = await myISTBalance(agd, addr); + + if (istBalance > cost) { + log('balance sufficient', { istBalance, cost }); + return; + } + const { sendValue, wantMinted, giveCollateral } = mintCalc( + istBalance, + cost, + config, + ); + log({ wantMinted }); + await mintIST(addr, sendValue, wantMinted, giveCollateral); +}; diff --git a/proposals/64:crabble-start/eval.sh b/proposals/64:crabble-start/eval.sh new file mode 100755 index 00000000..fdd0f6ac --- /dev/null +++ b/proposals/64:crabble-start/eval.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +# Exit when any command fails +set -e + +source /usr/src/upgrade-test-scripts/env_setup.sh + +ls -al + +# XXX using Ava serial to script the core-eval +yarn ava test-crabble-start.js + diff --git a/proposals/64:crabble-start/package.json b/proposals/64:crabble-start/package.json new file mode 100644 index 00000000..a7c82063 --- /dev/null +++ b/proposals/64:crabble-start/package.json @@ -0,0 +1,21 @@ +{ + "agoricProposal": { + "type": "/agoric.swingset.CoreEvalProposal" + }, + "type": "module", + "license": "Apache-2.0", + "dependencies": { + "@endo/zip": "^0.2.35", + "ava": "^5.3.1", + "better-sqlite3": "^8.5.1", + "execa": "^7.2.0", + "tmp": "^0.2.1" + }, + "scripts": { + "agops": "yarn --cwd /usr/src/agoric-sdk/ --silent agops" + }, + "ava": { + "timeout": "300s" + }, + "packageManager": "yarn@4.0.2" +} diff --git a/proposals/64:crabble-start/test-crabble-start.js b/proposals/64:crabble-start/test-crabble-start.js index 30273d59..5a2ce77d 100644 --- a/proposals/64:crabble-start/test-crabble-start.js +++ b/proposals/64:crabble-start/test-crabble-start.js @@ -57,10 +57,13 @@ const assetInfo = { /** @type {Record} */ buildAssets: { crabbleCoreEvalInfo: { - evals: [{ permit: 'proposal-permit.json', script: 'core-eval.js' }], + evals: [ + { permit: 'crabble-permit.json', script: 'crabbleCoreEval.js' }, + { permit: 'gov-permit.json', script: 'govStarting.js' }, + ], bundles: [ - 'bundle-crabble.json', - 'bundle-crabbleGovernor.json', + 'bundle-contract.json', + 'bundle-governor.json', ], }, }, @@ -81,19 +84,19 @@ const staticConfig = { initialCoins: `20000000ubld`, // enough to provision a smartWallet accounts: { mem1: { - impersonate: 'agoric1kupk4yyvnl3h80j753705nfm2nfxff5vktvd3z', + impersonate: 'agoric1ag5a8lhn00h4u9h2shpfpjpaq6v4kku54zk69m', address: 'agoric1s32tu4wtkqc5440p0uf0hk508nerfmunr65vtl', mnemonic: 'rival find chest wall myself guess fat hint frozen shed cake theme harbor physical bleak tube large desk cream increase scrap virus top bulb', }, mem2: { - impersonate: 'agoric10xh9n8qzjsxg9k5txdmvtj5kfr3092j8mptr7g', + impersonate: 'agoric140y0mqnq7ng5vvxxwpfe67988e5vqar9whg309', address: 'agoric1xdu48rxgakk5us7m3wud04pf92kzjmhwllzdef', mnemonic: 'orient tag produce jar expect travel consider zero flight pause rebuild rent blanket yellow siege ivory hidden loop unlock dream priority prevent horn load', }, mem3: { - impersonate: 'agoric1890064p6j3xhzzdf8daknd6kpvhw766ds8flgw', + impersonate: 'agoric1wqfu6hu5q2qtey9jtjapaae4df9zd492z4448k', address: 'agoric1hmdue96vs0p6zj42aa26x6zrqlythpxnvgsgpr', mnemonic: 'seven regular giggle castle universe find secret like inquiry round write pumpkin risk exhaust dress grab host message carbon student put kind gold treat', @@ -164,17 +167,17 @@ const makeTestContext = async (io = {}) => { test.before(async t => (t.context = await makeTestContext())); -test('initial', async t => { - const { src } = t.context; - const assetFaucet = src.join('bundle-assetsFaucet.json'); - const stat = assetFaucet.stat(); - const path = assetFaucet.toString(); - console.log({ - stat, - path, - }); - t.pass(); -}); +// test('initial', async t => { +// const { src } = t.context; +// const assetFaucet = src.join('bundle-assetsFaucet.json'); +// const stat = assetFaucet.stat(); +// const path = assetFaucet.toString(); +// console.log({ +// stat, +// path, +// }); +// t.pass(); +// }); test.serial(`pre-flight: not in agoricNames.instance`, async t => { const { config, agoric } = t.context; @@ -361,6 +364,7 @@ test.serial('core eval proposal passes', async t => { ], { from, chainId, yes: true }, ); + console.log('RESULT', { result }) t.log(txAbbr(result)); t.is(result.code, 0); diff --git a/proposals/64:crabble-start/test.sh b/proposals/64:crabble-start/test.sh new file mode 100644 index 00000000..80fc752e --- /dev/null +++ b/proposals/64:crabble-start/test.sh @@ -0,0 +1,7 @@ +#!/bin/bash + +set -e + +# source /usr/src/upgrade-test-scripts/env_setup.sh + +echo "no post-build tests for KREAd" diff --git a/proposals/64:crabble-start/use.sh b/proposals/64:crabble-start/use.sh new file mode 100644 index 00000000..b26ebbf2 --- /dev/null +++ b/proposals/64:crabble-start/use.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +# Exit when any command fails +set -e + +# source /usr/src/upgrade-test-scripts/env_setup.sh + +echo "TODO: mint character..." diff --git a/proposals/64:crabble-start/yarn.lock b/proposals/64:crabble-start/yarn.lock new file mode 100644 index 00000000..1e19d9e7 --- /dev/null +++ b/proposals/64:crabble-start/yarn.lock @@ -0,0 +1,2349 @@ +# This file is generated by running "yarn install" inside your project. +# Manual changes might be lost - proceed with caution! + +__metadata: + version: 8 + cacheKey: 10c0 + +"@endo/zip@npm:^0.2.35": + version: 0.2.35 + resolution: "@endo/zip@npm:0.2.35" + checksum: bb81c085e47a5d67342dcc039b2f471e4679e08de95cea3cdba598e2644125ec0b2002e7a1d3ff9a10977380487a58688d7e2c4d1d5525c16e46fed4b735372d + languageName: node + linkType: hard + +"@isaacs/cliui@npm:^8.0.2": + version: 8.0.2 + resolution: "@isaacs/cliui@npm:8.0.2" + dependencies: + string-width: "npm:^5.1.2" + string-width-cjs: "npm:string-width@^4.2.0" + strip-ansi: "npm:^7.0.1" + strip-ansi-cjs: "npm:strip-ansi@^6.0.1" + wrap-ansi: "npm:^8.1.0" + wrap-ansi-cjs: "npm:wrap-ansi@^7.0.0" + checksum: b1bf42535d49f11dc137f18d5e4e63a28c5569de438a221c369483731e9dac9fb797af554e8bf02b6192d1e5eba6e6402cf93900c3d0ac86391d00d04876789e + languageName: node + linkType: hard + +"@nodelib/fs.scandir@npm:2.1.5": + version: 2.1.5 + resolution: "@nodelib/fs.scandir@npm:2.1.5" + dependencies: + "@nodelib/fs.stat": "npm:2.0.5" + run-parallel: "npm:^1.1.9" + checksum: 732c3b6d1b1e967440e65f284bd06e5821fedf10a1bea9ed2bb75956ea1f30e08c44d3def9d6a230666574edbaf136f8cfd319c14fd1f87c66e6a44449afb2eb + languageName: node + linkType: hard + +"@nodelib/fs.stat@npm:2.0.5, @nodelib/fs.stat@npm:^2.0.2": + version: 2.0.5 + resolution: "@nodelib/fs.stat@npm:2.0.5" + checksum: 88dafe5e3e29a388b07264680dc996c17f4bda48d163a9d4f5c1112979f0ce8ec72aa7116122c350b4e7976bc5566dc3ddb579be1ceaacc727872eb4ed93926d + languageName: node + linkType: hard + +"@nodelib/fs.walk@npm:^1.2.3": + version: 1.2.8 + resolution: "@nodelib/fs.walk@npm:1.2.8" + dependencies: + "@nodelib/fs.scandir": "npm:2.1.5" + fastq: "npm:^1.6.0" + checksum: db9de047c3bb9b51f9335a7bb46f4fcfb6829fb628318c12115fbaf7d369bfce71c15b103d1fc3b464812d936220ee9bc1c8f762d032c9f6be9acc99249095b1 + languageName: node + linkType: hard + +"@npmcli/agent@npm:^2.0.0": + version: 2.2.0 + resolution: "@npmcli/agent@npm:2.2.0" + dependencies: + agent-base: "npm:^7.1.0" + http-proxy-agent: "npm:^7.0.0" + https-proxy-agent: "npm:^7.0.1" + lru-cache: "npm:^10.0.1" + socks-proxy-agent: "npm:^8.0.1" + checksum: 7b89590598476dda88e79c473766b67c682aae6e0ab0213491daa6083dcc0c171f86b3868f5506f22c09aa5ea69ad7dfb78f4bf39a8dca375d89a42f408645b3 + languageName: node + linkType: hard + +"@npmcli/fs@npm:^3.1.0": + version: 3.1.0 + resolution: "@npmcli/fs@npm:3.1.0" + dependencies: + semver: "npm:^7.3.5" + checksum: 162b4a0b8705cd6f5c2470b851d1dc6cd228c86d2170e1769d738c1fbb69a87160901411c3c035331e9e99db72f1f1099a8b734bf1637cc32b9a5be1660e4e1e + languageName: node + linkType: hard + +"@pkgjs/parseargs@npm:^0.11.0": + version: 0.11.0 + resolution: "@pkgjs/parseargs@npm:0.11.0" + checksum: 5bd7576bb1b38a47a7fc7b51ac9f38748e772beebc56200450c4a817d712232b8f1d3ef70532c80840243c657d491cf6a6be1e3a214cff907645819fdc34aadd + languageName: node + linkType: hard + +"abbrev@npm:^2.0.0": + version: 2.0.0 + resolution: "abbrev@npm:2.0.0" + checksum: f742a5a107473946f426c691c08daba61a1d15942616f300b5d32fd735be88fef5cba24201757b6c407fd564555fb48c751cfa33519b2605c8a7aadd22baf372 + languageName: node + linkType: hard + +"acorn-walk@npm:^8.2.0": + version: 8.3.1 + resolution: "acorn-walk@npm:8.3.1" + checksum: a23d2f7c6b6cad617f4c77f14dfeb062a239208d61753e9ba808d916c550add92b39535467d2e6028280761ac4f5a904cc9df21530b84d3f834e3edef74ddde5 + languageName: node + linkType: hard + +"acorn@npm:^8.8.2": + version: 8.11.2 + resolution: "acorn@npm:8.11.2" + bin: + acorn: bin/acorn + checksum: a3ed76c761b75ec54b1ec3068fb7f113a182e95aea7f322f65098c2958d232e3d211cb6dac35ff9c647024b63714bc528a26d54a925d1fef2c25585b4c8e4017 + languageName: node + linkType: hard + +"agent-base@npm:^7.0.2, agent-base@npm:^7.1.0": + version: 7.1.0 + resolution: "agent-base@npm:7.1.0" + dependencies: + debug: "npm:^4.3.4" + checksum: fc974ab57ffdd8421a2bc339644d312a9cca320c20c3393c9d8b1fd91731b9bbabdb985df5fc860f5b79d81c3e350daa3fcb31c5c07c0bb385aafc817df004ce + languageName: node + linkType: hard + +"aggregate-error@npm:^3.0.0": + version: 3.1.0 + resolution: "aggregate-error@npm:3.1.0" + dependencies: + clean-stack: "npm:^2.0.0" + indent-string: "npm:^4.0.0" + checksum: a42f67faa79e3e6687a4923050e7c9807db3848a037076f791d10e092677d65c1d2d863b7848560699f40fc0502c19f40963fb1cd1fb3d338a7423df8e45e039 + languageName: node + linkType: hard + +"aggregate-error@npm:^4.0.0": + version: 4.0.1 + resolution: "aggregate-error@npm:4.0.1" + dependencies: + clean-stack: "npm:^4.0.0" + indent-string: "npm:^5.0.0" + checksum: 75fd739f5c4c60a667cce35ccaf0edf135e147ef0be9a029cab75de14ac9421779b15339d562e58d25b233ea0ef2bbd4c916f149fdbcb73c2b9a62209e611343 + languageName: node + linkType: hard + +"ansi-regex@npm:^5.0.1": + version: 5.0.1 + resolution: "ansi-regex@npm:5.0.1" + checksum: 9a64bb8627b434ba9327b60c027742e5d17ac69277960d041898596271d992d4d52ba7267a63ca10232e29f6107fc8a835f6ce8d719b88c5f8493f8254813737 + languageName: node + linkType: hard + +"ansi-regex@npm:^6.0.1": + version: 6.0.1 + resolution: "ansi-regex@npm:6.0.1" + checksum: cbe16dbd2c6b2735d1df7976a7070dd277326434f0212f43abf6d87674095d247968209babdaad31bb00882fa68807256ba9be340eec2f1004de14ca75f52a08 + languageName: node + linkType: hard + +"ansi-styles@npm:^4.0.0": + version: 4.3.0 + resolution: "ansi-styles@npm:4.3.0" + dependencies: + color-convert: "npm:^2.0.1" + checksum: 895a23929da416f2bd3de7e9cb4eabd340949328ab85ddd6e484a637d8f6820d485f53933446f5291c3b760cbc488beb8e88573dd0f9c7daf83dccc8fe81b041 + languageName: node + linkType: hard + +"ansi-styles@npm:^6.0.0, ansi-styles@npm:^6.1.0, ansi-styles@npm:^6.2.1": + version: 6.2.1 + resolution: "ansi-styles@npm:6.2.1" + checksum: 5d1ec38c123984bcedd996eac680d548f31828bd679a66db2bdf11844634dde55fec3efa9c6bb1d89056a5e79c1ac540c4c784d592ea1d25028a92227d2f2d5c + languageName: node + linkType: hard + +"anymatch@npm:~3.1.2": + version: 3.1.3 + resolution: "anymatch@npm:3.1.3" + dependencies: + normalize-path: "npm:^3.0.0" + picomatch: "npm:^2.0.4" + checksum: 57b06ae984bc32a0d22592c87384cd88fe4511b1dd7581497831c56d41939c8a001b28e7b853e1450f2bf61992dfcaa8ae2d0d161a0a90c4fb631ef07098fbac + languageName: node + linkType: hard + +"argparse@npm:^1.0.7": + version: 1.0.10 + resolution: "argparse@npm:1.0.10" + dependencies: + sprintf-js: "npm:~1.0.2" + checksum: b2972c5c23c63df66bca144dbc65d180efa74f25f8fd9b7d9a0a6c88ae839db32df3d54770dcb6460cf840d232b60695d1a6b1053f599d84e73f7437087712de + languageName: node + linkType: hard + +"array-find-index@npm:^1.0.1": + version: 1.0.2 + resolution: "array-find-index@npm:1.0.2" + checksum: 86b9485c74ddd324feab807e10a6de3f9c1683856267236fac4bb4d4667ada6463e106db3f6c540ae6b720e0442b590ec701d13676df4c6af30ebf4da09b4f57 + languageName: node + linkType: hard + +"arrgv@npm:^1.0.2": + version: 1.0.2 + resolution: "arrgv@npm:1.0.2" + checksum: 7e6e782e6b749923ac7cbc4048ef6fe0844c4a59bfc8932fcd4c44566ba25eed46501f94dd7cf3c7297da88f3f599ca056bfb77d0c2484aebc92f04239f69124 + languageName: node + linkType: hard + +"arrify@npm:^3.0.0": + version: 3.0.0 + resolution: "arrify@npm:3.0.0" + checksum: 2e26601b8486f29780f1f70f7ac05a226755814c2a3ab42e196748f650af1dc310cd575a11dd4b9841c70fd7460b2dd2b8fe6fb7a3375878e2660706efafa58e + languageName: node + linkType: hard + +"ava@npm:^5.3.1": + version: 5.3.1 + resolution: "ava@npm:5.3.1" + dependencies: + acorn: "npm:^8.8.2" + acorn-walk: "npm:^8.2.0" + ansi-styles: "npm:^6.2.1" + arrgv: "npm:^1.0.2" + arrify: "npm:^3.0.0" + callsites: "npm:^4.0.0" + cbor: "npm:^8.1.0" + chalk: "npm:^5.2.0" + chokidar: "npm:^3.5.3" + chunkd: "npm:^2.0.1" + ci-info: "npm:^3.8.0" + ci-parallel-vars: "npm:^1.0.1" + clean-yaml-object: "npm:^0.1.0" + cli-truncate: "npm:^3.1.0" + code-excerpt: "npm:^4.0.0" + common-path-prefix: "npm:^3.0.0" + concordance: "npm:^5.0.4" + currently-unhandled: "npm:^0.4.1" + debug: "npm:^4.3.4" + emittery: "npm:^1.0.1" + figures: "npm:^5.0.0" + globby: "npm:^13.1.4" + ignore-by-default: "npm:^2.1.0" + indent-string: "npm:^5.0.0" + is-error: "npm:^2.2.2" + is-plain-object: "npm:^5.0.0" + is-promise: "npm:^4.0.0" + matcher: "npm:^5.0.0" + mem: "npm:^9.0.2" + ms: "npm:^2.1.3" + p-event: "npm:^5.0.1" + p-map: "npm:^5.5.0" + picomatch: "npm:^2.3.1" + pkg-conf: "npm:^4.0.0" + plur: "npm:^5.1.0" + pretty-ms: "npm:^8.0.0" + resolve-cwd: "npm:^3.0.0" + stack-utils: "npm:^2.0.6" + strip-ansi: "npm:^7.0.1" + supertap: "npm:^3.0.1" + temp-dir: "npm:^3.0.0" + write-file-atomic: "npm:^5.0.1" + yargs: "npm:^17.7.2" + peerDependencies: + "@ava/typescript": "*" + peerDependenciesMeta: + "@ava/typescript": + optional: true + bin: + ava: entrypoints/cli.mjs + checksum: 262cbdb9e8c3ce7177be91b92ba521e9d5aef577dcc8095cc591f86baaa291b91c88925928f5d26832c4d1b381a6ae99f2e8804077c592d0d32322c1212605cc + languageName: node + linkType: hard + +"balanced-match@npm:^1.0.0": + version: 1.0.2 + resolution: "balanced-match@npm:1.0.2" + checksum: 9308baf0a7e4838a82bbfd11e01b1cb0f0cf2893bc1676c27c2a8c0e70cbae1c59120c3268517a8ae7fb6376b4639ef81ca22582611dbee4ed28df945134aaee + languageName: node + linkType: hard + +"base64-js@npm:^1.3.1": + version: 1.5.1 + resolution: "base64-js@npm:1.5.1" + checksum: f23823513b63173a001030fae4f2dabe283b99a9d324ade3ad3d148e218134676f1ee8568c877cd79ec1c53158dcf2d2ba527a97c606618928ba99dd930102bf + languageName: node + linkType: hard + +"better-sqlite3@npm:^8.5.1": + version: 8.7.0 + resolution: "better-sqlite3@npm:8.7.0" + dependencies: + bindings: "npm:^1.5.0" + node-gyp: "npm:latest" + prebuild-install: "npm:^7.1.1" + checksum: 2583401b08531eee74c083c73f3a5902bc142b0e1c16de5b9caa92ee94f544e2cb512c214de2f762a6c83e593f26f70013214344a9ea66ace6d0619efbf04a1e + languageName: node + linkType: hard + +"binary-extensions@npm:^2.0.0": + version: 2.2.0 + resolution: "binary-extensions@npm:2.2.0" + checksum: d73d8b897238a2d3ffa5f59c0241870043aa7471335e89ea5e1ff48edb7c2d0bb471517a3e4c5c3f4c043615caa2717b5f80a5e61e07503d51dc85cb848e665d + languageName: node + linkType: hard + +"bindings@npm:^1.5.0": + version: 1.5.0 + resolution: "bindings@npm:1.5.0" + dependencies: + file-uri-to-path: "npm:1.0.0" + checksum: 3dab2491b4bb24124252a91e656803eac24292473e56554e35bbfe3cc1875332cfa77600c3bac7564049dc95075bf6fcc63a4609920ff2d64d0fe405fcf0d4ba + languageName: node + linkType: hard + +"bl@npm:^4.0.3": + version: 4.1.0 + resolution: "bl@npm:4.1.0" + dependencies: + buffer: "npm:^5.5.0" + inherits: "npm:^2.0.4" + readable-stream: "npm:^3.4.0" + checksum: 02847e1d2cb089c9dc6958add42e3cdeaf07d13f575973963335ac0fdece563a50ac770ac4c8fa06492d2dd276f6cc3b7f08c7cd9c7a7ad0f8d388b2a28def5f + languageName: node + linkType: hard + +"blueimp-md5@npm:^2.10.0": + version: 2.19.0 + resolution: "blueimp-md5@npm:2.19.0" + checksum: 85d04343537dd99a288c62450341dcce7380d3454c81f8e5a971ddd80307d6f9ef51b5b92ad7d48aaaa92fd6d3a1f6b2f4fada068faae646887f7bfabc17a346 + languageName: node + linkType: hard + +"brace-expansion@npm:^1.1.7": + version: 1.1.11 + resolution: "brace-expansion@npm:1.1.11" + dependencies: + balanced-match: "npm:^1.0.0" + concat-map: "npm:0.0.1" + checksum: 695a56cd058096a7cb71fb09d9d6a7070113c7be516699ed361317aca2ec169f618e28b8af352e02ab4233fb54eb0168460a40dc320bab0034b36ab59aaad668 + languageName: node + linkType: hard + +"brace-expansion@npm:^2.0.1": + version: 2.0.1 + resolution: "brace-expansion@npm:2.0.1" + dependencies: + balanced-match: "npm:^1.0.0" + checksum: b358f2fe060e2d7a87aa015979ecea07f3c37d4018f8d6deb5bd4c229ad3a0384fe6029bb76cd8be63c81e516ee52d1a0673edbe2023d53a5191732ae3c3e49f + languageName: node + linkType: hard + +"braces@npm:^3.0.2, braces@npm:~3.0.2": + version: 3.0.2 + resolution: "braces@npm:3.0.2" + dependencies: + fill-range: "npm:^7.0.1" + checksum: 321b4d675791479293264019156ca322163f02dc06e3c4cab33bb15cd43d80b51efef69b0930cfde3acd63d126ebca24cd0544fa6f261e093a0fb41ab9dda381 + languageName: node + linkType: hard + +"buffer@npm:^5.5.0": + version: 5.7.1 + resolution: "buffer@npm:5.7.1" + dependencies: + base64-js: "npm:^1.3.1" + ieee754: "npm:^1.1.13" + checksum: 27cac81cff434ed2876058d72e7c4789d11ff1120ef32c9de48f59eab58179b66710c488987d295ae89a228f835fc66d088652dffeb8e3ba8659f80eb091d55e + languageName: node + linkType: hard + +"cacache@npm:^18.0.0": + version: 18.0.1 + resolution: "cacache@npm:18.0.1" + dependencies: + "@npmcli/fs": "npm:^3.1.0" + fs-minipass: "npm:^3.0.0" + glob: "npm:^10.2.2" + lru-cache: "npm:^10.0.1" + minipass: "npm:^7.0.3" + minipass-collect: "npm:^2.0.1" + minipass-flush: "npm:^1.0.5" + minipass-pipeline: "npm:^1.2.4" + p-map: "npm:^4.0.0" + ssri: "npm:^10.0.0" + tar: "npm:^6.1.11" + unique-filename: "npm:^3.0.0" + checksum: a31666805a80a8b16ad3f85faf66750275a9175a3480896f4f6d31b5d53ef190484fabd71bdb6d2ea5603c717fbef09f4af03d6a65b525c8ef0afaa44c361866 + languageName: node + linkType: hard + +"callsites@npm:^4.0.0": + version: 4.1.0 + resolution: "callsites@npm:4.1.0" + checksum: 91700844127a6dcd4792d231a12dd8e9ec10525eb9962180a8558417d7e3f443e52a4f14746ad2838eaf14f79431ee1539d13bd188da280f720a06a91bd1157a + languageName: node + linkType: hard + +"cbor@npm:^8.1.0": + version: 8.1.0 + resolution: "cbor@npm:8.1.0" + dependencies: + nofilter: "npm:^3.1.0" + checksum: a836e2e7ea0efb1b9c4e5a4be906c57113d730cc42293a34072e0164ed110bb8ac035dc7dca2e3ebb641bd4b37e00fdbbf09c951aa864b3d4888a6ed8c6243f7 + languageName: node + linkType: hard + +"chalk@npm:^5.2.0": + version: 5.3.0 + resolution: "chalk@npm:5.3.0" + checksum: 8297d436b2c0f95801103ff2ef67268d362021b8210daf8ddbe349695333eb3610a71122172ff3b0272f1ef2cf7cc2c41fdaa4715f52e49ffe04c56340feed09 + languageName: node + linkType: hard + +"chokidar@npm:^3.5.3": + version: 3.5.3 + resolution: "chokidar@npm:3.5.3" + dependencies: + anymatch: "npm:~3.1.2" + braces: "npm:~3.0.2" + fsevents: "npm:~2.3.2" + glob-parent: "npm:~5.1.2" + is-binary-path: "npm:~2.1.0" + is-glob: "npm:~4.0.1" + normalize-path: "npm:~3.0.0" + readdirp: "npm:~3.6.0" + dependenciesMeta: + fsevents: + optional: true + checksum: 1076953093e0707c882a92c66c0f56ba6187831aa51bb4de878c1fec59ae611a3bf02898f190efec8e77a086b8df61c2b2a3ea324642a0558bdf8ee6c5dc9ca1 + languageName: node + linkType: hard + +"chownr@npm:^1.1.1": + version: 1.1.4 + resolution: "chownr@npm:1.1.4" + checksum: ed57952a84cc0c802af900cf7136de643d3aba2eecb59d29344bc2f3f9bf703a301b9d84cdc71f82c3ffc9ccde831b0d92f5b45f91727d6c9da62f23aef9d9db + languageName: node + linkType: hard + +"chownr@npm:^2.0.0": + version: 2.0.0 + resolution: "chownr@npm:2.0.0" + checksum: 594754e1303672171cc04e50f6c398ae16128eb134a88f801bf5354fd96f205320f23536a045d9abd8b51024a149696e51231565891d4efdab8846021ecf88e6 + languageName: node + linkType: hard + +"chunkd@npm:^2.0.1": + version: 2.0.1 + resolution: "chunkd@npm:2.0.1" + checksum: 4e0c5aac6048ecedfa4cd0a5f6c4f010c70a7b7645aeca7bfeb47cb0733c3463054f0ced3f2667b2e0e67edd75d68a8e05481b01115ba3f8a952a93026254504 + languageName: node + linkType: hard + +"ci-info@npm:^3.8.0": + version: 3.9.0 + resolution: "ci-info@npm:3.9.0" + checksum: 6f0109e36e111684291d46123d491bc4e7b7a1934c3a20dea28cba89f1d4a03acd892f5f6a81ed3855c38647e285a150e3c9ba062e38943bef57fee6c1554c3a + languageName: node + linkType: hard + +"ci-parallel-vars@npm:^1.0.1": + version: 1.0.1 + resolution: "ci-parallel-vars@npm:1.0.1" + checksum: 80952f699cbbc146092b077b4f3e28d085620eb4e6be37f069b4dbb3db0ee70e8eec3beef4ebe70ff60631e9fc743b9d0869678489f167442cac08b260e5ac08 + languageName: node + linkType: hard + +"clean-stack@npm:^2.0.0": + version: 2.2.0 + resolution: "clean-stack@npm:2.2.0" + checksum: 1f90262d5f6230a17e27d0c190b09d47ebe7efdd76a03b5a1127863f7b3c9aec4c3e6c8bb3a7bbf81d553d56a1fd35728f5a8ef4c63f867ac8d690109742a8c1 + languageName: node + linkType: hard + +"clean-stack@npm:^4.0.0": + version: 4.2.0 + resolution: "clean-stack@npm:4.2.0" + dependencies: + escape-string-regexp: "npm:5.0.0" + checksum: 2bdf981a0fef0a23c14255df693b30eb9ae27eedf212470d8c400a0c0b6fb82fbf1ff8c5216ccd5721e3670b700389c886b1dce5070776dc9fbcc040957758c0 + languageName: node + linkType: hard + +"clean-yaml-object@npm:^0.1.0": + version: 0.1.0 + resolution: "clean-yaml-object@npm:0.1.0" + checksum: a6505310590038afb9f0adc7f17a4c66787719c94d23f8491267ea4d9c405cdd378bd576ae1926169b6d997d4c59a8b86516bf4d16ba228280cf615598c58e05 + languageName: node + linkType: hard + +"cli-truncate@npm:^3.1.0": + version: 3.1.0 + resolution: "cli-truncate@npm:3.1.0" + dependencies: + slice-ansi: "npm:^5.0.0" + string-width: "npm:^5.0.0" + checksum: a19088878409ec0e5dc2659a5166929629d93cfba6d68afc9cde2282fd4c751af5b555bf197047e31c87c574396348d011b7aa806fec29c4139ea4f7f00b324c + languageName: node + linkType: hard + +"cliui@npm:^8.0.1": + version: 8.0.1 + resolution: "cliui@npm:8.0.1" + dependencies: + string-width: "npm:^4.2.0" + strip-ansi: "npm:^6.0.1" + wrap-ansi: "npm:^7.0.0" + checksum: 4bda0f09c340cbb6dfdc1ed508b3ca080f12992c18d68c6be4d9cf51756033d5266e61ec57529e610dacbf4da1c634423b0c1b11037709cc6b09045cbd815df5 + languageName: node + linkType: hard + +"code-excerpt@npm:^4.0.0": + version: 4.0.0 + resolution: "code-excerpt@npm:4.0.0" + dependencies: + convert-to-spaces: "npm:^2.0.1" + checksum: b6c5a06e039cecd2ab6a0e10ee0831de8362107d1f298ca3558b5f9004cb8e0260b02dd6c07f57b9a0e346c76864d2873311ee1989809fdeb05bd5fbbadde773 + languageName: node + linkType: hard + +"color-convert@npm:^2.0.1": + version: 2.0.1 + resolution: "color-convert@npm:2.0.1" + dependencies: + color-name: "npm:~1.1.4" + checksum: 37e1150172f2e311fe1b2df62c6293a342ee7380da7b9cfdba67ea539909afbd74da27033208d01d6d5cfc65ee7868a22e18d7e7648e004425441c0f8a15a7d7 + languageName: node + linkType: hard + +"color-name@npm:~1.1.4": + version: 1.1.4 + resolution: "color-name@npm:1.1.4" + checksum: a1a3f914156960902f46f7f56bc62effc6c94e84b2cae157a526b1c1f74b677a47ec602bf68a61abfa2b42d15b7c5651c6dbe72a43af720bc588dff885b10f95 + languageName: node + linkType: hard + +"common-path-prefix@npm:^3.0.0": + version: 3.0.0 + resolution: "common-path-prefix@npm:3.0.0" + checksum: c4a74294e1b1570f4a8ab435285d185a03976c323caa16359053e749db4fde44e3e6586c29cd051100335e11895767cbbd27ea389108e327d62f38daf4548fdb + languageName: node + linkType: hard + +"concat-map@npm:0.0.1": + version: 0.0.1 + resolution: "concat-map@npm:0.0.1" + checksum: c996b1cfdf95b6c90fee4dae37e332c8b6eb7d106430c17d538034c0ad9a1630cb194d2ab37293b1bdd4d779494beee7786d586a50bd9376fd6f7bcc2bd4c98f + languageName: node + linkType: hard + +"concordance@npm:^5.0.4": + version: 5.0.4 + resolution: "concordance@npm:5.0.4" + dependencies: + date-time: "npm:^3.1.0" + esutils: "npm:^2.0.3" + fast-diff: "npm:^1.2.0" + js-string-escape: "npm:^1.0.1" + lodash: "npm:^4.17.15" + md5-hex: "npm:^3.0.1" + semver: "npm:^7.3.2" + well-known-symbols: "npm:^2.0.0" + checksum: 59b440f330df3a7c9aa148ba588b3e99aed86acab225b4f01ffcea34ace4cf11f817e31153254e8f38ed48508998dad40b9106951a743c334d751f7ab21afb8a + languageName: node + linkType: hard + +"convert-to-spaces@npm:^2.0.1": + version: 2.0.1 + resolution: "convert-to-spaces@npm:2.0.1" + checksum: d90aa0e3b6a27f9d5265a8d32def3c5c855b3e823a9db1f26d772f8146d6b91020a2fdfd905ce8048a73fad3aaf836fef8188c67602c374405e2ae8396c4ac46 + languageName: node + linkType: hard + +"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.3": + version: 7.0.3 + resolution: "cross-spawn@npm:7.0.3" + dependencies: + path-key: "npm:^3.1.0" + shebang-command: "npm:^2.0.0" + which: "npm:^2.0.1" + checksum: 5738c312387081c98d69c98e105b6327b069197f864a60593245d64c8089c8a0a744e16349281210d56835bb9274130d825a78b2ad6853ca13cfbeffc0c31750 + languageName: node + linkType: hard + +"currently-unhandled@npm:^0.4.1": + version: 0.4.1 + resolution: "currently-unhandled@npm:0.4.1" + dependencies: + array-find-index: "npm:^1.0.1" + checksum: 32d197689ec32f035910202c1abb0dc6424dce01d7b51779c685119b380d98535c110ffff67a262fc7e367612a7dfd30d3d3055f9a6634b5a9dd1302de7ef11c + languageName: node + linkType: hard + +"date-time@npm:^3.1.0": + version: 3.1.0 + resolution: "date-time@npm:3.1.0" + dependencies: + time-zone: "npm:^1.0.0" + checksum: aa3e2e930d74b0b9e90f69de7a16d3376e30f21f1f4ce9a2311d8fec32d760e776efea752dafad0ce188187265235229013036202be053fc2d7979813bfb6ded + languageName: node + linkType: hard + +"debug@npm:4, debug@npm:^4.3.4": + version: 4.3.4 + resolution: "debug@npm:4.3.4" + dependencies: + ms: "npm:2.1.2" + peerDependenciesMeta: + supports-color: + optional: true + checksum: cedbec45298dd5c501d01b92b119cd3faebe5438c3917ff11ae1bff86a6c722930ac9c8659792824013168ba6db7c4668225d845c633fbdafbbf902a6389f736 + languageName: node + linkType: hard + +"decompress-response@npm:^6.0.0": + version: 6.0.0 + resolution: "decompress-response@npm:6.0.0" + dependencies: + mimic-response: "npm:^3.1.0" + checksum: bd89d23141b96d80577e70c54fb226b2f40e74a6817652b80a116d7befb8758261ad073a8895648a29cc0a5947021ab66705cb542fa9c143c82022b27c5b175e + languageName: node + linkType: hard + +"deep-extend@npm:^0.6.0": + version: 0.6.0 + resolution: "deep-extend@npm:0.6.0" + checksum: 1c6b0abcdb901e13a44c7d699116d3d4279fdb261983122a3783e7273844d5f2537dc2e1c454a23fcf645917f93fbf8d07101c1d03c015a87faa662755212566 + languageName: node + linkType: hard + +"detect-libc@npm:^2.0.0": + version: 2.0.2 + resolution: "detect-libc@npm:2.0.2" + checksum: a9f4ffcd2701525c589617d98afe5a5d0676c8ea82bcc4ed6f3747241b79f781d36437c59a5e855254c864d36a3e9f8276568b6b531c28d6e53b093a15703f11 + languageName: node + linkType: hard + +"dir-glob@npm:^3.0.1": + version: 3.0.1 + resolution: "dir-glob@npm:3.0.1" + dependencies: + path-type: "npm:^4.0.0" + checksum: dcac00920a4d503e38bb64001acb19df4efc14536ada475725e12f52c16777afdee4db827f55f13a908ee7efc0cb282e2e3dbaeeb98c0993dd93d1802d3bf00c + languageName: node + linkType: hard + +"eastasianwidth@npm:^0.2.0": + version: 0.2.0 + resolution: "eastasianwidth@npm:0.2.0" + checksum: 26f364ebcdb6395f95124fda411f63137a4bfb5d3a06453f7f23dfe52502905bd84e0488172e0f9ec295fdc45f05c23d5d91baf16bd26f0fe9acd777a188dc39 + languageName: node + linkType: hard + +"emittery@npm:^1.0.1": + version: 1.0.1 + resolution: "emittery@npm:1.0.1" + checksum: 2587f2f42bb5e004ba1cde61352d2151f4dd4f29eb79ad36f82e200da2faec9742d7bfca1492a024d60396e001e4b07d9b2b9c43be33547ff751ba8ff87c42ce + languageName: node + linkType: hard + +"emoji-regex@npm:^8.0.0": + version: 8.0.0 + resolution: "emoji-regex@npm:8.0.0" + checksum: b6053ad39951c4cf338f9092d7bfba448cdfd46fe6a2a034700b149ac9ffbc137e361cbd3c442297f86bed2e5f7576c1b54cc0a6bf8ef5106cc62f496af35010 + languageName: node + linkType: hard + +"emoji-regex@npm:^9.2.2": + version: 9.2.2 + resolution: "emoji-regex@npm:9.2.2" + checksum: af014e759a72064cf66e6e694a7fc6b0ed3d8db680427b021a89727689671cefe9d04151b2cad51dbaf85d5ba790d061cd167f1cf32eb7b281f6368b3c181639 + languageName: node + linkType: hard + +"encoding@npm:^0.1.13": + version: 0.1.13 + resolution: "encoding@npm:0.1.13" + dependencies: + iconv-lite: "npm:^0.6.2" + checksum: 36d938712ff00fe1f4bac88b43bcffb5930c1efa57bbcdca9d67e1d9d6c57cfb1200fb01efe0f3109b2ce99b231f90779532814a81370a1bd3274a0f58585039 + languageName: node + linkType: hard + +"end-of-stream@npm:^1.1.0, end-of-stream@npm:^1.4.1": + version: 1.4.4 + resolution: "end-of-stream@npm:1.4.4" + dependencies: + once: "npm:^1.4.0" + checksum: 870b423afb2d54bb8d243c63e07c170409d41e20b47eeef0727547aea5740bd6717aca45597a9f2745525667a6b804c1e7bede41f856818faee5806dd9ff3975 + languageName: node + linkType: hard + +"env-paths@npm:^2.2.0": + version: 2.2.1 + resolution: "env-paths@npm:2.2.1" + checksum: 285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4 + languageName: node + linkType: hard + +"err-code@npm:^2.0.2": + version: 2.0.3 + resolution: "err-code@npm:2.0.3" + checksum: b642f7b4dd4a376e954947550a3065a9ece6733ab8e51ad80db727aaae0817c2e99b02a97a3d6cecc648a97848305e728289cf312d09af395403a90c9d4d8a66 + languageName: node + linkType: hard + +"escalade@npm:^3.1.1": + version: 3.1.1 + resolution: "escalade@npm:3.1.1" + checksum: afd02e6ca91ffa813e1108b5e7756566173d6bc0d1eb951cb44d6b21702ec17c1cf116cfe75d4a2b02e05acb0b808a7a9387d0d1ca5cf9c04ad03a8445c3e46d + languageName: node + linkType: hard + +"escape-string-regexp@npm:5.0.0, escape-string-regexp@npm:^5.0.0": + version: 5.0.0 + resolution: "escape-string-regexp@npm:5.0.0" + checksum: 6366f474c6f37a802800a435232395e04e9885919873e382b157ab7e8f0feb8fed71497f84a6f6a81a49aab41815522f5839112bd38026d203aea0c91622df95 + languageName: node + linkType: hard + +"escape-string-regexp@npm:^2.0.0": + version: 2.0.0 + resolution: "escape-string-regexp@npm:2.0.0" + checksum: 2530479fe8db57eace5e8646c9c2a9c80fa279614986d16dcc6bcaceb63ae77f05a851ba6c43756d816c61d7f4534baf56e3c705e3e0d884818a46808811c507 + languageName: node + linkType: hard + +"esprima@npm:^4.0.0": + version: 4.0.1 + resolution: "esprima@npm:4.0.1" + bin: + esparse: ./bin/esparse.js + esvalidate: ./bin/esvalidate.js + checksum: ad4bab9ead0808cf56501750fd9d3fb276f6b105f987707d059005d57e182d18a7c9ec7f3a01794ebddcca676773e42ca48a32d67a250c9d35e009ca613caba3 + languageName: node + linkType: hard + +"esutils@npm:^2.0.3": + version: 2.0.3 + resolution: "esutils@npm:2.0.3" + checksum: 9a2fe69a41bfdade834ba7c42de4723c97ec776e40656919c62cbd13607c45e127a003f05f724a1ea55e5029a4cf2de444b13009f2af71271e42d93a637137c7 + languageName: node + linkType: hard + +"execa@npm:^7.2.0": + version: 7.2.0 + resolution: "execa@npm:7.2.0" + dependencies: + cross-spawn: "npm:^7.0.3" + get-stream: "npm:^6.0.1" + human-signals: "npm:^4.3.0" + is-stream: "npm:^3.0.0" + merge-stream: "npm:^2.0.0" + npm-run-path: "npm:^5.1.0" + onetime: "npm:^6.0.0" + signal-exit: "npm:^3.0.7" + strip-final-newline: "npm:^3.0.0" + checksum: 098cd6a1bc26d509e5402c43f4971736450b84d058391820c6f237aeec6436963e006fd8423c9722f148c53da86aa50045929c7278b5522197dff802d10f9885 + languageName: node + linkType: hard + +"expand-template@npm:^2.0.3": + version: 2.0.3 + resolution: "expand-template@npm:2.0.3" + checksum: 1c9e7afe9acadf9d373301d27f6a47b34e89b3391b1ef38b7471d381812537ef2457e620ae7f819d2642ce9c43b189b3583813ec395e2938319abe356a9b2f51 + languageName: node + linkType: hard + +"exponential-backoff@npm:^3.1.1": + version: 3.1.1 + resolution: "exponential-backoff@npm:3.1.1" + checksum: 160456d2d647e6019640bd07111634d8c353038d9fa40176afb7cd49b0548bdae83b56d05e907c2cce2300b81cae35d800ef92fefb9d0208e190fa3b7d6bb579 + languageName: node + linkType: hard + +"fast-diff@npm:^1.2.0": + version: 1.3.0 + resolution: "fast-diff@npm:1.3.0" + checksum: 5c19af237edb5d5effda008c891a18a585f74bf12953be57923f17a3a4d0979565fc64dbc73b9e20926b9d895f5b690c618cbb969af0cf022e3222471220ad29 + languageName: node + linkType: hard + +"fast-glob@npm:^3.3.0": + version: 3.3.2 + resolution: "fast-glob@npm:3.3.2" + dependencies: + "@nodelib/fs.stat": "npm:^2.0.2" + "@nodelib/fs.walk": "npm:^1.2.3" + glob-parent: "npm:^5.1.2" + merge2: "npm:^1.3.0" + micromatch: "npm:^4.0.4" + checksum: 42baad7b9cd40b63e42039132bde27ca2cb3a4950d0a0f9abe4639ea1aa9d3e3b40f98b1fe31cbc0cc17b664c9ea7447d911a152fa34ec5b72977b125a6fc845 + languageName: node + linkType: hard + +"fastq@npm:^1.6.0": + version: 1.15.0 + resolution: "fastq@npm:1.15.0" + dependencies: + reusify: "npm:^1.0.4" + checksum: 5ce4f83afa5f88c9379e67906b4d31bc7694a30826d6cc8d0f0473c966929017fda65c2174b0ec89f064ede6ace6c67f8a4fe04cef42119b6a55b0d465554c24 + languageName: node + linkType: hard + +"figures@npm:^5.0.0": + version: 5.0.0 + resolution: "figures@npm:5.0.0" + dependencies: + escape-string-regexp: "npm:^5.0.0" + is-unicode-supported: "npm:^1.2.0" + checksum: ce0f17d4ea8b0fc429c5207c343534a2f5284ecfb22aa08607da7dc84ed9e1cf754f5b97760e8dcb98d3c9d1a1e4d3d578fe3b5b99c426f05d0f06c7ba618e16 + languageName: node + linkType: hard + +"file-uri-to-path@npm:1.0.0": + version: 1.0.0 + resolution: "file-uri-to-path@npm:1.0.0" + checksum: 3b545e3a341d322d368e880e1c204ef55f1d45cdea65f7efc6c6ce9e0c4d22d802d5629320eb779d006fe59624ac17b0e848d83cc5af7cd101f206cb704f5519 + languageName: node + linkType: hard + +"fill-range@npm:^7.0.1": + version: 7.0.1 + resolution: "fill-range@npm:7.0.1" + dependencies: + to-regex-range: "npm:^5.0.1" + checksum: 7cdad7d426ffbaadf45aeb5d15ec675bbd77f7597ad5399e3d2766987ed20bda24d5fac64b3ee79d93276f5865608bb22344a26b9b1ae6c4d00bd94bf611623f + languageName: node + linkType: hard + +"find-up@npm:^6.0.0": + version: 6.3.0 + resolution: "find-up@npm:6.3.0" + dependencies: + locate-path: "npm:^7.1.0" + path-exists: "npm:^5.0.0" + checksum: 07e0314362d316b2b13f7f11ea4692d5191e718ca3f7264110127520f3347996349bf9e16805abae3e196805814bc66ef4bff2b8904dc4a6476085fc9b0eba07 + languageName: node + linkType: hard + +"foreground-child@npm:^3.1.0": + version: 3.1.1 + resolution: "foreground-child@npm:3.1.1" + dependencies: + cross-spawn: "npm:^7.0.0" + signal-exit: "npm:^4.0.1" + checksum: 9700a0285628abaeb37007c9a4d92bd49f67210f09067638774338e146c8e9c825c5c877f072b2f75f41dc6a2d0be8664f79ffc03f6576649f54a84fb9b47de0 + languageName: node + linkType: hard + +"fs-constants@npm:^1.0.0": + version: 1.0.0 + resolution: "fs-constants@npm:1.0.0" + checksum: a0cde99085f0872f4d244e83e03a46aa387b74f5a5af750896c6b05e9077fac00e9932fdf5aef84f2f16634cd473c63037d7a512576da7d5c2b9163d1909f3a8 + languageName: node + linkType: hard + +"fs-minipass@npm:^2.0.0": + version: 2.1.0 + resolution: "fs-minipass@npm:2.1.0" + dependencies: + minipass: "npm:^3.0.0" + checksum: 703d16522b8282d7299337539c3ed6edddd1afe82435e4f5b76e34a79cd74e488a8a0e26a636afc2440e1a23b03878e2122e3a2cfe375a5cf63c37d92b86a004 + languageName: node + linkType: hard + +"fs-minipass@npm:^3.0.0": + version: 3.0.3 + resolution: "fs-minipass@npm:3.0.3" + dependencies: + minipass: "npm:^7.0.3" + checksum: 63e80da2ff9b621e2cb1596abcb9207f1cf82b968b116ccd7b959e3323144cce7fb141462200971c38bbf2ecca51695069db45265705bed09a7cd93ae5b89f94 + languageName: node + linkType: hard + +"fs.realpath@npm:^1.0.0": + version: 1.0.0 + resolution: "fs.realpath@npm:1.0.0" + checksum: 444cf1291d997165dfd4c0d58b69f0e4782bfd9149fd72faa4fe299e68e0e93d6db941660b37dd29153bf7186672ececa3b50b7e7249477b03fdf850f287c948 + languageName: node + linkType: hard + +"fsevents@npm:~2.3.2": + version: 2.3.3 + resolution: "fsevents@npm:2.3.3" + dependencies: + node-gyp: "npm:latest" + checksum: a1f0c44595123ed717febbc478aa952e47adfc28e2092be66b8ab1635147254ca6cfe1df792a8997f22716d4cbafc73309899ff7bfac2ac3ad8cf2e4ecc3ec60 + conditions: os=darwin + languageName: node + linkType: hard + +"fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin": + version: 2.3.3 + resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin::version=2.3.3&hash=df0bf1" + dependencies: + node-gyp: "npm:latest" + conditions: os=darwin + languageName: node + linkType: hard + +"get-caller-file@npm:^2.0.5": + version: 2.0.5 + resolution: "get-caller-file@npm:2.0.5" + checksum: c6c7b60271931fa752aeb92f2b47e355eac1af3a2673f47c9589e8f8a41adc74d45551c1bc57b5e66a80609f10ffb72b6f575e4370d61cc3f7f3aaff01757cde + languageName: node + linkType: hard + +"get-stream@npm:^6.0.1": + version: 6.0.1 + resolution: "get-stream@npm:6.0.1" + checksum: 49825d57d3fd6964228e6200a58169464b8e8970489b3acdc24906c782fb7f01f9f56f8e6653c4a50713771d6658f7cfe051e5eb8c12e334138c9c918b296341 + languageName: node + linkType: hard + +"github-from-package@npm:0.0.0": + version: 0.0.0 + resolution: "github-from-package@npm:0.0.0" + checksum: 737ee3f52d0a27e26332cde85b533c21fcdc0b09fb716c3f8e522cfaa9c600d4a631dec9fcde179ec9d47cca89017b7848ed4d6ae6b6b78f936c06825b1fcc12 + languageName: node + linkType: hard + +"glob-parent@npm:^5.1.2, glob-parent@npm:~5.1.2": + version: 5.1.2 + resolution: "glob-parent@npm:5.1.2" + dependencies: + is-glob: "npm:^4.0.1" + checksum: cab87638e2112bee3f839ef5f6e0765057163d39c66be8ec1602f3823da4692297ad4e972de876ea17c44d652978638d2fd583c6713d0eb6591706825020c9ee + languageName: node + linkType: hard + +"glob@npm:^10.2.2, glob@npm:^10.3.10": + version: 10.3.10 + resolution: "glob@npm:10.3.10" + dependencies: + foreground-child: "npm:^3.1.0" + jackspeak: "npm:^2.3.5" + minimatch: "npm:^9.0.1" + minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0" + path-scurry: "npm:^1.10.1" + bin: + glob: dist/esm/bin.mjs + checksum: 13d8a1feb7eac7945f8c8480e11cd4a44b24d26503d99a8d8ac8d5aefbf3e9802a2b6087318a829fad04cb4e829f25c5f4f1110c68966c498720dd261c7e344d + languageName: node + linkType: hard + +"glob@npm:^7.1.3": + version: 7.2.3 + resolution: "glob@npm:7.2.3" + dependencies: + fs.realpath: "npm:^1.0.0" + inflight: "npm:^1.0.4" + inherits: "npm:2" + minimatch: "npm:^3.1.1" + once: "npm:^1.3.0" + path-is-absolute: "npm:^1.0.0" + checksum: 65676153e2b0c9095100fe7f25a778bf45608eeb32c6048cf307f579649bcc30353277b3b898a3792602c65764e5baa4f643714dfbdfd64ea271d210c7a425fe + languageName: node + linkType: hard + +"globby@npm:^13.1.4": + version: 13.2.2 + resolution: "globby@npm:13.2.2" + dependencies: + dir-glob: "npm:^3.0.1" + fast-glob: "npm:^3.3.0" + ignore: "npm:^5.2.4" + merge2: "npm:^1.4.1" + slash: "npm:^4.0.0" + checksum: a8d7cc7cbe5e1b2d0f81d467bbc5bc2eac35f74eaded3a6c85fc26d7acc8e6de22d396159db8a2fc340b8a342e74cac58de8f4aee74146d3d146921a76062664 + languageName: node + linkType: hard + +"graceful-fs@npm:^4.2.6": + version: 4.2.11 + resolution: "graceful-fs@npm:4.2.11" + checksum: 386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2 + languageName: node + linkType: hard + +"http-cache-semantics@npm:^4.1.1": + version: 4.1.1 + resolution: "http-cache-semantics@npm:4.1.1" + checksum: ce1319b8a382eb3cbb4a37c19f6bfe14e5bb5be3d09079e885e8c513ab2d3cd9214902f8a31c9dc4e37022633ceabfc2d697405deeaf1b8f3552bb4ed996fdfc + languageName: node + linkType: hard + +"http-proxy-agent@npm:^7.0.0": + version: 7.0.0 + resolution: "http-proxy-agent@npm:7.0.0" + dependencies: + agent-base: "npm:^7.1.0" + debug: "npm:^4.3.4" + checksum: a11574ff39436cee3c7bc67f259444097b09474605846ddd8edf0bf4ad8644be8533db1aa463426e376865047d05dc22755e638632819317c0c2f1b2196657c8 + languageName: node + linkType: hard + +"https-proxy-agent@npm:^7.0.1": + version: 7.0.2 + resolution: "https-proxy-agent@npm:7.0.2" + dependencies: + agent-base: "npm:^7.0.2" + debug: "npm:4" + checksum: 7735eb90073db087e7e79312e3d97c8c04baf7ea7ca7b013382b6a45abbaa61b281041a98f4e13c8c80d88f843785bcc84ba189165b4b4087b1e3496ba656d77 + languageName: node + linkType: hard + +"human-signals@npm:^4.3.0": + version: 4.3.1 + resolution: "human-signals@npm:4.3.1" + checksum: 40498b33fe139f5cc4ef5d2f95eb1803d6318ac1b1c63eaf14eeed5484d26332c828de4a5a05676b6c83d7b9e57727c59addb4b1dea19cb8d71e83689e5b336c + languageName: node + linkType: hard + +"iconv-lite@npm:^0.6.2": + version: 0.6.3 + resolution: "iconv-lite@npm:0.6.3" + dependencies: + safer-buffer: "npm:>= 2.1.2 < 3.0.0" + checksum: 98102bc66b33fcf5ac044099d1257ba0b7ad5e3ccd3221f34dd508ab4070edff183276221684e1e0555b145fce0850c9f7d2b60a9fcac50fbb4ea0d6e845a3b1 + languageName: node + linkType: hard + +"ieee754@npm:^1.1.13": + version: 1.2.1 + resolution: "ieee754@npm:1.2.1" + checksum: b0782ef5e0935b9f12883a2e2aa37baa75da6e66ce6515c168697b42160807d9330de9a32ec1ed73149aea02e0d822e572bca6f1e22bdcbd2149e13b050b17bb + languageName: node + linkType: hard + +"ignore-by-default@npm:^2.1.0": + version: 2.1.0 + resolution: "ignore-by-default@npm:2.1.0" + checksum: 3a6040dac25ed9da39dee73bf1634fdd1e15b0eb7cf52a6bdec81c310565782d8811c104ce40acb3d690d61c5fc38a91c78e6baee830a8a2232424dbc6b66981 + languageName: node + linkType: hard + +"ignore@npm:^5.2.4": + version: 5.3.0 + resolution: "ignore@npm:5.3.0" + checksum: dc06bea5c23aae65d0725a957a0638b57e235ae4568dda51ca142053ed2c352de7e3bc93a69b2b32ac31966a1952e9a93c5ef2e2ab7c6b06aef9808f6b55b571 + languageName: node + linkType: hard + +"imurmurhash@npm:^0.1.4": + version: 0.1.4 + resolution: "imurmurhash@npm:0.1.4" + checksum: 8b51313850dd33605c6c9d3fd9638b714f4c4c40250cff658209f30d40da60f78992fb2df5dabee4acf589a6a82bbc79ad5486550754bd9ec4e3fc0d4a57d6a6 + languageName: node + linkType: hard + +"indent-string@npm:^4.0.0": + version: 4.0.0 + resolution: "indent-string@npm:4.0.0" + checksum: 1e1904ddb0cb3d6cce7cd09e27a90184908b7a5d5c21b92e232c93579d314f0b83c246ffb035493d0504b1e9147ba2c9b21df0030f48673fba0496ecd698161f + languageName: node + linkType: hard + +"indent-string@npm:^5.0.0": + version: 5.0.0 + resolution: "indent-string@npm:5.0.0" + checksum: 8ee77b57d92e71745e133f6f444d6fa3ed503ad0e1bcd7e80c8da08b42375c07117128d670589725ed07b1978065803fa86318c309ba45415b7fe13e7f170220 + languageName: node + linkType: hard + +"inflight@npm:^1.0.4": + version: 1.0.6 + resolution: "inflight@npm:1.0.6" + dependencies: + once: "npm:^1.3.0" + wrappy: "npm:1" + checksum: 7faca22584600a9dc5b9fca2cd5feb7135ac8c935449837b315676b4c90aa4f391ec4f42240178244b5a34e8bede1948627fda392ca3191522fc46b34e985ab2 + languageName: node + linkType: hard + +"inherits@npm:2, inherits@npm:^2.0.3, inherits@npm:^2.0.4": + version: 2.0.4 + resolution: "inherits@npm:2.0.4" + checksum: 4e531f648b29039fb7426fb94075e6545faa1eb9fe83c29f0b6d9e7263aceb4289d2d4557db0d428188eeb449cc7c5e77b0a0b2c4e248ff2a65933a0dee49ef2 + languageName: node + linkType: hard + +"ini@npm:~1.3.0": + version: 1.3.8 + resolution: "ini@npm:1.3.8" + checksum: ec93838d2328b619532e4f1ff05df7909760b6f66d9c9e2ded11e5c1897d6f2f9980c54dd638f88654b00919ce31e827040631eab0a3969e4d1abefa0719516a + languageName: node + linkType: hard + +"ip@npm:^2.0.0": + version: 2.0.0 + resolution: "ip@npm:2.0.0" + checksum: 8d186cc5585f57372847ae29b6eba258c68862055e18a75cc4933327232cb5c107f89800ce29715d542eef2c254fbb68b382e780a7414f9ee7caf60b7a473958 + languageName: node + linkType: hard + +"irregular-plurals@npm:^3.3.0": + version: 3.5.0 + resolution: "irregular-plurals@npm:3.5.0" + checksum: 7c033bbe7325e5a6e0a26949cc6863b6ce273403d4cd5b93bd99b33fecb6605b0884097c4259c23ed0c52c2133bf7d1cdcdd7a0630e8c325161fe269b3447918 + languageName: node + linkType: hard + +"is-binary-path@npm:~2.1.0": + version: 2.1.0 + resolution: "is-binary-path@npm:2.1.0" + dependencies: + binary-extensions: "npm:^2.0.0" + checksum: a16eaee59ae2b315ba36fad5c5dcaf8e49c3e27318f8ab8fa3cdb8772bf559c8d1ba750a589c2ccb096113bb64497084361a25960899cb6172a6925ab6123d38 + languageName: node + linkType: hard + +"is-error@npm:^2.2.2": + version: 2.2.2 + resolution: "is-error@npm:2.2.2" + checksum: 475d3463968bf16e94485555d7cb7a879ed68685e08d365a3370972e626054f1846ebbb3934403091e06682445568601fe919e41646096e5007952d0c1f4fd9b + languageName: node + linkType: hard + +"is-extglob@npm:^2.1.1": + version: 2.1.1 + resolution: "is-extglob@npm:2.1.1" + checksum: 5487da35691fbc339700bbb2730430b07777a3c21b9ebaecb3072512dfd7b4ba78ac2381a87e8d78d20ea08affb3f1971b4af629173a6bf435ff8a4c47747912 + languageName: node + linkType: hard + +"is-fullwidth-code-point@npm:^3.0.0": + version: 3.0.0 + resolution: "is-fullwidth-code-point@npm:3.0.0" + checksum: bb11d825e049f38e04c06373a8d72782eee0205bda9d908cc550ccb3c59b99d750ff9537982e01733c1c94a58e35400661f57042158ff5e8f3e90cf936daf0fc + languageName: node + linkType: hard + +"is-fullwidth-code-point@npm:^4.0.0": + version: 4.0.0 + resolution: "is-fullwidth-code-point@npm:4.0.0" + checksum: df2a717e813567db0f659c306d61f2f804d480752526886954a2a3e2246c7745fd07a52b5fecf2b68caf0a6c79dcdace6166fdf29cc76ed9975cc334f0a018b8 + languageName: node + linkType: hard + +"is-glob@npm:^4.0.1, is-glob@npm:~4.0.1": + version: 4.0.3 + resolution: "is-glob@npm:4.0.3" + dependencies: + is-extglob: "npm:^2.1.1" + checksum: 17fb4014e22be3bbecea9b2e3a76e9e34ff645466be702f1693e8f1ee1adac84710d0be0bd9f967d6354036fd51ab7c2741d954d6e91dae6bb69714de92c197a + languageName: node + linkType: hard + +"is-lambda@npm:^1.0.1": + version: 1.0.1 + resolution: "is-lambda@npm:1.0.1" + checksum: 85fee098ae62ba6f1e24cf22678805473c7afd0fb3978a3aa260e354cb7bcb3a5806cf0a98403188465efedec41ab4348e8e4e79305d409601323855b3839d4d + languageName: node + linkType: hard + +"is-number@npm:^7.0.0": + version: 7.0.0 + resolution: "is-number@npm:7.0.0" + checksum: b4686d0d3053146095ccd45346461bc8e53b80aeb7671cc52a4de02dbbf7dc0d1d2a986e2fe4ae206984b4d34ef37e8b795ebc4f4295c978373e6575e295d811 + languageName: node + linkType: hard + +"is-plain-object@npm:^5.0.0": + version: 5.0.0 + resolution: "is-plain-object@npm:5.0.0" + checksum: 893e42bad832aae3511c71fd61c0bf61aa3a6d853061c62a307261842727d0d25f761ce9379f7ba7226d6179db2a3157efa918e7fe26360f3bf0842d9f28942c + languageName: node + linkType: hard + +"is-promise@npm:^4.0.0": + version: 4.0.0 + resolution: "is-promise@npm:4.0.0" + checksum: ebd5c672d73db781ab33ccb155fb9969d6028e37414d609b115cc534654c91ccd061821d5b987eefaa97cf4c62f0b909bb2f04db88306de26e91bfe8ddc01503 + languageName: node + linkType: hard + +"is-stream@npm:^3.0.0": + version: 3.0.0 + resolution: "is-stream@npm:3.0.0" + checksum: eb2f7127af02ee9aa2a0237b730e47ac2de0d4e76a4a905a50a11557f2339df5765eaea4ceb8029f1efa978586abe776908720bfcb1900c20c6ec5145f6f29d8 + languageName: node + linkType: hard + +"is-unicode-supported@npm:^1.2.0": + version: 1.3.0 + resolution: "is-unicode-supported@npm:1.3.0" + checksum: b8674ea95d869f6faabddc6a484767207058b91aea0250803cbf1221345cb0c56f466d4ecea375dc77f6633d248d33c47bd296fb8f4cdba0b4edba8917e83d8a + languageName: node + linkType: hard + +"isexe@npm:^2.0.0": + version: 2.0.0 + resolution: "isexe@npm:2.0.0" + checksum: 228cfa503fadc2c31596ab06ed6aa82c9976eec2bfd83397e7eaf06d0ccf42cd1dfd6743bf9aeb01aebd4156d009994c5f76ea898d2832c1fe342da923ca457d + languageName: node + linkType: hard + +"isexe@npm:^3.1.1": + version: 3.1.1 + resolution: "isexe@npm:3.1.1" + checksum: 9ec257654093443eb0a528a9c8cbba9c0ca7616ccb40abd6dde7202734d96bb86e4ac0d764f0f8cd965856aacbff2f4ce23e730dc19dfb41e3b0d865ca6fdcc7 + languageName: node + linkType: hard + +"jackspeak@npm:^2.3.5": + version: 2.3.6 + resolution: "jackspeak@npm:2.3.6" + dependencies: + "@isaacs/cliui": "npm:^8.0.2" + "@pkgjs/parseargs": "npm:^0.11.0" + dependenciesMeta: + "@pkgjs/parseargs": + optional: true + checksum: f01d8f972d894cd7638bc338e9ef5ddb86f7b208ce177a36d718eac96ec86638a6efa17d0221b10073e64b45edc2ce15340db9380b1f5d5c5d000cbc517dc111 + languageName: node + linkType: hard + +"js-string-escape@npm:^1.0.1": + version: 1.0.1 + resolution: "js-string-escape@npm:1.0.1" + checksum: 2c33b9ff1ba6b84681c51ca0997e7d5a1639813c95d5b61cb7ad47e55cc28fa4a0b1935c3d218710d8e6bcee5d0cd8c44755231e3a4e45fc604534d9595a3628 + languageName: node + linkType: hard + +"js-yaml@npm:^3.14.1": + version: 3.14.1 + resolution: "js-yaml@npm:3.14.1" + dependencies: + argparse: "npm:^1.0.7" + esprima: "npm:^4.0.0" + bin: + js-yaml: bin/js-yaml.js + checksum: 6746baaaeac312c4db8e75fa22331d9a04cccb7792d126ed8ce6a0bbcfef0cedaddd0c5098fade53db067c09fe00aa1c957674b4765610a8b06a5a189e46433b + languageName: node + linkType: hard + +"load-json-file@npm:^7.0.0": + version: 7.0.1 + resolution: "load-json-file@npm:7.0.1" + checksum: 7117459608a0b6329c7f78e6e1f541b3162dd901c29dd5af721fec8b270177d2e3d7999c971f344fff04daac368d052732e2c7146014bc84d15e0b636975e19a + languageName: node + linkType: hard + +"locate-path@npm:^7.1.0": + version: 7.2.0 + resolution: "locate-path@npm:7.2.0" + dependencies: + p-locate: "npm:^6.0.0" + checksum: 139e8a7fe11cfbd7f20db03923cacfa5db9e14fa14887ea121345597472b4a63c1a42a8a5187defeeff6acf98fd568da7382aa39682d38f0af27433953a97751 + languageName: node + linkType: hard + +"lodash@npm:^4.17.15": + version: 4.17.21 + resolution: "lodash@npm:4.17.21" + checksum: d8cbea072bb08655bb4c989da418994b073a608dffa608b09ac04b43a791b12aeae7cd7ad919aa4c925f33b48490b5cfe6c1f71d827956071dae2e7bb3a6b74c + languageName: node + linkType: hard + +"lru-cache@npm:^10.0.1, lru-cache@npm:^9.1.1 || ^10.0.0": + version: 10.1.0 + resolution: "lru-cache@npm:10.1.0" + checksum: 778bc8b2626daccd75f24c4b4d10632496e21ba064b126f526c626fbdbc5b28c472013fccd45d7646b9e1ef052444824854aed617b59cd570d01a8b7d651fc1e + languageName: node + linkType: hard + +"lru-cache@npm:^6.0.0": + version: 6.0.0 + resolution: "lru-cache@npm:6.0.0" + dependencies: + yallist: "npm:^4.0.0" + checksum: cb53e582785c48187d7a188d3379c181b5ca2a9c78d2bce3e7dee36f32761d1c42983da3fe12b55cb74e1779fa94cdc2e5367c028a9b35317184ede0c07a30a9 + languageName: node + linkType: hard + +"make-fetch-happen@npm:^13.0.0": + version: 13.0.0 + resolution: "make-fetch-happen@npm:13.0.0" + dependencies: + "@npmcli/agent": "npm:^2.0.0" + cacache: "npm:^18.0.0" + http-cache-semantics: "npm:^4.1.1" + is-lambda: "npm:^1.0.1" + minipass: "npm:^7.0.2" + minipass-fetch: "npm:^3.0.0" + minipass-flush: "npm:^1.0.5" + minipass-pipeline: "npm:^1.2.4" + negotiator: "npm:^0.6.3" + promise-retry: "npm:^2.0.1" + ssri: "npm:^10.0.0" + checksum: 43b9f6dcbc6fe8b8604cb6396957c3698857a15ba4dbc38284f7f0e61f248300585ef1eb8cc62df54e9c724af977e45b5cdfd88320ef7f53e45070ed3488da55 + languageName: node + linkType: hard + +"map-age-cleaner@npm:^0.1.3": + version: 0.1.3 + resolution: "map-age-cleaner@npm:0.1.3" + dependencies: + p-defer: "npm:^1.0.0" + checksum: 7495236c7b0950956c144fd8b4bc6399d4e78072a8840a4232fe1c4faccbb5eb5d842e5c0a56a60afc36d723f315c1c672325ca03c1b328650f7fcc478f385fd + languageName: node + linkType: hard + +"matcher@npm:^5.0.0": + version: 5.0.0 + resolution: "matcher@npm:5.0.0" + dependencies: + escape-string-regexp: "npm:^5.0.0" + checksum: eda5471fc9d5b7264d63c81727824adc3585ddb5cfdc5fce5a9b7c86f946ff181610735d330b1c37a84811df872d1290bf4e9401d2be2a414204343701144b18 + languageName: node + linkType: hard + +"md5-hex@npm:^3.0.1": + version: 3.0.1 + resolution: "md5-hex@npm:3.0.1" + dependencies: + blueimp-md5: "npm:^2.10.0" + checksum: ee2b4d8da16b527b3a3fe4d7a96720f43afd07b46a82d49421208b5a126235fb75cfb30b80d4029514772c8844273f940bddfbf4155c787f968f3be4060d01e4 + languageName: node + linkType: hard + +"mem@npm:^9.0.2": + version: 9.0.2 + resolution: "mem@npm:9.0.2" + dependencies: + map-age-cleaner: "npm:^0.1.3" + mimic-fn: "npm:^4.0.0" + checksum: c2c56141399e520d8f0e50186bb7e4b49300b33984dc919682f3f13e53dec0e6608fbd327d5ae99494f45061a3a05a8ee04ccba6dcf795c3c215b5aa906eb41f + languageName: node + linkType: hard + +"merge-stream@npm:^2.0.0": + version: 2.0.0 + resolution: "merge-stream@npm:2.0.0" + checksum: 867fdbb30a6d58b011449b8885601ec1690c3e41c759ecd5a9d609094f7aed0096c37823ff4a7190ef0b8f22cc86beb7049196ff68c016e3b3c671d0dac91ce5 + languageName: node + linkType: hard + +"merge2@npm:^1.3.0, merge2@npm:^1.4.1": + version: 1.4.1 + resolution: "merge2@npm:1.4.1" + checksum: 254a8a4605b58f450308fc474c82ac9a094848081bf4c06778200207820e5193726dc563a0d2c16468810516a5c97d9d3ea0ca6585d23c58ccfff2403e8dbbeb + languageName: node + linkType: hard + +"micromatch@npm:^4.0.4": + version: 4.0.5 + resolution: "micromatch@npm:4.0.5" + dependencies: + braces: "npm:^3.0.2" + picomatch: "npm:^2.3.1" + checksum: 3d6505b20f9fa804af5d8c596cb1c5e475b9b0cd05f652c5b56141cf941bd72adaeb7a436fda344235cef93a7f29b7472efc779fcdb83b478eab0867b95cdeff + languageName: node + linkType: hard + +"mimic-fn@npm:^4.0.0": + version: 4.0.0 + resolution: "mimic-fn@npm:4.0.0" + checksum: de9cc32be9996fd941e512248338e43407f63f6d497abe8441fa33447d922e927de54d4cc3c1a3c6d652857acd770389d5a3823f311a744132760ce2be15ccbf + languageName: node + linkType: hard + +"mimic-response@npm:^3.1.0": + version: 3.1.0 + resolution: "mimic-response@npm:3.1.0" + checksum: 0d6f07ce6e03e9e4445bee655202153bdb8a98d67ee8dc965ac140900d7a2688343e6b4c9a72cfc9ef2f7944dfd76eef4ab2482eb7b293a68b84916bac735362 + languageName: node + linkType: hard + +"minimatch@npm:^3.1.1": + version: 3.1.2 + resolution: "minimatch@npm:3.1.2" + dependencies: + brace-expansion: "npm:^1.1.7" + checksum: 0262810a8fc2e72cca45d6fd86bd349eee435eb95ac6aa45c9ea2180e7ee875ef44c32b55b5973ceabe95ea12682f6e3725cbb63d7a2d1da3ae1163c8b210311 + languageName: node + linkType: hard + +"minimatch@npm:^9.0.1": + version: 9.0.3 + resolution: "minimatch@npm:9.0.3" + dependencies: + brace-expansion: "npm:^2.0.1" + checksum: 85f407dcd38ac3e180f425e86553911d101455ca3ad5544d6a7cec16286657e4f8a9aa6695803025c55e31e35a91a2252b5dc8e7d527211278b8b65b4dbd5eac + languageName: node + linkType: hard + +"minimist@npm:^1.2.0, minimist@npm:^1.2.3": + version: 1.2.8 + resolution: "minimist@npm:1.2.8" + checksum: 19d3fcdca050087b84c2029841a093691a91259a47def2f18222f41e7645a0b7c44ef4b40e88a1e58a40c84d2ef0ee6047c55594d298146d0eb3f6b737c20ce6 + languageName: node + linkType: hard + +"minipass-collect@npm:^2.0.1": + version: 2.0.1 + resolution: "minipass-collect@npm:2.0.1" + dependencies: + minipass: "npm:^7.0.3" + checksum: 5167e73f62bb74cc5019594709c77e6a742051a647fe9499abf03c71dca75515b7959d67a764bdc4f8b361cf897fbf25e2d9869ee039203ed45240f48b9aa06e + languageName: node + linkType: hard + +"minipass-fetch@npm:^3.0.0": + version: 3.0.4 + resolution: "minipass-fetch@npm:3.0.4" + dependencies: + encoding: "npm:^0.1.13" + minipass: "npm:^7.0.3" + minipass-sized: "npm:^1.0.3" + minizlib: "npm:^2.1.2" + dependenciesMeta: + encoding: + optional: true + checksum: 1b63c1f3313e88eeac4689f1b71c9f086598db9a189400e3ee960c32ed89e06737fa23976c9305c2d57464fb3fcdc12749d3378805c9d6176f5569b0d0ee8a75 + languageName: node + linkType: hard + +"minipass-flush@npm:^1.0.5": + version: 1.0.5 + resolution: "minipass-flush@npm:1.0.5" + dependencies: + minipass: "npm:^3.0.0" + checksum: 2a51b63feb799d2bb34669205eee7c0eaf9dce01883261a5b77410c9408aa447e478efd191b4de6fc1101e796ff5892f8443ef20d9544385819093dbb32d36bd + languageName: node + linkType: hard + +"minipass-pipeline@npm:^1.2.4": + version: 1.2.4 + resolution: "minipass-pipeline@npm:1.2.4" + dependencies: + minipass: "npm:^3.0.0" + checksum: cbda57cea20b140b797505dc2cac71581a70b3247b84480c1fed5ca5ba46c25ecc25f68bfc9e6dcb1a6e9017dab5c7ada5eab73ad4f0a49d84e35093e0c643f2 + languageName: node + linkType: hard + +"minipass-sized@npm:^1.0.3": + version: 1.0.3 + resolution: "minipass-sized@npm:1.0.3" + dependencies: + minipass: "npm:^3.0.0" + checksum: 298f124753efdc745cfe0f2bdfdd81ba25b9f4e753ca4a2066eb17c821f25d48acea607dfc997633ee5bf7b6dfffb4eee4f2051eb168663f0b99fad2fa4829cb + languageName: node + linkType: hard + +"minipass@npm:^3.0.0": + version: 3.3.6 + resolution: "minipass@npm:3.3.6" + dependencies: + yallist: "npm:^4.0.0" + checksum: a114746943afa1dbbca8249e706d1d38b85ed1298b530f5808ce51f8e9e941962e2a5ad2e00eae7dd21d8a4aae6586a66d4216d1a259385e9d0358f0c1eba16c + languageName: node + linkType: hard + +"minipass@npm:^5.0.0": + version: 5.0.0 + resolution: "minipass@npm:5.0.0" + checksum: a91d8043f691796a8ac88df039da19933ef0f633e3d7f0d35dcd5373af49131cf2399bfc355f41515dc495e3990369c3858cd319e5c2722b4753c90bf3152462 + languageName: node + linkType: hard + +"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3": + version: 7.0.4 + resolution: "minipass@npm:7.0.4" + checksum: 6c7370a6dfd257bf18222da581ba89a5eaedca10e158781232a8b5542a90547540b4b9b7e7f490e4cda43acfbd12e086f0453728ecf8c19e0ef6921bc5958ac5 + languageName: node + linkType: hard + +"minizlib@npm:^2.1.1, minizlib@npm:^2.1.2": + version: 2.1.2 + resolution: "minizlib@npm:2.1.2" + dependencies: + minipass: "npm:^3.0.0" + yallist: "npm:^4.0.0" + checksum: 64fae024e1a7d0346a1102bb670085b17b7f95bf6cfdf5b128772ec8faf9ea211464ea4add406a3a6384a7d87a0cd1a96263692134323477b4fb43659a6cab78 + languageName: node + linkType: hard + +"mkdirp-classic@npm:^0.5.2, mkdirp-classic@npm:^0.5.3": + version: 0.5.3 + resolution: "mkdirp-classic@npm:0.5.3" + checksum: 95371d831d196960ddc3833cc6907e6b8f67ac5501a6582f47dfae5eb0f092e9f8ce88e0d83afcae95d6e2b61a01741ba03714eeafb6f7a6e9dcc158ac85b168 + languageName: node + linkType: hard + +"mkdirp@npm:^1.0.3": + version: 1.0.4 + resolution: "mkdirp@npm:1.0.4" + bin: + mkdirp: bin/cmd.js + checksum: 46ea0f3ffa8bc6a5bc0c7081ffc3907777f0ed6516888d40a518c5111f8366d97d2678911ad1a6882bf592fa9de6c784fea32e1687bb94e1f4944170af48a5cf + languageName: node + linkType: hard + +"ms@npm:2.1.2": + version: 2.1.2 + resolution: "ms@npm:2.1.2" + checksum: a437714e2f90dbf881b5191d35a6db792efbca5badf112f87b9e1c712aace4b4b9b742dd6537f3edf90fd6f684de897cec230abde57e87883766712ddda297cc + languageName: node + linkType: hard + +"ms@npm:^2.1.3": + version: 2.1.3 + resolution: "ms@npm:2.1.3" + checksum: d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48 + languageName: node + linkType: hard + +"napi-build-utils@npm:^1.0.1": + version: 1.0.2 + resolution: "napi-build-utils@npm:1.0.2" + checksum: 37fd2cd0ff2ad20073ce78d83fd718a740d568b225924e753ae51cb69d68f330c80544d487e5e5bd18e28702ed2ca469c2424ad948becd1862c1b0209542b2e9 + languageName: node + linkType: hard + +"negotiator@npm:^0.6.3": + version: 0.6.3 + resolution: "negotiator@npm:0.6.3" + checksum: 3ec9fd413e7bf071c937ae60d572bc67155262068ed522cf4b3be5edbe6ddf67d095ec03a3a14ebf8fc8e95f8e1d61be4869db0dbb0de696f6b837358bd43fc2 + languageName: node + linkType: hard + +"node-abi@npm:^3.3.0": + version: 3.52.0 + resolution: "node-abi@npm:3.52.0" + dependencies: + semver: "npm:^7.3.5" + checksum: 29fbc10dce6def79e164478a219ff8bc65ef219d536c6f906db255eb26b54ac667cf220f6c47910e4cbcea5125a123c5c624c10a9aedb4cdc8f8acef9c10c2cb + languageName: node + linkType: hard + +"node-gyp@npm:latest": + version: 10.0.1 + resolution: "node-gyp@npm:10.0.1" + dependencies: + env-paths: "npm:^2.2.0" + exponential-backoff: "npm:^3.1.1" + glob: "npm:^10.3.10" + graceful-fs: "npm:^4.2.6" + make-fetch-happen: "npm:^13.0.0" + nopt: "npm:^7.0.0" + proc-log: "npm:^3.0.0" + semver: "npm:^7.3.5" + tar: "npm:^6.1.2" + which: "npm:^4.0.0" + bin: + node-gyp: bin/node-gyp.js + checksum: abddfff7d873312e4ed4a5fb75ce893a5c4fb69e7fcb1dfa71c28a6b92a7f1ef6b62790dffb39181b5a82728ba8f2f32d229cf8cbe66769fe02cea7db4a555aa + languageName: node + linkType: hard + +"nofilter@npm:^3.1.0": + version: 3.1.0 + resolution: "nofilter@npm:3.1.0" + checksum: 92459f3864a067b347032263f0b536223cbfc98153913b5dce350cb39c8470bc1813366e41993f22c33cc6400c0f392aa324a4b51e24c22040635c1cdb046499 + languageName: node + linkType: hard + +"nopt@npm:^7.0.0": + version: 7.2.0 + resolution: "nopt@npm:7.2.0" + dependencies: + abbrev: "npm:^2.0.0" + bin: + nopt: bin/nopt.js + checksum: 9bd7198df6f16eb29ff16892c77bcf7f0cc41f9fb5c26280ac0def2cf8cf319f3b821b3af83eba0e74c85807cc430a16efe0db58fe6ae1f41e69519f585b6aff + languageName: node + linkType: hard + +"normalize-path@npm:^3.0.0, normalize-path@npm:~3.0.0": + version: 3.0.0 + resolution: "normalize-path@npm:3.0.0" + checksum: e008c8142bcc335b5e38cf0d63cfd39d6cf2d97480af9abdbe9a439221fd4d749763bab492a8ee708ce7a194bb00c9da6d0a115018672310850489137b3da046 + languageName: node + linkType: hard + +"npm-run-path@npm:^5.1.0": + version: 5.1.0 + resolution: "npm-run-path@npm:5.1.0" + dependencies: + path-key: "npm:^4.0.0" + checksum: ff6d77514489f47fa1c3b1311d09cd4b6d09a874cc1866260f9dea12cbaabda0436ed7f8c2ee44d147bf99a3af29307c6f63b0f83d242b0b6b0ab25dff2629e3 + 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" + dependencies: + wrappy: "npm:1" + checksum: 5d48aca287dfefabd756621c5dfce5c91a549a93e9fdb7b8246bc4c4790aa2ec17b34a260530474635147aeb631a2dcc8b32c613df0675f96041cbb8244517d0 + languageName: node + linkType: hard + +"onetime@npm:^6.0.0": + version: 6.0.0 + resolution: "onetime@npm:6.0.0" + dependencies: + mimic-fn: "npm:^4.0.0" + checksum: 4eef7c6abfef697dd4479345a4100c382d73c149d2d56170a54a07418c50816937ad09500e1ed1e79d235989d073a9bade8557122aee24f0576ecde0f392bb6c + languageName: node + linkType: hard + +"p-defer@npm:^1.0.0": + version: 1.0.0 + resolution: "p-defer@npm:1.0.0" + checksum: ed603c3790e74b061ac2cb07eb6e65802cf58dce0fbee646c113a7b71edb711101329ad38f99e462bd2e343a74f6e9366b496a35f1d766c187084d3109900487 + languageName: node + linkType: hard + +"p-event@npm:^5.0.1": + version: 5.0.1 + resolution: "p-event@npm:5.0.1" + dependencies: + p-timeout: "npm:^5.0.2" + checksum: 2317171489537f316661fa863f3bb711b2ceb89182937238422cec10223cbb958c432d6c26a238446a622d788187bdd295b1d8ecedbe2e467e045930d60202b0 + languageName: node + linkType: hard + +"p-limit@npm:^4.0.0": + version: 4.0.0 + resolution: "p-limit@npm:4.0.0" + dependencies: + yocto-queue: "npm:^1.0.0" + checksum: a56af34a77f8df2ff61ddfb29431044557fcbcb7642d5a3233143ebba805fc7306ac1d448de724352861cb99de934bc9ab74f0d16fe6a5460bdbdf938de875ad + languageName: node + linkType: hard + +"p-locate@npm:^6.0.0": + version: 6.0.0 + resolution: "p-locate@npm:6.0.0" + dependencies: + p-limit: "npm:^4.0.0" + checksum: d72fa2f41adce59c198270aa4d3c832536c87a1806e0f69dffb7c1a7ca998fb053915ca833d90f166a8c082d3859eabfed95f01698a3214c20df6bb8de046312 + languageName: node + linkType: hard + +"p-map@npm:^4.0.0": + version: 4.0.0 + resolution: "p-map@npm:4.0.0" + dependencies: + aggregate-error: "npm:^3.0.0" + checksum: 592c05bd6262c466ce269ff172bb8de7c6975afca9b50c975135b974e9bdaafbfe80e61aaaf5be6d1200ba08b30ead04b88cfa7e25ff1e3b93ab28c9f62a2c75 + languageName: node + linkType: hard + +"p-map@npm:^5.5.0": + version: 5.5.0 + resolution: "p-map@npm:5.5.0" + dependencies: + aggregate-error: "npm:^4.0.0" + checksum: 410bce846b1e3db6bb2ccab6248372ecf4e635fc2b31331c8f56478e73fec9e146e8b4547585e635703160a3d252a6a65b8f855834aebc2c3408eb5789630cc4 + languageName: node + linkType: hard + +"p-timeout@npm:^5.0.2": + version: 5.1.0 + resolution: "p-timeout@npm:5.1.0" + checksum: 1b026cf9d5878c64bec4341ca9cda8ec6b8b3aea8a57885ca0fe2b35753a20d767fb6f9d3aa41e1252f42bc95432c05ea33b6b18f271fb10bfb0789591850a41 + languageName: node + linkType: hard + +"parse-ms@npm:^3.0.0": + version: 3.0.0 + resolution: "parse-ms@npm:3.0.0" + checksum: 056b4a32a9d3749f3f4cfffefb45c45540491deaa8e1d8ad43c2ddde7ba04edd076bd1b298f521238bb5fb084a9b2c4a2ebb78aefa651afbc4c2b0af4232fc54 + languageName: node + linkType: hard + +"path-exists@npm:^5.0.0": + version: 5.0.0 + resolution: "path-exists@npm:5.0.0" + checksum: b170f3060b31604cde93eefdb7392b89d832dfbc1bed717c9718cbe0f230c1669b7e75f87e19901da2250b84d092989a0f9e44d2ef41deb09aa3ad28e691a40a + languageName: node + linkType: hard + +"path-is-absolute@npm:^1.0.0": + version: 1.0.1 + resolution: "path-is-absolute@npm:1.0.1" + checksum: 127da03c82172a2a50099cddbf02510c1791fc2cc5f7713ddb613a56838db1e8168b121a920079d052e0936c23005562059756d653b7c544c53185efe53be078 + languageName: node + linkType: hard + +"path-key@npm:^3.1.0": + version: 3.1.1 + resolution: "path-key@npm:3.1.1" + checksum: 748c43efd5a569c039d7a00a03b58eecd1d75f3999f5a28303d75f521288df4823bc057d8784eb72358b2895a05f29a070bc9f1f17d28226cc4e62494cc58c4c + languageName: node + linkType: hard + +"path-key@npm:^4.0.0": + version: 4.0.0 + resolution: "path-key@npm:4.0.0" + checksum: 794efeef32863a65ac312f3c0b0a99f921f3e827ff63afa5cb09a377e202c262b671f7b3832a4e64731003fa94af0263713962d317b9887bd1e0c48a342efba3 + languageName: node + linkType: hard + +"path-scurry@npm:^1.10.1": + version: 1.10.1 + resolution: "path-scurry@npm:1.10.1" + dependencies: + lru-cache: "npm:^9.1.1 || ^10.0.0" + minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0" + checksum: e5dc78a7348d25eec61ab166317e9e9c7b46818aa2c2b9006c507a6ff48c672d011292d9662527213e558f5652ce0afcc788663a061d8b59ab495681840c0c1e + languageName: node + linkType: hard + +"path-type@npm:^4.0.0": + version: 4.0.0 + resolution: "path-type@npm:4.0.0" + checksum: 666f6973f332f27581371efaf303fd6c272cc43c2057b37aa99e3643158c7e4b2626549555d88626e99ea9e046f82f32e41bbde5f1508547e9a11b149b52387c + languageName: node + linkType: hard + +"picomatch@npm:^2.0.4, picomatch@npm:^2.2.1, picomatch@npm:^2.3.1": + version: 2.3.1 + resolution: "picomatch@npm:2.3.1" + checksum: 26c02b8d06f03206fc2ab8d16f19960f2ff9e81a658f831ecb656d8f17d9edc799e8364b1f4a7873e89d9702dff96204be0fa26fe4181f6843f040f819dac4be + languageName: node + linkType: hard + +"pkg-conf@npm:^4.0.0": + version: 4.0.0 + resolution: "pkg-conf@npm:4.0.0" + dependencies: + find-up: "npm:^6.0.0" + load-json-file: "npm:^7.0.0" + checksum: 27d027609f27228edcde121f6f707b4ba1f5488e95e98f2e58652ae4e99792081bd1de67d591f4a0f05b02c0b66d745591d49f82041cbc8d41e2238ef5d73eb4 + languageName: node + linkType: hard + +"plur@npm:^5.1.0": + version: 5.1.0 + resolution: "plur@npm:5.1.0" + dependencies: + irregular-plurals: "npm:^3.3.0" + checksum: 26bb622b8545fcfd47bbf56fbcca66c08693708a232e403fa3589e00003c56c14231ac57c7588ca5db83ef4be1f61383402c4ea954000768f779f8aef6eb6da8 + languageName: node + linkType: hard + +"prebuild-install@npm:^7.1.1": + version: 7.1.1 + resolution: "prebuild-install@npm:7.1.1" + dependencies: + detect-libc: "npm:^2.0.0" + expand-template: "npm:^2.0.3" + github-from-package: "npm:0.0.0" + minimist: "npm:^1.2.3" + mkdirp-classic: "npm:^0.5.3" + napi-build-utils: "npm:^1.0.1" + node-abi: "npm:^3.3.0" + pump: "npm:^3.0.0" + rc: "npm:^1.2.7" + simple-get: "npm:^4.0.0" + tar-fs: "npm:^2.0.0" + tunnel-agent: "npm:^0.6.0" + bin: + prebuild-install: bin.js + checksum: 6dc70f36b0f4adcb2fe0ed38d874ab28b571fb1a9725d769e8ba3f64a15831e58462de09f3e6e64569bcc4a3e03b9328b56faa0d45fe10ae1574478814536c76 + languageName: node + linkType: hard + +"pretty-ms@npm:^8.0.0": + version: 8.0.0 + resolution: "pretty-ms@npm:8.0.0" + dependencies: + parse-ms: "npm:^3.0.0" + checksum: e960d633ecca45445cf5c6dffc0f5e4bef6744c92449ab0e8c6c704800675ab71e181c5e02ece5265e02137a33e313d3f3e355fbf8ea30b4b5b23de423329f8d + languageName: node + linkType: hard + +"proc-log@npm:^3.0.0": + version: 3.0.0 + resolution: "proc-log@npm:3.0.0" + checksum: f66430e4ff947dbb996058f6fd22de2c66612ae1a89b097744e17fb18a4e8e7a86db99eda52ccf15e53f00b63f4ec0b0911581ff2aac0355b625c8eac509b0dc + languageName: node + linkType: hard + +"promise-retry@npm:^2.0.1": + version: 2.0.1 + resolution: "promise-retry@npm:2.0.1" + dependencies: + err-code: "npm:^2.0.2" + retry: "npm:^0.12.0" + checksum: 9c7045a1a2928094b5b9b15336dcd2a7b1c052f674550df63cc3f36cd44028e5080448175b6f6ca32b642de81150f5e7b1a98b728f15cb069f2dd60ac2616b96 + languageName: node + linkType: hard + +"pump@npm:^3.0.0": + version: 3.0.0 + resolution: "pump@npm:3.0.0" + dependencies: + end-of-stream: "npm:^1.1.0" + once: "npm:^1.3.1" + checksum: bbdeda4f747cdf47db97428f3a135728669e56a0ae5f354a9ac5b74556556f5446a46f720a8f14ca2ece5be9b4d5d23c346db02b555f46739934cc6c093a5478 + languageName: node + linkType: hard + +"queue-microtask@npm:^1.2.2": + version: 1.2.3 + resolution: "queue-microtask@npm:1.2.3" + checksum: 900a93d3cdae3acd7d16f642c29a642aea32c2026446151f0778c62ac089d4b8e6c986811076e1ae180a694cedf077d453a11b58ff0a865629a4f82ab558e102 + languageName: node + linkType: hard + +"rc@npm:^1.2.7": + version: 1.2.8 + resolution: "rc@npm:1.2.8" + dependencies: + deep-extend: "npm:^0.6.0" + ini: "npm:~1.3.0" + minimist: "npm:^1.2.0" + strip-json-comments: "npm:~2.0.1" + bin: + rc: ./cli.js + checksum: 24a07653150f0d9ac7168e52943cc3cb4b7a22c0e43c7dff3219977c2fdca5a2760a304a029c20811a0e79d351f57d46c9bde216193a0f73978496afc2b85b15 + languageName: node + linkType: hard + +"readable-stream@npm:^3.1.1, readable-stream@npm:^3.4.0": + version: 3.6.2 + resolution: "readable-stream@npm:3.6.2" + dependencies: + inherits: "npm:^2.0.3" + string_decoder: "npm:^1.1.1" + util-deprecate: "npm:^1.0.1" + checksum: e37be5c79c376fdd088a45fa31ea2e423e5d48854be7a22a58869b4e84d25047b193f6acb54f1012331e1bcd667ffb569c01b99d36b0bd59658fb33f513511b7 + languageName: node + linkType: hard + +"readdirp@npm:~3.6.0": + version: 3.6.0 + resolution: "readdirp@npm:3.6.0" + dependencies: + picomatch: "npm:^2.2.1" + checksum: 6fa848cf63d1b82ab4e985f4cf72bd55b7dcfd8e0a376905804e48c3634b7e749170940ba77b32804d5fe93b3cc521aa95a8d7e7d725f830da6d93f3669ce66b + languageName: node + linkType: hard + +"require-directory@npm:^2.1.1": + version: 2.1.1 + resolution: "require-directory@npm:2.1.1" + checksum: 83aa76a7bc1531f68d92c75a2ca2f54f1b01463cb566cf3fbc787d0de8be30c9dbc211d1d46be3497dac5785fe296f2dd11d531945ac29730643357978966e99 + languageName: node + linkType: hard + +"resolve-cwd@npm:^3.0.0": + version: 3.0.0 + resolution: "resolve-cwd@npm:3.0.0" + dependencies: + resolve-from: "npm:^5.0.0" + checksum: e608a3ebd15356264653c32d7ecbc8fd702f94c6703ea4ac2fb81d9c359180cba0ae2e6b71faa446631ed6145454d5a56b227efc33a2d40638ac13f8beb20ee4 + languageName: node + linkType: hard + +"resolve-from@npm:^5.0.0": + version: 5.0.0 + resolution: "resolve-from@npm:5.0.0" + checksum: b21cb7f1fb746de8107b9febab60095187781137fd803e6a59a76d421444b1531b641bba5857f5dc011974d8a5c635d61cec49e6bd3b7fc20e01f0fafc4efbf2 + languageName: node + linkType: hard + +"retry@npm:^0.12.0": + version: 0.12.0 + resolution: "retry@npm:0.12.0" + checksum: 59933e8501727ba13ad73ef4a04d5280b3717fd650408460c987392efe9d7be2040778ed8ebe933c5cbd63da3dcc37919c141ef8af0a54a6e4fca5a2af177bfe + languageName: node + linkType: hard + +"reusify@npm:^1.0.4": + version: 1.0.4 + resolution: "reusify@npm:1.0.4" + checksum: c19ef26e4e188f408922c46f7ff480d38e8dfc55d448310dfb518736b23ed2c4f547fb64a6ed5bdba92cd7e7ddc889d36ff78f794816d5e71498d645ef476107 + languageName: node + linkType: hard + +"rimraf@npm:^3.0.0": + version: 3.0.2 + resolution: "rimraf@npm:3.0.2" + dependencies: + glob: "npm:^7.1.3" + bin: + rimraf: bin.js + checksum: 9cb7757acb489bd83757ba1a274ab545eafd75598a9d817e0c3f8b164238dd90eba50d6b848bd4dcc5f3040912e882dc7ba71653e35af660d77b25c381d402e8 + languageName: node + linkType: hard + +"root-workspace-0b6124@workspace:.": + version: 0.0.0-use.local + resolution: "root-workspace-0b6124@workspace:." + dependencies: + "@endo/zip": "npm:^0.2.35" + ava: "npm:^5.3.1" + better-sqlite3: "npm:^8.5.1" + execa: "npm:^7.2.0" + tmp: "npm:^0.2.1" + languageName: unknown + linkType: soft + +"run-parallel@npm:^1.1.9": + version: 1.2.0 + resolution: "run-parallel@npm:1.2.0" + dependencies: + queue-microtask: "npm:^1.2.2" + checksum: 200b5ab25b5b8b7113f9901bfe3afc347e19bb7475b267d55ad0eb86a62a46d77510cb0f232507c9e5d497ebda569a08a9867d0d14f57a82ad5564d991588b39 + languageName: node + linkType: hard + +"safe-buffer@npm:^5.0.1, safe-buffer@npm:~5.2.0": + version: 5.2.1 + resolution: "safe-buffer@npm:5.2.1" + checksum: 6501914237c0a86e9675d4e51d89ca3c21ffd6a31642efeba25ad65720bce6921c9e7e974e5be91a786b25aa058b5303285d3c15dbabf983a919f5f630d349f3 + languageName: node + linkType: hard + +"safer-buffer@npm:>= 2.1.2 < 3.0.0": + version: 2.1.2 + resolution: "safer-buffer@npm:2.1.2" + checksum: 7e3c8b2e88a1841c9671094bbaeebd94448111dd90a81a1f606f3f67708a6ec57763b3b47f06da09fc6054193e0e6709e77325415dc8422b04497a8070fa02d4 + languageName: node + linkType: hard + +"semver@npm:^7.3.2, semver@npm:^7.3.5": + version: 7.5.4 + resolution: "semver@npm:7.5.4" + dependencies: + lru-cache: "npm:^6.0.0" + bin: + semver: bin/semver.js + checksum: 5160b06975a38b11c1ab55950cb5b8a23db78df88275d3d8a42ccf1f29e55112ac995b3a26a522c36e3b5f76b0445f1eef70d696b8c7862a2b4303d7b0e7609e + languageName: node + linkType: hard + +"serialize-error@npm:^7.0.1": + version: 7.0.1 + resolution: "serialize-error@npm:7.0.1" + dependencies: + type-fest: "npm:^0.13.1" + checksum: 7982937d578cd901276c8ab3e2c6ed8a4c174137730f1fb0402d005af209a0e84d04acc874e317c936724c7b5b26c7a96ff7e4b8d11a469f4924a4b0ea814c05 + languageName: node + linkType: hard + +"shebang-command@npm:^2.0.0": + version: 2.0.0 + resolution: "shebang-command@npm:2.0.0" + dependencies: + shebang-regex: "npm:^3.0.0" + checksum: a41692e7d89a553ef21d324a5cceb5f686d1f3c040759c50aab69688634688c5c327f26f3ecf7001ebfd78c01f3c7c0a11a7c8bfd0a8bc9f6240d4f40b224e4e + languageName: node + linkType: hard + +"shebang-regex@npm:^3.0.0": + version: 3.0.0 + resolution: "shebang-regex@npm:3.0.0" + checksum: 1dbed0726dd0e1152a92696c76c7f06084eb32a90f0528d11acd764043aacf76994b2fb30aa1291a21bd019d6699164d048286309a278855ee7bec06cf6fb690 + languageName: node + linkType: hard + +"signal-exit@npm:^3.0.7": + version: 3.0.7 + resolution: "signal-exit@npm:3.0.7" + checksum: 25d272fa73e146048565e08f3309d5b942c1979a6f4a58a8c59d5fa299728e9c2fcd1a759ec870863b1fd38653670240cd420dad2ad9330c71f36608a6a1c912 + languageName: node + linkType: hard + +"signal-exit@npm:^4.0.1": + version: 4.1.0 + resolution: "signal-exit@npm:4.1.0" + checksum: 41602dce540e46d599edba9d9860193398d135f7ff72cab629db5171516cfae628d21e7bfccde1bbfdf11c48726bc2a6d1a8fb8701125852fbfda7cf19c6aa83 + languageName: node + linkType: hard + +"simple-concat@npm:^1.0.0": + version: 1.0.1 + resolution: "simple-concat@npm:1.0.1" + checksum: 62f7508e674414008910b5397c1811941d457dfa0db4fd5aa7fa0409eb02c3609608dfcd7508cace75b3a0bf67a2a77990711e32cd213d2c76f4fd12ee86d776 + languageName: node + linkType: hard + +"simple-get@npm:^4.0.0": + version: 4.0.1 + resolution: "simple-get@npm:4.0.1" + dependencies: + decompress-response: "npm:^6.0.0" + once: "npm:^1.3.1" + simple-concat: "npm:^1.0.0" + checksum: b0649a581dbca741babb960423248899203165769747142033479a7dc5e77d7b0fced0253c731cd57cf21e31e4d77c9157c3069f4448d558ebc96cf9e1eebcf0 + languageName: node + linkType: hard + +"slash@npm:^4.0.0": + version: 4.0.0 + resolution: "slash@npm:4.0.0" + checksum: b522ca75d80d107fd30d29df0549a7b2537c83c4c4ecd12cd7d4ea6c8aaca2ab17ada002e7a1d78a9d736a0261509f26ea5b489082ee443a3a810586ef8eff18 + languageName: node + linkType: hard + +"slice-ansi@npm:^5.0.0": + version: 5.0.0 + resolution: "slice-ansi@npm:5.0.0" + dependencies: + ansi-styles: "npm:^6.0.0" + is-fullwidth-code-point: "npm:^4.0.0" + checksum: 2d4d40b2a9d5cf4e8caae3f698fe24ae31a4d778701724f578e984dcb485ec8c49f0c04dab59c401821e80fcdfe89cace9c66693b0244e40ec485d72e543914f + languageName: node + linkType: hard + +"smart-buffer@npm:^4.2.0": + version: 4.2.0 + resolution: "smart-buffer@npm:4.2.0" + checksum: a16775323e1404dd43fabafe7460be13a471e021637bc7889468eb45ce6a6b207261f454e4e530a19500cc962c4cc5348583520843b363f4193cee5c00e1e539 + languageName: node + linkType: hard + +"socks-proxy-agent@npm:^8.0.1": + version: 8.0.2 + resolution: "socks-proxy-agent@npm:8.0.2" + dependencies: + agent-base: "npm:^7.0.2" + debug: "npm:^4.3.4" + socks: "npm:^2.7.1" + checksum: a842402fc9b8848a31367f2811ca3cd14c4106588b39a0901cd7a69029998adfc6456b0203617c18ed090542ad0c24ee4e9d4c75a0c4b75071e214227c177eb7 + languageName: node + linkType: hard + +"socks@npm:^2.7.1": + version: 2.7.1 + resolution: "socks@npm:2.7.1" + dependencies: + ip: "npm:^2.0.0" + smart-buffer: "npm:^4.2.0" + checksum: 43f69dbc9f34fc8220bc51c6eea1c39715ab3cfdb115d6e3285f6c7d1a603c5c75655668a5bbc11e3c7e2c99d60321fb8d7ab6f38cda6a215fadd0d6d0b52130 + languageName: node + linkType: hard + +"sprintf-js@npm:~1.0.2": + version: 1.0.3 + resolution: "sprintf-js@npm:1.0.3" + checksum: ecadcfe4c771890140da5023d43e190b7566d9cf8b2d238600f31bec0fc653f328da4450eb04bd59a431771a8e9cc0e118f0aa3974b683a4981b4e07abc2a5bb + languageName: node + linkType: hard + +"ssri@npm:^10.0.0": + version: 10.0.5 + resolution: "ssri@npm:10.0.5" + dependencies: + minipass: "npm:^7.0.3" + checksum: b091f2ae92474183c7ac5ed3f9811457e1df23df7a7e70c9476eaa9a0c4a0c8fc190fb45acefbf023ca9ee864dd6754237a697dc52a0fb182afe65d8e77443d8 + languageName: node + linkType: hard + +"stack-utils@npm:^2.0.6": + version: 2.0.6 + resolution: "stack-utils@npm:2.0.6" + dependencies: + escape-string-regexp: "npm:^2.0.0" + checksum: 651c9f87667e077584bbe848acaecc6049bc71979f1e9a46c7b920cad4431c388df0f51b8ad7cfd6eed3db97a2878d0fc8b3122979439ea8bac29c61c95eec8a + languageName: node + linkType: hard + +"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3": + version: 4.2.3 + resolution: "string-width@npm:4.2.3" + dependencies: + emoji-regex: "npm:^8.0.0" + is-fullwidth-code-point: "npm:^3.0.0" + strip-ansi: "npm:^6.0.1" + checksum: 1e525e92e5eae0afd7454086eed9c818ee84374bb80328fc41217ae72ff5f065ef1c9d7f72da41de40c75fa8bb3dee63d92373fd492c84260a552c636392a47b + languageName: node + linkType: hard + +"string-width@npm:^5.0.0, string-width@npm:^5.0.1, string-width@npm:^5.1.2": + version: 5.1.2 + resolution: "string-width@npm:5.1.2" + dependencies: + eastasianwidth: "npm:^0.2.0" + emoji-regex: "npm:^9.2.2" + strip-ansi: "npm:^7.0.1" + checksum: ab9c4264443d35b8b923cbdd513a089a60de339216d3b0ed3be3ba57d6880e1a192b70ae17225f764d7adbf5994e9bb8df253a944736c15a0240eff553c678ca + languageName: node + linkType: hard + +"string_decoder@npm:^1.1.1": + version: 1.3.0 + resolution: "string_decoder@npm:1.3.0" + dependencies: + safe-buffer: "npm:~5.2.0" + checksum: 810614ddb030e271cd591935dcd5956b2410dd079d64ff92a1844d6b7588bf992b3e1b69b0f4d34a3e06e0bd73046ac646b5264c1987b20d0601f81ef35d731d + languageName: node + linkType: hard + +"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1": + version: 6.0.1 + resolution: "strip-ansi@npm:6.0.1" + dependencies: + ansi-regex: "npm:^5.0.1" + checksum: 1ae5f212a126fe5b167707f716942490e3933085a5ff6c008ab97ab2f272c8025d3aa218b7bd6ab25729ca20cc81cddb252102f8751e13482a5199e873680952 + languageName: node + linkType: hard + +"strip-ansi@npm:^7.0.1": + version: 7.1.0 + resolution: "strip-ansi@npm:7.1.0" + dependencies: + ansi-regex: "npm:^6.0.1" + checksum: a198c3762e8832505328cbf9e8c8381de14a4fa50a4f9b2160138158ea88c0f5549fb50cb13c651c3088f47e63a108b34622ec18c0499b6c8c3a5ddf6b305ac4 + languageName: node + linkType: hard + +"strip-final-newline@npm:^3.0.0": + version: 3.0.0 + resolution: "strip-final-newline@npm:3.0.0" + checksum: a771a17901427bac6293fd416db7577e2bc1c34a19d38351e9d5478c3c415f523f391003b42ed475f27e33a78233035df183525395f731d3bfb8cdcbd4da08ce + languageName: node + linkType: hard + +"strip-json-comments@npm:~2.0.1": + version: 2.0.1 + resolution: "strip-json-comments@npm:2.0.1" + checksum: b509231cbdee45064ff4f9fd73609e2bcc4e84a4d508e9dd0f31f70356473fde18abfb5838c17d56fb236f5a06b102ef115438de0600b749e818a35fbbc48c43 + languageName: node + linkType: hard + +"supertap@npm:^3.0.1": + version: 3.0.1 + resolution: "supertap@npm:3.0.1" + dependencies: + indent-string: "npm:^5.0.0" + js-yaml: "npm:^3.14.1" + serialize-error: "npm:^7.0.1" + strip-ansi: "npm:^7.0.1" + checksum: 8164674f2e280cab875f0fef5bb36c15553c13e29697ff92f4e0d6bc62149f0303a89eee47535413ed145ea72e14a24d065bab233059d48a499ec5ebb4566b0f + languageName: node + linkType: hard + +"tar-fs@npm:^2.0.0": + version: 2.1.1 + resolution: "tar-fs@npm:2.1.1" + dependencies: + chownr: "npm:^1.1.1" + mkdirp-classic: "npm:^0.5.2" + pump: "npm:^3.0.0" + tar-stream: "npm:^2.1.4" + checksum: 871d26a934bfb7beeae4c4d8a09689f530b565f79bd0cf489823ff0efa3705da01278160da10bb006d1a793fa0425cf316cec029b32a9159eacbeaff4965fb6d + languageName: node + linkType: hard + +"tar-stream@npm:^2.1.4": + version: 2.2.0 + resolution: "tar-stream@npm:2.2.0" + dependencies: + bl: "npm:^4.0.3" + end-of-stream: "npm:^1.4.1" + fs-constants: "npm:^1.0.0" + inherits: "npm:^2.0.3" + readable-stream: "npm:^3.1.1" + checksum: 2f4c910b3ee7196502e1ff015a7ba321ec6ea837667220d7bcb8d0852d51cb04b87f7ae471008a6fb8f5b1a1b5078f62f3a82d30c706f20ada1238ac797e7692 + languageName: node + linkType: hard + +"tar@npm:^6.1.11, tar@npm:^6.1.2": + version: 6.2.0 + resolution: "tar@npm:6.2.0" + dependencies: + chownr: "npm:^2.0.0" + fs-minipass: "npm:^2.0.0" + minipass: "npm:^5.0.0" + minizlib: "npm:^2.1.1" + mkdirp: "npm:^1.0.3" + yallist: "npm:^4.0.0" + checksum: 02ca064a1a6b4521fef88c07d389ac0936730091f8c02d30ea60d472e0378768e870769ab9e986d87807bfee5654359cf29ff4372746cc65e30cbddc352660d8 + languageName: node + linkType: hard + +"temp-dir@npm:^3.0.0": + version: 3.0.0 + resolution: "temp-dir@npm:3.0.0" + checksum: a86978a400984cd5f315b77ebf3fe53bb58c61f192278cafcb1f3fb32d584a21dc8e08b93171d7874b7cc972234d3455c467306cc1bfc4524b622e5ad3bfd671 + languageName: node + linkType: hard + +"time-zone@npm:^1.0.0": + version: 1.0.0 + resolution: "time-zone@npm:1.0.0" + checksum: d00ebd885039109011b6e2423ebbf225160927333c2ade6d833e9cc4676db20759f1f3855fafde00d1bd668c243a6aa68938ce71fe58aab0d514e820d59c1d81 + languageName: node + linkType: hard + +"tmp@npm:^0.2.1": + version: 0.2.1 + resolution: "tmp@npm:0.2.1" + dependencies: + rimraf: "npm:^3.0.0" + checksum: 67607aa012059c9ce697bee820ee51bc0f39b29a8766def4f92d3f764d67c7cf9205d537d24e0cb1ce9685c40d4c628ead010910118ea18348666b5c46ed9123 + languageName: node + linkType: hard + +"to-regex-range@npm:^5.0.1": + version: 5.0.1 + resolution: "to-regex-range@npm:5.0.1" + dependencies: + is-number: "npm:^7.0.0" + checksum: 487988b0a19c654ff3e1961b87f471702e708fa8a8dd02a298ef16da7206692e8552a0250e8b3e8759270f62e9d8314616f6da274734d3b558b1fc7b7724e892 + languageName: node + linkType: hard + +"tunnel-agent@npm:^0.6.0": + version: 0.6.0 + resolution: "tunnel-agent@npm:0.6.0" + dependencies: + safe-buffer: "npm:^5.0.1" + checksum: 4c7a1b813e7beae66fdbf567a65ec6d46313643753d0beefb3c7973d66fcec3a1e7f39759f0a0b4465883499c6dc8b0750ab8b287399af2e583823e40410a17a + languageName: node + linkType: hard + +"type-fest@npm:^0.13.1": + version: 0.13.1 + resolution: "type-fest@npm:0.13.1" + checksum: 0c0fa07ae53d4e776cf4dac30d25ad799443e9eef9226f9fddbb69242db86b08584084a99885cfa5a9dfe4c063ebdc9aa7b69da348e735baede8d43f1aeae93b + languageName: node + linkType: hard + +"unique-filename@npm:^3.0.0": + version: 3.0.0 + resolution: "unique-filename@npm:3.0.0" + dependencies: + unique-slug: "npm:^4.0.0" + checksum: 6363e40b2fa758eb5ec5e21b3c7fb83e5da8dcfbd866cc0c199d5534c42f03b9ea9ab069769cc388e1d7ab93b4eeef28ef506ab5f18d910ef29617715101884f + languageName: node + linkType: hard + +"unique-slug@npm:^4.0.0": + version: 4.0.0 + resolution: "unique-slug@npm:4.0.0" + dependencies: + imurmurhash: "npm:^0.1.4" + checksum: cb811d9d54eb5821b81b18205750be84cb015c20a4a44280794e915f5a0a70223ce39066781a354e872df3572e8155c228f43ff0cce94c7cbf4da2cc7cbdd635 + languageName: node + linkType: hard + +"util-deprecate@npm:^1.0.1": + version: 1.0.2 + resolution: "util-deprecate@npm:1.0.2" + checksum: 41a5bdd214df2f6c3ecf8622745e4a366c4adced864bc3c833739791aeeeb1838119af7daed4ba36428114b5c67dcda034a79c882e97e43c03e66a4dd7389942 + languageName: node + linkType: hard + +"well-known-symbols@npm:^2.0.0": + version: 2.0.0 + resolution: "well-known-symbols@npm:2.0.0" + checksum: cb6c12e98877e8952ec28d13ae6f4fdb54ae1cb49b16a728720276dadd76c930e6cb0e174af3a4620054dd2752546f842540122920c6e31410208abd4958ee6b + languageName: node + linkType: hard + +"which@npm:^2.0.1": + version: 2.0.2 + resolution: "which@npm:2.0.2" + dependencies: + isexe: "npm:^2.0.0" + bin: + node-which: ./bin/node-which + checksum: 66522872a768b60c2a65a57e8ad184e5372f5b6a9ca6d5f033d4b0dc98aff63995655a7503b9c0a2598936f532120e81dd8cc155e2e92ed662a2b9377cc4374f + languageName: node + linkType: hard + +"which@npm:^4.0.0": + version: 4.0.0 + resolution: "which@npm:4.0.0" + dependencies: + isexe: "npm:^3.1.1" + bin: + node-which: bin/which.js + checksum: 449fa5c44ed120ccecfe18c433296a4978a7583bf2391c50abce13f76878d2476defde04d0f79db8165bdf432853c1f8389d0485ca6e8ebce3bbcded513d5e6a + languageName: node + linkType: hard + +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0, wrap-ansi@npm:^7.0.0": + version: 7.0.0 + resolution: "wrap-ansi@npm:7.0.0" + dependencies: + ansi-styles: "npm:^4.0.0" + string-width: "npm:^4.1.0" + strip-ansi: "npm:^6.0.0" + checksum: d15fc12c11e4cbc4044a552129ebc75ee3f57aa9c1958373a4db0292d72282f54373b536103987a4a7594db1ef6a4f10acf92978f79b98c49306a4b58c77d4da + languageName: node + linkType: hard + +"wrap-ansi@npm:^8.1.0": + version: 8.1.0 + resolution: "wrap-ansi@npm:8.1.0" + dependencies: + ansi-styles: "npm:^6.1.0" + string-width: "npm:^5.0.1" + strip-ansi: "npm:^7.0.1" + checksum: 138ff58a41d2f877eae87e3282c0630fc2789012fc1af4d6bd626eeb9a2f9a65ca92005e6e69a75c7b85a68479fe7443c7dbe1eb8fbaa681a4491364b7c55c60 + languageName: node + linkType: hard + +"wrappy@npm:1": + version: 1.0.2 + resolution: "wrappy@npm:1.0.2" + checksum: 56fece1a4018c6a6c8e28fbc88c87e0fbf4ea8fd64fc6c63b18f4acc4bd13e0ad2515189786dd2c30d3eec9663d70f4ecf699330002f8ccb547e4a18231fc9f0 + languageName: node + linkType: hard + +"write-file-atomic@npm:^5.0.1": + version: 5.0.1 + resolution: "write-file-atomic@npm:5.0.1" + dependencies: + imurmurhash: "npm:^0.1.4" + signal-exit: "npm:^4.0.1" + checksum: e8c850a8e3e74eeadadb8ad23c9d9d63e4e792bd10f4836ed74189ef6e996763959f1249c5650e232f3c77c11169d239cbfc8342fc70f3fe401407d23810505d + languageName: node + linkType: hard + +"y18n@npm:^5.0.5": + version: 5.0.8 + resolution: "y18n@npm:5.0.8" + checksum: 4df2842c36e468590c3691c894bc9cdbac41f520566e76e24f59401ba7d8b4811eb1e34524d57e54bc6d864bcb66baab7ffd9ca42bf1eda596618f9162b91249 + languageName: node + linkType: hard + +"yallist@npm:^4.0.0": + version: 4.0.0 + resolution: "yallist@npm:4.0.0" + checksum: 2286b5e8dbfe22204ab66e2ef5cc9bbb1e55dfc873bbe0d568aa943eb255d131890dfd5bf243637273d31119b870f49c18fcde2c6ffbb7a7a092b870dc90625a + languageName: node + linkType: hard + +"yargs-parser@npm:^21.1.1": + version: 21.1.1 + resolution: "yargs-parser@npm:21.1.1" + checksum: f84b5e48169479d2f402239c59f084cfd1c3acc197a05c59b98bab067452e6b3ea46d4dd8ba2985ba7b3d32a343d77df0debd6b343e5dae3da2aab2cdf5886b2 + languageName: node + linkType: hard + +"yargs@npm:^17.7.2": + version: 17.7.2 + resolution: "yargs@npm:17.7.2" + dependencies: + cliui: "npm:^8.0.1" + escalade: "npm:^3.1.1" + get-caller-file: "npm:^2.0.5" + require-directory: "npm:^2.1.1" + string-width: "npm:^4.2.3" + y18n: "npm:^5.0.5" + yargs-parser: "npm:^21.1.1" + checksum: ccd7e723e61ad5965fffbb791366db689572b80cca80e0f96aad968dfff4156cd7cd1ad18607afe1046d8241e6fb2d6c08bf7fa7bfb5eaec818735d8feac8f05 + languageName: node + linkType: hard + +"yocto-queue@npm:^1.0.0": + version: 1.0.0 + resolution: "yocto-queue@npm:1.0.0" + checksum: 856117aa15cf5103d2a2fb173f0ab4acb12b4b4d0ed3ab249fdbbf612e55d1cadfd27a6110940e24746fb0a78cf640b522cc8bca76f30a3b00b66e90cf82abe0 + languageName: node + linkType: hard From 71011855e193b8a2ef5c3da666d6d42abf1e00ab Mon Sep 17 00:00:00 2001 From: anilhelvaci Date: Tue, 12 Dec 2023 16:33:53 +0300 Subject: [PATCH 3/4] #1 Update assets --- .../assets/bundle-contract.json | 2 +- .../assets/bundle-governor.json | 2 +- .../assets/crabble-permit.json | 2 +- .../assets/crabbleCoreEval.js | 16 +++++++------- .../64:crabble-start/assets/gov-permit.json | 2 +- .../64:crabble-start/assets/govStarting.js | 22 ++++++++++--------- 6 files changed, 24 insertions(+), 22 deletions(-) diff --git a/proposals/64:crabble-start/assets/bundle-contract.json b/proposals/64:crabble-start/assets/bundle-contract.json index d1dc9b49..3c903684 100644 --- a/proposals/64:crabble-start/assets/bundle-contract.json +++ b/proposals/64:crabble-start/assets/bundle-contract.json @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"46f82a8b8348f7c2dcae1ddc1ace085f5f489d493f7df24ce8f2334199b21eeb9ed848de5e2814f200ba47470ff3bd83b08d74055da2a454f94c2a0c565bf557"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"145f84363c784c96bc5a5d456edf1853bf2bb04388a250f010a53234b333af46d8d08e3c58d6e3bac61c45b18e82a09199938466616016a22d9191448f8e505c"} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-governor.json b/proposals/64:crabble-start/assets/bundle-governor.json index 314918b1..c03a99e5 100644 --- a/proposals/64:crabble-start/assets/bundle-governor.json +++ b/proposals/64:crabble-start/assets/bundle-governor.json @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"bde789b8f6623f2352dc2d4a781f39066bbb63366602ac3c70943760418a9c7e63b8d9cfad6c8601e418ec5dfd29f1b62b2419bd2cd7f5907f59a62aff37e332"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"d67b9ac5100bf45a3369d393fe2cb38e0718f770cac936292a18270ed331865ffa817719f5c6ceacdb1a580572d71084db0545e8e13efaee38c7df76f51f756c"} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/crabble-permit.json b/proposals/64:crabble-start/assets/crabble-permit.json index 2ac5ccc0..8eb0b892 100644 --- a/proposals/64:crabble-start/assets/crabble-permit.json +++ b/proposals/64:crabble-start/assets/crabble-permit.json @@ -6,7 +6,7 @@ "agoricNames": true, "zoe": true, "namesByAddressAdmin": true, - "startMyGovernedUpgradable": true, + "startCrabbleGovernedUpgradable": true, "startUpgradable": true }, "installation": { diff --git a/proposals/64:crabble-start/assets/crabbleCoreEval.js b/proposals/64:crabble-start/assets/crabbleCoreEval.js index c0ac0d3d..328839b1 100644 --- a/proposals/64:crabble-start/assets/crabbleCoreEval.js +++ b/proposals/64:crabble-start/assets/crabbleCoreEval.js @@ -56,7 +56,9 @@ const startCommittee = async ( namesByAddressAdmin, startUpgradable, }, - installation: { consume: { committee: committeeInstallationP } }, + installation: { + consume: { committee: committeeInstallationP }, + }, instance: { produce: produceInstance }, }, config, @@ -114,7 +116,7 @@ const startCommittee = async ( * consume: { * zoe: Promise; * board: ERef, - * startMyGovernedUpgradable: Promise, + * startCrabbleGovernedUpgradable: Promise, * chainTimerService: ERef; * agoricNames: ERef; * }, @@ -128,15 +130,13 @@ const startCommittee = async ( * }>} committeeInfoP */ const startCrabble = async (powers, config, crabbleNode, committeeInfoP) => { - // eslint-disable-next-line - const contractBundleID = "b1-46f82a8b8348f7c2dcae1ddc1ace085f5f489d493f7df24ce8f2334199b21eeb9ed848de5e2814f200ba47470ff3bd83b08d74055da2a454f94c2a0c565bf557"; - // eslint-disable-next-line - const governorBundleID = "b1-bde789b8f6623f2352dc2d4a781f39066bbb63366602ac3c70943760418a9c7e63b8d9cfad6c8601e418ec5dfd29f1b62b2419bd2cd7f5907f59a62aff37e332"; + const contractBundleID = "b1-145f84363c784c96bc5a5d456edf1853bf2bb04388a250f010a53234b333af46d8d08e3c58d6e3bac61c45b18e82a09199938466616016a22d9191448f8e505c"; + const governorBundleID = "b1-d67b9ac5100bf45a3369d393fe2cb38e0718f770cac936292a18270ed331865ffa817719f5c6ceacdb1a580572d71084db0545e8e13efaee38c7df76f51f756c"; const { consume: { board, - startMyGovernedUpgradable, + startCrabbleGovernedUpgradable, zoe: zoeI, // only used for installation, not for startInstance chainTimerService, agoricNames: agoricNamesP, @@ -203,7 +203,7 @@ const startCrabble = async (powers, config, crabbleNode, committeeInfoP) => { }); logger('Starting governor, governed...'); - const kit = await E(startMyGovernedUpgradable)({ + const kit = await E(startCrabbleGovernedUpgradable)({ installation: contractInstallation, committeeCreatorFacet, contractGovernor: governorInstallation, diff --git a/proposals/64:crabble-start/assets/gov-permit.json b/proposals/64:crabble-start/assets/gov-permit.json index c5f9edd9..b7ed1c96 100644 --- a/proposals/64:crabble-start/assets/gov-permit.json +++ b/proposals/64:crabble-start/assets/gov-permit.json @@ -6,6 +6,6 @@ "zoe": true }, "produce": { - "startMyGovernedUpgradable": true + "startCrabbleGovernedUpgradable": true } } \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/govStarting.js b/proposals/64:crabble-start/assets/govStarting.js index dde650cf..fb037777 100644 --- a/proposals/64:crabble-start/assets/govStarting.js +++ b/proposals/64:crabble-start/assets/govStarting.js @@ -16,7 +16,7 @@ const ParamTypes = /** @type {const} */ ({ const { fromEntries, entries } = Object; /** @type { >>(obj: T) => Promise<{ [K in keyof T]: Awaited}> } */ -const allValues = async obj => { +const allValues = async (obj) => { const es = await Promise.all( entries(obj).map(async ([k, v]) => [k, await v]), ); @@ -59,7 +59,7 @@ const logger = (message) => { * }} govArgs * @returns {Promise>} */ -const startMyGovernedInstance = async ( +const startCrabbleGovernedInstance = async ( { zoe, governedContractInstallation, @@ -147,13 +147,13 @@ const startMyGovernedInstance = async ( /** * @param {BootstrapSpace & { * produce: { - * startMyGovernedUpgradable: Producer; + * startCrabbleGovernedUpgradable: Producer; * }; * }} powers */ -const produceStartMyGovernedUpgradable = async ({ +const produceStartCrabbleGovernedUpgradable = async ({ consume: { chainTimerService, governedContractKits, diagnostics, zoe }, - produce, // startMyGovernedUpgradable + produce, // startCrabbleGovernedUpgradable }) => { logger('Producing governed upgradable...'); /** @@ -176,8 +176,8 @@ const produceStartMyGovernedUpgradable = async ({ label, }) => { const contractKits = await governedContractKits; - logger('Init startMyGovernedInstance...'); - const facets = await startMyGovernedInstance( + logger('Init startCrabbleGovernedInstance...'); + const facets = await startCrabbleGovernedInstance( { zoe, governedContractInstallation: installation, @@ -207,10 +207,12 @@ const produceStartMyGovernedUpgradable = async ({ return facets; }; - produce.startMyGovernedUpgradable.resolve(harden(startGovernedUpgradable)); + produce.startCrabbleGovernedUpgradable.resolve( + harden(startGovernedUpgradable), + ); logger('Done.'); }; -harden(produceStartMyGovernedUpgradable); +harden(produceStartCrabbleGovernedUpgradable); // script completion value -produceStartMyGovernedUpgradable; +produceStartCrabbleGovernedUpgradable; From 2567476298f9ce309c53d5b06ff17d9b073ca793 Mon Sep 17 00:00:00 2001 From: anilhelvaci Date: Wed, 13 Dec 2023 00:42:10 +0300 Subject: [PATCH 4/4] #4 Crabble Xnet release, fix naming --- proposals/{64:crabble-start => c:crabble-start}/.yarnrc.yml | 0 .../assets/bundle-contract.json | 2 +- .../assets/bundle-governor.json | 2 +- .../assets/crabble-permit.json | 0 .../assets/crabbleCoreEval.js | 4 ++-- .../assets/gov-permit.json | 0 .../assets/govStarting.js | 0 .../core-eval-support.js | 0 proposals/{64:crabble-start => c:crabble-start}/eval.sh | 0 proposals/{64:crabble-start => c:crabble-start}/package.json | 0 .../test-crabble-start.js | 0 proposals/{64:crabble-start => c:crabble-start}/test.sh | 0 proposals/{64:crabble-start => c:crabble-start}/use.sh | 0 proposals/{64:crabble-start => c:crabble-start}/yarn.lock | 0 14 files changed, 4 insertions(+), 4 deletions(-) rename proposals/{64:crabble-start => c:crabble-start}/.yarnrc.yml (100%) rename proposals/{64:crabble-start => c:crabble-start}/assets/bundle-contract.json (90%) rename proposals/{64:crabble-start => c:crabble-start}/assets/bundle-governor.json (97%) rename proposals/{64:crabble-start => c:crabble-start}/assets/crabble-permit.json (100%) rename proposals/{64:crabble-start => c:crabble-start}/assets/crabbleCoreEval.js (95%) rename proposals/{64:crabble-start => c:crabble-start}/assets/gov-permit.json (100%) rename proposals/{64:crabble-start => c:crabble-start}/assets/govStarting.js (100%) rename proposals/{64:crabble-start => c:crabble-start}/core-eval-support.js (100%) rename proposals/{64:crabble-start => c:crabble-start}/eval.sh (100%) rename proposals/{64:crabble-start => c:crabble-start}/package.json (100%) rename proposals/{64:crabble-start => c:crabble-start}/test-crabble-start.js (100%) rename proposals/{64:crabble-start => c:crabble-start}/test.sh (100%) rename proposals/{64:crabble-start => c:crabble-start}/use.sh (100%) rename proposals/{64:crabble-start => c:crabble-start}/yarn.lock (100%) diff --git a/proposals/64:crabble-start/.yarnrc.yml b/proposals/c:crabble-start/.yarnrc.yml similarity index 100% rename from proposals/64:crabble-start/.yarnrc.yml rename to proposals/c:crabble-start/.yarnrc.yml diff --git a/proposals/64:crabble-start/assets/bundle-contract.json b/proposals/c:crabble-start/assets/bundle-contract.json similarity index 90% rename from proposals/64:crabble-start/assets/bundle-contract.json rename to proposals/c:crabble-start/assets/bundle-contract.json index 3c903684..9b3ef05c 100644 --- a/proposals/64:crabble-start/assets/bundle-contract.json +++ b/proposals/c:crabble-start/assets/bundle-contract.json @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"145f84363c784c96bc5a5d456edf1853bf2bb04388a250f010a53234b333af46d8d08e3c58d6e3bac61c45b18e82a09199938466616016a22d9191448f8e505c"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"UEsDBAoAAAAAAAAAAACyWjbA0aQBANGkAQAUAAAAY29tcGFydG1lbnQtbWFwLmpzb257CiAgImVudHJ5IjogewogICAgImNvbXBhcnRtZW50IjogImNyYWJibGUtY29udHJhY3QtdjAuMS4wIiwKICAgICJtb2R1bGUiOiAiLi9zcmMvY3JhYmJsZS5qcyIKICB9LAogICJjb21wYXJ0bWVudHMiOiB7CiAgICAiQGFnb3JpYy9hc3NlcnQtdjAuNi4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL2Fzc2VydCIsCiAgICAgICJsYWJlbCI6ICJAYWdvcmljL2Fzc2VydC12MC42LjAiLAogICAgICAibG9jYXRpb24iOiAiQGFnb3JpYy9hc3NlcnQtdjAuNi4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9hc3NlcnQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2Fzc2VydC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImFhNjQ3NTkzZTlmY2RjNzUxMDkyMTBlMjY2YjhlN2E5YzBlOTlkMDEzNmY3M2I5OTJhMTVjNDZhOWU4N2QwMWM5Y2Q2ZjBhMmY4YWU1YTgwYzRiYmI1ZWIwY2FmMzVmNDJjMDQyOGU5Y2NmMjI5ODUzZDM1YzBlOTRlMmIzMjM3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjkxMjFkMTVkY2IxMGY4NWY3N2I0MGQ0OGVlODdkNWQ1ZDc2ZjlkNDkwMmUwZThjN2Q4OGMzMTdjMGIyZmUzYTJiMGRlZWZmYTc4NzYyOTQxMThmZGY2NTFhZTRmYWM4NzM5MTc1NjkxNzI3ZGM3NDkyMzRjMTQ0NTI4NWE4NDVhIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMCI6IHsKICAgICAgIm5hbWUiOiAiQGFnb3JpYy9lcnRwIiwKICAgICAgImxhYmVsIjogIkBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2VydHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZXhwb3J0ZWQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci9zdWJzY3JpYmUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3N1YnNjcmliZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMvdGVzdFN1cHBvcnRzLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3RvcmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N3aW5nc2V0LXZhdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy92YXQtZGF0YSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMTgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9tYXJzaGFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL21hcnNoYWwtdjAuOC41IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiLi9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJleHBvcnRlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImEzNzc2ZTMyYjA0Mjc3NDU0OWNiZWJhYmZiNjIxZDZmOGVmOTJlMDNhZTdjMmQzMWQzMTg5NmFjMmVlY2VjOThkMWU5YjY5MjlhNGI1OTQ4MzQ2NzY4ZGI1MjFmZTIwNGFlZWRjZjVmZmYzNTlmZTJlNGNhMDVkNjNmNWE0OWQ3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Ftb3VudE1hdGguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2Ftb3VudE1hdGguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwMjVkYTYwMDk1YmNhYjJhOGY2ZjM1ZTQ0ZThjYTNmMmYxZGUzYmRkYmQ0MmFiYTBkODJmNTg4MDA0NjM4ZGZhYTZiMjQxNzk1ZjU5ZjBjZjYxNDlkYzIyYWZjOGIyY2U1N2Y1NjYwMjgwNzY2N2I0ODc5YzJjN2E0ZjU1YjYyYSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9kaXNwbGF5SW5mby5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZGlzcGxheUluZm8uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI4N2ZkMzZhNjQyOTFkYmMzYjJiZDk0OTMzMGQ4Mzk3OTYzNGM2MTVjOGI5MGRlYTRlZDYzZmM0ZWZiNzZmMjYyOGI3ZTcyNzc4YWEzZTc0NzE0NTQxODlhODMzNWJlMmZiMmYyNGQxOTgxZDU0MDdjMWM1MjhlYWJjNmFiZjAyZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIzM2E4MTQzNzhmNDFlMWI4ZTZiYzU2N2QzYmZkNGI0YTc4ZTg3ZTQ3YmE3ZjUxOWU5NTgwMjFlYTdmMGExMmFlOWFjOWY3NjZiNDcwNTI4ZDQ5ODhhNzY4ODE4ZjBiYWIxYTE0YWMwMTUxOTBkNTQzMWM4ZTU1YzFmMzNjNWNjZiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pc3N1ZXJLaXQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2lzc3VlcktpdC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjNlODkyYmYyYTUzOGYyZDVmYjVkMmYwYTJhNjY5Zjk0ZmFmMTZmZWU2N2I0ZGQwYWUxYzIyM2M5ZmM3NmU5YmYxNmZlNzc2OTg3NmVkNjI5YmQxZWFiZDRkZDIyYmJkN2E3YzhmNDg1NWM3NzIyYTNkNTRmOWY3MzE4NzZkYmZiIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21hdGhIZWxwZXJzL2NvcHlCYWdNYXRoSGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWF0aEhlbHBlcnMvY29weUJhZ01hdGhIZWxwZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZThiZThkYzM2MTRkYmUzNTdhMzhhZWYzZTg3NWExY2Y0NzMxNDhlNDliMzcxOGY4MGQ4Njc1Y2YzZjdhZjdkMDcyMzlhMWE3MDg0ZGU2YTdkNjY0MTIzYzYxYjk2MjU4OTZkMzM3OTE0MTRhYjRkMDUwYjZkNzZlMGU4MWIzNzciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWF0aEhlbHBlcnMvY29weVNldE1hdGhIZWxwZXJzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXRoSGVscGVycy9jb3B5U2V0TWF0aEhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhMTEzNjFjODgzY2RiODAyYzllMTk0YmNhYTE1YjU1ZWNiOTQ3ZjQ1YWQyMjQwNGYzYzk5Y2NjYzQ2ZmRjMDA2ZGI4YjZkMTZmOWY4OTNkYmZmYTNhMjM4ZGQwOGMwOTJiOTliODhkMDMzNWRlYjVkMWE0NGU3ZDdkNTI0ZDk2ZSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXRoSGVscGVycy9uYXRNYXRoSGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWF0aEhlbHBlcnMvbmF0TWF0aEhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlOTJlNjA3MTNlODU1ZDYwNDQxZjhhNDg3YTE1ODlmN2NlOTk1Yjc5MmQ5Yjk3NDcxZTBjMTlmNGU2MmZhNjUyMjI5OTRkMGMxOTJhOThmOTgyZDQ0MGQwNjkzMzM4MmZjNGM0N2E2MTRkZDUzYzcyNTRhNGE2MTdkODY5YmYzMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXRoSGVscGVycy9zZXRNYXRoSGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWF0aEhlbHBlcnMvc2V0TWF0aEhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2NjQ4YmQ0NmRmOTljZDgwYTBmMDEyMWZkZDQ4YmI4N2VkOTYyNjkzNjA4ZmIxYTNhNGE2YzA5NGI1NzI5YTBkOTZmNDBmMGYyMWJkNzQ2MTZlOTJhNDFmYzdjYzVlMTE1ZTI3MWRiMWRmNzdhNjRiNGNhMjUxYjI0OWI1ZDFkYiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXltZW50LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXltZW50LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNmZkN2Y5OWI4YmVjYTY5MzJmN2MzN2I2YTU0MjhmMTU3ZDE0YjM2NzNmNWIxODk1M2NkYjM4NTc5YThjZDQ2MTE5OTc1OTdkYjIzM2EzYzBkYTRiMDJhZTJhYTAyYjQ3YmU5MzM3ZDNmM2JjOTIyODRhYTZkZWU4ZjYxNjk1YjciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcGF5bWVudExlZGdlci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGF5bWVudExlZGdlci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI5MmM0YjUzNjY5MDlhZTFhMmVmMjk4MWI2ZmIwMzkyNzcyMGRiYmQxYTMyZTEwMzdhMGJjZmVhNDliMzA5Mjg1MTExZjEwZGIxMjAxYjA4ZmQzYWI3NWY5MDM0ZDg5OWM4ZmFjYWRjMDdmMGY1YTQ3NjZkYmUxMzgxNDBmYmExIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3B1cnNlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wdXJzZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImNkN2RkYTZhODQxODBjNjhlNmQwOTcyYTY4ZGM4ZGViYjUxNWI5MmNlODBjMjE4ODE2ZTUzMWYyNGRhNjQ4ZjU1NWY2ZjZjMmRiYjgyMDBlOTQzNTlhZDYxYzA0NjAyNjlhNGQ0YzA2NWE5MDVkYTk0ZTA1N2QzYWY1NjI1ZTIzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RyYW5zaWVudE5vdGlmaWVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90cmFuc2llbnROb3RpZmllci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImExMWIyYTZmMjlhZDQ5NmJiYWQwYzU5ODgyZGRjNDkwZjNlYmVjOTYwNmI1MWUwYjcwYmU1NTg1MTEyZDMyZTQ5ZWRhYjhlYzdhYTU3ZmYyYmQ3ZTQ2M2Y1ODdmZTY0YzA2YWM4ZDVjODYxMDIxZGI3NWRjMDM4YzNlNDRlNTU5IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVHdWFyZHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVHdWFyZHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlOGU2YjIwNWM5OTBkMjcwM2U2YTE4NGMxYTNkZjAxZThmNGVlYTk5MjdiZWIxMjAyMWFiNmQwZTE4MzUwODc1NTk2ZjU4MjhiNDBlMzc0YjUxZjVjZjdlZTYyNTkxZGJkMjVjMWI0NjliN2Q1OGM5MTE1ODg4YTNlYTVjZDQwMiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy1hbWJpZW50LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy1hbWJpZW50LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOTAyMWY1NGI5YWZjMDI1Y2EwZTkwZDJkYzJlMGJlZDJmYjA4YjA2M2M2ZDY4YTQ0YjFlYzJlYjc4MzkwNzY5NmMyZTRiM2NkODA1NjA1MWRjMTMxOGQ2YjQ1YWM1NzMxMmFmN2YzZjlkODQ0MmIyYmVmNDAyNzZhY2Y2MjQ0YzEiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL2dvdmVybmFuY2UiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAiLAogICAgICAibG9jYXRpb24iOiAiQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGFnb3JpYy9hc3NlcnQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9hc3NlcnQtdjAuNi4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvYXNzZXJ0LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvZXJ0cCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvZXJ0cC9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZXhwb3J0ZWQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9nb3Zlcm5hbmNlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL3N1YnNjcmliZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3Vic2NyaWJlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvdG9vbHMvdGVzdFN1cHBvcnRzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi90b29scy90ZXN0U3VwcG9ydHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zdG9yZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3dpbmdzZXQtdmF0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3dpbmdzZXQtdmF0LXYwLjMyLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N3aW5nc2V0LXZhdC9zcmMvdmF0cy9uZXR3b3JrL3R5cGVzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3dpbmdzZXQtdmF0LXYwLjMyLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy92YXRzL25ldHdvcmsvdHlwZXMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy90aW1lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdmF0LWRhdGEiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdHMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXRzLXYwLjE1LjItdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy96b2VTZXJ2aWNlL3pvZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9zcmMvY2xlYW5Qcm9wb3NhbC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvY2xlYW5Qcm9wb3NhbC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L2R1cmFiaWxpdHkuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvcmF0aW8uanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9yYXRpby5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9zcmMvbWFrZUhhbmRsZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbWFrZUhhbmRsZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvdHlwZUd1YXJkcy5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9jYXB0cCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9jYXB0cC12My4xLjEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbWFyc2hhbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvc2hpbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnN0YW50cy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29uc3RhbnRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYjllZmFkZDE1MGUwNjZiNDc3YzYxNDA3M2FhZDRjOWY4OWVhYzBmMzk3ZDZlZmRmMjc5ZjE5N2MyZjhmZmMyMmYyYjRmOWQwYjk5YmNjNTFkMWFiMzdmN2E3MjE5OGVkZmQxNmMyYTA4NjcyYjU4ZjQ5YTM3YzcxYjUxZDhjNzMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2Fzc2VydGlvbnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0R292ZXJuYW5jZS9hc3NlcnRpb25zLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjhjOGYzYTQyNmQ3MWZhZWQ0MWIxNjFhMTZmZmEzMDEyZTQzZTQwYWRiNTJiZTQ2OTNjYjUxNzM3ODU0YTc3MTU0MTAwZTE1M2JmYjZlMTczNzAwOTczMWJhMTA3N2ZkMTQ1ZDYzODNhM2UwZWJlYWUxOGU3ZTEwMTFjNjkyODUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkFwaS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkFwaS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImQ3ZjllYmYwNGYzMTRkYmJhNDdkZmFlYzc2MzhkNmRkMDM3ODNkN2FkYzEyYzMzMmExN2ZkNWZiNGJkZDdiODRmYzdmNDg0MjkyNzkyYjAzNjkxNTRhNjJlYmU4MjhmNThlZTdiMzI5NWJmMDIzMjMyMjk5NDJlYzQzOTRiYTBkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5GaWx0ZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5GaWx0ZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhY2Y5NGFjMDU3MTE2ZTY5MmM2MTU5Y2I4ZWQ0MmJiOWU5YTgwNThhNGM4ZmE1YWFhNjA3MjJiNWVlMzM3MGI2OWU2MzY5YjViYTYzZTVlNzM3MjNjYTFmZTk0Nzk4MWU2NDc5NGYwNDRjODljNjFkOTIxZDg0Y2ZlODhlZWI5YSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImNmODEyMGZiZDM0MTUwNmFlZDE5ZjdhYzI3ZTg3ZTkzOTRhOTU0YjFlNTIyMmNlMGRlNjM5MjEwOGRiZDUwMGFlZWFkMTVjMWEzMjMxMjMzZjY1MzJlMTQ0MGQ0MWZjM2EzNjNmNDA4OTkxNWFlNDE1MTU4NDkxYTg4NTIyYjZiIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9wYXJhbU1hbmFnZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0R292ZXJuYW5jZS9wYXJhbU1hbmFnZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhYjIyN2ZlYjJlOTg3NjVmYjJiOTU2MTgyNGMyNDE1NjU2ZGVjYWEzMDU1Y2Y4YzQwOWExZjg3MTMxOWYzYmE4MzI2NzA3NmI4Zjg3YmYyYjIxNzM3YTBmYTkwOWRjMmRkY2E4ZmU1ZGEzMTljYzU0MDkxOWI5YmZhMGY4YjdhNiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdEdvdmVybmFuY2UvdHlwZWRQYXJhbU1hbmFnZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjBmOTg3NzViM2EyNmFkYTA3MTJhOWU2ZDM0M2Y1YWU5M2E1NjdiYzQzZmNlMjEwYmJhNWM4ZDIzYmExN2M5Y2Y0MjMyYTBjMDNmODk2ODgwZTM2MjFjNmM1MjU3YjI0MDFiMjQ5MmYzODNjOGRjNTE3OGJmNzAwOGYxZmNhMzBmIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0R292ZXJub3IuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0R292ZXJub3IuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIzY2ZiMjg1ODVkYzk4NDZhOTU5NGFjMTRjOThkNTUyMjMyZGY4NzE5Njk4ZjdiNjUyM2Q0MTM0YTYwOWVlMGQ3MmUxZDhmMGFjYzM5ZDMwNGQ0YjEyOWEzM2QxNzI5ODlhNGI0YjUzNGRhM2JhOTBjMjIzZDkyNjg4MTgzNGFmYyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdEdvdmVybm9yS2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdEdvdmVybm9yS2l0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOGRjNWI4MDY2YjFjY2I0ZDYzMGYxOTc5Y2EyMGI5ODYxZjM2ZTc1Y2M5MWQ2NjA0YjZmOGI4NjQ2MjVhYTFmZmE0MGI2MGNkY2VkZjk1MTA1Nzk2ZGE3ODZhMjkzNmQ0MWFkZTkzZWUyMmVlMGRlYWE0NWU3YjNiZDEyM2U1NmQiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RIZWxwZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0SGVscGVyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjhiODU0NGZjNTEzZWE0NTEwYTNmNGRlNDQ5MWFiZTA3N2M3NDZjNWFjYWYyYzFlM2RjYmY4ZTM3Y2E2NjA5NjdiZmIxYzk4ZmI0OGRmNmMxN2NkOGZhZDk0NmEwNDIxZDBiNGY1MGQyMTI1NzAyNjczNGYxNWM5MzZhYmE1ZTUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOGEyYTQ1NjAxODU1Mjg4N2Q2NDcxYTljNDg3NDljNGVkMmY1ZWVjNzViZjNjNTRhN2Q5YjFjNDlkZmJlOWZmMmE2ZWVmNDgyMjkxZTlmZTcyMGVmNGNhNDU0YmYxMWYxZThlMTgzYTZjMmZjZDUyY2RlNzI2MTU5NzI5MDhlNGMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcXVlc3Rpb24uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3F1ZXN0aW9uLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMGNkNTcxN2ViYWJhNTRkNTlkNDQzNWFiMzZlZmY2YzQ4MmExYzdhYjZmMGRlMTU4MWFmMzU5NzQzYjk1MTBkYzU4MTVlZGZiMGZjNzZjYzljYTFjNGIxMmQwZjEzYmVlNjU4MWY1MzAzMzQxZDQ0MzZmNGIwMzkyZDlhNmY1ZjIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjI0YWJhYjMwMGVhNzJhZDg2Y2UzOTNmMTRkYzRhMGU4NmVmNzc5OWMzNzE1ZGVjOGRhODlmNDRjMmZkNTc0NzdmYjRhNzExN2EzYWVhYTQ0M2JmODBjYzVmM2Y0Mjg5MGI3OTE0ZTZmMTNlNjQyNGVmOTc2YzM4YzMzMTZmNmNkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLWFtYmllbnQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVzLWFtYmllbnQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyYzg0MzAwOTFhNDZjNDhhZjFkZjZkMGZjMjJjYzU2MzRkYWE5Y2U0M2IzYTQ4OThlM2M1N2EzZWIyNTFmZmM3ZmNkNDIyYmE4OTE3MjNhNWEyY2M5MjY3YzViZGJiMzI5ZjIwZWZiNGE0YmYyYTUzY2NhMmUwMGI2NDhmMzQ1NyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy92YWxpZGF0b3JzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy92YWxpZGF0b3JzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGRmM2MzM2JlYjg5ZWI3MjMwNzMyNTRhMmMzNjQ1ODQwZTI5YmRkYjMxZjU4NjViZjQ4N2Y4NmE0M2UxYWNiMzYxNDA5ZmFlYjU1YjQ0NmI3MGYzMWNkYjcyYjE3MjVkNjA1NzE2MGVhOTk0N2IxNjZjNjVmYWRlYmM2NjQ3YzAiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL2ludGVybmFsIiwKICAgICAgImxhYmVsIjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvaW50ZXJuYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvbmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9uZS9kdXJhYmxlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2R1cmFibGUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b25lL2hlYXAuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaGVhcC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvbmUvdmlydHVhbC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi92aXJ0dWFsLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MC44LjUiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3BhdHRlcm5zIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3BhdHRlcm5zLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3BhdHRlcm5zLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvc2hpbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3N0cmVhbSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9zdHJlYW0tdjAuMy4yNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vc3RyZWFtL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9zdHJlYW0tdjAuMy4yNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgImFueWxvZ2dlciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJhbnlsb2dnZXItdjAuMjEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vYW55bG9nZ2VyLmpzIgogICAgICAgIH0sCiAgICAgICAgImplc3NpZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJqZXNzaWUuanMtdjAuMy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbWFpbi5qcyIKICAgICAgICB9LAogICAgICAgICJqZXNzaWUuanMvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImplc3NpZS5qcy12MC4zLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jYWxsYmFjay5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY2FsbGJhY2suanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1MGZjMDkyMDc3ZWI5ZDE0Y2FmNWZkNDUzMWI4MDQ0NzI3YmRhYTY1NTRjNGQyZmNhOGY3NmY5YjJkYmEyZGQ0YmEzOTA5YzUxNzM5ZjQwZmI5MDI5ODlmZGNhMGI1ZGU2NTJkOTZiZDJmOGI3N2NlNTA1OGE4ZDAyNWI4ZWM4YiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb25maWcuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbmZpZy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjhhMzE4ZTEzNzliZTdhODg3MmRkOGRhOWU3ZmFhMGQ3OTIwNWI1Yzg5OWM1NDEwZmI5MGE0YmM4OTViNzU4NTVjYzcyYTdhOWZkZTM1ZGEwYTA3NWQwNmNhNzdhNWYwMGRjOGI2YmI0MDA5Y2UzZjE5NDNkOWJkY2NjYmJjZDUwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2RlYnVnLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9kZWJ1Zy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImUwMDFlYWNhNGIzYjI0NDc5NmFmNzFhZDQ5OTFlYjA5ZjkwMGRhOGFkNDY4MDRjMjJiMDgxYTg2MTk0ZTQ2MWIxNTEyNDU1ZWYyM2E1ZmFiMTJlMzdmZDYzOWY1MDdmMTkyNTZiOGNlMTA1M2ZkY2Q4NzA5ZTIyYWZmNjNhYWYwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjdhMTJlM2I4NzlmYjM5NDU0MzhkODI3MTNhOTViZDc3MTI5NzQ4ZDcwZjk2MWQxNWVlZGNiMmE0YzQ1OGZjZmJiYjljNzA5ZTUwMWNlNzdlYjMzNTJiNmM4N2IzYmNjNzFiMDY1YWViZWU3MDIxYjg2NDY0MTQ0ZjY4MTE0YmVjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2xpYi1jaGFpblN0b3JhZ2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2xpYi1jaGFpblN0b3JhZ2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI4NjczZTM5YjBlZGU1MjcyOGI5ZjI1NTE1MDIyYmI5ZGNiOTBjZDIzZWMwNTIzYjdiMDkyOTE5M2JhOTFjMTZmMTIzNzFmZGFmYTI2NjAwOTNiMDBlM2M4ZjVmOGIxNGRiMzhlMmUyNTUyNTJmZTEyNzQwYzAzYmMyNTQyZTZmZiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tZXRob2QtdG9vbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ldGhvZC10b29scy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQzNjQzNzlhY2UyNjUyZDkwYmVmNGFjZDA5M2Q5ZTFhYjIzYjUwMTc2ZDllZDcwNWFkYmJmZjhhMDI1ODJhOWNjODE1YTE5OTUzZGU3ZjZiNmZhZmE4MmIzNjQ5NjZjZmU0OGU1MjhhYTBmNTQ0YThmYjhlNTQ3MWQwNDhmMzkxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Rlc3RpbmctdXRpbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3Rlc3RpbmctdXRpbHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjYmZmN2RlNTFlZDJmODc0NDdhODJiMmZhNmU4NjAzNGI2MGE3NjE5YjM0ODA4Zjg4MGIyOWJkMjVjYThiNTY2Njc3Yjc4NDExNWM0YWQzYTMyNTJhM2UwNThmZjM5ZDg4NWQxZGEzYTg0MDA5ZGQwYjEwOWMxOGE2ZmMzYmRiNiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlR3VhcmRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlR3VhcmRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDA0N2IwZDk1ZjU5ZWUzYjZmMTA0MTc4Y2Y3M2ZjYjZjYzdiNTJiYzUzMTIxYTE4ODMxNTVkMTRmY2MzNjdjNTA1YTk2YjgyODNjN2ZiYTE3MDJkYzNmMmNmM2IzZTc4YzY1MjUwMmQ3OWFlM2Y0NjU2ODZjMmM5MjhiZWVkNjMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdXBncmFkZS1hcGkuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3VwZ3JhZGUtYXBpLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMjAxZWIzM2Q3MjRlMTdmMGEwYmI0Zjc3YWYxNzMzMmFlNWU2YjljOGFlZjg4NzJlMmEzZGYxYWJlZWQyMDU4NDgyMjE5MmUxNmQ5YzQ3YmQwOGY3ZmRjMmQxNTUwNzZkYzM1YWMwNDgzMDYwOTE0ZmU2YTA4MDJhYWM0ZWQ0YzIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdXRpbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3V0aWxzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiN2IxMTRiYmUzYTQ5YjM5ZDhmNWQ0NmZiNjA1NWUzOWMxYWQwMTI5OGI3NGRiODRjMzlmZDE5MDBlY2M0OTVlOTU2OGIwYTQ5MDg2ODQ2MDVhYjBmZDlmODJiOTQ3ZTdmMzE0MWE4Njk5NWI0NmU2ZTI5ZmIzNTA4ODAyNDQxYmIiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL25vdGlmaWVyIiwKICAgICAgImxhYmVsIjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2ludGVybmFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbC9zcmMvbGliLWNoYWluU3RvcmFnZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2xpYi1jaGFpblN0b3JhZ2UuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbC9zcmMvdGVzdGluZy11dGlscy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL3Rlc3RpbmctdXRpbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbC9zcmMvdXBncmFkZS1hcGkuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy91cGdyYWRlLWFwaS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZXhwb3J0ZWQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci9zdWJzY3JpYmUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3N1YnNjcmliZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMvdGVzdFN1cHBvcnRzLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3RvcmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N3aW5nLXN0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3dpbmctc3RvcmUtdjAuOS4yLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZ3NldC12YXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zd2luZ3NldC12YXQtdjAuMzIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdmF0LWRhdGEiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMTgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9tYXJzaGFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL21hcnNoYWwtdjAuOC41IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3NoaW0uanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICIuL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImV4cG9ydGVkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYTM3NzZlMzJiMDQyNzc0NTQ5Y2JlYmFiZmI2MjFkNmY4ZWY5MmUwM2FlN2MyZDMxZDMxODk2YWMyZWVjZWM5OGQxZTliNjkyOWE0YjU5NDgzNDY3NjhkYjUyMWZlMjA0YWVlZGNmNWZmZjM1OWZlMmU0Y2EwNWQ2M2Y1YTQ5ZDciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvYXN5bmNJdGVyYWJsZUFkYXB0b3IuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODA5Y2JlZWNiMmJkYTE3ZDVmNWRlNWQ3ODQ2YjAyZTVhMjNkN2Y1NGI5MDNkNDhhMTA0ZWIyNjNmY2YzNTI5OWFjZWE0YTNlYjFkNTdjNzUwYmQzZjRmZmFmOTJiYTkyMDcwYzVmYmE1MjZmYmQ0MTE1YjBhOTlkNWQwZGVhNDgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZTVjY2E0Y2M2NDVjZWUxNGUxMmE0NWY2ODhhMjc1MGYyM2MyYjgxMTQwOWJlN2YzNjlmZjA3ZjE3YjlkYTAyMzY0YThlNzNlMGMxOGFkMzQzMWM3ZTBjMWFlMDlmOTlkYzg0N2RiMzI1YWZiYTA2MmI2NWVhNmVkYTAyMmFlMjUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbm90aWZpZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL25vdGlmaWVyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmY1NjZjNmYyMDA3ZjNmNzkxMzI2MTYxY2JkMjA0MTk2YjQ1OTFlZWYwOTUyOTY0MmFmODRkZjBhM2RiZDdmNzNjMGZkNGViMTY2ZmE0YjdkOTY0NGY3ZWYxZDY3OGY3OWNlOTI3ZWY0NTZjYTcwMTE1N2YyYTE1MjI2NzNjMzIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcHVibGlzaC1raXQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3B1Ymxpc2gta2l0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYWU1MmY4OGVhNTQzYzFhOTIyZDFmNzEzZjk0NzAxNDg3MzRlOTEwODhhZDViMGZlZmE2ZjFiZjJhMzFiODdlNDNiNTMzOTg0NDkwMmFlMmQxZGIyNTQyYjZiNzgwOTZmYjY5NmVmYTQ2NDZkYzBjZjEwM2QyODBkYmM5YjVhZTAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3RvcmVkLW5vdGlmaWVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zdG9yZWQtbm90aWZpZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxNTFjNWVhYmNlMTdiMzdhNzQ4YTFhNTAyMDg2YWVhMGQ1YTQwZjQzYWQ4MTFjMzdiNzMwZDAwNGMwNmMwN2EzMWFjN2Q1ODdjOTk2Yjc3OTViNjYyN2UxMzk0NTZiM2UwZDZhYzJiNTAzNzU0NDA5Mzg2YjM2YzE2OWI1MzRjOSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdG9yZXN1Yi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc3RvcmVzdWIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3YzU0MDliNzUzZGU2N2M4NTk3OTM1ZmZmNDBiYmFmNGI2YjQ3ODA2ZmVkYjdlZmQ1YTQ5YzhmMmJmMDlhOWVmM2ExNWMxZTc2MzdkMWIzZWY1MjhjODlkZDEwMDZkNzNmZWI4Y2QxNTUyZDIxMDE1NzZmOTIyY2RmYTM3YmExMiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdWJzY3JpYmUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N1YnNjcmliZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFmZjg3OTQ2ZDMxNWIzYTc2ZWMwNzFlZjNmZjQ4MTNhYmY4M2Y3MTQ0NTEyNGQ4Mjg4YTMwZmVkZWMzMTY3MGM2NmRjZTBmNTNhNjc5MDVhYzNkNDc5YThiMjA3OTFkOGI2OWFjOTIyMTIyMTJmYzU4NTA4M2I0NWE4ZTAxY2Q2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3N1YnNjcmliZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N1YnNjcmliZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxNjE4ZmM2ZjVlNzFlNWUxYjdmMDY0NTE5ZThjNWU3OTY1MGM2ZGRmNTYyOTI3YTI2YTJlZjc0NWY1NGE1NjFlNzMzN2E1MzY5MDZjNDAxZmYyNmEyMjZkYmUwMDQ2YWIzZDZhN2Y2MmQ2OTM1ODg1NjU0N2IxYzc1ZmMzYTQyZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90b3BpYy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdG9waWMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5N2EwZTA0YTRhZWYzMjI1NmQyMThiODRiMjUyZGY4MjFkMDI1YjkwYmExZTM3NDU1N2U2MzU5YmVjMGUzMjE1MDM4MDM4YWY5ZmRmMDYxMDExMGI3NTg4OWU4MTRmN2ZjMGU1YzA4MmQ1NzhmNDI0MzMxZTI0NjFmZTZmNzc0NSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy1hbWJpZW50LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy1hbWJpZW50LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZmUxN2I5ZGI2NzNjNGExM2YzZTdlZjlhMGNiY2VmMTc5MjdmMTZlMTkzYzQzODA5YzhjNmJiYWY0YjU1ZTZkOTAxNjBkMzIyZmM3NTllOTY1MDQ0NWU5Mzc3MjNiMTRlYWRhMjlkYjYxNzNkMmJkZDVhZmI5YTM1YzM5ZjQ2M2UiCiAgICAgICAgfSwKICAgICAgICAiLi90b29scy90ZXN0U3VwcG9ydHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAidG9vbHMvdGVzdFN1cHBvcnRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODNmZGMwZTUwZDczZTA5ZWRhYjY0Y2Q5OGY2NmM0MzZlNDE0ZmY0YWI1MGZlY2UyYjI2ZDNhY2IwODNjNzNhZTVkNTM5MGM0ODBjN2FjNWI3YmUzMzIzZmQzZTJhYWY3YTFhY2UyMTA0N2I0NGY5ZDhjZGZlZDk1NjdmMzdlMjMiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL3N0b3JlIiwKICAgICAgImxhYmVsIjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2ludGVybmFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zdG9yZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9leG8iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXhvLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXhvL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9leG8tdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXhvL3Rvb2xzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V4by12MC4yLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MC44LjUiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGFzcy1zdHlsZS90b29scy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXR0ZXJucy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBmYXN0LWNoZWNrL2F2YS12MS4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2xpYi9lc20vYXZhLWZhc3QtY2hlY2suanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZmFzdC1jaGVjay9hdmEtdjEuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJleHBvcnRlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFhYTQ2MGJiYTc2NDQ0M2Q1Y2FmYjMzZjUyMjc5M2JiZTI5ZThkMjRmMmM1ZTc3YzdiNmExZWMwNDE1MGFmODAwYzdiZjFjMDVmZTUwNDUwZGZkMjk4Y2NkOTJhNzk4NjAxYjFiNDhhMmZjNDRhOWY5YmRiYjY4ZTA5MGNlYTI0IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjExNTgzZjY0NzZiMjA3YjgyYTE5NDU0NjcxZjQ5NmVkMTI3MGM3ZGFkMTEyMDE4MjEyZmQ5YTFhNTkyMmI1OTFmZTVhNWE0ZTJhZmRlYjNiNTE5N2ZlNDA4MjBkOTgyZjlhOWEwNWY0NDIzMGE1ZTNmNWE5NWRiMDIxNDY5OGEwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2xlZ2FjeS9sZWdhY3lNYXAuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2xlZ2FjeS9sZWdhY3lNYXAuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3YTY0ZmFiOWFkYWE1NTE4MTg4YjgzYjZlNGJlMjEwYmNkOTU3MGI4ODFlN2FhYmQ2NzljYjk3ZGFmNzdhYzhmOTM3MGE0MTQwMTg4MGQ4ZTkyMzA4M2RkZGEzMGI3NWJmYzQ0M2Y2ZDExMDk0NmE1YjcxOTJkNDEwNjc1NzQ0MyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9sZWdhY3kvbGVnYWN5V2Vha01hcC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbGVnYWN5L2xlZ2FjeVdlYWtNYXAuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxY2M5YmI2ZmFmMmMyOGMxMjY0NzlkNDcxZDUwN2U4NmUwYTIwZjc4OWIwY2Y5MzVjMmYzNDRiZGQ3ZTE4MDA3ZjliY2M2MzViN2UxMjMyNDVjY2FhNGU1ZGNkMzlhZDJmMjAyMGZjNjQ0OWIzYmEzZTlkZDBkZDFjYWU5ZmJmMSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdG9yZXMvc2NhbGFyTWFwU3RvcmUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N0b3Jlcy9zY2FsYXJNYXBTdG9yZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImExOGQwMmI0ZWNmZGE5MzExN2NlOWFlM2Y1N2NhYTc3ZWIyYmFmZTNhNzNmZDBmNjgxMmY2ZWFkMmYyNThkZTdkZjUwMzA4MTllNzk4MTc5ZTBjNWNmYmQwMWNiMTA0OTE3MjFmOTUxYTdlMmFlZjAzYjZmYjJhODgzMzhmOTdmIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc3RvcmVzL3NjYWxhclNldFN0b3JlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjM5OWFhZjY2NTU5OGQ0YWZkYzdjYWE5ZTU2NGJlYTgzYWMzODFmMzkwNTcwNzhiM2RhNmExMmZmZWFlMWQ1NTFjZjdjMmNmYTExYzM2OWI3MWM3NjhjYTk3ZmUwNjk4NDZjZTE4YjliNzE4NzZkN2YwNWMwYmE3NTAxN2VhY2QiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjZkNGE5M2NiYmQ3NGExMWFjNTUzNTRmYWRjNGZlNDIxZDdhZDlhNDMzODBiYmMxNGViZWM4YTJkMjk1ZjJiMGQwOWZkNDJmZWMxZjUzOWZmZWNiMTkxZDlhZTk5NGQ3ODRmMWE5MDFhM2YzMjFlMzk5NDRlZWExOGJlNTdmZjVkIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyZTlhMGVkZmQ1MTIxNzM4YzNlNWU0OTdiZDk3ZDYzYmE3ZjRlNjYwYWU0NDc0NjY5ZjY3ZjVlOTU4Y2E0ZjdhMDhkNDExYTE3OTBkODg2NDg5MGU3Y2E1MjU5OGUxNDc2ZTM4ZDczNzAxYjQ4YzkwNmY4MjMyNGVjN2U0ZjgyMiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zdG9yZXMvc3RvcmUtdXRpbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N0b3Jlcy9zdG9yZS11dGlscy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjBmZTE2YTZkODEyOGI1MGEyOGIzOWNkZjk2YTg3ZDFiMjEyYTZiYmYwNmY3NTIwMmY2OGQ1ZTVhOGMwOTJiMGEyZmY1ZmM0Y2Y4NjIzOWQxNDRkZTE0NDQ1ZGZlOWU4ZDU2MDY4ZDljZDZkZTUwYzVkNzdiMzFlNDk5NTdkM2M3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImEwODFkODQ0Njk4NDJhNTY3MjlhNTVlZWI1NDEyYzdmMmZmYzVjYjYyZTM3ZjBkMzM1YzUxMzZlYThkNzliODc5ODI2MDAwZGE0ZWJjMGJjZjdiN2I1MzdhNzc0ODJhMWU1MDQ5ZjA1NTdlNDY0MTA4Y2ZkNzUzMWFhNmE0NDQzIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL3N3aW5nc2V0LXZhdCIsCiAgICAgICJsYWJlbCI6ICJAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wIiwKICAgICAgImxvY2F0aW9uIjogIkBhZ29yaWMvc3dpbmdzZXQtdmF0LXYwLjMyLjMtdTExLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGFnb3JpYy9hc3NlcnQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9hc3NlcnQtdjAuNi4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvYXNzZXJ0LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvaW50ZXJuYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZy1zdG9yZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N3aW5nLXN0b3JlLXYwLjkuMi11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3dpbmdzZXQtbGl2ZXNsb3RzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3dpbmdzZXQtbGl2ZXNsb3RzLXYwLjEwLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N3aW5nc2V0LXZhdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZ3NldC14c25hcC1zdXBlcnZpc29yIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3dpbmdzZXQteHNuYXAtc3VwZXJ2aXNvci12MC4xMC4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZ3NldC14c25hcC1zdXBlcnZpc29yL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N3aW5nc2V0LXhzbmFwLXN1cGVydmlzb3ItdjAuMTAuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdGltZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy94c25hcCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3hzbmFwLXYwLjE0LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3hzbmFwLWxvY2tkb3duIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMveHNuYXAtbG9ja2Rvd24tdjAuMTQuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2Jhc2U2NCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9iYXNlNjQtdjAuMi4zMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vYmFzZTY0L2F0b2IuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYmFzZTY0LXYwLjIuMzEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2F0b2IuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vYmFzZTY0L2J0b2EuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYmFzZTY0LXYwLjIuMzEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2J0b2EuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vYmFzZTY0L2RlY29kZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9iYXNlNjQtdjAuMi4zMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZGVjb2RlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2Jhc2U2NC9lbmNvZGUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYmFzZTY0LXYwLjIuMzEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2VuY29kZS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9iYXNlNjQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Jhc2U2NC12MC4yLjMxIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vYmFzZTY0L3NoaW0uanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYmFzZTY0LXYwLjIuMzEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vYnVuZGxlLXNvdXJjZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9idW5kbGUtc291cmNlLXYyLjUuMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvY2FjaGUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi41LjEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2NhY2hlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi41LjEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2J1bmRsZS1zb3VyY2UtdjIuNS4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vY2FwdHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vY2FwdHAtdjMuMS4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vY2hlY2stYnVuZGxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NoZWNrLWJ1bmRsZS12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9jaGVjay1idW5kbGUvbGl0ZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9jaGVjay1idW5kbGUtdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vbGl0ZS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9jaGVjay1idW5kbGUvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NoZWNrLWJ1bmRsZS12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vY29tcGFydG1lbnQtbWFwcGVyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NvbXBhcnRtZW50LW1hcHBlci12MC44LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2NvbXBhcnRtZW50LW1hcHBlci9hcmNoaXZlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NvbXBhcnRtZW50LW1hcHBlci12MC44LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2FyY2hpdmUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vY29tcGFydG1lbnQtbWFwcGVyL2J1bmRsZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9jb21wYXJ0bWVudC1tYXBwZXItdjAuOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9idW5kbGUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vY29tcGFydG1lbnQtbWFwcGVyL2ltcG9ydC1hcmNoaXZlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NvbXBhcnRtZW50LW1hcHBlci12MC44LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2ltcG9ydC1hcmNoaXZlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2NvbXBhcnRtZW50LW1hcHBlci9pbXBvcnQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vY29tcGFydG1lbnQtbWFwcGVyLXYwLjguNCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW1wb3J0LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2NvbXBhcnRtZW50LW1hcHBlci9ub2RlLXBvd2Vycy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9jb21wYXJ0bWVudC1tYXBwZXItdjAuOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9ub2RlLXBvd2Vycy5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9jb21wYXJ0bWVudC1tYXBwZXIvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2NvbXBhcnRtZW50LW1hcHBlci12MC44LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vaW1wb3J0LWJ1bmRsZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9pbXBvcnQtYnVuZGxlLXYwLjMuNCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2luaXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vaW5pdC12MC41LjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9pbml0L2RlYnVnLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2luaXQtdjAuNS41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZGVidWcuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vaW5pdC9sZWdhY3kuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vaW5pdC12MC41LjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9sZWdhY3kuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vaW5pdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vaW5pdC12MC41LjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vaW5pdC9wcmUtYnVuZGxlLXNvdXJjZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9pbml0LXYwLjUuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3ByZS1idW5kbGUtc291cmNlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2luaXQvcHJlLXJlbW90aW5nLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2luaXQtdjAuNS41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcHJlLXJlbW90aW5nLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2luaXQvcHJlLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2luaXQtdjAuNS41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcHJlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2luaXQvdW5zYWZlLWZhc3QuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vaW5pdC12MC41LjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi91bnNhZmUtZmFzdC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9tYXJzaGFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL21hcnNoYWwtdjAuOC41IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vc2VzLWF2YSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9zZXMtYXZhLXYwLjIuNDAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Nlcy1hdmEvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vc2VzLWF2YS12MC4yLjQwIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9zZXMtYXZhL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9zZXMtYXZhLXYwLjIuNDAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby96aXAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vemlwLXYwLjIuMzEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3ppcC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vemlwLXYwLjIuMzEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby96aXAvcmVhZGVyLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3ppcC12MC4yLjMxIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9yZWFkZXIuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vemlwL3dyaXRlci5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby96aXAtdjAuMi4zMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vd3JpdGVyLmpzIgogICAgICAgIH0sCiAgICAgICAgImFuc2ktc3R5bGVzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImFuc2ktc3R5bGVzLXY2LjIuMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiYW55bG9nZ2VyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImFueWxvZ2dlci12MC4yMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9hbnlsb2dnZXIuanMiCiAgICAgICAgfSwKICAgICAgICAiYXZhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImF2YS12NS4yLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2VudHJ5cG9pbnRzL21haW4ubWpzIgogICAgICAgIH0sCiAgICAgICAgImF2YS9lc2xpbnQtcGx1Z2luLWhlbHBlciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJhdmEtdjUuMi4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9lbnRyeXBvaW50cy9lc2xpbnQtcGx1Z2luLWhlbHBlci5janMiCiAgICAgICAgfSwKICAgICAgICAiYXZhL3BsdWdpbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJhdmEtdjUuMi4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9lbnRyeXBvaW50cy9wbHVnaW4ubWpzIgogICAgICAgIH0sCiAgICAgICAgImltcG9ydC1tZXRhLXJlc29sdmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiaW1wb3J0LW1ldGEtcmVzb2x2ZS12Mi4yLjEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIm1pY3JvdGltZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJtaWNyb3RpbWUtdjMuMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleCIKICAgICAgICB9LAogICAgICAgICJzZW12ZXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VtdmVyLXY2LjMuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc2VtdmVyLmpzIgogICAgICAgIH0sCiAgICAgICAgInRtcCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJ0bXAtdjAuMi4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9saWIvdG1wLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiZXhwb3J0ZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5OGE4NTFiZGJmMmY0ZGQwOWExM2I1MjExMzBlMjk5ZjlkMTk1NWFlMTkyOTE2MjdjZDI4ZGY0ZmI1ZDQ4NzhlY2RmN2NlMmIyMmE1NjcwYjQzOTdiZjQ5MGI4MGQ4OTgyNDgxZGI1Y2ViMjI0YjEwYWZkZWZlNWM0NDUwNjI2NSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy92YXRzL25ldHdvcmsvdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3ZhdHMvbmV0d29yay90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjZhZTU5NmY1NjQ5MDcwMGMwMDdjZWMzMjc5ZTlkMTA0MjU5ODM1NzM2MjU3ZjAzZmE4NzdhM2E1OWNkODdjYTlhZWU5OWU2ZDVhM2RkOTQ0YjJlMWZmMzYzZTY0YWEyZDk2MTI5NGU2M2YyMTQ5ZDAwYTQ4MjVkMWFhMDZlY2JkIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL3RpbWUiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy90aW1lLXYwLjMuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy90aW1lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL25hdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNjVkZmQ0ZWFiNzJhNmM4YTg3ZWI3ODYzZTdkMTZmZGExMDc4ZDA4OGU0OGVkNTUyYmJlN2NhYmM1Y2VkOThjOTY1YjgyMGRmNDc4NzI4NTk3NDVhZjczNDg0ZDFkOGIyMTUzNWM2ZmYxZmM0YjVlNzU0ZTY2MTBkM2QxZjM3NDYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdGltZU1hdGguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3RpbWVNYXRoLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNmIyMWM4Zjk5M2E4OTdmNDc5ZTg4MmUzNTQwODA0Yjk4ZTkxMmQzNjlhODY3Y2M5MDQ3MzY3ODA5MjcxZGMxNzkxMmMxYThkNzY2NGIxYTk4MzYzNzBjNjdlN2JmYTRhNTllZjRhZjAxOTY3ZjUzMDQzZTk0NWRhNTlkOWExZDAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI3MjI0MTczYjZkNTFmZDI5ZTk4ZDNlZWZjY2I5NDA1MjQ3MTM1ODdhYjg4NDI1Mjk4YTkyYTBjNGIxYWY3MDVlYmE0ZmExOTI5YTNjN2YwYjE0ZDhmNmMzYTEzODdlODdmMjYyZWYyOTkzNjg5OTk2MWQzNTg2NDVmMWQ4ZmE4IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMCI6IHsKICAgICAgIm5hbWUiOiAiQGFnb3JpYy92YXQtZGF0YSIsCiAgICAgICJsYWJlbCI6ICJAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAYWdvcmljL2Fzc2VydCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2Fzc2VydC12MC42LjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9hc3NlcnQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3RvcmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZXhvLXV0aWxzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9leG8tdXRpbHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJkZjI5YzBmZDc4MTBjMzdjOWNjZjQwODY3YTAxOTk1ZTU2YmM3MzgyZjQ2OTU2OWI0OGE1OTVlZTY1NzY3ZGU3Yzc0MGFiN2FlOWUzMzBlMDk0YzQzNWFhZGI4Mjg4ZTBhNWYwOGM5NmRmNDZmZGM3ZDM2OWYyMDI1NDlhZTAyMCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJkMDdjNTNjZWEyZGU3MTVlMTk2YzZiZmM3MzMzZWFmZThkYWU3ZjhiNzJmNjc1MzUyMzM5MWVjOGQ1NzY3NjMyNTk2MTA2OTY1MWMzNzNjMzY0ZTI2M2NmZjJiMTUwMjQwZjAzZmQyMGQ2ZDAzOGQ2NzVlOGZhZGY5YmRhZmViNyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy92YXQtZGF0YS1iaW5kaW5ncy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdmF0LWRhdGEtYmluZGluZ3MuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJjNmUxYzhlYThjYWFkZmU5MDQ0M2RkNWYzZTBjNzNlMmZkY2M4OTE0NDgwZDkxMmEzZmUxZWM5YmRmNjBhYmM2NGM2MzRmYWFmOGYzM2UwZGE3OTc3NmVlMTNlOTMzZGQ5ZmE5NGYzNzVjZGRlMGFkNzk5YTVmODBiY2YyM2Q4ZiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCI6IHsKICAgICAgIm5hbWUiOiAiQGFnb3JpYy96b2UiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvYXNzZXJ0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvYXNzZXJ0LXYwLjYuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2Fzc2VydC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2VydHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL2VydHAvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvaW50ZXJuYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZXhwb3J0ZWQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9ub3RpZmllci9zdWJzY3JpYmUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3N1YnNjcmliZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMvdGVzdFN1cHBvcnRzLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvc3RvcmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N3aW5nc2V0LXZhdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zd2luZ3NldC12YXQvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zd2luZ3NldC12YXQtdjAuMzIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vZXhwb3J0ZWQuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy90aW1lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdmF0LWRhdGEiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvem9lU2VydmljZS96b2UuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vYnVuZGxlLXNvdXJjZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9idW5kbGUtc291cmNlLXYyLjUuMSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvY2FjaGUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi41LjEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2NhY2hlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi41LjEiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2J1bmRsZS1zb3VyY2UtdjIuNS4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vY2FwdHAiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vY2FwdHAtdjMuMS4xIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4xOCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ltcG9ydC1idW5kbGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vaW1wb3J0LWJ1bmRsZS12MC4zLjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9tYXJzaGFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL21hcnNoYWwtdjAuOC41IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXR0ZXJucy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiLi9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJleHBvcnRlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjhhYTc4YTE1MzgzNDYyZGZmNDViNjEyZWNiMDc5MThhZTU2ZGE1YWIwMjk0YWQwNjFhMDA0MWU5YWFhMThlYTY1N2Y5OTU0YjZlYTFlOGEzOGEyYWNlZTZmYmY2NDM1NWY4ZjA3OTJhNmZiOGRhODEwYmI3YmIwNTQ0Y2JjOTNmIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NsZWFuUHJvcG9zYWwuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NsZWFuUHJvcG9zYWwuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhZjM5NTY2Y2RhMzNmZjUyYmY5MDViZDAyMTc1NzM0MjIyNjI3YTEzMjk5MzJiODI4MmJjYmYwZmFiNzZmYTgwZTIzNThiMTU2MDJhMGNjYzg5ZGVmMThlNjgzNTI4MDU3MjI2MjhlZmVkODBlYTY4NTEwMGFiNDNkNTMwYzhkNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdEZhY2V0L29mZmVyU2FmZXR5LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdEZhY2V0L29mZmVyU2FmZXR5LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTJhMmZlZTQ2Njc2NzU3NTNhYjg2ZmI4NmVlZTc3N2FjYTI3NGUwMDczMWRlYmYyN2Y2N2Y2Mzc4MDVlZjY1NjE2OWUwNjJkOWJmMTk4MGVkMTJkYzdjODI1YjljYTg2YzYyZThjYzkyZWI0MmQ3NWFjMTkwOTNmOGUyYTUzZTQiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RGYWNldC9yaWdodHNDb25zZXJ2YXRpb24uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0RmFjZXQvcmlnaHRzQ29uc2VydmF0aW9uLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMjZmYTNkMGM2OGRlN2I2YjZmMDU1YmUyY2JlZWY5ZWEzYzQyMWVmMzI5NTJjNGZmYmRhMzE0OGRjNWIxZDU5MTdlYWNkMDk3NjBhZjBkOTdlYjUwOTgwNjMwOTVkMGY3ZjgwOTExY2EwYjYwY2EwMjA5ZjYwMGJlNjAyYTA3NzkiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RGYWNldC90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RGYWNldC90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjA0MjNiNjJkMTk0ZGNkZmNlNjViMzllOGZiZDk1OGZlZmM0MGFjODFkNjNjMzcyMzlmZjhkODEwZTFjMTMyZGQwMzkxOGU2YjI5ZTQ1ZTY3NjJmZDEwYzVkMDZlNmJhZDUxYTkyNmY1M2U0Y2I4NTg5OTQ4YjE2MjFkYWQyMTgxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9hdG9taWNUcmFuc2Zlci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RTdXBwb3J0L2F0b21pY1RyYW5zZmVyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjgzZGUxMmY3NzlhOTI2YjY3MTY1YTUyMWZlYjJlZGE2ZjVhZjg0NGExMzFkNjBkZmI0NjEzNmJiOTU1ODJhY2VkNjdmMDBjNjYzYmY2YTU3ZmY5NzJiZmVkMjE5ZmNhY2M5OTFhMjViNDc0YzU2YTM2OGQwOGJmNDNkOGI2MGYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RTdXBwb3J0L2JvbmRpbmdDdXJ2ZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0U3VwcG9ydC9ib25kaW5nQ3VydmVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZWZlYTVkN2YyMzk2MWNkZjNlNWIxOWIxYzk0OTY0NzQ1N2IxOGM3MmIyNzM4NGI0YzMzYjU0MjNjMDE5NWNhOGQ5ZDNiMDE0ZTBkOGI5MjI2MzgyOTgzOGVlN2NiZWMzNTgwZTg4YjMxNWZmNzQ0N2EwYWZkYTJjMjMyNmY1NTYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RTdXBwb3J0L2R1cmFiaWxpdHkuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMWI4ODlhM2JlZTBmNjM1YjMzM2ViMDU5MmQwOGYwOGI5NjdhYzFiZjgwMzBiN2QwYzFiMzY5MzhhNDA4ZDU1MzNhYWFhMTcxZjk1Y2E5ZGQwYTY3MjI2Nzg0NzQ2MjViNTkwYmMyMWJkMmI0NmFhOTYzZjQ1NTM4ZjkyNGZlNjkiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RTdXBwb3J0L2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdFN1cHBvcnQvaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2MzAzZmFmYjgwMjAzNzI4MmY1YjdlZDVjMjk2YzUzZWI2YTg1MzA5YTE5MTQyYjZhMDVhYjZkNWQyZDJlMDIxMWE0MDE1M2E3ODM4N2E5MDQ5ODY0OWIxYjZhZTBlYjQzODBkZmMzYjAwZjUzNTMwNzA0NDQzMTE3ZTcxMTg2OCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdFN1cHBvcnQvcHJpY2VBdXRob3JpdHkuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0U3VwcG9ydC9wcmljZUF1dGhvcml0eS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjE3MTA0NDQwNzI2YzZhYjcxODRiMDViYTc4ZTg2Y2JlZjdhYTEzMTA5OTMyMGYwMDZhMmEyOTE1YWI0NTNhY2QyMTM3Y2M3MDNmZDM0ZDhmMTE0ODEzYjBiYjRmZDBhNTM3YjAzZjc5NDdhODJiOTdlYWU5NTM3YjUyMDFjZGRlIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9wcmljZVF1b3RlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdFN1cHBvcnQvcHJpY2VRdW90ZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImMxOGI2Mjc5MTJmNjdlMWViY2M3Y2Y5MDY2NzA0MjEwOTY0NGFjM2JmMDhlM2JjZDE2NDAwM2E0Y2Q3ZjJiOGRkYzE1ZTRmY2U2NTcyYmNiMGU5YWEyZDk4NDk0MjUxMmNkNDQ4YWJjZGM5NDZiNGEzYWU0M2U1ZDBjYTM2NTVjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9yYXRpby5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RTdXBwb3J0L3JhdGlvLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMzUxMjBmNDU4NGQwOWJlYTg2MmQwYTI1NGY2OTE3ZGJmMWYwOTljOWRiYjBkOWQ0N2ExY2U5NDIyNDAwYmNjZDBjNmY0YjkyNTQ2M2E1MGU0YWYwYWNmMjU0OTMwMWNlNmFiNzAxN2RjMzAxNjlmNmMzN2ViZWFjNzhiYmIyM2MiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RTdXBwb3J0L3JlY29yZGVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdFN1cHBvcnQvcmVjb3JkZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlMTQxNGVkMmE1OGMwOTQ2ODE4MzhjNTUzYmJmYzQ1Mjg3ODdlMDUxNWZhMDNiY2VjZjNmNzJkNzMzZDc2YzY4YjE0MjU5ZjE4ZTZmNzQ2NzM0ZTcxNjAyYjNhYzhlOWZiZTZjMDY3NDBiMjhmYzBiODNmNmFlZWY0MjBlNTc5NiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdFN1cHBvcnQvc2FmZU1hdGguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0U3VwcG9ydC9zYWZlTWF0aC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImNhMjYyNTY4ZWViNTdiNGY2NTA5NWRiYTYzNDMxMmQyZWQ5YmYzMzM2NWI3MGZhZDQ0YmY1ODYzZGQwNWFmYjY1ZmFkYWNlY2M4MTEwNjU2MTNiNmFmNTllN2RlNTEyOTZiMzQ3ZDJlY2I0OWJiYTA3MGEyNzQyMGE0NTllOWYwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9zdGF0ZU1hY2hpbmUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0U3VwcG9ydC9zdGF0ZU1hY2hpbmUuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5Mjk4YmIyY2MyZjAwNDkzNzIxMzViYjc4MTNlYWIxNGEyN2I3M2QyYzYxZDM4Y2I0MmFiMjU2ZDlmZmVhNDZhZGQyYjc4MzFhMjFlYjQxOGE3ZjlkNDM3OTYwZDFjZDE2NjhjYmM5MTMzZTVhYTQ5YTZlMmQxMDRkZGExNjZiNyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdFN1cHBvcnQvc3RhdGlzdGljcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RTdXBwb3J0L3N0YXRpc3RpY3MuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0ZTY4NDUxNGZlMzllNjMwZDc4ZWY0OTkwZWIwMmJlZGEyODJmNmE1Yjc2ZThiNDQyODBmZWIxNzE3MGFlNGRjZDQ4YzFlMGVmZGZkMDJhNTRlYzI1MWRkMjViOTg1MDhkNWVmMTVkYWM0MDA5OGYzMDYyOWMwZDMyNzRlYjVhZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdFN1cHBvcnQvdG9waWNzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdFN1cHBvcnQvdG9waWNzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiY2E2NjdmMjg3ZjIzNmVlZWQyZDRmOTUxM2I4YTI4ZWU5M2UxMTBiNTRhNmJmYjk0YWM0MzE0NjhkYTg2NjAxZTgxMmQ4NjQ5Nzg2ODFhNDNjNzdlN2VjNzFlNDBjYTRiNWYzNWIxOWIzNjI5NjliZmI3NzJkZTRjODE2NGMwZmYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29udHJhY3RTdXBwb3J0L3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdFN1cHBvcnQvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxNzFiYjRkNGI3ZGQ2ZWY1NzhlNjNmYjgyMDlkZjczZjJkNjcyNDdiNzM2NDhhMDcwZTUxNTNmMzIxNmZiZmQxNWFkMTRkMmU2NDhmMjA2Yzg4MTkyODdiN2Q1Y2ZlNTM1NzIyZjJkMTBkZTE2NmJkOTI1ZjRkYjJmMWJiOTlmNCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdFN1cHBvcnQvem9lSGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RTdXBwb3J0L3pvZUhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJkMjE1OGJlOGZiMDAyYWMwMzM4NjQ1YWEzNzdlNWFmZTRkNDU1MDUyNTNiOWE3NzY4ZWFmZWQ4NWIwMTliM2I1MTM5NTZkYjYxNTJiMGE2ZTVlY2ZkNjRlZDcyNWY5NDlhMTE0OWJkYjI1ZTA2YmNjZDJmMWRjMGM4MDcxZGE2NCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdHMvY2FsbFNwcmVhZC90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RzL2NhbGxTcHJlYWQvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3ZTkxMmUzZjZlZmU4NTU2MWFlYmVmNGQ1NmVkMDcyYWI5N2ZhYjkyNTQ5ODRkMTA2YjNhZTQyOTI3ZDRmM2ZiNDJmMzc4ZmViZmI4Yzk2MjcxNTUzYWMwNWVlN2I0Njc5ZGRhYmI3OWIxMGY5NDA0ODBlOWZiMGIxNjdkMDBhMiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb250cmFjdHMvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvbnRyYWN0cy9leHBvcnRlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImJkNDgzMWFjZGJkYzAwNzQyOGU0YjE4YTViM2ExZmM3YjgyYjg1MTRiOGY5OTdiNjQwZDU1Mzg0NDJhZDc3MjM1YzVmNzk2OGQxZTJhMGE2NGY1ZDdmMmZkMDRiNzQ4Njc1ZjRiYjQ2ZTNmNzhkYzdkZTAyMmU5YmE1ODgyNTljIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0cy9sb2FuL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb250cmFjdHMvbG9hbi90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjI5YmIzM2JmYjI4YjUwNTk0NjU2OTY4MjBjNzA0YjU1MDM5MjUzMTNiYmVlNTY4ZDI5NzdkZWM1NTZkZjZkODJhNWM5OWIzMzE1MTVhYTEyNTEwMGE4OTc3NjE3YmNjZWNmZGE3NTAzNjY3YWI2ZGJkYWExM2FmYjc0MjkxMTRhIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvbnRyYWN0cy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29udHJhY3RzL3R5cGVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOGU0NmIzZDEzODY2ZTcxN2JmMjI1OGI1NTQ0MjA4OWVjNzdlODM1MGIwODI0ZmRmMjMxZGEwMmI0ODViMTBhZTg2OGRiYzM4MThhOTFkZGM1YmUxNWU5NDVlYTBmMjU2MmEyNjFiNWFjZjNkZmE2NzkyMTljYzM2YTFkNTA4ZGMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW50ZXJuYWwtdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2ludGVybmFsLXR5cGVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiN2UxZGMxMzM1YTkyYTcxMmRjOGEyZjRmOTcwYTU1OTEyOGQ4MmRhZTA1NmJmOTg0YTJiMzE1Y2U4YmI0ZjY1MGU4MDYwY2VjOGNiOWQzYWIzYWVjYzBjYTNhN2NjYWIxMWZhYmQxZjAyNjVmMzY2ODlmOWNkNDVmNzdlNjA2NjAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWFrZUhhbmRsZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFrZUhhbmRsZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQ0ZGUzOTUzMzA0MDExOTAxZDkwNTEzMjAwYjk4NjBmZDVmNTJhOWM2OWQxZjQyMTA4NTM1ZTgwNWQxNzFhMDE2MTIxZmZjYmE0ODk5OTEyZDk5YmU4ZmQyMjdiMmUwMmRmY2FiMTRmZmRjYTI4YjJkYmMzODU5YjI3MGFkYTVlIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL29iakFycmF5Q29udmVyc2lvbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvb2JqQXJyYXlDb252ZXJzaW9uLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZGNmOTg0YzlhYWJhNGI2ZWM2MDRhNzZjNDAxZjBkODFiM2U1NWUxYjRjMTY5MjQxOWZkOWI5ZTA4NzQzNmY2ZDZlN2I5YjM4YTg4ZGI2MzlmYmU3ZTFhMWJmNTYyNjYzNzlkZWU0NzE1MWVmMzBlYjZjYWIwNGM5ZjU5OTZlNTQiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImQ5Y2JmNjRmMWYwOWVlZTgyMjU2NjBiNzgzMzc2N2U4NzU5NmRkYjIxMWRkMTdiOWZlOTJkN2FhMGY3MGEzMmZlNDRjYjg5YzcyYTNmYzU5MGEzMWFhYjRiNzI2ZTZiNGJhNjU2YzFiN2QyMzVmNDJmY2U5MDkwMDcyODBhYTU3IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjliYzcyOTZkZGFhNGY3Zjc0OWViYWMzYTA2NmZjMTU1NDQ5YWYwNzBkMGYyNGE2YTE4MTZiZTEzYWQzMjQxMzFiZDI5ZTExNzM1ZmY5M2M5YmU1MWU5Mzc5MDY0YmYyZWI1YWY3MWE0YWVjY2JkZTFmZDQ1NjRlNGVhZTcwMjkzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3pvZVNlcnZpY2UvdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3pvZVNlcnZpY2UvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxNzg5MGQ3YzlmN2QwOWQyNDIzMjQ3ZDJlOTNlZjZmYWM2ODliZWU4MDE2NGQzMTYzMmI5MmIzYTJhOWNmODA3MThmZTg4MmUzNDNkOGVkZWE4YzdiMDQwZjhkYmUyNWM1OWNjMjE5ODI5NjllMGZlNmNlN2MwMDY5ODMzNTY5ZSIKICAgICAgICB9LAogICAgICAgICIuL3Rvb2xzL3R5cGVzLWFtYmllbnQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAidG9vbHMvdHlwZXMtYW1iaWVudC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImQ4NDcxOWFhMWNhNTBlZWY0ZTJhN2E1OWZmZjM4NzhkZDQ1NjE5NTk4OTk0ZTlkZjhiZDA3NTYxZGQyNTk4NzdiYmM3YTQwZTQ2ODY4MzU2YzQxYmI1NzA5MGRiYWJhZmQ0MjMzMDdiMjMyMTgwMjlkNTk4MzJlY2FkNzk0N2EwIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIjogewogICAgICAibmFtZSI6ICJAYWdvcmljL3pvbmUiLAogICAgICAibGFiZWwiOiAiQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMCIsCiAgICAgICJsb2NhdGlvbiI6ICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBhZ29yaWMvc3RvcmUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdC1kYXRhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b25lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvbmUvZHVyYWJsZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9kdXJhYmxlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9uZS9oZWFwLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2hlYXAuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b25lL3ZpcnR1YWwuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdmlydHVhbC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMTgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9oZWFwLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9oZWFwLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGJlMDAxYmQ2Y2QyNjM1ZTZhZmZlNTdjNGI5NzMwNTg1MjhlMzNkNWY5YzBjZmIyNWFiNDM4NDM0Njg2MDQ0NzkzNzdmMzZmMmRhNmQxNjQ3OWNiMTdkM2YxYzI3ODkwY2RlYzE1MzRmNWFlYTk3MjcyZTljMmNhOTcxYWQyMDUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTZmY2EwNmVhZjlhNDI2NDk0OGFjNDIzYmEwZmFmOThhY2JmNTQ1NDAyMjczNzk2MzQ4ZGQ0N2UzYzAyZGM0MDU3NjVlYmEwNzUxOTI3NWY4OTQ2NTkxMTNiZmExOGUwMzliMDE0M2U3ZjQ1YmUzOTIyNDEyMTgyZThmMzk4NWIiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL2Vudi1vcHRpb25zLXYwLjEuNCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZW52LW9wdGlvbnMiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjAuMS40IiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL2Vudi1vcHRpb25zLXYwLjEuNCIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9lbnYtb3B0aW9ucyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lbnYtb3B0aW9ucy12MC4xLjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2Vudi1vcHRpb25zL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9lbnYtb3B0aW9ucy12MC4xLjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNmUxMDZlZTZhZjg5Mzk0ZDBkZGIzZTJhZmIzMjY3ZDMxNzI2NzdhMGM3Y2E5NjlkNWExMjNmZjA5MDQyYjI3MTc1MWMzYzg1OTAyNDIwZDVlOGIxMDhiNzVmZDc3YmQ2MzU1NTBiNjUzODA1Y2E4NzhkODgwYzUwNWJmZWZmMDAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW52LW9wdGlvbnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2Vudi1vcHRpb25zLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZjAxYjMxN2U5M2I3Zjc0YTcxMzcyNjcwZWNiNmVhYzU3NjhjYTZlZjE4ZmQxNDhlOWZhMjk2MmEzMzY5Zjg2NjBkNmIyYzNhMWRmNGZjMzAxN2RhMmFmODQ3NDIxZTUzMjY1ZmQzMGFlNzc2ZDA1MmMwNzg3MDNjNmM3NzAzZGQiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTQuOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE0LjgiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9FLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9FLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMGIyOTJiMmMzYjRhMTZkMWY2YjhhMmY2Y2Y1ZTA2MDkxYzRkYjdmZGYwZjc0MTc1ZTlkYzIwMGI0MmU0ZWExMGZhY2RlZjRjOTNjMTNmNWQxNWEyYTkwZDc3OTZlNjFmZjk2N2FjODU4NmVlZTc2YTE0OWIyZDg3YjhiZDVhZjYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbm8tc2hpbS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbm8tc2hpbS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI1NGI5MWVlOWEwZjExNGQ5NzUyZmViOTI2MzdiMjliZjhiMWQ2Y2JiMmZlYWIwMTYzMjVmMTZlN2I5NWMwNmUwYmU3NWVmNjQyMzMzZDA4MTczNjE0YTZhMDJkZWUxMTZhMDc5MDBkNWU0ZTU5MTI3NjVjY2JlYmMwZWE5NmMwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RyYWNrLXR1cm5zLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90cmFjay10dXJucy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImIxMzA5M2UzNzlkZjdiY2Y2ODhlODM4NDYyMDI3ZjE3NTY5OTdlYmQ0NGM1MzhkYTc1NzBkMWVhOGQ2ZWI2ZjE2ZmY3NDU5NWU0YzIzNmY4OTY2ZGY4NGFkNzQwYWFhYjA0MWViY2YzNGVlZDNiNmIxNDgyODE3ZGNlNzEzMGJhIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL2V2ZW50dWFsLXNlbmQiLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvRS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvRS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImM1MzY4NDgyNmNiNTY2MDlmNjJiN2Q2YjRkZTMzZGFkMjJjMjBhZGFhMmViMzg4MDBjMzY0Y2VjNTA5NzM4M2U5NzNmMDU4YjMzNWQ0ZTRjNDgwMzBlNDI4ZjdiOThkZGEyYmYyMjg4ZGJhMzAwOGFjYjU3YjRhZTcyMjA2NGNiIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL25vLXNoaW0uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL25vLXNoaW0uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2ZTI4MjAyY2ViMjNlMDY0ZDVkY2NiZTAyMWFlN2QxYTVmZGNjYzAyMzQyNzBkYzU2MjRmZDkxZGYyMzZmOTA3ZGNjNWQyNTQzMjZkMWNkMzJhYzUxMTc2MDJkMmZhMjM5ZTZmMzIwMzMyODJmZDY3ZTI0ZjFhN2E0ZGU5NTYzMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90cmFjay10dXJucy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHJhY2stdHVybnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJkNzlkM2EyOWViN2JmM2JhOGEzOWYyZjhhZWY4NTBhOGE5Y2ZlMTBmOTU3MjNkMjcxZDQ0ZTIxMjJhMmU4ZDJkZTQ5NDI2YzFjNGQ0OGNhNTljOGJhNmZmMGRmOTI5OTU1MjhkMzQ5ZWVmZTFkMGQ1MDNiZGZhODFmODRmZWU2ZSIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy42IjogewogICAgICAibmFtZSI6ICJAZW5kby9ldmVudHVhbC1zZW5kIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuNiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjYiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZW52LW9wdGlvbnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjAuMS40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9lbnYtb3B0aW9ucy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZW52LW9wdGlvbnMtdjAuMS40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL0UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL0UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5NzZkYTc4ZDI1NGZmZTlhMGEyZWYyMzJkZjM5ZDc3MTZlYWIwYTIzYzM3NWEwNWU5ZTcwOTAzYzMwZTcxY2JhNGQ5YWI0ZTNiYzk2MDM3N2ZmNjJlNjg2NmYwNWYyMWY0OTM0MWMwNjBkNzI4Mzc2NzYzZTRkMTJkNjEyYjA4OSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9leHBvcnRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9leHBvcnRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOThhODUxYmRiZjJmNGRkMDlhMTNiNTIxMTMwZTI5OWY5ZDE5NTVhZTE5MjkxNjI3Y2QyOGRmNGZiNWQ0ODc4ZWNkZjdjZTJiMjJhNTY3MGI0Mzk3YmY0OTBiODBkODk4MjQ4MWRiNWNlYjIyNGIxMGFmZGVmZTVjNDQ1MDYyNjUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbm8tc2hpbS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbm8tc2hpbS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjVjOGYyODc4ZTVhYTJkOTgyYzQ3MzJjNjM3OTZlYWE3MzY5MWVkODU2Y2VkZmY2ODNlYmNkYTA5MmMyMTE1NjI3ZTE5YzllN2ZhOWY2YTc1YWM5YTg5YTM2MjE2YzQ5NDJhNjBiOTJmNTgyY2Q0N2M2NmRmNjNhYWYxNTE3YzE1IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RyYWNrLXR1cm5zLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90cmFjay10dXJucy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjllMzk3NjNjOTc1MjY5NzViNWQxYmNlYjM5ODBmZjAyOGRlYWRjMWJiMGIwYWMwNjAxNTU1NWYyNzVmMGY2Y2E0ZTFiZGVlOWFjY2EzZjM3NjhiMTVlYjM5ZTAxMDlkNzljMTVjOGQ1NjQyMDA0YjNiMmI3MzllNTAyMzEyZmFhIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9leG8tdjAuMi4yIjogewogICAgICAibmFtZSI6ICJAZW5kby9leG8iLAogICAgICAibGFiZWwiOiAiQGVuZG8vZXhvLXYwLjIuMiIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9leG8tdjAuMi4yIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V4byI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9leG8tdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9leG8vcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V4by12MC4yLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9leG8vdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXhvLXYwLjIuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGF0dGVybnMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXR0ZXJucy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImNiMTljMGQ3NGNjNTA4ODI3YjBjOThjMzQ1YmQ1Nzc1NTBlNWVhMjEwYTk1MTUzNzA4MmQzOTA2ZGJkYjdiMGYyODNhYzc2Yjc1MTQ4ZjI0ZGM4ZjI3MjNiMmI1NDg3Njg4ODBiZWJjYmNjYmY4MjBkMDY1YWMwMTVlMzEyZmMxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2V4by1tYWtlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2V4by1tYWtlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhYjZkZjE3Y2VjNzA2MjM3Yjg2ZWZiZTBmM2EzYjllYzhmZTUxNmM1ZTA1MTYwN2I4MTlhZWNiMmU2MGQzMjc1MzAzMzVjZTkxZmFiNzc4ZmYxZjUxNDVmMGRjNzgzYzhlNjI3N2JlNjZlZTg3YjZlNmI1MDA0YWU1ZjhmY2ZiNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9leG8tdG9vbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2V4by10b29scy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjg2NmJkYzNlYjM1ZTBiZDE5ODcyM2Q0YTU2OTAyNDY4MjZmNGYwZDY4YzBkN2M1NDhmNDkzOGFkM2M5NWI0Y2JmOGI5MTgzMjZhODRiYjAwYjRiMDQ4M2Q3ODU0NmY2NzYwZmIzNGI2ZTQ3NWVkMmVlYzgwOTY4NTMyYjZkZjNiIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9mYXItdjAuMi4xOCI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZmFyIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMTgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjY4NzQ5N2UzYmY2OGM1Mjc5ZjM2ZDQwZTI4ZTRhNzQzOTcxNTg0MDMxZjY0MGVlNDk3MmQ5MjU1YTI5ZTkxYmFkMThmZDQ2OTljNGJkY2IzYjM2ODJjMTk2NWQ3NmMyOTlkNDdmYjU4MmQyNjI4YmZmYzRmY2I3YzBmM2Q2ZjFjIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9mYXItdjAuMi4yMiI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vZmFyIiwKICAgICAgImxhYmVsIjogIkBlbmRvL2Zhci12MC4yLjIyIiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL2Zhci12MC4yLjIyIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy42IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9mYXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZmFyLXYwLjIuMjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjY4NzQ5N2UzYmY2OGM1Mjc5ZjM2ZDQwZTI4ZTRhNzQzOTcxNTg0MDMxZjY0MGVlNDk3MmQ5MjU1YTI5ZTkxYmFkMThmZDQ2OTljNGJkY2IzYjM2ODJjMTk2NWQ3NmMyOTlkNDdmYjU4MmQyNjI4YmZmYzRmY2I3YzBmM2Q2ZjFjIgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9tYXJzaGFsLXYwLjguNSI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vbWFyc2hhbCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbWFyc2hhbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9tYXJzaGFsLXYwLjguNSIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vbmF0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGFzcy1zdHlsZS90b29scy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjJlYzJmNzZiZmVlMzdmNDRhOGQzYWYyN2IyNzg2NmE3ZDMzZjc4NjllYTg3Mjg1ZTRmY2ZmMWMzZDA3NjRjMWJjM2E1ZGMxNzUzMWM3MWQzM2UxZWM2NGI3NTk2MGNiYWY3ZmVlZTA0YjdkNWNmMzA1YmI4MDRkMzA1YTc4MGE2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2RlZXBseUZ1bGZpbGxlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZGVlcGx5RnVsZmlsbGVkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTM1YTY5NjJkNzJkOWQyNDA1MWI5NzQ5OTMyMzI3MTllZjZkOTY0OGJhZWYzODMyMmE2MzU4NzAxMThkNjgyYTNjOTY2MmIxMDIwNTc1ZTM4YWJhZDA2Y2Q1NDNjYzIxZmYxMmRlZTUxZmFhMjQ3YTYzNDk2YTdkNzcyOGMyNzIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlUGFzc2FibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2VuY29kZVBhc3NhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGEwMmVjMWIxYjEzZWM4ZTFlN2JkNzVmZjA3YTAzZGVlZTUxODhmY2Q2MjAxZTRiNWEwY2M0ZmE0YjYxNTUzZWQwZTJiODI0YjkxMzJjNWVkOWZkNzA5MDBiYWIxNmZkM2MxNGE0NzFiMDAzYzI1Y2UyNjFhZjQyMDMzMWFlNDkiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lbmNvZGVUb0NhcERhdGEuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5YThkZDJhMmZmOGFiMDVkODEyNTg5N2YxNzJhYTBhOWZhNDI5NmRhZjgyOWY0NjgyNjdiNTkzZDQ1YTg2YzBlNDc4ODI0ZGQwYWJmNTVkZjE4ZDgwZjE3OTAzMjY0ODZhNTNjNTAwY2ZkNzU5N2ZkN2JiM2ZmYzU4MGY1NDdmOSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZW5jb2RlVG9TbWFsbGNhcHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3YjIzM2E1YzU2MjIyMTI0YWFiNWRlNDllMjFmNzZkNjdiNmUzY2YxZGUwZjI0NWYyMWI4NmJmYjQzNmMwMjBmNTBjMGNjNTkwYTk2YTBkYmFhOTNlNmQzOTQzOTU1ODFmZTc2OTE0OTAwMzQ3NTQ3NTg4MmUyMjNhNjcwMzQ1YyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLWp1c3Rpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1qdXN0aW4uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJiYjgyZDU5NWQyYWZkNWQ5YzAyYzVjYmUwMmU3ZjdjOTYwODdjNjBjZDA5MDkxYjk5NzgyYmQ4YTdjMTI2YjIzOTI2MmU5OGQwZjQ2MGE0ODk4MWI1Y2YzNTExYjdiNzhjZDBmMDAxYjJmYTBlNWU5MzgxNDM1ZGExNmRiMTY3YyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFyc2hhbC1zdHJpbmdpZnkuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJmZDYzMmQ2NGY3NjM5ZGIyNzkwMDc2ZjdmNTkzMWI0NWNjZTJkODQzODdjZGEyYzc4YzkxYTQyMjlmODE2MzQ0MTc2YmI0NzAwOGUxOTc3MDRmNmI3ZGFhZmQyNzQzZGViNDVhZDA2YzViYzZiODhjMDM4ZGYwZTZkZmJhMjdmMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tYXJzaGFsLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYXJzaGFsLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDI2MTQ3MDcxNGQ2NWQzM2NlNmM4ZGZkOWRiNGNjYmZjYTRiYzg4YjMxOTk5YmYwMTk3Yjk1YmQwMjczZmNhZWMzOWM0ZTg2NjY5Zjk3NzBiYTcxMmIwYjViNmNkMjMyM2Q1YmM0YmEyZjUwYzdiZTFkNTczN2ZlOWE0N2Y2MDMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmFua09yZGVyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yYW5rT3JkZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1ZjA4NmE2MGNkMGYzOWQ3MjYwYjg3ZjliYTIwMDA3MmIxOWZhY2M3NGJjYzBhNjI3NmNkMGIxMGZhMzlkOTFjOWZlN2UzNzk4Yzc4MDA4YTBmYTFiMjdjZWM0NTYyM2U1YTJhYWU4MWM1NDU2MDMwZGQxNDc1Yjg5NTFmMTJiNCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5OGE4NTFiZGJmMmY0ZGQwOWExM2I1MjExMzBlMjk5ZjlkMTk1NWFlMTkyOTE2MjdjZDI4ZGY0ZmI1ZDQ4NzhlY2RmN2NlMmIyMmE1NjcwYjQzOTdiZjQ5MGI4MGQ4OTgyNDgxZGI1Y2ViMjI0YjEwYWZkZWZlNWM0NDUwNjI2NSIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vbmF0LXY0LjEuMjciOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL25hdCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9uYXQtdjQuMS4yNyIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9uYXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbmF0LXY0LjEuMjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9uYXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL25hdC12NC4xLjI3IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2luZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODI1MDgyZjRjOGNhNmFhN2VjZmFiOTBhYzExNjVhZmQ1OGM3MDBjMDVmYjQ2YzM4MGE4ZWE0MjdkMGNiN2MwMmFkYjEzMzYzNTBiNzM0NGY2OTI1NjFjMmE5OGZhMjdmZGRkMTk0YzNhNjEzNTVmZmQ4MmI0ZjczN2ViYTk0OTkiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIjogewogICAgICAibmFtZSI6ICJAZW5kby9wYXNzLXN0eWxlIiwKICAgICAgImxhYmVsIjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcGFzcy1zdHlsZS90b29scy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuMyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBmYXN0LWNoZWNrL2F2YS12MS4xLjMiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2xpYi9lc20vYXZhLWZhc3QtY2hlY2suanMiCiAgICAgICAgfSwKICAgICAgICAiQGZhc3QtY2hlY2svYXZhL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZmFzdC1jaGVjay9hdmEtdjEuMS4zIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc2YjczMjAzYjNhYzFlNzYwMTA4NzJmMTY2NDU3ZDU1NTMyOGY0NTljZjUwYTU3MmZmYTAxMDQxZWMwOTMzYTdmNTc5MTcwYWNlMGI2ZTc2YWY3OTJlMTJiYmJlMWFmNTViZDZkMmM2OGM0ZWYxMWI0MGRkYTk0ZWZkYzYxYjczIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvcHlBcnJheS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29weUFycmF5LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMzM4YmI2MGY3ODU0YjRhN2I2MWExZmQzM2IyNGE3ZTlkMDU4ZGE3OTBlNmYwYTI5NjQ0M2Y3MDlmMjA2ZmVmNzMxNTBiN2UyZGVkNzk5YzYzOWI1ODg0OGRjNDVhNGYzZmNhYTk5YTBmMWU3MjVhMmFkOWE0M2RjZTY5MDgzOTEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29weVJlY29yZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvY29weVJlY29yZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU0YjgxMjVkMDlkNzNiMDI1YzgzOWY2MjUxZGNjMDZhNTNkY2QyNWFlOTE4Yzk3M2UzNjAxNjExNjMwOGE0OGMxODMwYWQzMzg3M2Q5YjhlZWUwNmFkNTBiODI5ZDQ1MDM2ZThjNDg2MDM2MzllMmE1NDgyZWUyYmE5Y2RkMzBmIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2Vycm9yLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9lcnJvci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc0ZTYyNzI3Y2NhOGNmM2MyYjVhM2E3OGE1YjI3OWYzNjc5M2EzOGQzNjcxODE1MmFjYTViMWUxODY2NjViMzA2MzhkZDEyNGExYmI4Y2M5NDRjMTExYTcxMjY4NmI0NGQwZjdjYWFiNGYyZjVmMDI3M2EwNGY0Mjc2ZjI3MzhjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2l0ZXItaGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvaXRlci1oZWxwZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNDc2ZWJmMzRlNzNkMDUwMzkzNzQ3ZTllYWYzNWQ5NzA3YTE5MDVkNGNjMWM1MTBhNGYxOWUxNWZjMzUwZWNiMWRiNDliMmY1MWY4NGZhYWVjYjliNjdhZjU0OGFjYzJlNTEyZmFiMmZhMTYxMGIzNjhkZDFhMTc5ZWEwZjMzNGUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWFrZS1mYXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2UtZmFyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDhlZWRhMzZkZWRjYWJjZWZmYTlmMjZlNjM1MjVlNjg4NzFhMzJjYmVkY2Q3YzFhZDZiNmQ1OTQzNjZiMjcyNDhjMWQ0MzZlMWY5ZGNmM2IwOTcxMDdlMzgwMWQyMjk4MTQ0NWM4YzMzMmNiZDA1MzAwNzU5OWRlNTMyYmFmMTIiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWFrZVRhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvbWFrZVRhZ2dlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjJkMGU0YmM2ZTQ3ZTNmNjQ3OTQ2ZTFhNGI5YTBjZWE2NDdjMzUzMDdlOTU1M2U1OGYzYzEzMjE2MTgzNmI5ZDNiOGM3ZTcwMWIzZTY4NjA3MWI2MDFmNGIwYjgwMjMzMjZmOWJhNDg3YWVjODAyNTJjOTVjYWFkOGZkOTk2MTQwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXNzU3R5bGUtaGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQ5NWFlZDg3NGI0OTU3NjQ4ZjBlNTVjOGM3NTkyZGM3ZTFiNjUzMDc5ZTI1ODY1OTViZGNmODkzN2Y3MjJjMmJlODY3YWRjYTE2M2QwNDA0MzI1MTA2NjEzMGUwMmRkYzhjYjc2NjNjZjhkODc2NGIxMGJmNmEyNmE5NjI0ZjEzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Bhc3NTdHlsZU9mLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXNzU3R5bGVPZi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjdjMGM3OGIwNmZmZjJiMTc1ZDg0M2E5YjEzZmY4NzM5NzBjNmMyZWViMmUwYTJhMjA3ZTlhY2IyNWE5YjBhNjIxZDRlYzhkMjFlMGNjYTg4M2QyMDExYmZlZTA3ZjdkYjcyOGUyZWMwYjQ1YjI0ZDI1OGVjYmZlMGRlZTAwMzUyIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3JlbW90YWJsZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmVtb3RhYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNTU4NDJmZTgyNTFkNGUwOTZmMTNjYmU1ZWJmN2UwYjMwYzZiNTMwYTAwYjM0ZmEwN2JlODA0ZDVkN2I0MDBhMDJiMjZmZjQyNjhiMTRkZDg3N2U5NmUxYWUzM2FkMDhlZjJhYjg4MTI5NjMyZDYyODc1OTUyZWFmZDAxNzIxMWMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc2FmZS1wcm9taXNlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zYWZlLXByb21pc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5YjczNDFmODllZjdkYWE1YTNhMDE4MGUxYmZmNzFjNTJkMDg4NzFlYjBhZmNlNTc3NDcwM2Q5NTE4MmRkMGMwMmMwNTA4MzNlZjYxOTliZjMxMmFjNWMwMmRiZTQ1MjNlNGQ4YTBmMTk2OTEyNWVjNzc1OTZjY2I3NjUwM2ZjNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9zeW1ib2wuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3N5bWJvbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImI5OTE5Yjc4ZDA3MzY5YzY3Y2JlNjhlODY4MGIyYzkxOWQ2MDlkMmRiY2JiMjFkMmM4MGNmZjI2MmEzNjQ1MzQ3YTUzMGU3MzkxZDQxZTc4YTQ0OGQ3NTE4MzI2YTFjZTNlY2I5Yzk5ZDE2MzQzOTAxNjM5NjU0OTJhZGUwNDljIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3RhZ2dlZC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdGFnZ2VkLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZDM5ZjMwNWJjNzlmMWRiOWE2Y2ZiZjk1MjUxOTI1YjJlZTU2YmQyOWJiMTU1N2YyNDQ2OThmYzIzNWQwYWY5ZTcyN2FjNTcyMDIyNmUzMmRjODBmYzhhZjM2MTdiMGE0ZDUzY2U3NzJlNzAzZTI1ZmYwYjllYmVkNzRjNzU3MzkiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZUd1YXJkcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZUd1YXJkcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk0MTcwYzRlMTZkNTM3OTVhODQ3OWQwYzFhNzlkMTliMTkwZDkyMmUxNjMwMWU3YTBiYjhiODE2ZDNjNDliZDI1ZmUwYjg0ZTg3OWRhNzgwYzNmYzA2NDFhZDY5Y2M1N2RkMWU3OTVlY2U3ZThiYjI4MTJmNzQzMDU4YWZmMDIwIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk4YTg1MWJkYmYyZjRkZDA5YTEzYjUyMTEzMGUyOTlmOWQxOTU1YWUxOTI5MTYyN2NkMjhkZjRmYjVkNDg3OGVjZGY3Y2UyYjIyYTU2NzBiNDM5N2JmNDkwYjgwZDg5ODI0ODFkYjVjZWIyMjRiMTBhZmRlZmU1YzQ0NTA2MjY1IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuNyI6IHsKICAgICAgIm5hbWUiOiAiQGVuZG8vcGFzcy1zdHlsZSIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuNyIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuNyIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9wYXNzLXN0eWxlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXNzLXN0eWxlL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXNzLXN0eWxlLXYwLjEuNyIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Bhc3Mtc3R5bGUvdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcGFzcy1zdHlsZS12MC4xLjciLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjYwIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvc2hpbS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjYwIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBmYXN0LWNoZWNrL2F2YSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZmFzdC1jaGVjay9hdmEtdjEuMS42IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9saWIvZXNtL2F2YS1mYXN0LWNoZWNrLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBmYXN0LWNoZWNrL2F2YS9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGZhc3QtY2hlY2svYXZhLXYxLjEuNiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3NmI3MzIwM2IzYWMxZTc2MDEwODcyZjE2NjQ1N2Q1NTUzMjhmNDU5Y2Y1MGE1NzJmZmEwMTA0MWVjMDkzM2E3ZjU3OTE3MGFjZTBiNmU3NmFmNzkyZTEyYmJiZTFhZjU1YmQ2ZDJjNjhjNGVmMTFiNDBkZGE5NGVmZGM2MWI3MyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jb3B5QXJyYXkuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvcHlBcnJheS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjMzOGJiNjBmNzg1NGI0YTdiNjFhMWZkMzNiMjRhN2U5ZDA1OGRhNzkwZTZmMGEyOTY0NDNmNzA5ZjIwNmZlZjczMTUwYjdlMmRlZDc5OWM2MzliNTg4NDhkYzQ1YTRmM2ZjYWE5OWEwZjFlNzI1YTJhZDlhNDNkY2U2OTA4MzkxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2NvcHlSZWNvcmQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2NvcHlSZWNvcmQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI1NGI4MTI1ZDA5ZDczYjAyNWM4MzlmNjI1MWRjYzA2YTUzZGNkMjVhZTkxOGM5NzNlMzYwMTYxMTYzMDhhNDhjMTgzMGFkMzM4NzNkOWI4ZWVlMDZhZDUwYjgyOWQ0NTAzNmU4YzQ4NjAzNjM5ZTJhNTQ4MmVlMmJhOWNkZDMwZiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9lcnJvci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvZXJyb3IuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5NzBjNzNhNjYwMDE2OWMyZGFlYjQ0ZTMxODc2YTY0NDE2YTc4MTlhYjA0NzZlZTU0YzBiMjNhNDgwYjQ3M2VjZTE4Nzk5MDg2OTI0NGFhOTQwNWE2MDBmOThmNGI2MjQxZTYyODY1Y2ZlM2FkMzkzMWRiZTVjMTg0NGNiOTkzMCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pdGVyLWhlbHBlcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2l0ZXItaGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjQ3NmViZjM0ZTczZDA1MDM5Mzc0N2U5ZWFmMzVkOTcwN2ExOTA1ZDRjYzFjNTEwYTRmMTllMTVmYzM1MGVjYjFkYjQ5YjJmNTFmODRmYWFlY2I5YjY3YWY1NDhhY2MyZTUxMmZhYjJmYTE2MTBiMzY4ZGQxYTE3OWVhMGYzMzRlIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2UtZmFyLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tYWtlLWZhci5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImJjZDcwOWQ2ZWNhOWQwNDAyYjAzMWVmNWM5MzlhM2Y4ZjYzYWIyMGEzOWE5NjU1MjY5YTIyMWYwZmE3OWVhODQxNTZmOTlhNmU4MTk4NTdiMTcxNjg4NjM4OWE1ZDdjMzhlYTYzOTJlNDQ5ZGIwOGVhNjUzODBkNWRkYTQ5ZDQzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21ha2VUYWdnZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21ha2VUYWdnZWQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyZDBlNGJjNmU0N2UzZjY0Nzk0NmUxYTRiOWEwY2VhNjQ3YzM1MzA3ZTk1NTNlNThmM2MxMzIxNjE4MzZiOWQzYjhjN2U3MDFiM2U2ODYwNzFiNjAxZjRiMGI4MDIzMzI2ZjliYTQ4N2FlYzgwMjUyYzk1Y2FhZDhmZDk5NjE0MCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlLWhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI0OTVhZWQ4NzRiNDk1NzY0OGYwZTU1YzhjNzU5MmRjN2UxYjY1MzA3OWUyNTg2NTk1YmRjZjg5MzdmNzIyYzJiZTg2N2FkY2ExNjNkMDQwNDMyNTEwNjYxMzBlMDJkZGM4Y2I3NjYzY2Y4ZDg3NjRiMTBiZjZhMjZhOTYyNGYxMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wYXNzU3R5bGVPZi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGFzc1N0eWxlT2YuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3NGRlZDlmNmViOWE3YjU2ODhjMjY0NzEwYWUxZGI0MDAyZThhM2FlMDk1MTNkZTRjOGJkNjdmMTljNTJlNzMxMTRlYTA1NWQzMmZmNTAwMWE3OThiZDk4MjBlMTI3ZDBmZTM1ODc0Y2QzMmQwZjkyNGM0NzVmZjkzMWMyZjUxZiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yZW1vdGFibGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JlbW90YWJsZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjU1ODQyZmU4MjUxZDRlMDk2ZjEzY2JlNWViZjdlMGIzMGM2YjUzMGEwMGIzNGZhMDdiZTgwNGQ1ZDdiNDAwYTAyYjI2ZmY0MjY4YjE0ZGQ4NzdlOTZlMWFlMzNhZDA4ZWYyYWI4ODEyOTYzMmQ2Mjg3NTk1MmVhZmQwMTcyMTFjIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3NhZmUtcHJvbWlzZS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvc2FmZS1wcm9taXNlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOWI3MzQxZjg5ZWY3ZGFhNWEzYTAxODBlMWJmZjcxYzUyZDA4ODcxZWIwYWZjZTU3NzQ3MDNkOTUxODJkZDBjMDJjMDUwODMzZWY2MTk5YmYzMTJhYzVjMDJkYmU0NTIzZTRkOGEwZjE5NjkxMjVlYzc3NTk2Y2NiNzY1MDNmYzUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvc3ltYm9sLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9zeW1ib2wuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJiOTkxOWI3OGQwNzM2OWM2N2NiZTY4ZTg2ODBiMmM5MTlkNjA5ZDJkYmNiYjIxZDJjODBjZmYyNjJhMzY0NTM0N2E1MzBlNzM5MWQ0MWU3OGE0NDhkNzUxODMyNmExY2UzZWNiOWM5OWQxNjM0MzkwMTYzOTY1NDkyYWRlMDQ5YyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90YWdnZWQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3RhZ2dlZC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImQzOWYzMDViYzc5ZjFkYjlhNmNmYmY5NTI1MTkyNWIyZWU1NmJkMjliYjE1NTdmMjQ0Njk4ZmMyMzVkMGFmOWU3MjdhYzU3MjAyMjZlMzJkYzgwZmM4YWYzNjE3YjBhNGQ1M2NlNzcyZTcwM2UyNWZmMGI5ZWJlZDc0Yzc1NzM5IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVHdWFyZHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVHdWFyZHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5NDE3MGM0ZTE2ZDUzNzk1YTg0NzlkMGMxYTc5ZDE5YjE5MGQ5MjJlMTYzMDFlN2EwYmI4YjgxNmQzYzQ5YmQyNWZlMGI4NGU4NzlkYTc4MGMzZmMwNjQxYWQ2OWNjNTdkZDFlNzk1ZWNlN2U4YmIyODEyZjc0MzA1OGFmZjAyMCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5OGE4NTFiZGJmMmY0ZGQwOWExM2I1MjExMzBlMjk5ZjlkMTk1NWFlMTkyOTE2MjdjZDI4ZGY0ZmI1ZDQ4NzhlY2RmN2NlMmIyMmE1NjcwYjQzOTdiZjQ5MGI4MGQ4OTgyNDgxZGI1Y2ViMjI0YjEwYWZkZWZlNWM0NDUwNjI2NSIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIjogewogICAgICAibmFtZSI6ICJAZW5kby9wYXR0ZXJucyIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9wYXR0ZXJucy12MC4yLjIiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vcGF0dGVybnMtdjAuMi4yIiwKICAgICAgIm1vZHVsZXMiOiB7CiAgICAgICAgIkBlbmRvL2V2ZW50dWFsLXNlbmQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvbm8tc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9tYXJzaGFsIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL21hcnNoYWwtdjAuOC41IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wYXR0ZXJucyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXR0ZXJucy12MC4yLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3BhdHRlcm5zL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wYXR0ZXJucy12MC4yLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3NoaW0uanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICIuL2luZGV4LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogImluZGV4LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGMxMTA1NWZjYTU4NGFmNGQ0NzM5OWM1NGJjNTBkODFhYTY4YzYwM2E1NTBiZjY5YTA5YjI3Yzg5ZjY4NWU5NzQ0NTQ1YTc1M2FkNWU4ZmUzMzMxYWRiZDlkNGRjYTE0M2E1ODdkZDYwOTM0ZmI0MWM4MmY0YTFlOWViMWRlNTAiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMva2V5cy9jaGVja0tleS5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMva2V5cy9jaGVja0tleS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjVlNzJhNWRjZDY0ZTFkN2QyNTQ1Y2UzMGNjMzcwMjQ4NDM5MGM5ZDVjZGRiOWQwNWNlYTMzNmU4OGVlOGU5MzNiYzMxNTAzYzRjMjVjMzdlMGExY2FjOGNkZTMxY2JiZjQ3ODE4NjRkMGQ4OWQ3MWZlZTU4NGY1OWIwMTkzNDIxIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2tleXMvY29tcGFyZUtleXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2tleXMvY29tcGFyZUtleXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJkMmQzNzI4N2EyZWFjOWY0MWNjNDRhOTIwMWY5OWRmMjIxYTY3NmE0N2NlNzlkODA2MGI3YzU2N2MyZTYzZjdkZWJkOTI2ZmZlMzUyMjNlYTdmMzU5ZmY2YTliMzBhODM2OGEzOTZhYjZkZGZjNGI4YjEyMjY0MWY4NWM5YjhlNyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9rZXlzL2NvcHlCYWcuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2tleXMvY29weUJhZy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImZkZTRmODJmMmM0ZDQ5ZGIzYTk4MTRiZGJjZjFlYzY0ZDcxZDhmYWQ1MjFlMTEwZTY4MTJkM2IzNzNlZDkyOGI4NjFkNzVmMDdhNjdlM2NmNGMzZmVkNmFkZTQ1NTdiYmY0YWQ5NDU3MzVhMjM4ZGVkZGQwNTNjMDkzMmU2YTA2IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2tleXMvY29weVNldC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMva2V5cy9jb3B5U2V0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNGVhYjdlYzI4NGNhZGUxYjA0ZGY0ZjNiZTY4NmMxNzJiMDQzOTFmMGVlZDg1NDhlNDlmOTMxYjNjMmM0YzUxODNlODQxMWVlNjVhMGI5YjZkZmI1ZmRmMWFkYjhlNGEzNjEyNTBhZTAxOTFlMmVjNjBjNTgxNDE4ZThjYTUwNDciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMva2V5cy9tZXJnZS1iYWctb3BlcmF0b3JzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9rZXlzL21lcmdlLWJhZy1vcGVyYXRvcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI4Yjk4OTJiM2EyNWJmNmJhZDMyMzVkNmEzNzY1NmYxMWE0M2U0NGEzOGZlOGQ1YzhlNDM1YjFmMDljYmYyYjQyZjZhZDY0OTQ0NjRkNTdhZDE5NDdmNzhjOGExMDE5NmJiZDhmNTBiNjRlMjUxMDY3NjNlZGE5M2RlMjdhZGViZCIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9rZXlzL21lcmdlLXNldC1vcGVyYXRvcnMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2tleXMvbWVyZ2Utc2V0LW9wZXJhdG9ycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjRiMWI0MTdjNmRkOTMyZGI4MWY5ZGExMTRjMDIwYzdkMDI3OGJmMTJiYThjNDYwN2ZmNDBhYmM1ZTMwMTU5NTFkY2RmYmEyZTAxYTAxNTNmNGQwZmY5YTM3NTRlYmMwMDQ2MDc3ZjdhODQyMzE3YjMxYmI3YTNmMWNiMGZjOTIzIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3BhdHRlcm5zL3BhdHRlcm5NYXRjaGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcGF0dGVybnMvcGF0dGVybk1hdGNoZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiYzI3NmM2ZmJjNjNiNWJiZjgzYWNmMGU5OTMxN2U5MDM1ZmYzOGQwNGE3YjYxYjI5ZjgwMDM1Mzg1MDFmZWNkZjJiZTk5NzZhZGY5ZTIyYTkwMDlhYjRmNTExYjk4ZTdlZmM2NDlmYTczZTJhOWFjMzIzNjNjY2RlOGFhYTUxM2EiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdHlwZXMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3R5cGVzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOThhODUxYmRiZjJmNGRkMDlhMTNiNTIxMTMwZTI5OWY5ZDE5NTVhZTE5MjkxNjI3Y2QyOGRmNGZiNWQ0ODc4ZWNkZjdjZTJiMjJhNTY3MGI0Mzk3YmY0OTBiODBkODk4MjQ4MWRiNWNlYjIyNGIxMGFmZGVmZTVjNDQ1MDYyNjUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdXRpbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3V0aWxzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMTE0YjNhNDA0MzgyMmY4ZmJmZDIyYWI2MDE5Y2MxYTdlNjBhZGNmN2E1N2Q3MGQyN2U4ZWYxYzExMjI2Mjc1ZjdlMzEzNzZkODQzNmExNDc5OThjYTlhMDQ2MDc2OTIxZDM2NzJlYzkxZGY2ZDZmMzIxMTA1YmNkYWIzZDY3MzAiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3Byb21pc2Uta2l0IiwKICAgICAgImxhYmVsIjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAibG9jYXRpb24iOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9wcm9taXNlLWtpdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL3Byb21pc2Uta2l0L3NoaW0uanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc2hpbS5qcyIKICAgICAgICB9LAogICAgICAgICJzZXMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VzLXYwLjE4LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgInNlcy9sb2NrZG93biI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJzZXMtdjAuMTguNCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAic2VzL3BhY2thZ2UuanNvbiI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJzZXMtdjAuMTguNCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgInNlcy90b29scy5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJzZXMtdjAuMTguNCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vdG9vbHMuanMiCiAgICAgICAgfSwKICAgICAgICAiLi9pbmRleC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJpbmRleC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjI5ZmZlNTVhMzEwMzczYTQ1N2FhOWQwNzcxNjExODUwNTRlYjM2ZjgzNTMyOGZjYTE0ZWZkMTE0NTFjNjE1MDJhMTIwYjgzYzc0ODIwNGZhMDg3N2FmYzcwNTJlYjIyYTRkN2IwZTFiMGI2MThkYjkwMjE3ZDZlOGNlNzdhMjkyIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2lzLXByb21pc2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2lzLXByb21pc2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIxODE0ZGQxNDNkZmY3M2RlM2VlNGMxZjA3NzA3ZTU3N2NhYWNhYTNhYmY0YjA1OTBjZGVkZTEwYjkxOTlhOTJkNzk3ZjBjMTFiYjczODI5NWM0OWYxZTdlZjkwZjNkMTE2ZTI4ZTc0YzA4NjczNGViY2E4YmNkYTFkYzkzOWQ0NyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9tZW1vLXJhY2UuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21lbW8tcmFjZS5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImVlYTU1ZmEyY2MxYjczNmUwMmJiODMyMjQ2ZGNjNmZjZDRhMGExZWJjMjQxZTM4MWVmNmY2NGJkOGVjNDZhMTVkM2Y3OTdlYzIyYTM1YzljNWM5NTE0MjRlMzlmZDZhNjg3Y2RiNDE1NWM4ZGI3MWY2ZWZlN2QzZmU5N2U5NDVhIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjc1ZTgzMzZjYmM0MWNkMmY2MzExNzdjMDYxMDljZjNmOGI1MTgxNGNiMzNlMjIwODJjOGU5ZWVlMDcyZWM0ODkxOWQwOGQ0M2QyOWQ1NjU1MTgyNmM4OTUxMzU4MzU0ZDY4ZTVhYTA5NmM2YWE1NjYxMzQ5ZTBmYTEwODE2Zjc5IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3R5cGVzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlcy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjk4YTg1MWJkYmYyZjRkZDA5YTEzYjUyMTEzMGUyOTlmOWQxOTU1YWUxOTI5MTYyN2NkMjhkZjRmYjVkNDg3OGVjZGY3Y2UyYjIyYTU2NzBiNDM5N2JmNDkwYjgwZDg5ODI0ODFkYjVjZWIyMjRiMTBhZmRlZmU1YzQ0NTA2MjY1IgogICAgICAgIH0KICAgICAgfQogICAgfSwKICAgICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjYwIjogewogICAgICAibmFtZSI6ICJAZW5kby9wcm9taXNlLWtpdCIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9wcm9taXNlLWtpdC12MC4yLjYwIiwKICAgICAgImxvY2F0aW9uIjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi42MCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAic2VzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC44IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJzZXMvbG9ja2Rvd24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VzLXYwLjE4LjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgInNlcy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VzLXYwLjE4LjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJzZXMvdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VzLXYwLjE4LjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyOWZmZTU1YTMxMDM3M2E0NTdhYTlkMDc3MTYxMTg1MDU0ZWIzNmY4MzUzMjhmY2ExNGVmZDExNDUxYzYxNTAyYTEyMGI4M2M3NDgyMDRmYTA4NzdhZmM3MDUyZWIyMmE0ZDdiMGUxYjBiNjE4ZGI5MDIxN2Q2ZThjZTc3YTI5MiIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9pcy1wcm9taXNlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9pcy1wcm9taXNlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMTgxNGRkMTQzZGZmNzNkZTNlZTRjMWYwNzcwN2U1NzdjYWFjYWEzYWJmNGIwNTkwY2RlZGUxMGI5MTk5YTkyZDc5N2YwYzExYmI3MzgyOTVjNDlmMWU3ZWY5MGYzZDExNmUyOGU3NGMwODY3MzRlYmNhOGJjZGExZGM5MzlkNDciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbWVtby1yYWNlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9tZW1vLXJhY2UuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJlZWE1NWZhMmNjMWI3MzZlMDJiYjgzMjI0NmRjYzZmY2Q0YTBhMWViYzI0MWUzODFlZjZmNjRiZDhlYzQ2YTE1ZDNmNzk3ZWMyMmEzNWM5YzVjOTUxNDI0ZTM5ZmQ2YTY4N2NkYjQxNTVjOGRiNzFmNmVmZTdkM2ZlOTdlOTQ1YSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI3NWU4MzM2Y2JjNDFjZDJmNjMxMTc3YzA2MTA5Y2YzZjhiNTE4MTRjYjMzZTIyMDgyYzhlOWVlZTA3MmVjNDg5MTlkMDhkNDNkMjlkNTY1NTE4MjZjODk1MTM1ODM1NGQ2OGU1YWEwOTZjNmFhNTY2MTM0OWUwZmExMDgxNmY3OSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlcy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvdHlwZXMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI5OGE4NTFiZGJmMmY0ZGQwOWExM2I1MjExMzBlMjk5ZjlkMTk1NWFlMTkyOTE2MjdjZDI4ZGY0ZmI1ZDQ4NzhlY2RmN2NlMmIyMmE1NjcwYjQzOTdiZjQ5MGI4MGQ4OTgyNDgxZGI1Y2ViMjI0YjEwYWZkZWZlNWM0NDUwNjI2NSIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiQGVuZG8vc3RyZWFtLXYwLjMuMjUiOiB7CiAgICAgICJuYW1lIjogIkBlbmRvL3N0cmVhbSIsCiAgICAgICJsYWJlbCI6ICJAZW5kby9zdHJlYW0tdjAuMy4yNSIsCiAgICAgICJsb2NhdGlvbiI6ICJAZW5kby9zdHJlYW0tdjAuMy4yNSIsCiAgICAgICJtb2R1bGVzIjogewogICAgICAgICJAZW5kby9ldmVudHVhbC1zZW5kIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL25vLXNoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41NiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vcHJvbWlzZS1raXQvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJAZW5kby9wcm9taXNlLWtpdC9zaGltLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NoaW0uanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vc3RyZWFtIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3N0cmVhbS12MC4zLjI1IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAZW5kby9zdHJlYW0vcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL3N0cmVhbS12MC4zLjI1IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAic2VzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogInNlcy12MC4xOC40IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJzZXMvbG9ja2Rvd24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VzLXYwLjE4LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgInNlcy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VzLXYwLjE4LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3BhY2thZ2UuanNvbiIKICAgICAgICB9LAogICAgICAgICJzZXMvdG9vbHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAic2VzLXYwLjE4LjQiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3Rvb2xzLmpzIgogICAgICAgIH0sCiAgICAgICAgIi4vaW5kZXguanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAiaW5kZXguanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwMDk0MTMyY2I5YWNlN2YyYWE4ZmIyNGE4NWE4NjBkNDhkZDdjM2U1NDQwMDFmZWNmZWQwYTk3ZGMxYTM3YzJmZTNkM2QxYzBlNDQwOTkwYTg2MGU1ZjQzZTdlNmI1N2UzYTBlMTQ2MDI0YjA1ZDk4ODMwNmM2ZjkwNjhiNWEyZiIKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICAiY3JhYmJsZS1jb250cmFjdC12MC4xLjAiOiB7CiAgICAgICJuYW1lIjogImNyYWJibGUtY29udHJhY3QiLAogICAgICAibGFiZWwiOiAiY3JhYmJsZS1jb250cmFjdC12MC4xLjAiLAogICAgICAibG9jYXRpb24iOiAiY3JhYmJsZS1jb250cmFjdC12MC4xLjAiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGFnb3JpYy9hc3NlcnQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9hc3NlcnQtdjAuNi4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvYXNzZXJ0LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvZGVwbG95LXNjcmlwdC1zdXBwb3J0IjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvZGVwbG95LXNjcmlwdC1zdXBwb3J0LXYwLjEwLjQtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9oZWxwZXJzLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvZXJ0cCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvZ292ZXJuYW5jZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvaW50ZXItcHJvdG9jb2wiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9pbnRlci1wcm90b2NvbC12MC4xNi4yLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9pbnRlcm5hbCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL2V4cG9ydGVkLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL25vdGlmaWVyL3N1YnNjcmliZS5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3Vic2NyaWJlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvbm90aWZpZXIvdG9vbHMvdGVzdFN1cHBvcnRzLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi90b29scy90ZXN0U3VwcG9ydHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy9zbWFydC13YWxsZXQiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy9zbWFydC13YWxsZXQtdjAuNS40LXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3N0b3JlIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy90aW1lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvdmF0LWRhdGEiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9pbmRleC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3ZhdHMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy92YXRzLXYwLjE1LjItdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9lIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy96b2VTZXJ2aWNlL3pvZS5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9leHBvcnRlZC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9leHBvcnRlZC5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L2F0b21pY1RyYW5zZmVyLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9jb250cmFjdFN1cHBvcnQvYXRvbWljVHJhbnNmZXIuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC9pbmRleC5qcyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvY29udHJhY3RTdXBwb3J0L2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvcmVjb3JkZXIuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC9yZWNvcmRlci5qcyIKICAgICAgICB9LAogICAgICAgICJAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L3NhZmVNYXRoLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9jb250cmFjdFN1cHBvcnQvc2FmZU1hdGguanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC90b3BpY3MuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC90b3BpY3MuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b2Uvc3JjL21ha2VIYW5kbGUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL21ha2VIYW5kbGUuanMiCiAgICAgICAgfSwKICAgICAgICAiQGFnb3JpYy96b2Uvc3JjL3R5cGVHdWFyZHMuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL3R5cGVHdWFyZHMuanMiCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vYnVuZGxlLXNvdXJjZSI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9idW5kbGUtc291cmNlLXYyLjguMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvY2FjaGUuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi44LjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2NhY2hlLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvZXhwb3J0ZWQuanMiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vYnVuZGxlLXNvdXJjZS12Mi44LjAiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2V4cG9ydGVkLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2J1bmRsZS1zb3VyY2UvcGFja2FnZS5qc29uIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2J1bmRsZS1zb3VyY2UtdjIuOC4wIiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9wYWNrYWdlLmpzb24iCiAgICAgICAgfSwKICAgICAgICAiQGVuZG8vZXZlbnR1YWwtc2VuZCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE0LjgiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9uby1zaGltLmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL2ZhciI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJAZW5kby9mYXItdjAuMi4yMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgIkBlbmRvL21hcnNoYWwiOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiQGVuZG8vbWFyc2hhbC12MC42LjkiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL2luZGV4LmpzIgogICAgICAgIH0sCiAgICAgICAgImFnb3JpYyI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJhZ29yaWMtdjAuMjEuMi11MTEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vc3JjL21haW4uanMiCiAgICAgICAgfSwKICAgICAgICAiY3JhYmJsZS1jb250cmFjdCI6IHsKICAgICAgICAgICJjb21wYXJ0bWVudCI6ICJjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMCIsCiAgICAgICAgICAibW9kdWxlIjogIi4vaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvYXNzZXJ0aW9uSGVscGVycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvYXNzZXJ0aW9uSGVscGVycy5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImM5OGMwMWY3OWMyMGY0ZWRiYTg0MmJhNDgxMDdjOWMwZjZlYmI2YWQ1NTE5Y2QyY2UyNDU4YThmMWE2MTQyMzgyODQwZTgwNzU5NDYxMGQ5NDI3NDZhZDNjNjY1MWU2MzEyYTExNWQ2YTg0NmIyODZlOGU3ZDVjMWQwZGI1MDM5IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL2JpZEhvbGRlci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvYmlkSG9sZGVyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNDFlMTQzZDIzNTJhMzQzMTkwYjc0MmNmODY3NWI5MTQxY2E3N2Y5NWZiYWU3NDdlMGYxMjNiM2M1OTM2MWFiYzA5OTM3ZDNkNWVmN2E1YzI4M2E2NjIyM2FmZWE1YWQ0M2IzYmU4YzRlMWY4ZjA0YjhlYjUyOGEyMGYwNmUzZTEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvYmlkS2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9iaWRLaXQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhMjY1NjdmNzM1YzdmMmJiOWNlZjU2MmE4MjBjZGZmNDlmYTAzNzk1Y2IwNzVjZjEyMDVjNGQzZjkwMjU3ODhmMTMyZDU2YzYxZTU4YWJjMzlmYWRkNDU3MDViYjU5MDJlM2JlMjkyMTMxNjExODg2YzJlYzNkNzA1YWZhMjY3NyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9iaWRzTWFuYWdlci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvYmlkc01hbmFnZXIuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICJhZDc0ODdlNTAwNTEzYjhlMTM1NTRkYmFkYTJmMDBkNDBlZmQzOWY4YzJjNTQ1ZjZmZTUzZjJjZjRkYmE5MmJjMjEwMDViMDgzYWMzMTRjZDEzZDdiMzhlMGY0ODIzY2E1YzM0MjhiMzI3NDYwNzgxNzUyMDc3ZjU4MWQ0MDk5NyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jYXRhbG9nLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jYXRhbG9nLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOWVmNjQyMmExZDNmODhhY2ZjZGM2OTIzZDJlNjQ0ODc2MjgwMDVlYmNiNTBjZmU3MGFiZmMzYzM1ZDU3MmE2ZTA2ZjgxMGEzMDMxMzRlMGI3YzQzZDI3OWJlMmI1ZjY2NDczM2MxMjAxY2JlZWRjZTU5MzhiNDZkMDUyNGQ4MWMiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvY29uc3RhbnRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jb25zdGFudHMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI4ODJhODk3ODA0Y2YyNmRiN2I4NmM0ZWFiNzljZjJkMmNkYTQxYjQ5NWRmYmVlMzBkZmNhNjk4OTc1MGZlM2ZiNjgwN2FjZGJlNWQ3MWI3ZTNlMGE5ZjU4ZDMzM2QxNTFjYmMxNjczYzQyOTQ0Y2IxNzdmODJjODFjY2U5ZWFiNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9jcmFiYmxlLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9jcmFiYmxlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiY2M4ZmY5ZTY5Mjc1NGU5ZDAyZDI4NDVjM2M1MmYzYzM3ZTIzZGVkNjczNGQ0ZGU3ZjYwY2YyNzA5MjQ2ODI0OWM5YmVhODhhOWZkMzcyNzhhMmQwODg5MTMwMzVhNTc5Y2ZlZGY1MDIyZWQyMGQzNDRmMTgwZTM1OTUzOTZlMjgiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbGVhc2VIb2xkZXIuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2xlYXNlSG9sZGVyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiZTcxNTRmNTViZmYzMTQ0OTAyYTU3ODBjNTMzOWFiYWUwMjRlZGI4MmZlNWE2ZjA3YTk3MzA5YWRlODM1OTI0ZDg0NTMwZjk3OTNiYjM0NTU5YTJiZDEzNzYyOGRkOGY4ZDk1M2U4NzJhNGZjZmUyNDRlNmE1Y2E1YTUzNmI0M2EiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvbGVhc2VLaXQuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL2xlYXNlS2l0LmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNzQxYjQ3NzYyYWI3Y2U1NTM1YjJjN2M3ZDQwNWMwOGYxZjQ3NTI3M2E0YzYzMDk5NzlmMDY0NjlmNzU0Y2RjNDZlNWQ1YWQ2MmI4YTkzYjQ4ODEyMjAwYWY3OWUxYWI3OTY0NjY5YjI4ZWMwMzExM2VmMmQzMDkyNmE3ZGY4ZmUiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcGF0dGVybk1hdGNoZXJIZWxwZXJzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9wYXR0ZXJuTWF0Y2hlckhlbHBlcnMuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICI2NGIzZGRiOGE2MDJiMWM0ZWJlNDY5MzU3MDc2YzMzNDVlYjFjZjlmNzQzMGI3MTkyNjI1NWE3ZDk3MTM3NWI5MjVkN2U5NTYxOTI2M2MzYjg1ZmRiNWQyYTljODc0Y2JjMjk2MTVmZmI0YWYyNzM4ZjExYWZlNDEwZGI5YmIzMyIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yZW50YWwuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JlbnRhbC5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjIzMTZhM2RkNGQzOGY5NDFiODVjMjRkMzdkMTg1MmFjMzMyODAwNDY5MmVmMTIzOThkYTA5MDkwZWU2ZjdlOGQ5NTI1ODk1MjIxZjdlYmE5ZDFiYTQ4NjBiMjY1Mjk5MTQ4ZTA4MTVkMzVjOWRjZjJjOGUxMmM1YmU5ODk5Yzc4IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3JlbnRhbEhvbGRlci5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmVudGFsSG9sZGVyLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNzFlZjZmNmZhNmY1NGE5N2NhOTU0NWZlNjFjN2M5ODAwNDUyOTAyYzUwYjJlNWVlZTM2MzRlYTc4OTBjNTllOGE4MmM1NWQ2MTM1MDlkOGEyMTA3YzU3NzljNTIyNmZjMjQ4MmYyNGQwNDNiNTRiNDNlM2NkNGZiZGYzMzIzZDciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmVudGFsS2l0LmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yZW50YWxLaXQuanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIyMzY3ZjA5NmFhNGU2NGU4YTQ0NjVjMWE2MDIxMjk0MWU4MWJhMGY5ZWNlNjczZmIzOTgzYTg3ZGJiMGEwZDBjMjE3YWVlNzVjZjY5NmVlZGMzYmE0ZjcxYzExZmMzZWZlMDc1N2E0MWM1OGNiM2MzMzEyZDJiZmU1NDBlNmUwNSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy90eXBlR3VhcmRzLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy90eXBlR3VhcmRzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNmRiMjM1YzVkMTUwZDhjMDIxNGEwNWUxYjkyNzg4OTYyZDUxNTNlZjk3MWFjOThkZDE4ZjdhZDRjNWVjYTIyMDk1ZDQ4MWM4NmI1MDA2ZThhM2IwNTY2Y2U1NjM5MzJhNDcxYTg1YzkzMzczYTU4Njk0YWZiOWIxNjhjZWI3MDciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvdXRpbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3V0aWxzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNzk1Mzk2OGY2MDNkNzhmNGY0OGVhMjQzYjRhYjNjMzlmNzYzYWE3ZDFjM2NhOGFiODhjOWUwYjI3NzQ3MTBmNTg0NGY2OWQ2NDgyNGQ3MzgwM2Q1NmJhZThiNTFkYjBjMDAyNDI1OTU0MmEzZDQ4MWFiNjFmMzI0NmVmZmMzNmQiCiAgICAgICAgfQogICAgICB9CiAgICB9LAogICAgImplc3NpZS5qcy12MC4zLjIiOiB7CiAgICAgICJuYW1lIjogImplc3NpZS5qcyIsCiAgICAgICJsYWJlbCI6ICJqZXNzaWUuanMtdjAuMy4yIiwKICAgICAgImxvY2F0aW9uIjogImplc3NpZS5qcy12MC4zLjIiLAogICAgICAibW9kdWxlcyI6IHsKICAgICAgICAiQGVuZG8vZmFyIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogIkBlbmRvL2Zhci12MC4yLjE4IiwKICAgICAgICAgICJtb2R1bGUiOiAiLi9zcmMvaW5kZXguanMiCiAgICAgICAgfSwKICAgICAgICAiamVzc2llLmpzIjogewogICAgICAgICAgImNvbXBhcnRtZW50IjogImplc3NpZS5qcy12MC4zLjIiLAogICAgICAgICAgIm1vZHVsZSI6ICIuL3NyYy9tYWluLmpzIgogICAgICAgIH0sCiAgICAgICAgImplc3NpZS5qcy9wYWNrYWdlLmpzb24iOiB7CiAgICAgICAgICAiY29tcGFydG1lbnQiOiAiamVzc2llLmpzLXYwLjMuMiIsCiAgICAgICAgICAibW9kdWxlIjogIi4vcGFja2FnZS5qc29uIgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL21haW4uanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL21haW4uanMiLAogICAgICAgICAgInBhcnNlciI6ICJwcmUtbWpzLWpzb24iLAogICAgICAgICAgInNoYTUxMiI6ICIwMWRjYmUzNGY0YzIyNGQ2ZDZmZmRkZWNiM2RlNWJkZjJmZjMxMzg2NjdmNTZmNDk5NTU2OWYwYzJkOWZjZTNiNGRlYzQzM2YwZDQ1NmExOGI5NWQ3ZjNmMjM3YzExOTZjNDg3YmM0NGU0NDZmMjk1Y2Y2M2QyZDU4M2Q3ODg4OSIKICAgICAgICB9LAogICAgICAgICIuL3NyYy9yaW5nMC9FLmpzIjogewogICAgICAgICAgImxvY2F0aW9uIjogInNyYy9yaW5nMC9FLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiMzIxMjRiY2NjODQ2MDE5MDA2MWY0Y2RiZDhkZjQ5YmQ3MjNkMWM2NTVhYjk5ZDAyNjc2ZjhhMTExYTBmNzRlNDc2MmNhYzQzZWNkZWViODVkMjkzZjM3YzgyZWJjMjVmYzRlMDUyYzk5MjM3OGJjN2ViZTEwZTY4MWNkODMwMzciCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzAvYXN5bmMtZ2VuZXJhdGUuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JpbmcwL2FzeW5jLWdlbmVyYXRlLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiOWE5NWQxZGJjYzhmNGJlODE0MjA0ZjY4MzJjMWVhYzMwNjIxZmNjYjAzMjhjMGVjNDFlYTVhMDM5MTQ5OThjOGVmZjkwMTllZmY2NWFkNjYyODljMDE1OTE4MWQ5YjQ5ZGIyY2Q5NmYzZmI1OWUyMWFkYjg0ZDlhNGMwZTg5N2YiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzAvbWFpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmluZzAvbWFpbi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogImJmNzE2Mzc4MmY2NzJmNjI4NDQ5MjViNmJiNGZkOWQwMTdiOGI2NDJmZjMzNjQ0ZjI1OWVlMDA3ZTJiYjVhODFiMjRiZmUwNjQxNzQwNWIwNTA1MTlmYjUzYzIwYTgzZjI5ZGUxMmY4M2MzYjlkNjk2Y2Y3Zjg0ZTk4ZGU1MTE4IgogICAgICAgIH0sCiAgICAgICAgIi4vc3JjL3JpbmcwL21ha2Vycy5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmluZzAvbWFrZXJzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiODM1N2JiZjZiMTFiYmNiY2EzYjk1OWM1ZWUxYWVhNGZhZWMzNGZlMzQ2YjgzODE5NDAyZTkzZGZiYmRlN2ZmOGZkY2UzOWUxZjYwOGRiYjc2NTQwYTgxY2E0OThlZmQ0NjkyOWY0MWU3ODllMjliYjZkYWY2N2FkM2MxNzVhNWYiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzEvYXN5bmMtdG9vbHMuanMiOiB7CiAgICAgICAgICAibG9jYXRpb24iOiAic3JjL3JpbmcxL2FzeW5jLXRvb2xzLmpzIiwKICAgICAgICAgICJwYXJzZXIiOiAicHJlLW1qcy1qc29uIiwKICAgICAgICAgICJzaGE1MTIiOiAiNzBiZjEyMWE3YTU2OTUxNGMyZTBjMWFhNTFkMTZlM2UwZDEzYWM1ZWFmOTAxNTNhMWMyNTdjNjlhY2JhY2FiMGY0YTJkYzYxNTAzYjMzNzJlYjBhOTgwNmE2MTUyNjUxZjcwMTlhMzdiZTkyZGU4NGQ4YTIyNTVlN2YzMzEwNzEiCiAgICAgICAgfSwKICAgICAgICAiLi9zcmMvcmluZzEvbWFpbi5qcyI6IHsKICAgICAgICAgICJsb2NhdGlvbiI6ICJzcmMvcmluZzEvbWFpbi5qcyIsCiAgICAgICAgICAicGFyc2VyIjogInByZS1tanMtanNvbiIsCiAgICAgICAgICAic2hhNTEyIjogIjFlMTQ0OTBjZTUzYWY0MmJlNTI0NmM3MTY5Mjg4MzQ2NmY3MTRlODk4MjRjNzMzYmM0MzNlYTI5NWIyMjI5Y2Q0ZjdjM2I4YmEwMmM2OTk3YzcyZmYwMjc5NGExMjY3ZTllNWU0ZjEzYTI1ZGM0NmJkZTRkZmU1MjNjZGU1NTQ4IgogICAgICAgIH0KICAgICAgfQogICAgfQogIH0KfVBLAwQKAAAAAAAAAAAAOYpWAjsLAAA7CwAAIwAAAEBhZ29yaWMvYXNzZXJ0LXYwLjYuMC9zcmMvYXNzZXJ0LmpzeyJpbXBvcnRzIjpbIi4vdHlwZXMuanMiXSwiZXhwb3J0cyI6WyJGYWlsIiwiTm9uTnVsbGlzaCIsImFuIiwiYXNzZXJ0IiwiZGV0YWlscyIsImlkZW50Q2hlY2tlciIsIm1ha2VBc3NlcnQiLCJxIiwicXVvdGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3R5cGVzLmpzXCIsIFtdXV0pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShhbiwgJ25hbWUnLCB7dmFsdWU6IFwiYW5cIn0pOyRo4oCNX29uY2UuYW4oYW4pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuXG5jb25zdHtmcmVlemV9PU9iamVjdDtcblxuLyoqIEB0eXBlIHtBc3NlcnR9ICovXG5jb25zdCBnbG9iYWxBc3NlcnQ9Z2xvYmFsVGhpcy5hc3NlcnQ7JGjigI1fb25jZS5nbG9iYWxBc3NlcnQoZ2xvYmFsQXNzZXJ0KTtcblxuaWYoZ2xvYmFsQXNzZXJ0PT09dW5kZWZpbmVkKXtcbnRocm93IEVycm9yKFxuIGBDYW5ub3QgaW5pdGlhbGl6ZSBAYWdvcmljL2Fzc2VydCwgbWlzc2luZyBnbG9iYWxUaGlzLmFzc2VydCwgaW1wb3J0ICdzZXMnIGJlZm9yZSAnQGFnb3JpYy9hc3NlcnQnYCk7XG5cbiB9XG5cbmNvbnN0IG1pc3Npbmc9LyoqIEB0eXBlIHtjb25zdH0gKi9bXG4nZmFpbCcsXG4nZXF1YWwnLFxuJ3R5cGVvZicsXG4nc3RyaW5nJyxcbidub3RlJyxcbidkZXRhaWxzJyxcbidGYWlsJyxcbidxdW90ZScsXG4nbWFrZUFzc2VydCddLlxuZmlsdGVyKChuYW1lKT0+Z2xvYmFsQXNzZXJ0W25hbWVdPT09dW5kZWZpbmVkKTtcbmlmKG1pc3NpbmcubGVuZ3RoPjApe1xudGhyb3cgRXJyb3IoXG4gYENhbm5vdCBpbml0aWFsaXplIEBhZ29yaWMvYXNzZXJ0LCBtaXNzaW5nIGdsb2JhbFRoaXMuYXNzZXJ0IG1ldGhvZHMgJHttaXNzaW5nLmpvaW4oXG4nLCAnKVxuIH1gKTtcblxuIH1cblxuY29uc3R7ZGV0YWlscyxGYWlsLHF1b3RlLG1ha2VBc3NlcnR9PWdsb2JhbEFzc2VydDskaOKAjV9vbmNlLmRldGFpbHMoZGV0YWlscyk7JGjigI1fb25jZS5GYWlsKEZhaWwpOyRo4oCNX29uY2UucXVvdGUocXVvdGUpOyRo4oCNX29uY2UubWFrZUFzc2VydChtYWtlQXNzZXJ0KTtcblxuXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VCB8IG51bGwgfCB1bmRlZmluZWR9IHZhbFxuICogQHBhcmFtIHtzdHJpbmd9IFtvcHREZXRhaWxzXVxuICogQHJldHVybnMge1R9XG4gKi9cbmNvbnN0ICAgICAgICBOb25OdWxsaXNoPSh2YWwsb3B0RGV0YWlscz0gYHVuZXhwZWN0ZWQgJHtxdW90ZSh2YWwpfWApPT57XG5pZih2YWwhPW51bGwpe1xuLyogVGhpcyBgIT0gbnVsbGAgaWRpb20gY2hlY2tzIHRoYXQgYHZhbGAgaXMgbmVpdGhlciBgbnVsbGAgbm9yIGB1bmRlZmluZWRgLiovXG5yZXR1cm4gdmFsO1xuIH1cbmFzc2VydC5mYWlsKG9wdERldGFpbHMpO1xuIH07JGjigI1fb25jZS5Ob25OdWxsaXNoKE5vbk51bGxpc2gpO1xuaGFyZGVuKE5vbk51bGxpc2gpO1xuXG4vKipcbiAqIFByZXBlbmQgdGhlIGNvcnJlY3QgaW5kZWZpbml0ZSBhcnRpY2xlIG9udG8gYSBub3VuLCB0eXBpY2FsbHkgYSB0eXBlb2YgcmVzdWx0XG4gKiBlLmcuLCBcImFuIE9iamVjdFwiIHZzLiBcImEgTnVtYmVyXCJcbiAqXG4gKiBAZGVwcmVjYXRlZFxuICogQHBhcmFtIHtzdHJpbmd9IHN0ciBUaGUgbm91biB0byBwcmVwZW5kXG4gKiBAcmV0dXJucyB7c3RyaW5nfSBUaGUgbm91biBwcmVwZW5kZWQgd2l0aCBhL2FuXG4gKi9cbmZ1bmN0aW9uIGFuKHN0cil7XG5zdHI9IGAke3N0cn1gO1xuaWYoc3RyLmxlbmd0aD49MSYmJ2FlaW91QUVJT1UnLmluY2x1ZGVzKHN0clswXSkpe1xucmV0dXJuIGBhbiAke3N0cn1gO1xuIH1cbnJldHVybiBgYSAke3N0cn1gO1xuIH1cbmZyZWV6ZShhbik7XG5cblxuLyoqXG4gKiBJbiB0aGUgYGFzc2VydEZvb2AvYGlzRm9vYC9gY2hlY2tGb29gIHBhdHRlcm4sIGBjaGVja0Zvb2AgaGFzIGEgYGNoZWNrYFxuICogcGFyYW1ldGVyIG9mIHR5cGUgYENoZWNrZXJgLiBgYXNzZXJ0Rm9vYCBjYWxscyBgY2hlY2tGb29gIHBhc3Nlc1xuICogYGFzc2VydENoZWNrZXJgIGFzIHRoZSBgY2hlY2tgIGFyZ3VtZW50LiBgaXNGb29gIHBhc3NlcyBgaWRlbnRDaGVja2VyYFxuICogYXMgdGhlIGBjaGVja2AgYXJndW1lbnQuIGBpZGVudENoZWNrZXJgIGFjdHMgcHJlY2lzZWx5IGxpa2UgYW5cbiAqIGlkZW50aXR5IGZ1bmN0aW9uLCBidXQgaXMgdHlwZWQgYXMgYSBgQ2hlY2tlcmAgdG8gaW5kaWNhdGUgaXRzXG4gKiBpbnRlbmRlZCB1c2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpZGVudENoZWNrZXI9KGNvbmQsX2RldGFpbHMpPT5jb25kOyRo4oCNX29uY2UuaWRlbnRDaGVja2VyKGlkZW50Q2hlY2tlcik7XG5oYXJkZW4oaWRlbnRDaGVja2VyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnQiOlsiZ2xvYmFsQXNzZXJ0Il0sImRldGFpbHMiOlsiZGV0YWlscyJdLCJGYWlsIjpbIkZhaWwiXSwicXVvdGUiOlsicXVvdGUiXSwicSI6WyJxdW90ZSJdLCJtYWtlQXNzZXJ0IjpbIm1ha2VBc3NlcnQiXSwiYW4iOlsiYW4iXSwiTm9uTnVsbGlzaCI6WyJOb25OdWxsaXNoIl0sImlkZW50Q2hlY2tlciI6WyJpZGVudENoZWNrZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAABbmH7NouAADaLgAAIgAAAEBhZ29yaWMvYXNzZXJ0LXYwLjYuMC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAdHMtY2hlY2sqL1xuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuLyogQmFzZWQgb24qL1xuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2Jsb2IvSEVBRC9wYWNrYWdlcy9zZXMvc3JjL2Vycm9yL3R5cGVzLmpzKi9cbi8qIENvb3JkaW5hdGUgZWRpdHMgdW50aWwgd2UgcmVmYWN0b3IgdG8gYXZvaWQgdGhpcyBkdXBsaWNhdGlvbiovXG4vKiBBdCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzI3NzQqL1xuLyogaXMgYSByZWNvcmQgb2YgYSBmYWlsZWQgYXR0ZW1wdCB0byByZW1vdmUgdGhpcyBkdXBsaWNhdGlvbi4qL1xuXG4vKipcbiAqIEBjYWxsYmFjayBCYXNlQXNzZXJ0XG4gKiBUaGUgYGFzc2VydGAgZnVuY3Rpb24gaXRzZWxmLlxuICpcbiAqIEBwYXJhbSB7Kn0gZmxhZyBUaGUgdHJ1dGh5L2ZhbHN5IHZhbHVlXG4gKiBAcGFyYW0ge0RldGFpbHN9IFtvcHREZXRhaWxzXSBUaGUgZGV0YWlscyB0byB0aHJvd1xuICogQHBhcmFtIHtFcnJvckNvbnN0cnVjdG9yfSBbRXJyb3JDb25zdHJ1Y3Rvcl0gQW4gb3B0aW9uYWwgYWx0ZXJuYXRlIGVycm9yXG4gKiBjb25zdHJ1Y3RvciB0byB1c2UuXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBmbGFnfVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQXNzZXJ0TWFrZUVycm9yT3B0aW9uc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IFtlcnJvck5hbWVdXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0TWFrZUVycm9yXG4gKlxuICogVGhlIGBhc3NlcnQuZXJyb3JgIG1ldGhvZCwgcmVjb3JkaW5nIGRldGFpbHMgZm9yIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBvcHRpb25hbCBgb3B0RGV0YWlsc2AgY2FuIGJlIGEgc3RyaW5nLlxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc10gVGhlIGRldGFpbHMgb2Ygd2hhdCB3YXMgYXNzZXJ0ZWRcbiAqIEBwYXJhbSB7RXJyb3JDb25zdHJ1Y3Rvcn0gW0Vycm9yQ29uc3RydWN0b3JdIEFuIG9wdGlvbmFsIGFsdGVybmF0ZSBlcnJvclxuICogY29uc3RydWN0b3IgdG8gdXNlLlxuICogQHBhcmFtIHtBc3NlcnRNYWtlRXJyb3JPcHRpb25zfSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHtFcnJvcn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRGYWlsXG4gKlxuICogVGhlIGBhc3NlcnQuZmFpbGAgbWV0aG9kLlxuICpcbiAqIEZhaWwgYW4gYXNzZXJ0aW9uLCByZWNvcmRpbmcgZnVsbCBkZXRhaWxzIHRvIHRoZSBjb25zb2xlIGFuZFxuICogcmFpc2luZyBhbiBleGNlcHRpb24gd2l0aCBhIG1lc3NhZ2UgaW4gd2hpY2ggYGRldGFpbHNgIHN1YnN0aXR1dGlvbiB2YWx1ZXNcbiAqIGhhdmUgYmVlbiBtYXNrZWQuXG4gKlxuICogVGhlIG9wdGlvbmFsIGBvcHREZXRhaWxzYCBjYW4gYmUgYSBzdHJpbmcgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5XG4gKiB3aXRoIHRoZSBub2RlanMgYXNzZXJ0aW9uIGxpYnJhcnkuXG4gKiBAcGFyYW0ge0RldGFpbHN9IFtvcHREZXRhaWxzXSBUaGUgZGV0YWlscyBvZiB3aGF0IHdhcyBhc3NlcnRlZFxuICogQHBhcmFtIHtFcnJvckNvbnN0cnVjdG9yfSBbRXJyb3JDb25zdHJ1Y3Rvcl0gQW4gb3B0aW9uYWwgYWx0ZXJuYXRlIGVycm9yXG4gKiBjb25zdHJ1Y3RvciB0byB1c2UuXG4gKiBAcmV0dXJucyB7bmV2ZXJ9XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0RXF1YWxcbiAqIFRoZSBgYXNzZXJ0LmVxdWFsYCBtZXRob2RcbiAqXG4gKiBBc3NlcnQgdGhhdCB0d28gdmFsdWVzIG11c3QgYmUgYE9iamVjdC5pc2AuXG4gKiBAcGFyYW0geyp9IGFjdHVhbCBUaGUgdmFsdWUgd2UgcmVjZWl2ZWRcbiAqIEBwYXJhbSB7Kn0gZXhwZWN0ZWQgV2hhdCB3ZSB3YW50ZWRcbiAqIEBwYXJhbSB7RGV0YWlsc30gW29wdERldGFpbHNdIFRoZSBkZXRhaWxzIHRvIHRocm93XG4gKiBAcGFyYW0ge0Vycm9yQ29uc3RydWN0b3J9IFtFcnJvckNvbnN0cnVjdG9yXSBBbiBvcHRpb25hbCBhbHRlcm5hdGUgZXJyb3JcbiAqIGNvbnN0cnVjdG9yIHRvIHVzZS5cbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5cbi8qIFR5cGUgYWxsIHRoZSBvdmVybG9hZHMgb2YgdGhlIGFzc2VydFR5cGVvZiBmdW5jdGlvbi4qL1xuLyogVGhlcmUgbWF5IGV2ZW50dWFsbHkgYmUgYSBiZXR0ZXIgd2F5IHRvIGRvIHRoaXMsIGJ1dCovXG4vKiB0aGVtcyB0aGUgYnJlYWtzIHdpdGggVHlwZXNjcmlwdCA0LjAuKi9cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFR5cGVvZkJpZ2ludFxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuXG4gKiBAcGFyYW0geydiaWdpbnQnfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIGJpZ2ludH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRUeXBlb2ZCb29sZWFuXG4gKiBAcGFyYW0ge2FueX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7J2Jvb2xlYW4nfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIGJvb2xlYW59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0VHlwZW9mRnVuY3Rpb25cbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHBhcmFtIHsnZnVuY3Rpb24nfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIEZ1bmN0aW9ufVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFR5cGVvZk51bWJlclxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuXG4gKiBAcGFyYW0geydudW1iZXInfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIG51bWJlcn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRUeXBlb2ZPYmplY3RcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHBhcmFtIHsnb2JqZWN0J30gdHlwZW5hbWVcbiAqIEBwYXJhbSB7RGV0YWlsc30gW29wdERldGFpbHNdXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBzcGVjaW1lbiBpcyBSZWNvcmQ8YW55LCBhbnk+IHwgbnVsbH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRUeXBlb2ZTdHJpbmdcbiAqIEBwYXJhbSB7YW55fSBzcGVjaW1lblxuICogQHBhcmFtIHsnc3RyaW5nJ30gdHlwZW5hbWVcbiAqIEBwYXJhbSB7RGV0YWlsc30gW29wdERldGFpbHNdXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBzcGVjaW1lbiBpcyBzdHJpbmd9XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0VHlwZW9mU3ltYm9sXG4gKiBAcGFyYW0ge2FueX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7J3N5bWJvbCd9IHR5cGVuYW1lXG4gKiBAcGFyYW0ge0RldGFpbHN9IFtvcHREZXRhaWxzXVxuICogQHJldHVybnMge2Fzc2VydHMgc3BlY2ltZW4gaXMgc3ltYm9sfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFR5cGVvZlVuZGVmaW5lZFxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuXG4gKiBAcGFyYW0geyd1bmRlZmluZWQnfSB0eXBlbmFtZVxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc11cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIHVuZGVmaW5lZH1cbiAqL1xuXG4vKipcbiAqIFRoZSBgYXNzZXJ0LnR5cGVvZmAgbWV0aG9kXG4gKlxuICogQHR5cGVkZWYge0Fzc2VydFR5cGVvZkJpZ2ludCAmIEFzc2VydFR5cGVvZkJvb2xlYW4gJiBBc3NlcnRUeXBlb2ZGdW5jdGlvbiAmIEFzc2VydFR5cGVvZk51bWJlciAmIEFzc2VydFR5cGVvZk9iamVjdCAmIEFzc2VydFR5cGVvZlN0cmluZyAmIEFzc2VydFR5cGVvZlN5bWJvbCAmIEFzc2VydFR5cGVvZlVuZGVmaW5lZH0gQXNzZXJ0VHlwZW9mXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0U3RyaW5nXG4gKiBUaGUgYGFzc2VydC5zdHJpbmdgIG1ldGhvZC5cbiAqXG4gKiBgYXNzZXJ0LnN0cmluZyh2KWAgaXMgZXF1aXZhbGVudCB0byBgYXNzZXJ0LnR5cGVvZih2LCAnc3RyaW5nJylgLiBXZVxuICogc3BlY2lhbCBjYXNlIHRoaXMgb25lIGJlY2F1c2UgaXQgaXMgdGhlIG1vc3QgZnJlcXVlbnRseSB1c2VkLlxuICpcbiAqIEFzc2VydCBhbiBleHBlY3RlZCB0eXBlb2YgcmVzdWx0LlxuICogQHBhcmFtIHthbnl9IHNwZWNpbWVuIFRoZSB2YWx1ZSB0byBnZXQgdGhlIHR5cGVvZlxuICogQHBhcmFtIHtEZXRhaWxzfSBbb3B0RGV0YWlsc10gVGhlIGRldGFpbHMgdG8gdGhyb3dcbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIHN0cmluZ31cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnROb3RlXG4gKiBUaGUgYGFzc2VydC5ub3RlYCBtZXRob2QuXG4gKlxuICogQW5ub3RhdGUgYW4gZXJyb3Igd2l0aCBkZXRhaWxzLCBwb3RlbnRpYWxseSB0byBiZSB1c2VkIGJ5IGFuXG4gKiBhdWdtZW50ZWQgY29uc29sZSBzdWNoIGFzIHRoZSBjYXVzYWwgY29uc29sZSBvZiBgY29uc29sZS5qc2AsIHRvXG4gKiBwcm92aWRlIGV4dHJhIGluZm9ybWF0aW9uIGFzc29jaWF0ZWQgd2l0aCBsb2dnZWQgZXJyb3JzLlxuICpcbiAqIEBwYXJhbSB7RXJyb3J9IGVycm9yXG4gKiBAcGFyYW0ge0RldGFpbHN9IGRldGFpbHNOb3RlXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHR5cGVkZWYge3t9fSBEZXRhaWxzVG9rZW5cbiAqIEEgY2FsbCB0byB0aGUgYGRldGFpbHNgIHRlbXBsYXRlIGxpdGVyYWwgbWFrZXMgYW5kIHJldHVybnMgYSBmcmVzaCBkZXRhaWxzXG4gKiB0b2tlbiwgd2hpY2ggaXMgYSBmcm96ZW4gZW1wdHkgb2JqZWN0IGFzc29jaWF0ZWQgd2l0aCB0aGUgYXJndW1lbnRzIG9mIHRoYXRcbiAqIGBkZXRhaWxzYCB0ZW1wbGF0ZSBsaXRlcmFsIGV4cHJlc3Npb24uXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nIHwgRGV0YWlsc1Rva2VufSBEZXRhaWxzXG4gKiBFaXRoZXIgYSBwbGFpbiBzdHJpbmcsIG9yIG1hZGUgYnkgdGhlIGBkZXRhaWxzYCB0ZW1wbGF0ZSBsaXRlcmFsIHRhZy5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN0cmluZ2FibGVQYXlsb2FkXG4gKiBIb2xkcyB0aGUgcGF5bG9hZCBwYXNzZWQgdG8gcXVvdGUgc28gdGhhdCBpdHMgcHJpbnRlZCBmb3JtIGlzIHZpc2libGUuXG4gKiBAcHJvcGVydHkgeygpID0+IHN0cmluZ30gdG9TdHJpbmcgSG93IHRvIHByaW50IHRoZSBwYXlsb2FkXG4gKi9cblxuLyoqXG4gKiBUbyBcImRlY2xhc3NpZnlcIiBhbmQgcXVvdGUgYSBzdWJzdGl0dXRpb24gdmFsdWUgdXNlZCBpbiBhXG4gKiBgYGAgZGV0YWlsc2AuLi5gIGBgYCB0ZW1wbGF0ZSBsaXRlcmFsLCBlbmNsb3NlIHRoYXQgc3Vic3RpdHV0aW9uIGV4cHJlc3Npb25cbiAqIGluIGEgY2FsbCB0byBgcXVvdGVgLiBUaGlzIG1ha2VzIHRoZSB2YWx1ZSBhcHBlYXIgcXVvdGVkXG4gKiAoYXMgaWYgd2l0aCBgSlNPTi5zdHJpbmdpZnlgKSBpbiB0aGUgbWVzc2FnZSBvZiB0aGUgdGhyb3duIGVycm9yLiBUaGVcbiAqIHBheWxvYWQgaXRzZWxmIGlzIHN0aWxsIHBhc3NlZCB1bnF1b3RlZCB0byB0aGUgY29uc29sZSBhcyBpdCB3b3VsZCBiZVxuICogd2l0aG91dCBgcXVvdGVgLlxuICpcbiAqIEZvciBleGFtcGxlLCB0aGUgZm9sbG93aW5nIHdpbGwgcmV2ZWFsIHRoZSBleHBlY3RlZCBza3kgY29sb3IsIGJ1dCBub3QgdGhlXG4gKiBhY3R1YWwgaW5jb3JyZWN0IHNreSBjb2xvciwgaW4gdGhlIHRocm93biBlcnJvcidzIG1lc3NhZ2U6XG4gKiBgYGBqc1xuICogc2t5LmNvbG9yID09PSBleHBlY3RlZENvbG9yIHx8IEZhaWxgJHtza3kuY29sb3J9IHNob3VsZCBiZSAke3F1b3RlKGV4cGVjdGVkQ29sb3IpfWA7XG4gKiBgYGBcbiAqXG4gKiBUaGUgbm9ybWFsIGNvbnZlbnRpb24gaXMgdG8gbG9jYWxseSByZW5hbWUgYGRldGFpbHNgIHRvIGBYYCBhbmQgYHF1b3RlYCB0byBgcWBcbiAqIGxpa2UgYGNvbnN0IHsgZGV0YWlsczogWCwgcXVvdGU6IHEgfSA9IGFzc2VydDtgLCBzbyB0aGUgYWJvdmUgZXhhbXBsZSB3b3VsZCB0aGVuIGJlXG4gKiBgYGBqc1xuICogc2t5LmNvbG9yID09PSBleHBlY3RlZENvbG9yIHx8IEZhaWxgJHtza3kuY29sb3J9IHNob3VsZCBiZSAke3EoZXhwZWN0ZWRDb2xvcil9YDtcbiAqIGBgYFxuICpcbiAqIEBjYWxsYmFjayBBc3NlcnRRdW90ZVxuICogQHBhcmFtIHsqfSBwYXlsb2FkIFdoYXQgdG8gZGVjbGFzc2lmeVxuICogQHBhcmFtIHsoc3RyaW5nfG51bWJlcil9IFtzcGFjZXNdXG4gKiBAcmV0dXJucyB7U3RyaW5nYWJsZVBheWxvYWR9IFRoZSBkZWNsYXNzaWZpZWQgcGF5bG9hZFxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFJhaXNlXG4gKlxuICogVG8gbWFrZSBhbiBgYXNzZXJ0YCB3aGljaCB0ZXJtaW5hdGVzIHNvbWUgbGFyZ2VyIHVuaXQgb2YgY29tcHV0YXRpb25cbiAqIGxpa2UgYSB0cmFuc2FjdGlvbiwgdmF0LCBvciBwcm9jZXNzLCBjYWxsIGBtYWtlQXNzZXJ0YCB3aXRoIGEgYFJhaXNlYFxuICogY2FsbGJhY2ssIHdoZXJlIHRoYXQgY2FsbGJhY2sgYWN0dWFsbHkgcGVyZm9ybXMgdGhhdCBsYXJnZXIgdGVybWluYXRpb24uXG4gKiBJZiBwb3NzaWJsZSwgdGhlIGNhbGxiYWNrIHNob3VsZCBhbHNvIHJlcG9ydCBpdHMgYHJlYXNvbmAgcGFyYW1ldGVyIGFzXG4gKiB0aGUgYWxsZWdlZCByZWFzb24gZm9yIHRoZSB0ZXJtaW5hdGlvbi5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSByZWFzb25cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBNYWtlQXNzZXJ0XG4gKlxuICogTWFrZXMgYW5kIHJldHVybnMgYW4gYGFzc2VydGAgZnVuY3Rpb24gb2JqZWN0IHRoYXQgc2hhcmVzIHRoZSBib29ra2VlcGluZ1xuICogc3RhdGUgZGVmaW5lZCBieSB0aGlzIG1vZHVsZSB3aXRoIG90aGVyIGBhc3NlcnRgIGZ1bmN0aW9uIG9iamVjdHMgbWFkZSBieVxuICogYG1ha2VBc3NlcnRgLiBUaGlzIHN0YXRlIGlzIHBlci1tb2R1bGUtaW5zdGFuY2UgYW5kIGlzIGV4cG9zZWQgYnkgdGhlXG4gKiBgbG9nZ2VkRXJyb3JIYW5kbGVyYCBhYm92ZS4gV2UgcmVmZXIgdG8gYGFzc2VydGAgYXMgYSBcImZ1bmN0aW9uIG9iamVjdFwiXG4gKiBiZWNhdXNlIGl0IGNhbiBiZSBjYWxsZWQgZGlyZWN0bHkgYXMgYSBmdW5jdGlvbiwgYnV0IGFsc28gaGFzIG1ldGhvZHMgdGhhdFxuICogY2FuIGJlIGNhbGxlZC5cbiAqXG4gKiBJZiBgb3B0UmFpc2VgIGlzIHByb3ZpZGVkLCB0aGUgcmV0dXJuZWQgYGFzc2VydGAgZnVuY3Rpb24gb2JqZWN0IHdpbGwgY2FsbFxuICogYG9wdFJhaXNlKHJlYXNvbilgIGJlZm9yZSB0aHJvd2luZyB0aGUgZXJyb3IuIFRoaXMgZW5hYmxlcyBgb3B0UmFpc2VgIHRvXG4gKiBlbmdhZ2UgaW4gZXZlbiBtb3JlIHZpb2xlbnQgdGVybWluYXRpb24gYmVoYXZpb3IsIGxpa2UgdGVybWluYXRpbmcgdGhlIHZhdCxcbiAqIHRoYXQgcHJldmVudHMgZXhlY3V0aW9uIGZyb20gcmVhY2hpbmcgdGhlIGZvbGxvd2luZyB0aHJvdy4gSG93ZXZlciwgaWZcbiAqIGBvcHRSYWlzZWAgcmV0dXJucyBub3JtYWxseSwgd2hpY2ggd291bGQgYmUgdW51c3VhbCwgdGhlIHRocm93IGZvbGxvd2luZ1xuICogYG9wdFJhaXNlKHJlYXNvbilgIHdvdWxkIHN0aWxsIGhhcHBlbi5cbiAqXG4gKiBAcGFyYW0ge1JhaXNlfSBbb3B0UmFpc2VdXG4gKiBAcGFyYW0ge2Jvb2xlYW59IFt1bnJlZGFjdGVkXVxuICogQHJldHVybnMge0Fzc2VydH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsodGVtcGxhdGU6IFRlbXBsYXRlU3RyaW5nc0FycmF5IHwgc3RyaW5nW10sIC4uLmFyZ3M6IGFueSkgPT4gRGV0YWlsc1Rva2VufSBEZXRhaWxzVGFnXG4gKlxuICogVXNlIHRoZSBgZGV0YWlsc2AgZnVuY3Rpb24gYXMgYSB0ZW1wbGF0ZSBsaXRlcmFsIHRhZyB0byBjcmVhdGVcbiAqIGluZm9ybWF0aXZlIGVycm9yIG1lc3NhZ2VzLiBUaGUgYXNzZXJ0aW9uIGZ1bmN0aW9ucyB0YWtlIHN1Y2ggbWVzc2FnZXNcbiAqIGFzIG9wdGlvbmFsIGFyZ3VtZW50czpcbiAqIGBgYGpzXG4gKiBhc3NlcnQoc2t5LmlzQmx1ZSgpLCBkZXRhaWxzYCR7c2t5LmNvbG9yfSBzaG91bGQgYmUgXCJibHVlXCJgKTtcbiAqIGBgYFxuICogb3IgZm9sbG93aW5nIHRoZSBub3JtYWwgY29udmVudGlvbiB0byBsb2NhbGx5IHJlbmFtZSBgZGV0YWlsc2AgdG8gYFhgXG4gKiBhbmQgYHF1b3RlYCB0byBgcWAgbGlrZSBgY29uc3QgeyBkZXRhaWxzOiBYLCBxdW90ZTogcSB9ID0gYXNzZXJ0O2A6XG4gKiBgYGBqc1xuICogYXNzZXJ0KHNreS5pc0JsdWUoKSwgWGAke3NreS5jb2xvcn0gc2hvdWxkIGJlIFwiYmx1ZVwiYCk7XG4gKiBgYGBcbiAqIEhvd2V2ZXIsIG5vdGUgdGhhdCBpbiBtb3N0IGNhc2VzIGl0IGlzIHByZWZlcmFibGUgdG8gaW5zdGVhZCB1c2UgdGhlIGBGYWlsYFxuICogdGVtcGxhdGUgbGl0ZXJhbCB0YWcgKHdoaWNoIGhhcyB0aGUgc2FtZSBpbnB1dCBzaWduYXR1cmUgYXMgYGRldGFpbHNgXG4gKiBidXQgYXV0b21hdGljYWxseSBjcmVhdGVzIGFuZCB0aHJvd3MgYW4gZXJyb3IpOlxuICogYGBganNcbiAqIHNreS5pc0JsdWUoKSB8fCBGYWlsYCR7c2t5LmNvbG9yfSBzaG91bGQgYmUgXCJibHVlXCJgO1xuICogYGBgXG4gKlxuICogVGhlIGRldGFpbHMgdGVtcGxhdGUgdGFnIHJldHVybnMgYSBgRGV0YWlsc1Rva2VuYCBvYmplY3QgdGhhdCBjYW4gcHJpbnRcbiAqIGl0c2VsZiB3aXRoIHRoZSBmb3JtYXR0ZWQgbWVzc2FnZSBpbiB0d28gd2F5cy5cbiAqIEl0IHdpbGwgcmVwb3J0IGZ1bGwgZGV0YWlscyB0byB0aGUgY29uc29sZSwgYnV0XG4gKiBtYXNrIGVtYmVkZGVkIHN1YnN0aXR1dGlvbiB2YWx1ZXMgd2l0aCB0aGVpciB0eXBlb2YgaW5mb3JtYXRpb24gaW4gdGhlIHRocm93biBlcnJvclxuICogdG8gcHJldmVudCByZXZlYWxpbmcgc2VjcmV0cyB1cCB0aGUgZXhjZXB0aW9uYWwgcGF0aC4gSW4gdGhlIGV4YW1wbGVcbiAqIGFib3ZlLCB0aGUgdGhyb3duIGVycm9yIG1heSByZXZlYWwgb25seSB0aGF0IGBza3kuY29sb3JgIGlzIGEgc3RyaW5nLFxuICogd2hlcmVhcyB0aGUgc2FtZSBkaWFnbm9zdGljIHByaW50ZWQgdG8gdGhlIGNvbnNvbGUgcmV2ZWFscyB0aGF0IHRoZVxuICogc2t5IHdhcyBncmVlbi4gVGhpcyBtYXNraW5nIGNhbiBiZSBkaXNhYmxlZCBmb3IgYW4gaW5kaXZpZHVhbCBzdWJzdGl0dXRpb24gdmFsdWVcbiAqIHVzaW5nIGBxdW90ZWAuXG4gKlxuICogVGhlIGByYXdgIHByb3BlcnR5IG9mIGFuIGlucHV0IHRlbXBsYXRlIGFycmF5IGlzIGlnbm9yZWQsIHNvIGEgc2ltcGxlXG4gKiBhcnJheSBvZiBzdHJpbmdzIG1heSBiZSBwcm92aWRlZCBkaXJlY3RseS5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsodGVtcGxhdGU6IFRlbXBsYXRlU3RyaW5nc0FycmF5IHwgc3RyaW5nW10sIC4uLmFyZ3M6IGFueSkgPT4gbmV2ZXJ9IEZhaWxUYWdcbiAqXG4gKiBVc2UgdGhlIGBGYWlsYCBmdW5jdGlvbiBhcyBhIHRlbXBsYXRlIGxpdGVyYWwgdGFnIHRvIGVmZmljaWVudGx5XG4gKiBjcmVhdGUgYW5kIHRocm93IGEgYGRldGFpbHNgLXN0eWxlIGVycm9yIG9ubHkgd2hlbiBhIGNvbmRpdGlvbiBpcyBub3Qgc2F0aXNmaWVkLlxuICogYGBganNcbiAqIGNvbmRpdGlvbiB8fCBGYWlsYC4uLmNvbXBsYWludC4uLmA7XG4gKiBgYGBcbiAqIFRoaXMgYXZvaWRzIHRoZSBvdmVyaGVhZCBvZiBjcmVhdGluZyB1c3VhbGx5LXVubmVjZXNzYXJ5IGVycm9ycyBsaWtlXG4gKiBgYGBqc1xuICogYXNzZXJ0KGNvbmRpdGlvbiwgZGV0YWlsc2AuLi5jb21wbGFpbnQuLi5gKTtcbiAqIGBgYFxuICogd2hpbGUgaW1wcm92aW5nIHJlYWRhYmlsaXR5IG92ZXIgYWx0ZXJuYXRpdmVzIGxpa2VcbiAqIGBgYGpzXG4gKiBjb25kaXRpb24gfHwgYXNzZXJ0LmZhaWwoZGV0YWlsc2AuLi5jb21wbGFpbnQuLi5gKTtcbiAqIGBgYFxuICpcbiAqIEhvd2V2ZXIsIGR1ZSB0byBjdXJyZW50IHdlYWtuZXNzIGluIFR5cGVTY3JpcHQsIHN0YXRpYyByZWFzb25pbmdcbiAqIGlzIGxlc3MgcG93ZXJmdWwgd2l0aCB0aGUgYHx8YCBwYXR0ZXJucyB0aGFuIHdpdGggYW4gYGFzc2VydGAgY2FsbC5cbiAqIFVudGlsL3VubGVzcyBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUxNDI2IGlzIGZpeGVkLFxuICogZm9yIGB8fGAtc3R5bGUgYXNzZXJ0aW9ucyB3aGVyZSB0aGlzIGxvc3Mgb2Ygc3RhdGljIHJlYXNvbmluZyBpcyBhIHByb2JsZW0sXG4gKiBpbnN0ZWFkIGV4cHJlc3MgdGhlIGFzc2VydGlvbiBhc1xuICogYGBganNcbiAqICAgaWYgKCFjb25kaXRpb24pIHtcbiAqICAgICBGYWlsYC4uLmNvbXBsYWludC4uLmA7XG4gKiAgIH1cbiAqIGBgYFxuICogb3IsIGlmIG5lZWRlZCxcbiAqIGBgYGpzXG4gKiAgIGlmICghY29uZGl0aW9uKSB7XG4gKiAgICAgLy8gYHRocm93YCBpcyBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MsIGJ1dCBpdCBpbXByb3ZlcyBzdGF0aWMgYW5hbHlzaXNcbiAqICAgICB0aHJvdyBGYWlsYC4uLmNvbXBsYWludC4uLmA7XG4gKiAgIH1cbiAqIGBgYFxuICovXG5cbi8qKlxuICogYXNzZXJ0IHRoYXQgZXhwciBpcyB0cnV0aHksIHdpdGggYW4gb3B0aW9uYWwgZGV0YWlscyB0byBkZXNjcmliZVxuICogdGhlIGFzc2VydGlvbi4gSXQgaXMgYSB0YWdnZWQgdGVtcGxhdGUgbGl0ZXJhbCBsaWtlXG4gKiBgYGBqc1xuICogYXNzZXJ0KGV4cHIsIGRldGFpbHNgLi4uLmApO2BcbiAqIGBgYFxuICpcbiAqIFRoZSBsaXRlcmFsIHBvcnRpb25zIG9mIHRoZSB0ZW1wbGF0ZSBhcmUgYXNzdW1lZCBub24tc2Vuc2l0aXZlLCBhc1xuICogYXJlIHRoZSBgdHlwZW9mYCB0eXBlcyBvZiB0aGUgc3Vic3RpdHV0aW9uIHZhbHVlcy4gVGhlc2UgYXJlXG4gKiBhc3NlbWJsZWQgaW50byB0aGUgdGhyb3duIGVycm9yIG1lc3NhZ2UuIFRoZSBhY3R1YWwgY29udGVudHMgb2YgdGhlXG4gKiBzdWJzdGl0dXRpb24gdmFsdWVzIGFyZSBhc3N1bWVkIHNlbnNpdGl2ZSwgdG8gYmUgcmV2ZWFsZWQgdG9cbiAqIHRoZSBjb25zb2xlIG9ubHkuIFdlIGFzc3VtZSBvbmx5IHRoZSB2aXJ0dWFsIHBsYXRmb3JtJ3Mgb3duZXIgY2FuIHJlYWRcbiAqIHdoYXQgaXMgd3JpdHRlbiB0byB0aGUgY29uc29sZSwgd2hlcmUgdGhlIG93bmVyIGlzIGluIGEgcHJpdmlsZWdlZFxuICogcG9zaXRpb24gb3ZlciBjb21wdXRhdGlvbiBydW5uaW5nIG9uIHRoYXQgcGxhdGZvcm0uXG4gKlxuICogVGhlIG9wdGlvbmFsIGBvcHREZXRhaWxzYCBjYW4gYmUgYSBzdHJpbmcgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5XG4gKiB3aXRoIHRoZSBub2RlanMgYXNzZXJ0aW9uIGxpYnJhcnkuXG4gKlxuICogQHR5cGVkZWYgeyBCYXNlQXNzZXJ0ICYge1xuICogICB0eXBlb2Y6IEFzc2VydFR5cGVvZixcbiAqICAgZXJyb3I6IEFzc2VydE1ha2VFcnJvcixcbiAqICAgZmFpbDogQXNzZXJ0RmFpbCxcbiAqICAgZXF1YWw6IEFzc2VydEVxdWFsLFxuICogICBzdHJpbmc6IEFzc2VydFN0cmluZyxcbiAqICAgbm90ZTogQXNzZXJ0Tm90ZSxcbiAqICAgZGV0YWlsczogRGV0YWlsc1RhZyxcbiAqICAgRmFpbDogRmFpbFRhZyxcbiAqICAgcXVvdGU6IEFzc2VydFF1b3RlLFxuICogICBtYWtlQXNzZXJ0OiBNYWtlQXNzZXJ0LFxuICogfSB9IEFzc2VydFxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAKuKI6ZsAQAAbAEAACYAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9leHBvcnRlZC5qc3siaW1wb3J0cyI6WyIuL3NyYy90eXBlcy1hbWJpZW50LmpzIl0sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vc3JjL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAFP1hb9GNwAARjcAACwAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvYW1vdW50TWF0aC5qc3siaW1wb3J0cyI6WyIuL21hdGhIZWxwZXJzL2NvcHlCYWdNYXRoSGVscGVycy5qcyIsIi4vbWF0aEhlbHBlcnMvY29weVNldE1hdGhIZWxwZXJzLmpzIiwiLi9tYXRoSGVscGVycy9uYXRNYXRoSGVscGVycy5qcyIsIi4vbWF0aEhlbHBlcnMvc2V0TWF0aEhlbHBlcnMuanMiLCJAYWdvcmljL3N0b3JlIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbIkFtb3VudE1hdGgiLCJBc3NldEtpbmQiLCJhc3NlcnRBc3NldEtpbmQiLCJhc3NlcnRWYWx1ZUdldEhlbHBlcnMiLCJnZXRBc3NldEtpbmQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcGFzc1N0eWxlT2YsYXNzZXJ0UmVtb3RhYmxlLGFzc2VydFJlY29yZCxNLG1hdGNoZXMsbmF0TWF0aEhlbHBlcnMsc2V0TWF0aEhlbHBlcnMsY29weVNldE1hdGhIZWxwZXJzLGNvcHlCYWdNYXRoSGVscGVyczskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcImFzc2VydFJlbW90YWJsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UmVtb3RhYmxlID0gJGjigI1fYSldXSxbXCJhc3NlcnRSZWNvcmRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlY29yZCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJtYXRjaGVzXCIsIFskaOKAjV9hID0+IChtYXRjaGVzID0gJGjigI1fYSldXV1dLFtcIi4vbWF0aEhlbHBlcnMvbmF0TWF0aEhlbHBlcnMuanNcIiwgW1tcIm5hdE1hdGhIZWxwZXJzXCIsIFskaOKAjV9hID0+IChuYXRNYXRoSGVscGVycyA9ICRo4oCNX2EpXV1dXSxbXCIuL21hdGhIZWxwZXJzL3NldE1hdGhIZWxwZXJzLmpzXCIsIFtbXCJzZXRNYXRoSGVscGVyc1wiLCBbJGjigI1fYSA9PiAoc2V0TWF0aEhlbHBlcnMgPSAkaOKAjV9hKV1dXV0sW1wiLi9tYXRoSGVscGVycy9jb3B5U2V0TWF0aEhlbHBlcnMuanNcIiwgW1tcImNvcHlTZXRNYXRoSGVscGVyc1wiLCBbJGjigI1fYSA9PiAoY29weVNldE1hdGhIZWxwZXJzID0gJGjigI1fYSldXV1dLFtcIi4vbWF0aEhlbHBlcnMvY29weUJhZ01hdGhIZWxwZXJzLmpzXCIsIFtbXCJjb3B5QmFnTWF0aEhlbHBlcnNcIiwgWyRo4oCNX2EgPT4gKGNvcHlCYWdNYXRoSGVscGVycyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuLyoqXG4gKiBDb25zdGFudHMgZm9yIHRoZSBraW5kcyBvZiBhc3NldHMgd2Ugc3VwcG9ydC5cbiAqXG4gKiBAdHlwZSB7eyBOQVQ6ICduYXQnLCBTRVQ6ICdzZXQnLCBDT1BZX1NFVDogJ2NvcHlTZXQnLCBDT1BZX0JBRzogJ2NvcHlCYWcnIH19XG4gKi9cbmNvbnN0IEFzc2V0S2luZD1oYXJkZW4oe1xuTkFUOiduYXQnLFxuU0VUOidzZXQnLFxuQ09QWV9TRVQ6J2NvcHlTZXQnLFxuQ09QWV9CQUc6J2NvcHlCYWcnfSk7JGjigI1fb25jZS5Bc3NldEtpbmQoQXNzZXRLaW5kKTtcblxuY29uc3QgYXNzZXRLaW5kTmFtZXM9aGFyZGVuKE9iamVjdC52YWx1ZXMoQXNzZXRLaW5kKS5zb3J0KCkpO1xuXG4vKipcbiAqIEBwYXJhbSB7QXNzZXRLaW5kfSBhbGxlZ2VkQUtcbiAqL1xuY29uc3QgYXNzZXJ0QXNzZXRLaW5kPShhbGxlZ2VkQUspPT57XG5hc3NldEtpbmROYW1lcy5pbmNsdWRlcyhhbGxlZ2VkQUspfHxcbkZhaWwgYFRoZSBhc3NldEtpbmQgJHthbGxlZ2VkQUt9IG11c3QgYmUgb25lIG9mICR7cShhc3NldEtpbmROYW1lcyl9YDtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0QXNzZXRLaW5kKGFzc2VydEFzc2V0S2luZCk7XG5oYXJkZW4oYXNzZXJ0QXNzZXRLaW5kKTtcblxuLyoqXG4gKiBBbW91bnRzIGRlc2NyaWJlIGRpZ2l0YWwgYXNzZXRzLiBGcm9tIGFuIGFtb3VudCwgeW91IGNhbiBsZWFybiB0aGVcbiAqIGJyYW5kIG9mIGRpZ2l0YWwgYXNzZXQgYXMgd2VsbCBhcyBcImhvdyBtdWNoXCIgb3IgXCJob3cgbWFueVwiLiBBbW91bnRzXG4gKiBoYXZlIHR3byBwYXJ0czogYSBicmFuZCAobG9vc2VseSBzcGVha2luZywgdGhlIHR5cGUgb2YgZGlnaXRhbFxuICogYXNzZXQpIGFuZCB0aGUgdmFsdWUgKHRoZSBhbnN3ZXIgdG8gXCJob3cgbXVjaFwiKS4gRm9yIGV4YW1wbGUsIGluXG4gKiB0aGUgcGhyYXNlIFwiNSBidWNrc1wiLCBcImJ1Y2tzXCIgdGFrZXMgdGhlIHJvbGUgb2YgdGhlIGJyYW5kIGFuZCB0aGVcbiAqIHZhbHVlIGlzIDUuIEFtb3VudHMgY2FuIGRlc2NyaWJlIGZ1bmdpYmxlIGFuZCBub24tZnVuZ2libGUgZGlnaXRhbFxuICogYXNzZXRzLiBBbW91bnRzIGFyZSBwYXNzLWJ5LWNvcHkgYW5kIGNhbiBiZSBtYWRlIGJ5IGFuZCBzZW50IHRvXG4gKiBhbnlvbmUuXG4gKlxuICogVGhlIGlzc3VlciBpcyB0aGUgYXV0aG9yaXRhdGl2ZSBzb3VyY2Ugb2YgdGhlIGFtb3VudCBpbiBwYXltZW50c1xuICogYW5kIHB1cnNlcy4gVGhlIGlzc3VlciBtdXN0IGJlIGFibGUgdG8gZG8gdGhpbmdzIHN1Y2ggYXMgYWRkXG4gKiBkaWdpdGFsIGFzc2V0cyB0byBhIHB1cnNlIGFuZCB3aXRoZHJhdyBkaWdpdGFsIGFzc2V0cyBmcm9tIGEgcHVyc2UuXG4gKiBUbyBkbyBzbywgaXQgbXVzdCBrbm93IGhvdyB0byBhZGQgYW5kIHN1YnRyYWN0IGRpZ2l0YWwgYXNzZXRzLlxuICogUmF0aGVyIHRoYW4gaGFyZC1jb2RpbmcgYSBwYXJ0aWN1bGFyIHNvbHV0aW9uLCB3ZSBjaG9zZSB0b1xuICogcGFyYW1ldGVyaXplIHRoZSBpc3N1ZXIgd2l0aCBhIGNvbGxlY3Rpb24gb2YgcG9seW1vcnBoaWMgZnVuY3Rpb25zLFxuICogd2hpY2ggd2UgY2FsbCBgQW1vdW50TWF0aGAuIFRoZXNlIG1hdGggZnVuY3Rpb25zIGluY2x1ZGUgY29uY2VwdHNcbiAqIGxpa2UgYWRkaXRpb24sIHN1YnRyYWN0aW9uLCBhbmQgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvLlxuICpcbiAqIFdlIGFsc28gd2FudCB0byBtYWtlIHN1cmUgdGhlcmUgaXMgbm8gY29uZnVzaW9uIGFzIHRvIHdoYXQga2luZCBvZlxuICogYXNzZXQgd2UgYXJlIHVzaW5nLiBUaHVzLCBBbW91bnRNYXRoIGluY2x1ZGVzIGNoZWNrcyBvZiB0aGVcbiAqIGBicmFuZGAsIHRoZSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHR5cGUgb2YgZGlnaXRhbCBhc3NldC4gSWZcbiAqIHRoZSB3cm9uZyBicmFuZCBpcyB1c2VkIGluIEFtb3VudE1hdGgsIGFuIGVycm9yIGlzIHRocm93biBhbmQgdGhlXG4gKiBvcGVyYXRpb24gZG9lcyBub3Qgc3VjY2VlZC5cbiAqXG4gKiBBbW91bnRNYXRoIHVzZXMgbWF0aEhlbHBlcnMgdG8gZG8gbW9zdCBvZiB0aGUgd29yaywgYnV0IHRoZW4gYWRkc1xuICogdGhlIGJyYW5kIHRvIHRoZSByZXN1bHQuIFRoZSBmdW5jdGlvbiBgdmFsdWVgIGdldHMgdGhlIHZhbHVlIGZyb21cbiAqIHRoZSBhbW91bnQgYnkgcmVtb3ZpbmcgdGhlIGJyYW5kIChhbW91bnQgLT4gdmFsdWUpLCBhbmQgdGhlXG4gKiBmdW5jdGlvbiBgbWFrZWAgYWRkcyB0aGUgYnJhbmQgdG8gcHJvZHVjZSBhbiBhbW91bnQgKHZhbHVlIC0+XG4gKiBhbW91bnQpLiBUaGUgZnVuY3Rpb24gYGNvZXJjZWAgdGFrZXMgYW4gYW1vdW50IGFuZCBjaGVja3MgaXQsXG4gKiByZXR1cm5pbmcgYW4gYW1vdW50IChhbW91bnQgLT4gYW1vdW50KS5cbiAqXG4gKiBFYWNoIGlzc3VlciBvZiBkaWdpdGFsIGFzc2V0cyBoYXMgYW4gYXNzb2NpYXRlZCBicmFuZCBpbiBhXG4gKiBvbmUtdG8tb25lIG1hcHBpbmcuIEluIHVudHJ1c3RlZCBjb250ZXh0cywgc3VjaCBhcyBpbiBhbmFseXppbmdcbiAqIHBheW1lbnRzIGFuZCBhbW91bnRzLCB3ZSBjYW4gZ2V0IHRoZSBicmFuZCBhbmQgZmluZCB0aGUgaXNzdWVyXG4gKiB3aGljaCBtYXRjaGVzIHRoZSBicmFuZC4gVGhlIGlzc3VlciBhbmQgdGhlIGJyYW5kIG11dHVhbGx5IHZhbGlkYXRlXG4gKiBlYWNoIG90aGVyLlxuICovXG5cbmNvbnN0IGhlbHBlcnM9e1xubmF0Om5hdE1hdGhIZWxwZXJzLFxuc2V0OnNldE1hdGhIZWxwZXJzLFxuY29weVNldDpjb3B5U2V0TWF0aEhlbHBlcnMsXG5jb3B5QmFnOmNvcHlCYWdNYXRoSGVscGVyc307XG5cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Ftb3VudFZhbHVlfSBWXG4gKiBAdHlwZSB7KHZhbHVlOiBWKSA9PiBBc3NldEtpbmRGb3JWYWx1ZTxWPn1cbiAqL1xuY29uc3QgYXNzZXJ0VmFsdWVHZXRBc3NldEtpbmQ9KHZhbHVlKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHZhbHVlKTtcbmlmKHBhc3NTdHlsZT09PSdiaWdpbnQnKXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCovXG5yZXR1cm4nbmF0JztcbiB9XG5pZihwYXNzU3R5bGU9PT0nY29weUFycmF5Jyl7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xucmV0dXJuJ3NldCc7XG4gfVxuaWYobWF0Y2hlcyh2YWx1ZSxNLnNldCgpKSl7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xucmV0dXJuJ2NvcHlTZXQnO1xuIH1cbmlmKG1hdGNoZXModmFsdWUsTS5iYWcoKSkpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBjYXN0Ki9cbnJldHVybidjb3B5QmFnJztcbiB9XG4vKiBUT0RPIFRoaXMgaXNuJ3QgcXVpdGUgdGhlIHJpZ2h0IGVycm9yIG1lc3NhZ2UsIGluIGNhc2UgdmFsdWVQYXNzU3R5bGUqL1xuLyogaXMgJ3RhZ2dlZCcuIFdlIHdvdWxkIG5lZWQgdG8gZGlzdGluZ3Vpc2ggd2hhdCBraW5kIG9mIHRhZ2dlZCovXG4vKiBvYmplY3QgaXQgaXMuKi9cbi8qIEFsc28sIHRoaXMga2luZCBvZiBtYW51YWwgbGlzdGluZyBpcyBhIG1haW50ZW5hbmNlIGhhemFyZCB3ZSovXG4vKiAoVE9ETykgd2lsbCBlbmNvdW50ZXIgd2hlbiB3ZSBleHRlbmQgdGhlIG1hdGggaGVscGVycyBmdXJ0aGVyLiovXG50aHJvdyBGYWlsIGB2YWx1ZSAke3ZhbHVlfSBtdXN0IGJlIGEgYmlnaW50LCBjb3B5U2V0LCBjb3B5QmFnLCBvciBhbiBhcnJheSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9O1xuXG4vKipcbiAqIEFzc2VydHMgdGhhdCB2YWx1ZSBpcyBhIHZhbGlkIEFtb3VudE1hdGggYW5kIHJldHVybnMgdGhlIGFwcHJvcHJpYXRlIGhlbHBlcnMuXG4gKlxuICogTWFkZSBhdmFpbGFibGUgb25seSBmb3IgdGVzdGluZywgYnV0IGl0IGlzIGhhcm1sZXNzIGZvciBvdGhlciB1c2VzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QW1vdW50VmFsdWV9IFZcbiAqIEBwYXJhbSB7Vn0gdmFsdWVcbiAqIEByZXR1cm5zIHtNYXRoSGVscGVyczxWPn1cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFZhbHVlR2V0SGVscGVycz0odmFsdWUpPT5cbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCovXG5oZWxwZXJzW2Fzc2VydFZhbHVlR2V0QXNzZXRLaW5kKHZhbHVlKV07XG5cbi8qKiBAdHlwZSB7KGFsbGVnZWRCcmFuZDogQnJhbmQsIGJyYW5kPzogQnJhbmQpID0+IHZvaWR9ICovJGjigI1fb25jZS5hc3NlcnRWYWx1ZUdldEhlbHBlcnMoYXNzZXJ0VmFsdWVHZXRIZWxwZXJzKTtcbmNvbnN0IG9wdGlvbmFsQnJhbmRDaGVjaz0oYWxsZWdlZEJyYW5kLGJyYW5kKT0+e1xuaWYoYnJhbmQhPT11bmRlZmluZWQpe1xuYXNzZXJ0UmVtb3RhYmxlKGJyYW5kLCdicmFuZCcpO1xuYWxsZWdlZEJyYW5kPT09YnJhbmR8fFxuRmFpbCBgYW1vdW50J3MgYnJhbmQgJHtxKGFsbGVnZWRCcmFuZCl9IGRpZCBub3QgbWF0Y2ggZXhwZWN0ZWQgYnJhbmQgJHtxKFxuYnJhbmQpXG4gfWA7XG4gfVxuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSBsZWZ0QW1vdW50XG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gcmlnaHRBbW91bnRcbiAqIEBwYXJhbSB7QnJhbmQ8Sz4gfCB1bmRlZmluZWR9IGJyYW5kXG4gKiBAcmV0dXJucyB7TWF0aEhlbHBlcnM8Kj59XG4gKi9cbmNvbnN0IGNoZWNrTFJBbmRHZXRIZWxwZXJzPShsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kPXVuZGVmaW5lZCk9PntcbmFzc2VydFJlY29yZChsZWZ0QW1vdW50LCdsZWZ0QW1vdW50Jyk7XG5hc3NlcnRSZWNvcmQocmlnaHRBbW91bnQsJ3JpZ2h0QW1vdW50Jyk7XG5jb25zdHt2YWx1ZTpsZWZ0VmFsdWUsYnJhbmQ6bGVmdEJyYW5kfT1sZWZ0QW1vdW50O1xuY29uc3R7dmFsdWU6cmlnaHRWYWx1ZSxicmFuZDpyaWdodEJyYW5kfT1yaWdodEFtb3VudDtcbmFzc2VydFJlbW90YWJsZShsZWZ0QnJhbmQsJ2xlZnRCcmFuZCcpO1xuYXNzZXJ0UmVtb3RhYmxlKHJpZ2h0QnJhbmQsJ3JpZ2h0QnJhbmQnKTtcbm9wdGlvbmFsQnJhbmRDaGVjayhsZWZ0QnJhbmQsYnJhbmQpO1xub3B0aW9uYWxCcmFuZENoZWNrKHJpZ2h0QnJhbmQsYnJhbmQpO1xubGVmdEJyYW5kPT09cmlnaHRCcmFuZHx8XG5GYWlsIGBCcmFuZHMgaW4gbGVmdCAke3EobGVmdEJyYW5kKX0gYW5kIHJpZ2h0ICR7cShcbnJpZ2h0QnJhbmQpXG4gfSBzaG91bGQgbWF0Y2ggYnV0IGRvIG5vdGA7XG5jb25zdCBsZWZ0SGVscGVycz1hc3NlcnRWYWx1ZUdldEhlbHBlcnMobGVmdFZhbHVlKTtcbmNvbnN0IHJpZ2h0SGVscGVycz1hc3NlcnRWYWx1ZUdldEhlbHBlcnMocmlnaHRWYWx1ZSk7XG5sZWZ0SGVscGVycz09PXJpZ2h0SGVscGVyc3x8XG5GYWlsIGBUaGUgbGVmdCAke2xlZnRBbW91bnR9IGFuZCByaWdodCBhbW91bnQgJHtyaWdodEFtb3VudH0gaGFkIGRpZmZlcmVudCBhc3NldEtpbmRzYDtcbnJldHVybiBsZWZ0SGVscGVycztcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge01hdGhIZWxwZXJzPEFzc2V0VmFsdWVGb3JLaW5kPEs+Pn0gaFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IGxlZnRBbW91bnRcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSByaWdodEFtb3VudFxuICogQHJldHVybnMge1tLLCBLXX1cbiAqL1xuY29uc3QgY29lcmNlTFI9KGgsbGVmdEFtb3VudCxyaWdodEFtb3VudCk9Pntcbi8qIEB0cy1leHBlY3QtZXJyb3IgY291bGQgYmUgYXJiaXRyYXJ5IHN1YnR5cGUqL1xucmV0dXJuW2guZG9Db2VyY2UobGVmdEFtb3VudC52YWx1ZSksaC5kb0NvZXJjZShyaWdodEFtb3VudC52YWx1ZSldO1xuIH07XG5cbi8qKlxuICogUmV0dXJucyB0cnVlIGlmIHRoZSBsZWZ0QW1vdW50IGlzIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byB0aGVcbiAqIHJpZ2h0QW1vdW50LiBUaGUgbm90aW9uIG9mIFwiZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvXCIgZGVwZW5kc1xuICogb24gdGhlIGtpbmQgb2YgYW1vdW50LCBhcyBkZWZpbmVkIGJ5IHRoZSBNYXRoSGVscGVycy4gRm9yIGV4YW1wbGUsXG4gKiB3aGV0aGVyIHJlY3RhbmdsZSBBIGlzIGdyZWF0ZXIgdGhhbiByZWN0YW5nbGUgQiBkZXBlbmRzIG9uIHdoZXRoZXIgcmVjdGFuZ2xlXG4gKiBBIGluY2x1ZGVzIHJlY3RhbmdsZSBCIGFzIGRlZmluZWQgYnkgdGhlIGxvZ2ljIGluIE1hdGhIZWxwZXJzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gbGVmdEFtb3VudFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IHJpZ2h0QW1vdW50XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgaXNHVEU9KGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuY29uc3QgaD1jaGVja0xSQW5kR2V0SGVscGVycyhsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kKTtcbnJldHVybiBoLmRvSXNHVEUoLi4uY29lcmNlTFIoaCxsZWZ0QW1vdW50LHJpZ2h0QW1vdW50KSk7XG4gfTtcblxuLyoqXG4gKiBMb2dpYyBmb3IgbWFuaXB1bGF0aW5nIGFtb3VudHMuXG4gKlxuICogQW1vdW50cyBhcmUgdGhlIGNhbm9uaWNhbCBkZXNjcmlwdGlvbiBvZiB0cmFkYWJsZSBnb29kcy4gVGhleSBhcmUgbWFuaXB1bGF0ZWRcbiAqIGJ5IGlzc3VlcnMgYW5kIG1pbnRzLCBhbmQgcmVwcmVzZW50IHRoZSBnb29kcyBhbmQgY3VycmVuY3kgY2FycmllZCBieSBwdXJzZXNcbiAqIGFuZFxuICogcGF5bWVudHMuIFRoZXkgY2FuIGJlIHVzZWQgdG8gcmVwcmVzZW50IHRoaW5ncyBsaWtlIGN1cnJlbmN5LCBzdG9jaywgYW5kIHRoZVxuICogYWJzdHJhY3QgcmlnaHQgdG8gcGFydGljaXBhdGUgaW4gYSBwYXJ0aWN1bGFyIGV4Y2hhbmdlLlxuICovXG5jb25zdCBBbW91bnRNYXRoPXtcbi8qKlxuICogTWFrZSBhbiBhbW91bnQgZnJvbSBhIHZhbHVlIGJ5IGFkZGluZyB0aGUgYnJhbmQuXG4gKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7QnJhbmQ8Sz59IGJyYW5kXG4gKiBAcGFyYW0ge0Fzc2V0VmFsdWVGb3JLaW5kPEs+fSBhbGxlZ2VkVmFsdWVcbiAqIEByZXR1cm5zIHtBbW91bnQ8Sz59XG4gKi9cbi8qIGFsbGVnZWRWYWx1ZSBoYXMgYSBjb25kaXRpb25hbCBleHByZXNzaW9uIGZvciB0eXBlIHdpZGVuaW5nLCB0byBwcmV2ZW50IFYgYmVpbmcgYm91bmQgdG8gYSBhIGxpdGVyYWwgbGlrZSAxbiovXG5tYWtlOihicmFuZCxhbGxlZ2VkVmFsdWUpPT57XG5hc3NlcnRSZW1vdGFibGUoYnJhbmQsJ2JyYW5kJyk7XG5jb25zdCBoPWFzc2VydFZhbHVlR2V0SGVscGVycyhhbGxlZ2VkVmFsdWUpO1xuY29uc3QgdmFsdWU9aC5kb0NvZXJjZShhbGxlZ2VkVmFsdWUpO1xucmV0dXJuIGhhcmRlbih7YnJhbmQsdmFsdWV9KTtcbiB9LFxuLyoqXG4gKiBNYWtlIHN1cmUgdGhpcyBhbW91bnQgaXMgdmFsaWQgZW5vdWdoLCBhbmQgcmV0dXJuIGEgY29ycmVzcG9uZGluZ1xuICogdmFsaWQgYW1vdW50IGlmIHNvLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBicmFuZFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IGFsbGVnZWRBbW91bnRcbiAqIEByZXR1cm5zIHtBbW91bnQ8Sz59XG4gKi9cbmNvZXJjZTooYnJhbmQsYWxsZWdlZEFtb3VudCk9PntcbmFzc2VydFJlbW90YWJsZShicmFuZCwnYnJhbmQnKTtcbmFzc2VydFJlY29yZChhbGxlZ2VkQW1vdW50LCdhbW91bnQnKTtcbmNvbnN0e2JyYW5kOmFsbGVnZWRCcmFuZCx2YWx1ZTphbGxlZ2VkVmFsdWV9PWFsbGVnZWRBbW91bnQ7XG5icmFuZD09PWFsbGVnZWRCcmFuZHx8XG5GYWlsIGBUaGUgYnJhbmQgaW4gdGhlIGFsbGVnZWRBbW91bnQgJHthbGxlZ2VkQW1vdW50fSBpbiAnY29lcmNlJyBkaWRuJ3QgbWF0Y2ggdGhlIHNwZWNpZmllZCBicmFuZCAke2JyYW5kfS5gO1xuLyogV2lsbCB0aHJvdyBvbiBpbmFwcHJvcHJpYXRlIHZhbHVlKi9cbnJldHVybiBBbW91bnRNYXRoLm1ha2UoYnJhbmQsYWxsZWdlZFZhbHVlKTtcbiB9LFxuLyoqXG4gKiBFeHRyYWN0IGFuZCByZXR1cm4gdGhlIHZhbHVlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBicmFuZFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IGFtb3VudFxuICogQHJldHVybnMge0Fzc2V0VmFsdWVGb3JLaW5kPEs+fVxuICovXG5nZXRWYWx1ZTooYnJhbmQsYW1vdW50KT0+QW1vdW50TWF0aC5jb2VyY2UoYnJhbmQsYW1vdW50KS52YWx1ZSxcbi8qKlxuICogUmV0dXJuIHRoZSBhbW91bnQgcmVwcmVzZW50aW5nIGFuIGVtcHR5IGFtb3VudC4gVGhpcyBpcyB0aGVcbiAqIGlkZW50aXR5IGVsZW1lbnQgZm9yIE1hdGhIZWxwZXJzLmFkZCBhbmQgTWF0SGVscGVycy5zdWJ0cmFjdC5cbiAqXG4gKiBAdHlwZSB7e1xuICogICAoYnJhbmQ6IEJyYW5kKTogQW1vdW50PCduYXQnPjtcbiAqICAgPEsgZXh0ZW5kcyBBc3NldEtpbmQ+KGJyYW5kOiBCcmFuZCwgYXNzZXRLaW5kOiBLKTogQW1vdW50PEs+O1xuICogfX1cbiAqL1xubWFrZUVtcHR5OihicmFuZCxhc3NldEtpbmQ9LyoqIEB0eXBlIHtjb25zdH0gKi8nbmF0Jyk9PntcbmFzc2VydFJlbW90YWJsZShicmFuZCwnYnJhbmQnKTtcbmFzc2VydEFzc2V0S2luZChhc3NldEtpbmQpO1xuY29uc3QgdmFsdWU9aGVscGVyc1thc3NldEtpbmRdLmRvTWFrZUVtcHR5KCk7XG5yZXR1cm4gaGFyZGVuKHticmFuZCx2YWx1ZX0pO1xuIH0sXG4vKipcbiAqIFJldHVybiB0aGUgYW1vdW50IHJlcHJlc2VudGluZyBhbiBlbXB0eSBhbW91bnQsIHVzaW5nIGFub3RoZXJcbiAqIGFtb3VudCBhcyB0aGUgdGVtcGxhdGUgZm9yIHRoZSBicmFuZCBhbmQgYXNzZXRLaW5kLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gYW1vdW50XG4gKiBAcmV0dXJucyB7QW1vdW50PEs+fVxuICovXG5tYWtlRW1wdHlGcm9tQW1vdW50OihhbW91bnQpPT57XG5hc3NlcnRSZWNvcmQoYW1vdW50LCdhbW91bnQnKTtcbmNvbnN0e2JyYW5kLHZhbHVlfT1hbW91bnQ7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xuY29uc3QgYXNzZXRLaW5kPWFzc2VydFZhbHVlR2V0QXNzZXRLaW5kKHZhbHVlKTtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCAoaWdub3JlIGIvYyBlcnJvcmluZyBpbiBDSSBidXQgbm90IG15IElERSkqL1xucmV0dXJuIEFtb3VudE1hdGgubWFrZUVtcHR5KGJyYW5kLGFzc2V0S2luZCk7XG4gfSxcbi8qKlxuICogUmV0dXJuIHRydWUgaWYgdGhlIEFtb3VudCBpcyBlbXB0eS4gT3RoZXJ3aXNlIGZhbHNlLlxuICpcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnRcbiAqIEBwYXJhbSB7QnJhbmR9IFticmFuZF1cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5pc0VtcHR5OihhbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuYXNzZXJ0UmVjb3JkKGFtb3VudCwnYW1vdW50Jyk7XG5jb25zdHticmFuZDphbGxlZ2VkQnJhbmQsdmFsdWV9PWFtb3VudDtcbmFzc2VydFJlbW90YWJsZShhbGxlZ2VkQnJhbmQsJ2JyYW5kJyk7XG5vcHRpb25hbEJyYW5kQ2hlY2soYWxsZWdlZEJyYW5kLGJyYW5kKTtcbmNvbnN0IGg9YXNzZXJ0VmFsdWVHZXRIZWxwZXJzKHZhbHVlKTtcbnJldHVybiBoLmRvSXNFbXB0eShoLmRvQ29lcmNlKHZhbHVlKSk7XG4gfSxcbmlzR1RFLFxuLyoqXG4gKiBSZXR1cm5zIHRydWUgaWYgdGhlIGxlZnRBbW91bnQgZXF1YWxzIHRoZSByaWdodEFtb3VudC4gV2UgYXNzdW1lXG4gKiB0aGF0IGlmIGlzR1RFIGlzIHRydWUgaW4gYm90aCBkaXJlY3Rpb25zLCBpc0VxdWFsIGlzIGFsc28gdHJ1ZVxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gbGVmdEFtb3VudFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IHJpZ2h0QW1vdW50XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuaXNFcXVhbDoobGVmdEFtb3VudCxyaWdodEFtb3VudCxicmFuZD11bmRlZmluZWQpPT57XG5jb25zdCBoPWNoZWNrTFJBbmRHZXRIZWxwZXJzKGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQpO1xucmV0dXJuIGguZG9Jc0VxdWFsKC4uLmNvZXJjZUxSKGgsbGVmdEFtb3VudCxyaWdodEFtb3VudCkpO1xuIH0sXG4vKipcbiAqIFJldHVybnMgYSBuZXcgYW1vdW50IHRoYXQgaXMgdGhlIHVuaW9uIG9mIGJvdGggbGVmdEFtb3VudCBhbmQgcmlnaHRBbW91bnQuXG4gKlxuICogRm9yIGZ1bmdpYmxlIGFtb3VudCB0aGlzIG1lYW5zIGFkZGluZyB0aGUgdmFsdWVzLiBGb3Igb3RoZXIga2luZHMgb2ZcbiAqIGFtb3VudCwgaXQgdXN1YWxseSBtZWFucyBpbmNsdWRpbmcgYWxsIG9mIHRoZSBlbGVtZW50cyBmcm9tIGJvdGhcbiAqIGxlZnQgYW5kIHJpZ2h0LlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gbGVmdEFtb3VudFxuICogQHBhcmFtIHtBbW91bnQ8Sz59IHJpZ2h0QW1vdW50XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7QW1vdW50PEs+fVxuICovXG5hZGQ6KGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuY29uc3QgaD1jaGVja0xSQW5kR2V0SGVscGVycyhsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kKTtcbmNvbnN0IHZhbHVlPWguZG9BZGQoLi4uY29lcmNlTFIoaCxsZWZ0QW1vdW50LHJpZ2h0QW1vdW50KSk7XG5yZXR1cm4gaGFyZGVuKHticmFuZDpsZWZ0QW1vdW50LmJyYW5kLHZhbHVlfSk7XG4gfSxcbi8qKlxuICogUmV0dXJucyBhIG5ldyBhbW91bnQgdGhhdCBpcyB0aGUgbGVmdEFtb3VudCBtaW51cyB0aGUgcmlnaHRBbW91bnRcbiAqIChpLmUuIGV2ZXJ5dGhpbmcgaW4gdGhlIGxlZnRBbW91bnQgdGhhdCBpcyBub3QgaW4gdGhlXG4gKiByaWdodEFtb3VudCkuIElmIGxlZnRBbW91bnQgZG9lc24ndCBpbmNsdWRlIHJpZ2h0QW1vdW50XG4gKiAoc3VidHJhY3Rpb24gcmVzdWx0cyBpbiBhIG5lZ2F0aXZlKSwgdGhyb3cgIGFuIGVycm9yLiBCZWNhdXNlIHRoZVxuICogbGVmdCBhbW91bnQgbXVzdCBpbmNsdWRlIHRoZSByaWdodCBhbW91bnQsIHRoaXMgaXMgTk9UIGVxdWl2YWxlbnRcbiAqIHRvIHNldCBzdWJ0cmFjdGlvbi5cbiAqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gS1xuICogQHBhcmFtIHtBbW91bnQ8Sz59IGxlZnRBbW91bnRcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSByaWdodEFtb3VudFxuICogQHBhcmFtIHtCcmFuZDxLPn0gW2JyYW5kXVxuICogQHJldHVybnMge0Ftb3VudDxLPn1cbiAqL1xuc3VidHJhY3Q6KGxlZnRBbW91bnQscmlnaHRBbW91bnQsYnJhbmQ9dW5kZWZpbmVkKT0+e1xuY29uc3QgaD1jaGVja0xSQW5kR2V0SGVscGVycyhsZWZ0QW1vdW50LHJpZ2h0QW1vdW50LGJyYW5kKTtcbmNvbnN0IHZhbHVlPWguZG9TdWJ0cmFjdCguLi5jb2VyY2VMUihoLGxlZnRBbW91bnQscmlnaHRBbW91bnQpKTtcbnJldHVybiBoYXJkZW4oe2JyYW5kOmxlZnRBbW91bnQuYnJhbmQsdmFsdWV9KTtcbiB9LFxuLyoqXG4gKiBSZXR1cm5zIHRoZSBtaW4gdmFsdWUgYmV0d2VlbiB4IGFuZCB5IHVzaW5nIGlzR1RFXG4gKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSB4XG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0geVxuICogQHBhcmFtIHtCcmFuZDxLPn0gW2JyYW5kXVxuICogQHJldHVybnMge0Ftb3VudDxLPn1cbiAqL1xubWluOih4LHksYnJhbmQ9dW5kZWZpbmVkKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnkqL1xuaXNHVEUoeCx5LGJyYW5kKT9cbnk6XG5pc0dURSh5LHgsYnJhbmQpP1xueDpcbkZhaWwgYCR7eH0gYW5kICR7eX0gYXJlIGluY29tcGFyYWJsZWAsXG4vKipcbiAqIFJldHVybnMgdGhlIG1heCB2YWx1ZSBiZXR3ZWVuIHggYW5kIHkgdXNpbmcgaXNHVEVcbiAqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gS1xuICogQHBhcmFtIHtBbW91bnQ8Sz59IHhcbiAqIEBwYXJhbSB7QW1vdW50PEs+fSB5XG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBbYnJhbmRdXG4gKiBAcmV0dXJucyB7QW1vdW50PEs+fVxuICovXG5tYXg6KHgseSxicmFuZD11bmRlZmluZWQpPT5cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1uZXN0ZWQtdGVybmFyeSovXG5pc0dURSh4LHksYnJhbmQpP1xueDpcbmlzR1RFKHkseCk/XG55OlxuRmFpbCBgJHt4fSBhbmQgJHt5fSBhcmUgaW5jb21wYXJhYmxlYH07JGjigI1fb25jZS5BbW91bnRNYXRoKEFtb3VudE1hdGgpO1xuXG5oYXJkZW4oQW1vdW50TWF0aCk7XG5cbi8qKlxuICogQHBhcmFtIHtBbW91bnR9IGFtb3VudFxuICovXG5jb25zdCBnZXRBc3NldEtpbmQ9KGFtb3VudCk9PntcbmFzc2VydFJlY29yZChhbW91bnQsJ2Ftb3VudCcpO1xuY29uc3R7dmFsdWV9PWFtb3VudDtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCAoaWdub3JlIGIvYyBlcnJvcmluZyBpbiBDSSBidXQgbm90IG15IElERSkqL1xucmV0dXJuIGFzc2VydFZhbHVlR2V0QXNzZXRLaW5kKHZhbHVlKTtcbiB9OyRo4oCNX29uY2UuZ2V0QXNzZXRLaW5kKGdldEFzc2V0S2luZCk7XG5oYXJkZW4oZ2V0QXNzZXRLaW5kKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJBc3NldEtpbmQiOlsiQXNzZXRLaW5kIl0sImFzc2VydEFzc2V0S2luZCI6WyJhc3NlcnRBc3NldEtpbmQiXSwiQW1vdW50TWF0aCI6WyJBbW91bnRNYXRoIl0sImdldEFzc2V0S2luZCI6WyJnZXRBc3NldEtpbmQiXSwiYXNzZXJ0VmFsdWVHZXRIZWxwZXJzIjpbImFzc2VydFZhbHVlR2V0SGVscGVycyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABKlADt1QUAANUFAAAtAAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL2Rpc3BsYXlJbmZvLmpzeyJpbXBvcnRzIjpbIi4vdHlwZUd1YXJkcy5qcyIsIkBhZ29yaWMvYXNzZXJ0IiwiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbImNvZXJjZURpc3BsYXlJbmZvIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhaWwsbXVzdE1hdGNoLERpc3BsYXlJbmZvU2hhcGU7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9hc3NlcnRcIiwgW1tcIkZhaWxcIiwgWyRo4oCNX2EgPT4gKEZhaWwgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJEaXNwbGF5SW5mb1NoYXBlXCIsIFskaOKAjV9hID0+IChEaXNwbGF5SW5mb1NoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG4vKipcbiAqIEBwYXJhbSB7QWRkaXRpb25hbERpc3BsYXlJbmZvfSBhbGxlZ2VkRGlzcGxheUluZm9cbiAqIEBwYXJhbSB7QXNzZXRLaW5kfSBhc3NldEtpbmRcbiAqIEByZXR1cm5zIHtEaXNwbGF5SW5mb31cbiAqL1xuY29uc3QgICAgICAgIGNvZXJjZURpc3BsYXlJbmZvPShhbGxlZ2VkRGlzcGxheUluZm8sYXNzZXRLaW5kKT0+e1xubXVzdE1hdGNoKGFsbGVnZWREaXNwbGF5SW5mbyxEaXNwbGF5SW5mb1NoYXBlLCdkaXNwbGF5SW5mbycpO1xuXG5pZihhbGxlZ2VkRGlzcGxheUluZm8uYXNzZXRLaW5kIT09dW5kZWZpbmVkKXtcbmFsbGVnZWREaXNwbGF5SW5mby5hc3NldEtpbmQ9PT1hc3NldEtpbmR8fFxuRmFpbCBgZGlzcGxheUluZm8uYXNzZXRLaW5kIHdhcyBwcmVzZW50ICgke2FsbGVnZWREaXNwbGF5SW5mby5hc3NldEtpbmR9KSBhbmQgZGlkIG5vdCBtYXRjaCB0aGUgYXNzZXRLaW5kIGFyZ3VtZW50ICgke2Fzc2V0S2luZH0pYDtcbiB9XG5jb25zdCBkaXNwbGF5SW5mbz1oYXJkZW4oey4uLmFsbGVnZWREaXNwbGF5SW5mbyxhc3NldEtpbmR9KTtcblxuaWYoZGlzcGxheUluZm8uZGVjaW1hbFBsYWNlcyE9PXVuZGVmaW5lZCl7XG5OdW1iZXIuaXNTYWZlSW50ZWdlcihkaXNwbGF5SW5mby5kZWNpbWFsUGxhY2VzKXx8XG5GYWlsIGBkZWNpbWFsUGxhY2VzICR7ZGlzcGxheUluZm8uZGVjaW1hbFBsYWNlc30gaXMgbm90IGEgc2FmZSBpbnRlZ2VyYDtcbiB9XG5cbnJldHVybiBkaXNwbGF5SW5mbztcbiB9OyRo4oCNX29uY2UuY29lcmNlRGlzcGxheUluZm8oY29lcmNlRGlzcGxheUluZm8pO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImNvZXJjZURpc3BsYXlJbmZvIjpbImNvZXJjZURpc3BsYXlJbmZvIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEMwe9zoAQAA6AEAACcAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiLi9hbW91bnRNYXRoLmpzIiwiLi9pc3N1ZXJLaXQuanMiLCIuL3R5cGVHdWFyZHMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL2Ftb3VudE1hdGguanMiLCIuL2lzc3VlcktpdC5qcyIsIi4vdHlwZUd1YXJkcy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vYW1vdW50TWF0aC5qc1wiLCBbXV0sW1wiLi9pc3N1ZXJLaXQuanNcIiwgW11dLFtcIi4vdHlwZUd1YXJkcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAANV3BKJggAACYIAAAKwAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9pc3N1ZXJLaXQuanN7ImltcG9ydHMiOlsiLi9hbW91bnRNYXRoLmpzIiwiLi9kaXNwbGF5SW5mby5qcyIsIi4vcGF5bWVudExlZGdlci5qcyIsIi4vdHlwZXMtYW1iaWVudC5qcyIsIkBhZ29yaWMvYXNzZXJ0IiwiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvdmF0LWRhdGEiXSwiZXhwb3J0cyI6WyJoYXNJc3N1ZXIiLCJtYWtlRHVyYWJsZUlzc3VlcktpdCIsIm1ha2VJc3N1ZXJLaXQiLCJwcmVwYXJlSXNzdWVyS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydCxhc3NlcnRQYXR0ZXJuLG1ha2VTY2FsYXJCaWdNYXBTdG9yZSxBc3NldEtpbmQsYXNzZXJ0QXNzZXRLaW5kLGNvZXJjZURpc3BsYXlJbmZvLHByZXBhcmVQYXltZW50TGVkZ2VyOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJhc3NlcnRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJhc3NlcnRQYXR0ZXJuXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXR0ZXJuID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIm1ha2VTY2FsYXJCaWdNYXBTdG9yZVwiLCBbJGjigI1fYSA9PiAobWFrZVNjYWxhckJpZ01hcFN0b3JlID0gJGjigI1fYSldXV1dLFtcIi4vYW1vdW50TWF0aC5qc1wiLCBbW1wiQXNzZXRLaW5kXCIsIFskaOKAjV9hID0+IChBc3NldEtpbmQgPSAkaOKAjV9hKV1dLFtcImFzc2VydEFzc2V0S2luZFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0QXNzZXRLaW5kID0gJGjigI1fYSldXV1dLFtcIi4vZGlzcGxheUluZm8uanNcIiwgW1tcImNvZXJjZURpc3BsYXlJbmZvXCIsIFskaOKAjV9hID0+IChjb2VyY2VEaXNwbGF5SW5mbyA9ICRo4oCNX2EpXV1dXSxbXCIuL3BheW1lbnRMZWRnZXIuanNcIiwgW1tcInByZXBhcmVQYXltZW50TGVkZ2VyXCIsIFskaOKAjV9hID0+IChwcmVwYXJlUGF5bWVudExlZGdlciA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gQmFnZ2FnZSAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJc3N1ZXJSZWNvcmRcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBuYW1lXG4gKiBAcHJvcGVydHkge0t9IGFzc2V0S2luZFxuICogQHByb3BlcnR5IHtBZGRpdGlvbmFsRGlzcGxheUluZm99IGRpc3BsYXlJbmZvXG4gKiBAcHJvcGVydHkge1BhdHRlcm59IGVsZW1lbnRTaGFwZVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBwYXJhbSB7SXNzdWVyUmVjb3JkPEs+fSBpc3N1ZXJSZWNvcmRcbiAqIEBwYXJhbSB7QmFnZ2FnZX0gaXNzdWVyQmFnZ2FnZVxuICogQHBhcmFtIHtTaHV0ZG93bldpdGhGYWlsdXJlfSBbb3B0U2h1dGRvd25XaXRoRmFpbHVyZV0gSWYgdGhpcyBpc3N1ZXIgZmFpbHNcbiAqIGluIHRoZSBtaWRkbGUgb2YgYW4gYXRvbWljIGFjdGlvbiAod2hpY2ggYnR3IHNob3VsZCBuZXZlciBoYXBwZW4pLCBpdFxuICogcG90ZW50aWFsbHkgbGVhdmVzIGl0cyBsZWRnZXIgaW4gYSBjb3JydXB0ZWQgc3RhdGUuIElmIHRoaXMgZnVuY3Rpb24gd2FzXG4gKiBwcm92aWRlZCwgdGhlbiB0aGUgZmFpbGVkIGF0b21pYyBhY3Rpb24gd2lsbCBjYWxsIGl0LCBzbyB0aGF0IHNvbWVcbiAqIGxhcmdlciB1bml0IG9mIGNvbXB1dGF0aW9uLCBsaWtlIHRoZSBlbmNsb3NpbmcgdmF0LCBjYW4gYmUgc2h1dGRvd25cbiAqIGJlZm9yZSBhbnl0aGluZyBlbHNlIGlzIGNvcnJ1cHRlZCBieSB0aGF0IGNvcnJ1cHRlZCBzdGF0ZS5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzM0MzRcbiAqIEByZXR1cm5zIHtJc3N1ZXJLaXQ8Sz59XG4gKi9cbmNvbnN0IHNldHVwSXNzdWVyS2l0PShcbntuYW1lLGFzc2V0S2luZCxkaXNwbGF5SW5mbyxlbGVtZW50U2hhcGV9LFxuaXNzdWVyQmFnZ2FnZSxcbm9wdFNodXRkb3duV2l0aEZhaWx1cmU9dW5kZWZpbmVkKT0+XG57XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuYXNzZXJ0QXNzZXRLaW5kKGFzc2V0S2luZCk7XG5cbi8qIEFkZCBhc3NldEtpbmQgdG8gZGlzcGxheUluZm8sIG9yIG92ZXJyaWRlIGlmIHByZXNlbnQqL1xuY29uc3QgY2xlYW5EaXNwbGF5SW5mbz1jb2VyY2VEaXNwbGF5SW5mbyhkaXNwbGF5SW5mbyxhc3NldEtpbmQpO1xuaWYob3B0U2h1dGRvd25XaXRoRmFpbHVyZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKG9wdFNodXRkb3duV2l0aEZhaWx1cmUsJ2Z1bmN0aW9uJyk7XG4gfVxuXG5pZihlbGVtZW50U2hhcGUhPT11bmRlZmluZWQpe1xuYXNzZXJ0UGF0dGVybihlbGVtZW50U2hhcGUpO1xuIH1cblxuLyogQXR0ZW51YXRlIHRoZSBwb3dlcmZ1bCBhdXRob3JpdHkgdG8gbWludCBhbmQgY2hhbmdlIGJhbGFuY2VzKi9cbi8qKiBAdHlwZSB7UGF5bWVudExlZGdlcjxLPn0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY291bGQgYmUgaW5zdGFudGlhdGVkIHdpdGggZGlmZmVyZW50IHN1YnR5cGUgb2YgQXNzZXRLaW5kKi9cbmNvbnN0e2lzc3VlcixtaW50LGJyYW5kLG1pbnRSZWNvdmVyeVB1cnNlfT1wcmVwYXJlUGF5bWVudExlZGdlcihcbmlzc3VlckJhZ2dhZ2UsXG5uYW1lLFxuYXNzZXRLaW5kLFxuY2xlYW5EaXNwbGF5SW5mbyxcbmVsZW1lbnRTaGFwZSxcbm9wdFNodXRkb3duV2l0aEZhaWx1cmUpO1xuXG5cbnJldHVybiBoYXJkZW4oe1xuYnJhbmQsXG5pc3N1ZXIsXG5taW50LFxubWludFJlY292ZXJ5UHVyc2UsXG5kaXNwbGF5SW5mbzpjbGVhbkRpc3BsYXlJbmZvfSk7XG5cbiB9O1xuaGFyZGVuKHNldHVwSXNzdWVyS2l0KTtcblxuLyoqIFRoZSBrZXkgYXQgd2hpY2ggdGhlIGlzc3VlciByZWNvcmQgaXMgc3RvcmVkLiAqL1xuY29uc3QgSU5TVEFOQ0VfS0VZPSdpc3N1ZXInO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGlzc3VlckJhZ2dhZ2VcbiAqIEBwYXJhbSB7U2h1dGRvd25XaXRoRmFpbHVyZX0gW29wdFNodXRkb3duV2l0aEZhaWx1cmVdIElmIHRoaXMgaXNzdWVyIGZhaWxzXG4gKiBpbiB0aGUgbWlkZGxlIG9mIGFuIGF0b21pYyBhY3Rpb24gKHdoaWNoIGJ0dyBzaG91bGQgbmV2ZXIgaGFwcGVuKSwgaXRcbiAqIHBvdGVudGlhbGx5IGxlYXZlcyBpdHMgbGVkZ2VyIGluIGEgY29ycnVwdGVkIHN0YXRlLiBJZiB0aGlzIGZ1bmN0aW9uIHdhc1xuICogcHJvdmlkZWQsIHRoZW4gdGhlIGZhaWxlZCBhdG9taWMgYWN0aW9uIHdpbGwgY2FsbCBpdCwgc28gdGhhdCBzb21lXG4gKiBsYXJnZXIgdW5pdCBvZiBjb21wdXRhdGlvbiwgbGlrZSB0aGUgZW5jbG9zaW5nIHZhdCwgY2FuIGJlIHNodXRkb3duXG4gKiBiZWZvcmUgYW55dGhpbmcgZWxzZSBpcyBjb3JydXB0ZWQgYnkgdGhhdCBjb3JydXB0ZWQgc3RhdGUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNDM0XG4gKiBAcmV0dXJucyB7SXNzdWVyS2l0PEs+fVxuICovXG5jb25zdCAgICAgICAgcHJlcGFyZUlzc3VlcktpdD0oXG5pc3N1ZXJCYWdnYWdlLFxub3B0U2h1dGRvd25XaXRoRmFpbHVyZT11bmRlZmluZWQpPT5cbntcbmNvbnN0IGlzc3VlclJlY29yZD1pc3N1ZXJCYWdnYWdlLmdldChJTlNUQU5DRV9LRVkpO1xucmV0dXJuIHNldHVwSXNzdWVyS2l0KGlzc3VlclJlY29yZCxpc3N1ZXJCYWdnYWdlLG9wdFNodXRkb3duV2l0aEZhaWx1cmUpO1xuIH07JGjigI1fb25jZS5wcmVwYXJlSXNzdWVyS2l0KHByZXBhcmVJc3N1ZXJLaXQpO1xuaGFyZGVuKHByZXBhcmVJc3N1ZXJLaXQpO1xuXG4vKipcbiAqIERvZXMgYmFnZ2FnZSBhbHJlYWR5IGhhdmUgYW4gaXNzdWVyIGZyb20gcHJlcGFyZUlzc3VlcktpdCgpP1xuICogVGhhdCBpczogZG9lcyBpdCBoYXZlIHRoZSByZWxldmFudCBrZXlzIGRlZmluZWQ/XG4gKlxuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKi9cbmNvbnN0ICAgICAgICBoYXNJc3N1ZXI9KGJhZ2dhZ2UpPT5iYWdnYWdlLmhhcyhJTlNUQU5DRV9LRVkpO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtQYXJ0aWFsPHtlbGVtZW50U2hhcGU6IFBhdHRlcm59Pn0gSXNzdWVyT3B0aW9uc1JlY29yZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIFRoZSBuYW1lIGJlY29tZXMgcGFydCBvZiB0aGUgYnJhbmQgaW4gYXNzZXQgZGVzY3JpcHRpb25zLlxuICogVGhlIG5hbWUgaXMgdXNlZnVsIGZvciBkZWJ1Z2dpbmcgYW5kIGRvdWJsZS1jaGVja2luZ1xuICogYXNzdW1wdGlvbnMsIGJ1dCBzaG91bGQgbm90IGJlIHRydXN0ZWQgd3J0IGFueSBleHRlcm5hbCBuYW1lc3BhY2UuXG4gKiBGb3IgZXhhbXBsZSwgYW55b25lIGNvdWxkIGNyZWF0ZSBhIG5ldyBpc3N1ZXIga2l0IHdpdGggbmFtZSAnQlRDJywgYnV0XG4gKiBpdCBpcyBub3QgYml0Y29pbiBvciBldmVuIHJlbGF0ZWQuIEl0IGlzIG9ubHkgdGhlIG5hbWUgYWNjb3JkaW5nXG4gKiB0byB0aGF0IGlzc3VlciBhbmQgYnJhbmQuXG4gKlxuICogVGhlIGFzc2V0S2luZCB3aWxsIGJlIHVzZWQgdG8gaW1wb3J0IGEgc3BlY2lmaWMgbWF0aEhlbHBlcnNcbiAqIGZyb20gdGhlIG1hdGhIZWxwZXJzIGxpYnJhcnkuIEZvciBleGFtcGxlLCBuYXRNYXRoSGVscGVycywgdGhlXG4gKiBkZWZhdWx0LCBpcyB1c2VkIGZvciBiYXNpYyBmdW5naWJsZSB0b2tlbnMuXG4gKlxuICogIGBkaXNwbGF5SW5mb2AgZ2l2ZXMgaW5mb3JtYXRpb24gdG8gdGhlIFVJIG9uIGhvdyB0byBkaXNwbGF5IHRoZSBhbW91bnQuXG4gKlxuICogQHBhcmFtIHtCYWdnYWdlfSBpc3N1ZXJCYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtLfSBbYXNzZXRLaW5kPUFzc2V0S2luZC5OQVRdXG4gKiBAcGFyYW0ge0FkZGl0aW9uYWxEaXNwbGF5SW5mb30gW2Rpc3BsYXlJbmZvPXt9XVxuICogQHBhcmFtIHtTaHV0ZG93bldpdGhGYWlsdXJlfSBbb3B0U2h1dGRvd25XaXRoRmFpbHVyZV0gSWYgdGhpcyBpc3N1ZXIgZmFpbHNcbiAqIGluIHRoZSBtaWRkbGUgb2YgYW4gYXRvbWljIGFjdGlvbiAod2hpY2ggYnR3IHNob3VsZCBuZXZlciBoYXBwZW4pLCBpdFxuICogcG90ZW50aWFsbHkgbGVhdmVzIGl0cyBsZWRnZXIgaW4gYSBjb3JydXB0ZWQgc3RhdGUuIElmIHRoaXMgZnVuY3Rpb24gd2FzXG4gKiBwcm92aWRlZCwgdGhlbiB0aGUgZmFpbGVkIGF0b21pYyBhY3Rpb24gd2lsbCBjYWxsIGl0LCBzbyB0aGF0IHNvbWVcbiAqIGxhcmdlciB1bml0IG9mIGNvbXB1dGF0aW9uLCBsaWtlIHRoZSBlbmNsb3NpbmcgdmF0LCBjYW4gYmUgc2h1dGRvd25cbiAqIGJlZm9yZSBhbnl0aGluZyBlbHNlIGlzIGNvcnJ1cHRlZCBieSB0aGF0IGNvcnJ1cHRlZCBzdGF0ZS5cbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzM0MzRcbiAqIEBwYXJhbSB7SXNzdWVyT3B0aW9uc1JlY29yZH0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7SXNzdWVyS2l0PEs+fVxuICovJGjigI1fb25jZS5oYXNJc3N1ZXIoaGFzSXNzdWVyKTtcbmNvbnN0ICAgICAgICBtYWtlRHVyYWJsZUlzc3VlcktpdD0oXG5pc3N1ZXJCYWdnYWdlLFxubmFtZSxcbi8qIEB0cy1leHBlY3QtZXJyb3IgSyBjb3VsZCBiZSBpbnN0YW50aWF0ZWQgd2l0aCBhIGRpZmZlcmVudCBzdWJ0eXBlIG9mIEFzc2V0S2luZCovXG5hc3NldEtpbmQ9QXNzZXRLaW5kLk5BVCxcbmRpc3BsYXlJbmZvPWhhcmRlbih7fSksXG5vcHRTaHV0ZG93bldpdGhGYWlsdXJlPXVuZGVmaW5lZCxcbntlbGVtZW50U2hhcGU9dW5kZWZpbmVkfT17fSk9Plxue1xuY29uc3QgaXNzdWVyRGF0YT1oYXJkZW4oe25hbWUsYXNzZXRLaW5kLGRpc3BsYXlJbmZvLGVsZW1lbnRTaGFwZX0pO1xuaXNzdWVyQmFnZ2FnZS5pbml0KElOU1RBTkNFX0tFWSxpc3N1ZXJEYXRhKTtcbnJldHVybiBzZXR1cElzc3VlcktpdChpc3N1ZXJEYXRhLGlzc3VlckJhZ2dhZ2Usb3B0U2h1dGRvd25XaXRoRmFpbHVyZSk7XG4gfTskaOKAjV9vbmNlLm1ha2VEdXJhYmxlSXNzdWVyS2l0KG1ha2VEdXJhYmxlSXNzdWVyS2l0KTtcbmhhcmRlbihtYWtlRHVyYWJsZUlzc3VlcktpdCk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IFtLPSduYXQnXVxuICogVGhlIG5hbWUgYmVjb21lcyBwYXJ0IG9mIHRoZSBicmFuZCBpbiBhc3NldCBkZXNjcmlwdGlvbnMuXG4gKiBUaGUgbmFtZSBpcyB1c2VmdWwgZm9yIGRlYnVnZ2luZyBhbmQgZG91YmxlLWNoZWNraW5nXG4gKiBhc3N1bXB0aW9ucywgYnV0IHNob3VsZCBub3QgYmUgdHJ1c3RlZCB3cnQgYW55IGV4dGVybmFsIG5hbWVzcGFjZS5cbiAqIEZvciBleGFtcGxlLCBhbnlvbmUgY291bGQgY3JlYXRlIGEgbmV3IGlzc3VlciBraXQgd2l0aCBuYW1lICdCVEMnLCBidXRcbiAqIGl0IGlzIG5vdCBiaXRjb2luIG9yIGV2ZW4gcmVsYXRlZC4gSXQgaXMgb25seSB0aGUgbmFtZSBhY2NvcmRpbmdcbiAqIHRvIHRoYXQgaXNzdWVyIGFuZCBicmFuZC5cbiAqXG4gKiBUaGUgYXNzZXRLaW5kIHdpbGwgYmUgdXNlZCB0byBpbXBvcnQgYSBzcGVjaWZpYyBtYXRoSGVscGVyc1xuICogZnJvbSB0aGUgbWF0aEhlbHBlcnMgbGlicmFyeS4gRm9yIGV4YW1wbGUsIG5hdE1hdGhIZWxwZXJzLCB0aGVcbiAqIGRlZmF1bHQsIGlzIHVzZWQgZm9yIGJhc2ljIGZ1bmdpYmxlIHRva2Vucy5cbiAqXG4gKiAgYGRpc3BsYXlJbmZvYCBnaXZlcyBpbmZvcm1hdGlvbiB0byB0aGUgVUkgb24gaG93IHRvIGRpc3BsYXkgdGhlIGFtb3VudC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtLfSBbYXNzZXRLaW5kPSduYXQnXVxuICogQHBhcmFtIHtBZGRpdGlvbmFsRGlzcGxheUluZm99IFtkaXNwbGF5SW5mbz17fV1cbiAqIEBwYXJhbSB7U2h1dGRvd25XaXRoRmFpbHVyZX0gW29wdFNodXRkb3duV2l0aEZhaWx1cmVdIElmIHRoaXMgaXNzdWVyIGZhaWxzXG4gKiBpbiB0aGUgbWlkZGxlIG9mIGFuIGF0b21pYyBhY3Rpb24gKHdoaWNoIGJ0dyBzaG91bGQgbmV2ZXIgaGFwcGVuKSwgaXRcbiAqIHBvdGVudGlhbGx5IGxlYXZlcyBpdHMgbGVkZ2VyIGluIGEgY29ycnVwdGVkIHN0YXRlLiBJZiB0aGlzIGZ1bmN0aW9uIHdhc1xuICogcHJvdmlkZWQsIHRoZW4gdGhlIGZhaWxlZCBhdG9taWMgYWN0aW9uIHdpbGwgY2FsbCBpdCwgc28gdGhhdCBzb21lXG4gKiBsYXJnZXIgdW5pdCBvZiBjb21wdXRhdGlvbiwgbGlrZSB0aGUgZW5jbG9zaW5nIHZhdCwgY2FuIGJlIHNodXRkb3duXG4gKiBiZWZvcmUgYW55dGhpbmcgZWxzZSBpcyBjb3JydXB0ZWQgYnkgdGhhdCBjb3JydXB0ZWQgc3RhdGUuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNDM0XG4gKiBAcGFyYW0ge0lzc3Vlck9wdGlvbnNSZWNvcmR9IFtvcHRpb25zXVxuICogQHJldHVybnMge0lzc3VlcktpdDxLPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VJc3N1ZXJLaXQ9KFxubmFtZSxcbi8qIEB0cy1leHBlY3QtZXJyb3IgSyBjb3VsZCBiZSBpbnN0YW50aWF0ZWQgd2l0aCBhIGRpZmZlcmVudCBzdWJ0eXBlIG9mIEFzc2V0S2luZCovXG5hc3NldEtpbmQ9QXNzZXRLaW5kLk5BVCxcbmRpc3BsYXlJbmZvPWhhcmRlbih7fSksXG5vcHRTaHV0ZG93bldpdGhGYWlsdXJlPXVuZGVmaW5lZCxcbntlbGVtZW50U2hhcGU9dW5kZWZpbmVkfT17fSk9PlxuXG5tYWtlRHVyYWJsZUlzc3VlcktpdChcbm1ha2VTY2FsYXJCaWdNYXBTdG9yZSgnZHJvcHBlZCBpc3N1ZXIga2l0Jyx7ZHVyYWJsZTp0cnVlfSksXG5uYW1lLFxuYXNzZXRLaW5kLFxuZGlzcGxheUluZm8sXG5vcHRTaHV0ZG93bldpdGhGYWlsdXJlLFxue2VsZW1lbnRTaGFwZX0pOyRo4oCNX29uY2UubWFrZUlzc3VlcktpdChtYWtlSXNzdWVyS2l0KTtcblxuaGFyZGVuKG1ha2VJc3N1ZXJLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVJc3N1ZXJLaXQiOlsicHJlcGFyZUlzc3VlcktpdCJdLCJoYXNJc3N1ZXIiOlsiaGFzSXNzdWVyIl0sIm1ha2VEdXJhYmxlSXNzdWVyS2l0IjpbIm1ha2VEdXJhYmxlSXNzdWVyS2l0Il0sIm1ha2VJc3N1ZXJLaXQiOlsibWFrZUlzc3VlcktpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACAyG7uswUAALMFAABAAAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL2NvcHlCYWdNYXRoSGVscGVycy5qc3siaW1wb3J0cyI6WyIuLi90eXBlcy1hbWJpZW50LmpzIiwiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbImNvcHlCYWdNYXRoSGVscGVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBrZXlFUSxtYWtlQ29weUJhZyxtdXN0TWF0Y2gsTSxnZXRDb3B5QmFnRW50cmllcyxiYWdJc1N1cGVyYmFnLGJhZ1VuaW9uLGJhZ0Rpc2pvaW50U3VidHJhY3Q7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wia2V5RVFcIiwgWyRo4oCNX2EgPT4gKGtleUVRID0gJGjigI1fYSldXSxbXCJtYWtlQ29weUJhZ1wiLCBbJGjigI1fYSA9PiAobWFrZUNvcHlCYWcgPSAkaOKAjV9hKV1dLFtcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJnZXRDb3B5QmFnRW50cmllc1wiLCBbJGjigI1fYSA9PiAoZ2V0Q29weUJhZ0VudHJpZXMgPSAkaOKAjV9hKV1dLFtcImJhZ0lzU3VwZXJiYWdcIiwgWyRo4oCNX2EgPT4gKGJhZ0lzU3VwZXJiYWcgPSAkaOKAjV9hKV1dLFtcImJhZ1VuaW9uXCIsIFskaOKAjV9hID0+IChiYWdVbmlvbiA9ICRo4oCNX2EpXV0sW1wiYmFnRGlzam9pbnRTdWJ0cmFjdFwiLCBbJGjigI1fYSA9PiAoYmFnRGlzam9pbnRTdWJ0cmFjdCA9ICRo4oCNX2EpXV1dXSxbXCIuLi90eXBlcy1hbWJpZW50LmpzXCIsIFtdXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGUge0NvcHlCYWd9ICovXG5jb25zdCBlbXB0eT1tYWtlQ29weUJhZyhbXSk7XG5cbi8qKlxuICogQHR5cGUge01hdGhIZWxwZXJzPENvcHlCYWc+fVxuICovXG5jb25zdCAgICAgICAgY29weUJhZ01hdGhIZWxwZXJzPWhhcmRlbih7XG5kb0NvZXJjZTooYmFnKT0+e1xubXVzdE1hdGNoKGJhZyxNLmJhZygpLCdiYWcgb2YgYW1vdW50Jyk7XG5yZXR1cm4gYmFnO1xuIH0sXG5kb01ha2VFbXB0eTooKT0+ZW1wdHksXG5kb0lzRW1wdHk6KGJhZyk9PmdldENvcHlCYWdFbnRyaWVzKGJhZykubGVuZ3RoPT09MCxcbmRvSXNHVEU6YmFnSXNTdXBlcmJhZyxcbmRvSXNFcXVhbDprZXlFUSxcbmRvQWRkOmJhZ1VuaW9uLFxuZG9TdWJ0cmFjdDpiYWdEaXNqb2ludFN1YnRyYWN0fSk7JGjigI1fb25jZS5jb3B5QmFnTWF0aEhlbHBlcnMoY29weUJhZ01hdGhIZWxwZXJzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJjb3B5QmFnTWF0aEhlbHBlcnMiOlsiY29weUJhZ01hdGhIZWxwZXJzIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAHHnYj3HBQAAxwUAAEAAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvbWF0aEhlbHBlcnMvY29weVNldE1hdGhIZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiY29weVNldE1hdGhIZWxwZXJzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGtleUVRLG1ha2VDb3B5U2V0LG11c3RNYXRjaCxNLGdldENvcHlTZXRLZXlzLHNldElzU3VwZXJzZXQsc2V0RGlzam9pbnRVbmlvbixzZXREaXNqb2ludFN1YnRyYWN0OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV0sW1wibWFrZUNvcHlTZXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VDb3B5U2V0ID0gJGjigI1fYSldXSxbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV0sW1wiZ2V0Q29weVNldEtleXNcIiwgWyRo4oCNX2EgPT4gKGdldENvcHlTZXRLZXlzID0gJGjigI1fYSldXSxbXCJzZXRJc1N1cGVyc2V0XCIsIFskaOKAjV9hID0+IChzZXRJc1N1cGVyc2V0ID0gJGjigI1fYSldXSxbXCJzZXREaXNqb2ludFVuaW9uXCIsIFskaOKAjV9hID0+IChzZXREaXNqb2ludFVuaW9uID0gJGjigI1fYSldXSxbXCJzZXREaXNqb2ludFN1YnRyYWN0XCIsIFskaOKAjV9hID0+IChzZXREaXNqb2ludFN1YnRyYWN0ID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZSB7Q29weVNldH0gKi9cbmNvbnN0IGVtcHR5PW1ha2VDb3B5U2V0KFtdKTtcblxuLyoqXG4gKiBAdHlwZSB7TWF0aEhlbHBlcnM8Q29weVNldD59XG4gKi9cbmNvbnN0ICAgICAgICBjb3B5U2V0TWF0aEhlbHBlcnM9aGFyZGVuKHtcbmRvQ29lcmNlOihzZXQpPT57XG5tdXN0TWF0Y2goc2V0LE0uc2V0KCksJ3NldCBvZiBhbW91bnQnKTtcbnJldHVybiBzZXQ7XG4gfSxcbmRvTWFrZUVtcHR5OigpPT5lbXB0eSxcbmRvSXNFbXB0eTooc2V0KT0+Z2V0Q29weVNldEtleXMoc2V0KS5sZW5ndGg9PT0wLFxuZG9Jc0dURTpzZXRJc1N1cGVyc2V0LFxuZG9Jc0VxdWFsOmtleUVRLFxuZG9BZGQ6c2V0RGlzam9pbnRVbmlvbixcbmRvU3VidHJhY3Q6c2V0RGlzam9pbnRTdWJ0cmFjdH0pOyRo4oCNX29uY2UuY29weVNldE1hdGhIZWxwZXJzKGNvcHlTZXRNYXRoSGVscGVycyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiY29weVNldE1hdGhIZWxwZXJzIjpbImNvcHlTZXRNYXRoSGVscGVycyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAD/3LD7KgYAACoGAAA8AAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL25hdE1hdGhIZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLWFtYmllbnQuanMiLCJAZW5kby9uYXQiXSwiZXhwb3J0cyI6WyJuYXRNYXRoSGVscGVycyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBOYXQsaXNOYXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRo4oCNX2EgPT4gKE5hdCA9ICRo4oCNX2EpXV0sW1wiaXNOYXRcIiwgWyRo4oCNX2EgPT4gKGlzTmF0ID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuY29uc3QgZW1wdHk9MG47XG5cbi8qKlxuICogRnVuZ2libGUgZGlnaXRhbCBhc3NldHMgdXNlIHRoZSBuYXRNYXRoSGVscGVycyB0byBtYW5hZ2UgYmFsYW5jZXMgLVxuICogdGhlIG9wZXJhdGlvbnMgYXJlIG1lcmVseSBhcml0aG1ldGljIG9uIG5hdHVyYWwsIG5vbi1uZWdhdGl2ZVxuICogbnVtYmVycy5cbiAqXG4gKiBOYXR1cmFsIG51bWJlcnMgYXJlIHVzZWQgZm9yIGZ1bmdpYmxlIGVyaWdodHMgc3VjaCBhcyBtb25leSBiZWNhdXNlXG4gKiByb3VuZGluZyBpc3N1ZXMgbWFrZSBmbG9hdHMgcHJvYmxlbWF0aWMuIEFsbCBvcGVyYXRpb25zIHNob3VsZCBiZVxuICogZG9uZSB3aXRoIHRoZSBzbWFsbGVzdCB3aG9sZSB1bml0IHN1Y2ggdGhhdCB0aGUgYG5hdE1hdGhIZWxwZXJzYCBuZXZlclxuICogZGVhbHMgd2l0aCBmcmFjdGlvbmFsIHBhcnRzLlxuICpcbiAqIEB0eXBlIHtNYXRoSGVscGVyczxOYXRWYWx1ZT59XG4gKi9cbmNvbnN0ICAgICAgICBuYXRNYXRoSGVscGVycz1oYXJkZW4oe1xuZG9Db2VyY2U6KG5hdCk9Pntcbi8qIFRPRE86IHRpZ2h0ZW4gdGhlIGRlZmluaXRpb24gb2YgTmF0IGluIEBhZ29yaWMvbmF0IHRvIHRocm93IG9uIGBudW1iZXJgKi9cbmFzc2VydC50eXBlb2YobmF0LCdiaWdpbnQnKTtcbmlzTmF0KG5hdCl8fEZhaWwgYHZhbHVlICR7bmF0fSBtdXN0IGJlIGEgbmF0dXJhbCBudW1iZXJgO1xucmV0dXJuIE5hdChuYXQpO1xuIH0sXG5kb01ha2VFbXB0eTooKT0+ZW1wdHksXG5kb0lzRW1wdHk6KG5hdCk9Pm5hdD09PWVtcHR5LFxuZG9Jc0dURToobGVmdCxyaWdodCk9PmxlZnQ+PXJpZ2h0LFxuZG9Jc0VxdWFsOihsZWZ0LHJpZ2h0KT0+bGVmdD09PXJpZ2h0LFxuLyogQmlnSW50cyBkb24ndCBvYnNlcnZhYmx5IG92ZXJmbG93Ki9cbmRvQWRkOihsZWZ0LHJpZ2h0KT0+bGVmdCtyaWdodCxcbmRvU3VidHJhY3Q6KGxlZnQscmlnaHQpPT5OYXQobGVmdC1yaWdodCl9KTskaOKAjV9vbmNlLm5hdE1hdGhIZWxwZXJzKG5hdE1hdGhIZWxwZXJzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJuYXRNYXRoSGVscGVycyI6WyJuYXRNYXRoSGVscGVycyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAmmZgvnwcAAJ8HAAA8AAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL3NldE1hdGhIZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL3N0b3JlIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbInNldE1hdGhIZWxwZXJzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHBhc3NTdHlsZU9mLGFzc2VydEtleSxlbGVtZW50c0lzU3VwZXJzZXQsZWxlbWVudHNEaXNqb2ludFVuaW9uLGVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCxjb2VyY2VUb0VsZW1lbnRzLGVsZW1lbnRzQ29tcGFyZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiYXNzZXJ0S2V5XCIsIFskaOKAjV9hID0+IChhc3NlcnRLZXkgPSAkaOKAjV9hKV1dLFtcImVsZW1lbnRzSXNTdXBlcnNldFwiLCBbJGjigI1fYSA9PiAoZWxlbWVudHNJc1N1cGVyc2V0ID0gJGjigI1fYSldXSxbXCJlbGVtZW50c0Rpc2pvaW50VW5pb25cIiwgWyRo4oCNX2EgPT4gKGVsZW1lbnRzRGlzam9pbnRVbmlvbiA9ICRo4oCNX2EpXV0sW1wiZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0XCIsIFskaOKAjV9hID0+IChlbGVtZW50c0Rpc2pvaW50U3VidHJhY3QgPSAkaOKAjV9hKV1dLFtcImNvZXJjZVRvRWxlbWVudHNcIiwgWyRo4oCNX2EgPT4gKGNvZXJjZVRvRWxlbWVudHMgPSAkaOKAjV9hKV1dLFtcImVsZW1lbnRzQ29tcGFyZVwiLCBbJGjigI1fYSA9PiAoZWxlbWVudHNDb21wYXJlID0gJGjigI1fYSldXV1dLFtcIi4uL3R5cGVzLWFtYmllbnQuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiBPcGVyYXRpb25zIGZvciBhcnJheXMgd2l0aCB1bmlxdWUgb2JqZWN0cyBpZGVudGlmeWluZyBhbmQgcHJvdmlkaW5nKi9cbi8qIGluZm9ybWF0aW9uIGFib3V0IGRpZ2l0YWwgYXNzZXRzLiBVc2VkIGZvciBab2UgaW52aXRlcy4qL1xuLyoqIEB0eXBlIHtTZXRWYWx1ZX0gKi9cbmNvbnN0IGVtcHR5PWhhcmRlbihbXSk7XG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgUmVwbGFjZSBhcnJheS1iYXNlZCBTZXRNYXRoIHdpdGggQ29weVNldC1iYXNlZCBDb3B5U2V0TWF0aFxuICogQHR5cGUge01hdGhIZWxwZXJzPFNldFZhbHVlPn1cbiAqL1xuY29uc3QgICAgICAgIHNldE1hdGhIZWxwZXJzPWhhcmRlbih7XG5kb0NvZXJjZToobGlzdCk9Pntcbmxpc3Q9Y29lcmNlVG9FbGVtZW50cyhsaXN0KTtcbi8qIEFzc2VydCB0aGF0IGxpc3QgY29udGFpbnMgb25seSovXG4vKiAqIHBhc3MtYnktY29weSBwcmltaXRpdmVzLCovXG4vKiAqIHBhc3MtYnktY29weSBjb250YWluZXJzIGNvbnRhaW5pbmcga2V5cywqL1xuLyogKiByZW1vdGFibGVzLiovXG5hc3NlcnRLZXkobGlzdCk7XG5yZXR1cm4gbGlzdDtcbiB9LFxuZG9NYWtlRW1wdHk6KCk9PmVtcHR5LFxuZG9Jc0VtcHR5OihsaXN0KT0+cGFzc1N0eWxlT2YobGlzdCk9PT0nY29weUFycmF5JyYmbGlzdC5sZW5ndGg9PT0wLFxuZG9Jc0dURTplbGVtZW50c0lzU3VwZXJzZXQsXG5kb0lzRXF1YWw6KHgseSk9PmVsZW1lbnRzQ29tcGFyZSh4LHkpPT09MCxcbmRvQWRkOmVsZW1lbnRzRGlzam9pbnRVbmlvbixcbmRvU3VidHJhY3Q6ZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0fSk7JGjigI1fb25jZS5zZXRNYXRoSGVscGVycyhzZXRNYXRoSGVscGVycyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsic2V0TWF0aEhlbHBlcnMiOlsic2V0TWF0aEhlbHBlcnMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAsDioH6UEAAClBAAAKQAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9wYXltZW50LmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsicHJlcGFyZVBheW1lbnRLaW5kIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGluaXRFbXB0eSxwcmVwYXJlRXhvQ2xhc3M7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiaW5pdEVtcHR5XCIsIFskaOKAjV9hID0+IChpbml0RW1wdHkgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wicHJlcGFyZUV4b0NsYXNzXCIsIFskaOKAjV9hID0+IChwcmVwYXJlRXhvQ2xhc3MgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gQmFnZ2FnZSAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGlzc3VlckJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBuYW1lXG4gKiBAcGFyYW0ge0JyYW5kPEs+fSBicmFuZFxuICogQHBhcmFtIHtJbnRlcmZhY2VHdWFyZH0gUGF5bWVudElcbiAqIEByZXR1cm5zIHsoKSA9PiBQYXltZW50PEs+fVxuICovXG5jb25zdCAgICAgICAgcHJlcGFyZVBheW1lbnRLaW5kPShpc3N1ZXJCYWdnYWdlLG5hbWUsYnJhbmQsUGF5bWVudEkpPT57XG5jb25zdCBtYWtlUGF5bWVudD1wcmVwYXJlRXhvQ2xhc3MoXG5pc3N1ZXJCYWdnYWdlLFxuIGAke25hbWV9IHBheW1lbnRgLFxuUGF5bWVudEksXG5pbml0RW1wdHksXG57XG5nZXRBbGxlZ2VkQnJhbmQoKXtcbnJldHVybiBicmFuZDtcbiB9fSk7XG5cblxucmV0dXJuIG1ha2VQYXltZW50O1xuIH07JGjigI1fb25jZS5wcmVwYXJlUGF5bWVudEtpbmQocHJlcGFyZVBheW1lbnRLaW5kKTtcbmhhcmRlbihwcmVwYXJlUGF5bWVudEtpbmQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVQYXltZW50S2luZCI6WyJwcmVwYXJlUGF5bWVudEtpbmQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAD9fo7usxAADrMQAALwAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9wYXltZW50TGVkZ2VyLmpzeyJpbXBvcnRzIjpbIi4vYW1vdW50TWF0aC5qcyIsIi4vcGF5bWVudC5qcyIsIi4vcHVyc2UuanMiLCIuL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL3N0b3JlIiwiQGFnb3JpYy9zdG9yZS9leHBvcnRlZC5qcyIsIkBhZ29yaWMvdmF0LWRhdGEiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbInByZXBhcmVQYXltZW50TGVkZ2VyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzUHJvbWlzZSxtdXN0TWF0Y2gsTSxrZXlFUSxwcm92aWRlRHVyYWJsZVdlYWtNYXBTdG9yZSxwcmVwYXJlRXhvLHByb3ZpZGUsQW1vdW50TWF0aCxwcmVwYXJlUGF5bWVudEtpbmQscHJlcGFyZVB1cnNlS2luZCxCcmFuZEksbWFrZUlzc3VlckludGVyZmFjZXM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJrZXlFUVwiLCBbJGjigI1fYSA9PiAoa2V5RVEgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmVcIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlID0gJGjigI1fYSldXSxbXCJwcmVwYXJlRXhvXCIsIFskaOKAjV9hID0+IChwcmVwYXJlRXhvID0gJGjigI1fYSldXSxbXCJwcm92aWRlXCIsIFskaOKAjV9hID0+IChwcm92aWRlID0gJGjigI1fYSldXV1dLFtcIi4vYW1vdW50TWF0aC5qc1wiLCBbW1wiQW1vdW50TWF0aFwiLCBbJGjigI1fYSA9PiAoQW1vdW50TWF0aCA9ICRo4oCNX2EpXV1dXSxbXCIuL3BheW1lbnQuanNcIiwgW1tcInByZXBhcmVQYXltZW50S2luZFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZVBheW1lbnRLaW5kID0gJGjigI1fYSldXV1dLFtcIi4vcHVyc2UuanNcIiwgW1tcInByZXBhcmVQdXJzZUtpbmRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVQdXJzZUtpbmQgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZS9leHBvcnRlZC5qc1wiLCBbXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJCcmFuZElcIiwgWyRo4oCNX2EgPT4gKEJyYW5kSSA9ICRo4oCNX2EpXV0sW1wibWFrZUlzc3VlckludGVyZmFjZXNcIiwgWyRo4oCNX2EgPT4gKG1ha2VJc3N1ZXJJbnRlcmZhY2VzID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YScpLkJhZ2dhZ2V9IEJhZ2dhZ2UgKi9cblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG4vKipcbiAqIEBwYXJhbSB7QnJhbmR9IGJyYW5kXG4gKiBAcGFyYW0ge0Fzc2V0S2luZH0gYXNzZXRLaW5kXG4gKiBAcGFyYW0ge1BhdHRlcm59IGVsZW1lbnRTaGFwZVxuICovXG5jb25zdCBhbW91bnRTaGFwZUZyb21FbGVtZW50U2hhcGU9KGJyYW5kLGFzc2V0S2luZCxlbGVtZW50U2hhcGUpPT57XG5sZXQgdmFsdWVTaGFwZTtcbnN3aXRjaChhc3NldEtpbmQpe1xuY2FzZSduYXQnOntcbnZhbHVlU2hhcGU9TS5uYXQoKTtcbmVsZW1lbnRTaGFwZT09PXVuZGVmaW5lZHx8XG5GYWlsIGBGdW5naWJsZSBhc3NldHMgY2Fubm90IGhhdmUgYW4gZWxlbWVudFNoYXBlOiAke3EoZWxlbWVudFNoYXBlKX1gO1xuYnJlYWs7XG4gfVxuY2FzZSdzZXQnOntcbmlmKGVsZW1lbnRTaGFwZT09PXVuZGVmaW5lZCl7XG52YWx1ZVNoYXBlPU0uYXJyYXlPZihNLmtleSgpKTtcbiB9ZWxzZXtcbnZhbHVlU2hhcGU9TS5hcnJheU9mKE0uYW5kKE0ua2V5KCksZWxlbWVudFNoYXBlKSk7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSdjb3B5U2V0Jzp7XG5pZihlbGVtZW50U2hhcGU9PT11bmRlZmluZWQpe1xudmFsdWVTaGFwZT1NLnNldCgpO1xuIH1lbHNle1xudmFsdWVTaGFwZT1NLnNldE9mKGVsZW1lbnRTaGFwZSk7XG4gfVxuYnJlYWs7XG4gfVxuY2FzZSdjb3B5QmFnJzp7XG5pZihlbGVtZW50U2hhcGU9PT11bmRlZmluZWQpe1xudmFsdWVTaGFwZT1NLmJhZygpO1xuIH1lbHNle1xudmFsdWVTaGFwZT1NLmJhZ09mKGVsZW1lbnRTaGFwZSk7XG4gfVxuYnJlYWs7XG4gfVxuZGVmYXVsdDp7XG5GYWlsIGB1bmV4cGVjdGVkIGFzc2V0IGtpbmQgJHtxKGFzc2V0S2luZCl9YDtcbiB9fVxuXG5cbmNvbnN0IGFtb3VudFNoYXBlPWhhcmRlbih7XG5icmFuZCwvKiBtYXRjaGVzIG9ubHkgdGhpcyBleGFjdCBicmFuZCovXG52YWx1ZTp2YWx1ZVNoYXBlfSk7XG5cbnJldHVybiBhbW91bnRTaGFwZTtcbiB9O1xuXG4vKipcbiAqIE1ha2UgdGhlIHBheW1lbnRMZWRnZXIsIHRoZSBzb3VyY2Ugb2YgdHJ1dGggZm9yIHRoZSBiYWxhbmNlcyBvZlxuICogcGF5bWVudHMuIEFsbCBtaW50aW5nIGFuZCB0cmFuc2ZlciBhdXRob3JpdHkgb3JpZ2luYXRlcyBoZXJlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGlzc3VlckJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBuYW1lXG4gKiBAcGFyYW0ge0t9IGFzc2V0S2luZFxuICogQHBhcmFtIHtEaXNwbGF5SW5mbzxLPn0gZGlzcGxheUluZm9cbiAqIEBwYXJhbSB7UGF0dGVybn0gZWxlbWVudFNoYXBlXG4gKiBAcGFyYW0ge1NodXRkb3duV2l0aEZhaWx1cmV9IFtvcHRTaHV0ZG93bldpdGhGYWlsdXJlXVxuICogQHJldHVybnMge1BheW1lbnRMZWRnZXI8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlUGF5bWVudExlZGdlcj0oXG5pc3N1ZXJCYWdnYWdlLFxubmFtZSxcbmFzc2V0S2luZCxcbmRpc3BsYXlJbmZvLFxuZWxlbWVudFNoYXBlLFxub3B0U2h1dGRvd25XaXRoRmFpbHVyZT11bmRlZmluZWQpPT5cbntcbi8qKiBAdHlwZSB7QnJhbmQ8Sz59ICovXG4vKiBAdHMtZXhwZWN0LWVycm9yIFhYWCBjYWxsV2hlbiovXG5jb25zdCBicmFuZD1wcmVwYXJlRXhvKGlzc3VlckJhZ2dhZ2UsIGAke25hbWV9IGJyYW5kYCxCcmFuZEkse1xuaXNNeUlzc3VlcihhbGxlZ2VkSXNzdWVyKXtcbi8qIEJyYW5kSSBkZWxheXMgY2FsbGluZyB0aGlzIG1ldGhvZCB1bnRpbCBgYWxsZWdlZElzc3VlcmAgaXMgYSBSZW1vdGFibGUqL1xucmV0dXJuIGFsbGVnZWRJc3N1ZXI9PT1pc3N1ZXI7XG4gfSxcbmdldEFsbGVnZWROYW1lKCl7XG5yZXR1cm4gbmFtZTtcbiB9LFxuLyogR2l2ZSBpbmZvcm1hdGlvbiB0byBVSSBvbiBob3cgdG8gZGlzcGxheSB0aGUgYW1vdW50LiovXG5nZXREaXNwbGF5SW5mbygpe1xucmV0dXJuIGRpc3BsYXlJbmZvO1xuIH0sXG5nZXRBbW91bnRTaGFwZSgpe1xucmV0dXJuIGFtb3VudFNoYXBlO1xuIH19KTtcblxuXG5jb25zdCBhbW91bnRTaGFwZT1hbW91bnRTaGFwZUZyb21FbGVtZW50U2hhcGUoXG5icmFuZCxcbmFzc2V0S2luZCxcbmVsZW1lbnRTaGFwZSk7XG5cblxuY29uc3R7SXNzdWVySSxNaW50SSxQYXltZW50SSxQdXJzZUlLaXR9PW1ha2VJc3N1ZXJJbnRlcmZhY2VzKFxuYnJhbmQsXG5hc3NldEtpbmQsXG5hbW91bnRTaGFwZSk7XG5cblxuY29uc3QgbWFrZVBheW1lbnQ9cHJlcGFyZVBheW1lbnRLaW5kKGlzc3VlckJhZ2dhZ2UsbmFtZSxicmFuZCxQYXltZW50SSk7XG5cbi8qKiBAdHlwZSB7U2h1dGRvd25XaXRoRmFpbHVyZX0gKi9cbmNvbnN0IHNodXRkb3duTGVkZ2VyV2l0aEZhaWx1cmU9KHJlYXNvbik9Pntcbi8qIFRPRE8gVGhpcyBzaG91bGQgYWxzbyBkZXN0cm95IGxlZGdlciBzdGF0ZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvMzQzNCovXG5pZihvcHRTaHV0ZG93bldpdGhGYWlsdXJlIT09dW5kZWZpbmVkKXtcbnRyeXtcbm9wdFNodXRkb3duV2l0aEZhaWx1cmUocmVhc29uKTtcbiB9Y2F0Y2goZXJySW5TaHV0ZG93bil7XG5hc3NlcnQubm90ZShlcnJJblNodXRkb3duLFggYENhdXNlZCBieTogJHtyZWFzb259YCk7XG50aHJvdyBlcnJJblNodXRkb3duO1xuIH1cbiB9XG50aHJvdyByZWFzb247XG4gfTtcblxuLyoqIEB0eXBlIHtXZWFrTWFwU3RvcmU8UGF5bWVudCwgQW1vdW50Pn0gKi9cbmNvbnN0IHBheW1lbnRMZWRnZXI9cHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUoXG5pc3N1ZXJCYWdnYWdlLFxuJ3BheW1lbnRMZWRnZXInLFxue3ZhbHVlU2hhcGU6YW1vdW50U2hhcGV9KTtcblxuXG4vKipcbiAqIEEgd2l0aGRyYXduIGxpdmUgcGF5bWVudCBpcyBhc3NvY2lhdGVkIHdpdGggdGhlIHJlY292ZXJ5IHNldCBvZlxuICogdGhlIHB1cnNlIGl0IHdhcyB3aXRoZHJhd24gZnJvbS4gTGV0J3MgY2FsbCB0aGVzZSBcInJlY292ZXJhYmxlXCJcbiAqIHBheW1lbnRzLiBBbGwgcmVjb3ZlcmFibGUgcGF5bWVudHMgYXJlIGxpdmUsIGJ1dCBub3QgYWxsIGxpdmVcbiAqIHBheW1lbnRzIGFyZSByZWNvdmVyYWJsZS4gV2UgZG8gdGhlIGJvb2trZWVwaW5nIGZvciBwYXltZW50IHJlY292ZXJ5XG4gKiB3aXRoIHRoaXMgd2Vha21hcCBmcm9tIHJlY292ZXJhYmxlIHBheW1lbnRzIHRvIHRoZSByZWNvdmVyeSBzZXQgdGhleSBhcmVcbiAqIGluLlxuICogQSBidW5jaCBvZiBpbnRlcmVzdGluZyBpbnZhcmlhbnRzIGhlcmU6XG4gKiAgICAqIEV2ZXJ5IHBheW1lbnQgdGhhdCBpcyBhIGtleSBpbiB0aGUgb3V0ZXIgYHBheW1lbnRSZWNvdmVyeVNldHNgXG4gKiAgICAgIHdlYWtNYXAgaXMgYWxzbyBpbiB0aGUgcmVjb3Zlcnkgc2V0IGluZGV4ZWQgYnkgdGhhdCBwYXltZW50LlxuICogICAgKiBJbXBsaWVkIGJ5IHRoZSBhYm92ZSBidXQgd29ydGggc3RhdGluZzogdGhlIHBheW1lbnQgaXMgb25seVxuICogICAgICBpbiBhdCBtb3N0IG9uZSByZWNvdmVyeSBzZXQuXG4gKiAgICAqIEEgcmVjb3Zlcnkgc2V0IG9ubHkgY29udGFpbnMgc3VjaCBwYXltZW50cy5cbiAqICAgICogRXZlcnkgcHVyc2UgaXMgYXNzb2NpYXRlZCB3aXRoIGV4YWN0bHkgb25lIHJlY292ZXJ5IHNldCB1bmlxdWUgdG9cbiAqICAgICAgaXQuXG4gKiAgICAqIEEgcHVyc2UncyByZWNvdmVyeSBzZXQgb25seSBjb250YWlucyBwYXltZW50cyB3aXRoZHJhd24gZnJvbVxuICogICAgICB0aGF0IHB1cnNlIGFuZCBub3QgeWV0IGNvbnN1bWVkLlxuICpcbiAqIEB0eXBlIHtXZWFrTWFwU3RvcmU8UGF5bWVudCwgU2V0U3RvcmU8UGF5bWVudD4+fVxuICovXG5jb25zdCBwYXltZW50UmVjb3ZlcnlTZXRzPXByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlKFxuaXNzdWVyQmFnZ2FnZSxcbidwYXltZW50UmVjb3ZlcnlTZXRzJyk7XG5cblxuLyoqXG4gKiBUbyBtYWludGFpbiB0aGUgaW52YXJpYW50cyBsaXN0ZWQgaW4gdGhlIGBwYXltZW50UmVjb3ZlcnlTZXRzYCBjb21tZW50LFxuICogYGluaXRQYXltZW50YCBzaG91bGQgY29udGFpbiB0aGUgb25seVxuICogY2FsbCB0byBgcGF5bWVudExlZGdlci5pbml0YC5cbiAqXG4gKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnRcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnRcbiAqIEBwYXJhbSB7U2V0U3RvcmU8UGF5bWVudD59IFtvcHRSZWNvdmVyeVNldF1cbiAqL1xuY29uc3QgaW5pdFBheW1lbnQ9KHBheW1lbnQsYW1vdW50LG9wdFJlY292ZXJ5U2V0PXVuZGVmaW5lZCk9PntcbmlmKG9wdFJlY292ZXJ5U2V0IT09dW5kZWZpbmVkKXtcbm9wdFJlY292ZXJ5U2V0LmFkZChwYXltZW50KTtcbnBheW1lbnRSZWNvdmVyeVNldHMuaW5pdChwYXltZW50LG9wdFJlY292ZXJ5U2V0KTtcbiB9XG5wYXltZW50TGVkZ2VyLmluaXQocGF5bWVudCxhbW91bnQpO1xuIH07XG5cbi8qKlxuICogVG8gbWFpbnRhaW4gdGhlIGludmFyaWFudHMgbGlzdGVkIGluIHRoZSBgcGF5bWVudFJlY292ZXJ5U2V0c2AgY29tbWVudCxcbiAqIGBkZWxldGVQYXltZW50YCBzaG91bGQgY29udGFpbiB0aGUgb25seVxuICogY2FsbCB0byBgcGF5bWVudExlZGdlci5kZWxldGVgLlxuICpcbiAqIEBwYXJhbSB7UGF5bWVudH0gcGF5bWVudFxuICovXG5jb25zdCBkZWxldGVQYXltZW50PShwYXltZW50KT0+e1xucGF5bWVudExlZGdlci5kZWxldGUocGF5bWVudCk7XG5pZihwYXltZW50UmVjb3ZlcnlTZXRzLmhhcyhwYXltZW50KSl7XG5jb25zdCByZWNvdmVyeVNldD1wYXltZW50UmVjb3ZlcnlTZXRzLmdldChwYXltZW50KTtcbnBheW1lbnRSZWNvdmVyeVNldHMuZGVsZXRlKHBheW1lbnQpO1xucmVjb3ZlcnlTZXQuZGVsZXRlKHBheW1lbnQpO1xuIH1cbiB9O1xuXG4vKiogQHR5cGUgeyhsZWZ0OiBBbW91bnQsIHJpZ2h0OiBBbW91bnQpID0+IEFtb3VudCB9ICovXG5jb25zdCBhZGQ9KGxlZnQscmlnaHQpPT5BbW91bnRNYXRoLmFkZChsZWZ0LHJpZ2h0LGJyYW5kKTtcbi8qKiBAdHlwZSB7KGxlZnQ6IEFtb3VudCwgcmlnaHQ6IEFtb3VudCkgPT4gQW1vdW50IH0gKi9cbmNvbnN0IHN1YnRyYWN0PShsZWZ0LHJpZ2h0KT0+QW1vdW50TWF0aC5zdWJ0cmFjdChsZWZ0LHJpZ2h0LGJyYW5kKTtcbi8qKiBAdHlwZSB7KGFsbGVnZWRBbW91bnQ6IEFtb3VudCkgPT4gQW1vdW50fSAqL1xuY29uc3QgY29lcmNlPShhbGxlZ2VkQW1vdW50KT0+QW1vdW50TWF0aC5jb2VyY2UoYnJhbmQsYWxsZWdlZEFtb3VudCk7XG4vKiogQHR5cGUgeyhsZWZ0OiBBbW91bnQsIHJpZ2h0OiBBbW91bnQpID0+IGJvb2xlYW4gfSAqL1xuXG4vKipcbiAqIE1ldGhvZHMgbGlrZSBkZXBvc2l0KCkgaGF2ZSBhbiBvcHRpb25hbCBzZWNvbmQgcGFyYW1ldGVyXG4gKiBgb3B0QW1vdW50U2hhcGVgXG4gKiB3aGljaCwgaWYgcHJlc2VudCwgaXMgc3VwcG9zZWQgdG8gbWF0Y2ggdGhlIGJhbGFuY2Ugb2YgdGhlXG4gKiBwYXltZW50LiBUaGlzIGhlbHBlciBmdW5jdGlvbiBkb2VzIHRoYXQgY2hlY2suXG4gKlxuICogTm90ZTogYG9wdEFtb3VudFNoYXBlYCBpcyB1c2VyLXN1cHBsaWVkIHdpdGggbm8gcHJldmlvdXMgdmFsaWRhdGlvbi5cbiAqXG4gKiBAcGFyYW0ge0Ftb3VudH0gcGF5bWVudEJhbGFuY2VcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge3ZvaWR9XG4gKi9cbmNvbnN0IGFzc2VydEFtb3VudENvbnNpc3RlbnQ9KHBheW1lbnRCYWxhbmNlLG9wdEFtb3VudFNoYXBlKT0+e1xuaWYob3B0QW1vdW50U2hhcGUhPT11bmRlZmluZWQpe1xubXVzdE1hdGNoKHBheW1lbnRCYWxhbmNlLG9wdEFtb3VudFNoYXBlLCdhbW91bnQnKTtcbiB9XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnRcbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5jb25zdCBhc3NlcnRMaXZlUGF5bWVudD0ocGF5bWVudCk9PntcbnBheW1lbnRMZWRnZXIuaGFzKHBheW1lbnQpfHxcbkZhaWwgYCR7cGF5bWVudH0gd2FzIG5vdCBhIGxpdmUgcGF5bWVudCBmb3IgYnJhbmQgJHtxKFxuYnJhbmQpXG4gfS4gSXQgY291bGQgYmUgYSB1c2VkLXVwIHBheW1lbnQsIGEgcGF5bWVudCBmb3IgYW5vdGhlciBicmFuZCwgb3IgaXQgbWlnaHQgbm90IGJlIGEgcGF5bWVudCBhdCBhbGwuYDtcbiB9O1xuXG4vKipcbiAqIFVzZWQgYnkgdGhlIHB1cnNlIGNvZGUgdG8gaW1wbGVtZW50IHB1cnNlLmRlcG9zaXRcbiAqXG4gKiBAcGFyYW0ge0Ftb3VudH0gY3VycmVudEJhbGFuY2UgLSB0aGUgY3VycmVudCBiYWxhbmNlIG9mIHRoZSBwdXJzZVxuICogYmVmb3JlIGEgZGVwb3NpdFxuICogQHBhcmFtIHsobmV3UHVyc2VCYWxhbmNlOiBBbW91bnQpID0+IHZvaWR9IHVwZGF0ZVB1cnNlQmFsYW5jZSAtXG4gKiBjb21taXQgdGhlIHB1cnNlIGJhbGFuY2VcbiAqIEBwYXJhbSB7UGF5bWVudH0gc3JjUGF5bWVudFxuICogQHBhcmFtIHtQYXR0ZXJufSBbb3B0QW1vdW50U2hhcGVdXG4gKiBAcmV0dXJucyB7QW1vdW50fVxuICovXG5jb25zdCBkZXBvc2l0SW50ZXJuYWw9KFxuY3VycmVudEJhbGFuY2UsXG51cGRhdGVQdXJzZUJhbGFuY2UsXG5zcmNQYXltZW50LFxub3B0QW1vdW50U2hhcGU9dW5kZWZpbmVkKT0+XG57XG4haXNQcm9taXNlKHNyY1BheW1lbnQpfHxcbmFzc2VydC5mYWlsKFxuIGBkZXBvc2l0IGRvZXMgbm90IGFjY2VwdCBwcm9taXNlcyBhcyBmaXJzdCBhcmd1bWVudC4gSW5zdGVhZCBvZiBwYXNzaW5nIHRoZSBwcm9taXNlIChkZXBvc2l0KHBheW1lbnRQcm9taXNlKSksIGNvbnNpZGVyIHVud3JhcHBpbmcgdGhlIHByb21pc2UgZmlyc3Q6IEUud2hlbihwYXltZW50UHJvbWlzZSwgKGFjdHVhbFBheW1lbnQgPT4gZGVwb3NpdChhY3R1YWxQYXltZW50KSlgLFxuVHlwZUVycm9yKTtcblxuYXNzZXJ0TGl2ZVBheW1lbnQoc3JjUGF5bWVudCk7XG5jb25zdCBzcmNQYXltZW50QmFsYW5jZT1wYXltZW50TGVkZ2VyLmdldChzcmNQYXltZW50KTtcbmFzc2VydEFtb3VudENvbnNpc3RlbnQoc3JjUGF5bWVudEJhbGFuY2Usb3B0QW1vdW50U2hhcGUpO1xuY29uc3QgbmV3UHVyc2VCYWxhbmNlPWFkZChzcmNQYXltZW50QmFsYW5jZSxjdXJyZW50QmFsYW5jZSk7XG50cnl7XG4vKiBDT01NSVQgUE9JTlQqL1xuLyogTW92ZSB0aGUgYXNzZXRzIGluIGBzcmNQYXltZW50YCBpbnRvIHRoaXMgcHVyc2UsIHVzaW5nIHVwIHRoZSovXG4vKiBzb3VyY2UgcGF5bWVudCwgc3VjaCB0aGF0IHRvdGFsIGFzc2V0cyBhcmUgY29uc2VydmVkLiovXG5kZWxldGVQYXltZW50KHNyY1BheW1lbnQpO1xudXBkYXRlUHVyc2VCYWxhbmNlKG5ld1B1cnNlQmFsYW5jZSk7XG4gfWNhdGNoKGVycil7XG5zaHV0ZG93bkxlZGdlcldpdGhGYWlsdXJlKGVycik7XG50aHJvdyBlcnI7XG4gfVxucmV0dXJuIHNyY1BheW1lbnRCYWxhbmNlO1xuIH07XG5cbi8qKlxuICogVXNlZCBieSB0aGUgcHVyc2UgY29kZSB0byBpbXBsZW1lbnQgcHVyc2Uud2l0aGRyYXdcbiAqXG4gKiBAcGFyYW0ge0Ftb3VudH0gY3VycmVudEJhbGFuY2UgLSB0aGUgY3VycmVudCBiYWxhbmNlIG9mIHRoZSBwdXJzZVxuICogYmVmb3JlIGEgd2l0aGRyYXdhbFxuICogQHBhcmFtIHsobmV3UHVyc2VCYWxhbmNlOiBBbW91bnQpID0+IHZvaWR9IHVwZGF0ZVB1cnNlQmFsYW5jZSAtXG4gKiBjb21taXQgdGhlIHB1cnNlIGJhbGFuY2VcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnQgLSB0aGUgYW1vdW50IHRvIGJlIHdpdGhkcmF3blxuICogQHBhcmFtIHtTZXRTdG9yZTxQYXltZW50Pn0gcmVjb3ZlcnlTZXRcbiAqIEByZXR1cm5zIHtQYXltZW50fVxuICovXG5jb25zdCB3aXRoZHJhd0ludGVybmFsPShcbmN1cnJlbnRCYWxhbmNlLFxudXBkYXRlUHVyc2VCYWxhbmNlLFxuYW1vdW50LFxucmVjb3ZlcnlTZXQpPT5cbntcbmFtb3VudD1jb2VyY2UoYW1vdW50KTtcbkFtb3VudE1hdGguaXNHVEUoY3VycmVudEJhbGFuY2UsYW1vdW50KXx8XG5GYWlsIGBXaXRoZHJhd2FsIG9mICR7YW1vdW50fSBmYWlsZWQgYmVjYXVzZSB0aGUgcHVyc2Ugb25seSBjb250YWluZWQgJHtjdXJyZW50QmFsYW5jZX1gO1xuY29uc3QgbmV3UHVyc2VCYWxhbmNlPXN1YnRyYWN0KGN1cnJlbnRCYWxhbmNlLGFtb3VudCk7XG5cbmNvbnN0IHBheW1lbnQ9bWFrZVBheW1lbnQoKTtcbnRyeXtcbi8qIENPTU1JVCBQT0lOVCBNb3ZlIHRoZSB3aXRoZHJhd24gYXNzZXRzIGZyb20gdGhpcyBwdXJzZSBpbnRvKi9cbi8qIHBheW1lbnQuIFRvdGFsIGFzc2V0cyBtdXN0IHJlbWFpbiBjb25zZXJ2ZWQuKi9cbnVwZGF0ZVB1cnNlQmFsYW5jZShuZXdQdXJzZUJhbGFuY2UpO1xuaW5pdFBheW1lbnQocGF5bWVudCxhbW91bnQscmVjb3ZlcnlTZXQpO1xuIH1jYXRjaChlcnIpe1xuc2h1dGRvd25MZWRnZXJXaXRoRmFpbHVyZShlcnIpO1xudGhyb3cgZXJyO1xuIH1cbnJldHVybiBwYXltZW50O1xuIH07XG5cbmNvbnN0IG1ha2VFbXB0eVB1cnNlPXByZXBhcmVQdXJzZUtpbmQoXG5pc3N1ZXJCYWdnYWdlLFxubmFtZSxcbmFzc2V0S2luZCxcbmJyYW5kLFxuUHVyc2VJS2l0LFxuaGFyZGVuKHtcbmRlcG9zaXRJbnRlcm5hbCxcbndpdGhkcmF3SW50ZXJuYWx9KSk7XG5cblxuXG4vKiogQHR5cGUge0lzc3VlcjxLPn0gKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCBkdWUgdG8gY2FsbFdoZW4gZGlzY3JlcGFuY3kqL1xuY29uc3QgaXNzdWVyPXByZXBhcmVFeG8oaXNzdWVyQmFnZ2FnZSwgYCR7bmFtZX0gaXNzdWVyYCxJc3N1ZXJJLHtcbmdldEJyYW5kKCl7XG5yZXR1cm4gYnJhbmQ7XG4gfSxcbmdldEFsbGVnZWROYW1lKCl7XG5yZXR1cm4gbmFtZTtcbiB9LFxuZ2V0QXNzZXRLaW5kKCl7XG5yZXR1cm4gYXNzZXRLaW5kO1xuIH0sXG5nZXREaXNwbGF5SW5mbygpe1xucmV0dXJuIGRpc3BsYXlJbmZvO1xuIH0sXG5tYWtlRW1wdHlQdXJzZSgpe1xucmV0dXJuIG1ha2VFbXB0eVB1cnNlKCk7XG4gfSxcbi8qKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnQgYXdhaXRlZCBieSBjYWxsV2hlbiAqL1xuaXNMaXZlKHBheW1lbnQpe1xuLyogSXNzdWVySSBkZWxheXMgY2FsbGluZyB0aGlzIG1ldGhvZCB1bnRpbCBgcGF5bWVudGAgaXMgYSBSZW1vdGFibGUqL1xucmV0dXJuIHBheW1lbnRMZWRnZXIuaGFzKHBheW1lbnQpO1xuIH0sXG4vKiogQHBhcmFtIHtQYXltZW50fSBwYXltZW50IGF3YWl0ZWQgYnkgY2FsbFdoZW4gKi9cbmdldEFtb3VudE9mKHBheW1lbnQpe1xuLyogSXNzdWVySSBkZWxheXMgY2FsbGluZyB0aGlzIG1ldGhvZCB1bnRpbCBgcGF5bWVudGAgaXMgYSBSZW1vdGFibGUqL1xuYXNzZXJ0TGl2ZVBheW1lbnQocGF5bWVudCk7XG5yZXR1cm4gcGF5bWVudExlZGdlci5nZXQocGF5bWVudCk7XG4gfSxcbi8qKlxuICogQHBhcmFtIHtQYXltZW50fSBwYXltZW50IGF3YWl0ZWQgYnkgY2FsbFdoZW5cbiAqIEBwYXJhbSB7UGF0dGVybn0gb3B0QW1vdW50U2hhcGVcbiAqL1xuYnVybihwYXltZW50LG9wdEFtb3VudFNoYXBlPXVuZGVmaW5lZCl7XG4vKiBJc3N1ZXJJIGRlbGF5cyBjYWxsaW5nIHRoaXMgbWV0aG9kIHVudGlsIGBwYXltZW50YCBpcyBhIFJlbW90YWJsZSovXG5hc3NlcnRMaXZlUGF5bWVudChwYXltZW50KTtcbmNvbnN0IHBheW1lbnRCYWxhbmNlPXBheW1lbnRMZWRnZXIuZ2V0KHBheW1lbnQpO1xuYXNzZXJ0QW1vdW50Q29uc2lzdGVudChwYXltZW50QmFsYW5jZSxvcHRBbW91bnRTaGFwZSk7XG50cnl7XG4vKiBDT01NSVQgUE9JTlQuKi9cbmRlbGV0ZVBheW1lbnQocGF5bWVudCk7XG4gfWNhdGNoKGVycil7XG5zaHV0ZG93bkxlZGdlcldpdGhGYWlsdXJlKGVycik7XG50aHJvdyBlcnI7XG4gfVxucmV0dXJuIHBheW1lbnRCYWxhbmNlO1xuIH19KTtcblxuXG4vKipcbiAqIFByb3ZpZGVzIGZvciB0aGUgcmVjb3Zlcnkgb2YgbmV3bHkgbWludGVkIGJ1dCBub3QteWV0LWRlcG9zaXRlZCBwYXltZW50cy5cbiAqXG4gKiBCZWNhdXNlIHRoZSBgbWludFJlY292ZXJ5UHVyc2VgIGlzIHBsYWNlZCBpbiBiYWdnYWdlLCBldmVuIGlmIHRoZVxuICogY2FsbGVyIG9mIGBtYWtlSXNzdWVyS2l0YCBkcm9wcyBpdCBvbiB0aGUgZmxvb3IsIGl0IGNhbiBzdGlsbCBiZVxuICogcmVjb3ZlcmVkIGluIGFuIGVtZXJnZW5jeSB1cGdyYWRlLlxuICpcbiAqIEB0eXBlIHtQdXJzZTxLPn1cbiAqL1xuY29uc3QgbWludFJlY292ZXJ5UHVyc2U9cHJvdmlkZShpc3N1ZXJCYWdnYWdlLCdtaW50UmVjb3ZlcnlQdXJzZScsKCk9PlxubWFrZUVtcHR5UHVyc2UoKSk7XG5cblxuLyoqIEB0eXBlIHtNaW50PEs+fSAqL1xuY29uc3QgbWludD1wcmVwYXJlRXhvKGlzc3VlckJhZ2dhZ2UsIGAke25hbWV9IG1pbnRgLE1pbnRJLHtcbmdldElzc3Vlcigpe1xucmV0dXJuIGlzc3VlcjtcbiB9LFxubWludFBheW1lbnQobmV3QW1vdW50KXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgY2hlY2tlZCBjYXN0Ki9cbm5ld0Ftb3VudD1jb2VyY2UobmV3QW1vdW50KTtcbm11c3RNYXRjaChuZXdBbW91bnQsYW1vdW50U2hhcGUsJ21pbnRlZCBhbW91bnQnKTtcbi8qIGByYXdQYXltZW50YCBpcyBub3QgYXNzb2NpYXRlZCB3aXRoIGFueSByZWNvdmVyeSBzZXQsIGFuZCovXG4vKiBzbyBtdXN0IG5vdCBlc2NhcGUuKi9cbmNvbnN0IHJhd1BheW1lbnQ9bWFrZVBheW1lbnQoKTtcbmluaXRQYXltZW50KHJhd1BheW1lbnQsbmV3QW1vdW50LHVuZGVmaW5lZCk7XG5cbmNvbnN0IG1pbnRSZWNvdmVyeVB1cnNlQmVmb3JlPW1pbnRSZWNvdmVyeVB1cnNlLmdldEN1cnJlbnRBbW91bnQoKTtcbm1pbnRSZWNvdmVyeVB1cnNlLmRlcG9zaXQocmF3UGF5bWVudCxuZXdBbW91bnQpO1xuY29uc3QgcGF5bWVudD1taW50UmVjb3ZlcnlQdXJzZS53aXRoZHJhdyhuZXdBbW91bnQpO1xuY29uc3QgbWludFJlY292ZXJ5UHVyc2VBZnRlcj1taW50UmVjb3ZlcnlQdXJzZS5nZXRDdXJyZW50QW1vdW50KCk7XG5hc3NlcnQoa2V5RVEobWludFJlY292ZXJ5UHVyc2VCZWZvcmUsbWludFJlY292ZXJ5UHVyc2VBZnRlcikpO1xucmV0dXJuIHBheW1lbnQ7XG4gfX0pO1xuXG5cbmNvbnN0IGlzc3VlcktpdD1oYXJkZW4oe2lzc3VlcixtaW50LGJyYW5kLG1pbnRSZWNvdmVyeVB1cnNlfSk7XG5yZXR1cm4gaXNzdWVyS2l0O1xuIH07JGjigI1fb25jZS5wcmVwYXJlUGF5bWVudExlZGdlcihwcmVwYXJlUGF5bWVudExlZGdlcik7XG5oYXJkZW4ocHJlcGFyZVBheW1lbnRMZWRnZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVQYXltZW50TGVkZ2VyIjpbInByZXBhcmVQYXltZW50TGVkZ2VyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAKJFRULADwAAwA8AACcAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvcHVyc2UuanN7ImltcG9ydHMiOlsiLi9hbW91bnRNYXRoLmpzIiwiLi90cmFuc2llbnROb3RpZmllci5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsicHJlcGFyZVB1cnNlS2luZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLHByZXBhcmVFeG9DbGFzc0tpdCxtYWtlU2NhbGFyQmlnU2V0U3RvcmUsQW1vdW50TWF0aCxtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQ7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJwcmVwYXJlRXhvQ2xhc3NLaXRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzc0tpdCA9ICRo4oCNX2EpXV0sW1wibWFrZVNjYWxhckJpZ1NldFN0b3JlXCIsIFskaOKAjV9hID0+IChtYWtlU2NhbGFyQmlnU2V0U3RvcmUgPSAkaOKAjV9hKV1dXV0sW1wiLi9hbW91bnRNYXRoLmpzXCIsIFtbXCJBbW91bnRNYXRoXCIsIFskaOKAjV9hID0+IChBbW91bnRNYXRoID0gJGjigI1fYSldXV1dLFtcIi4vdHJhbnNpZW50Tm90aWZpZXIuanNcIiwgW1tcIm1ha2VUcmFuc2llbnROb3RpZmllcktpdFwiLCBbJGjigI1fYSA9PiAobWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuY29uc3QgICAgICAgIHByZXBhcmVQdXJzZUtpbmQ9KFxuaXNzdWVyQmFnZ2FnZSxcbm5hbWUsXG5hc3NldEtpbmQsXG5icmFuZCxcblB1cnNlSUtpdCxcbnB1cnNlTWV0aG9kcyk9Plxue1xuY29uc3QgYW1vdW50U2hhcGU9YnJhbmQuZ2V0QW1vdW50U2hhcGUoKTtcblxuLyogTm90ZTogVmlydHVhbCBmb3IgaGlnaCBjYXJkaW5hbGl0eSwgYnV0ICpub3QqIGR1cmFibGUsIGFuZCBzbyovXG4vKiBicm9rZW4gYWNyb3NzIGFuIHVwZ3JhZGUuKi9cbmNvbnN0e3Byb3ZpZGVOb3RpZmllcix1cGRhdGU6dXBkYXRlQmFsYW5jZX09bWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0KCk7XG5cbmNvbnN0IHVwZGF0ZVB1cnNlQmFsYW5jZT0oc3RhdGUsbmV3UHVyc2VCYWxhbmNlLHB1cnNlKT0+e1xuc3RhdGUuY3VycmVudEJhbGFuY2U9bmV3UHVyc2VCYWxhbmNlO1xudXBkYXRlQmFsYW5jZShwdXJzZSxwdXJzZS5nZXRDdXJyZW50QW1vdW50KCkpO1xuIH07XG5cbi8qIC0gVGhpcyBraW5kIGlzIGEgcGFpciBvZiBwdXJzZSBhbmQgZGVwb3NpdEZhY2V0IHRoYXQgaGF2ZSBhIDE6MSovXG4vKiBjb3JyZXNwb25kZW5jZS4qL1xuLyogLSBUaGV5IGFyZSB2aXJ0dWFsaXplZCB0b2dldGhlciB0byBzaGFyZSBhIHNpbmdsZSBzdGF0ZSByZWNvcmQuKi9cbi8qIC0gQW4gYWx0ZXJuYXRpdmUgZGVzaWduIGNvbnNpZGVyZWQgd2FzIHRvIGhhdmUgdGhpcyByZXR1cm4gYSBQdXJzZSBhbG9uZSovXG4vKiB0aGF0IGNyZWF0ZWQgZGVwb3NpdEZhY2V0IGFzIG5lZWRlZC4gQnV0IHRoaXMgYXBwcm9hY2ggZW5zdXJlcyBhIGNvbnN0YW50Ki9cbi8qIGlkZW50aXR5IGZvciB0aGUgZmFjZXQgYW5kIGV4ZXJjaXNlcyB0aGUgbXVsdGktZmFjZXRlZCBvYmplY3Qgc3R5bGUuKi9cbmNvbnN0e2RlcG9zaXRJbnRlcm5hbCx3aXRoZHJhd0ludGVybmFsfT1wdXJzZU1ldGhvZHM7XG5jb25zdCBtYWtlUHVyc2VLaXQ9cHJlcGFyZUV4b0NsYXNzS2l0KFxuaXNzdWVyQmFnZ2FnZSxcbiBgJHtuYW1lfSBQdXJzZWAsXG5QdXJzZUlLaXQsXG4oKT0+e1xuY29uc3QgY3VycmVudEJhbGFuY2U9QW1vdW50TWF0aC5tYWtlRW1wdHkoYnJhbmQsYXNzZXRLaW5kKTtcblxuLyoqIEB0eXBlIHtTZXRTdG9yZTxQYXltZW50Pn0gKi9cbmNvbnN0IHJlY292ZXJ5U2V0PW1ha2VTY2FsYXJCaWdTZXRTdG9yZSgncmVjb3Zlcnkgc2V0Jyx7XG5kdXJhYmxlOnRydWV9KTtcblxuXG5yZXR1cm57XG5jdXJyZW50QmFsYW5jZSxcbnJlY292ZXJ5U2V0fTtcblxuIH0sXG57XG5wdXJzZTp7XG5kZXBvc2l0KHNyY1BheW1lbnQsb3B0QW1vdW50U2hhcGU9dW5kZWZpbmVkKXtcbi8qIFB1cnNlSSBkb2VzICpub3QqIGRlbGF5IGBkZXBvc2l0YCB1bnRpbCBgc3JjUGF5bWVudGAgaXMgZnVsZnVsbGVkLiovXG4vKiBTZWUgdGhlIGNvbW1lbnRzIG9uIFB1cnNlSS5kZXBvc2l0IGluIHR5cGVHdWFyZHMuanMqL1xuY29uc3R7c3RhdGV9PXRoaXM7XG4vKiBOb3RlIENPTU1JVCBQT0lOVCB3aXRoaW4gZGVwb3NpdC4qL1xucmV0dXJuIGRlcG9zaXRJbnRlcm5hbChcbnN0YXRlLmN1cnJlbnRCYWxhbmNlLFxuKG5ld1B1cnNlQmFsYW5jZSk9PlxudXBkYXRlUHVyc2VCYWxhbmNlKHN0YXRlLG5ld1B1cnNlQmFsYW5jZSx0aGlzLmZhY2V0cy5wdXJzZSksXG5zcmNQYXltZW50LFxub3B0QW1vdW50U2hhcGUpO1xuXG4gfSxcbndpdGhkcmF3KGFtb3VudCl7XG5jb25zdHtzdGF0ZX09dGhpcztcbi8qIE5vdGUgQ09NTUlUIFBPSU5UIHdpdGhpbiB3aXRoZHJhdy4qL1xucmV0dXJuIHdpdGhkcmF3SW50ZXJuYWwoXG5zdGF0ZS5jdXJyZW50QmFsYW5jZSxcbihuZXdQdXJzZUJhbGFuY2UpPT5cbnVwZGF0ZVB1cnNlQmFsYW5jZShzdGF0ZSxuZXdQdXJzZUJhbGFuY2UsdGhpcy5mYWNldHMucHVyc2UpLFxuYW1vdW50LFxuc3RhdGUucmVjb3ZlcnlTZXQpO1xuXG4gfSxcbmdldEN1cnJlbnRBbW91bnQoKXtcbnJldHVybiB0aGlzLnN0YXRlLmN1cnJlbnRCYWxhbmNlO1xuIH0sXG5nZXRDdXJyZW50QW1vdW50Tm90aWZpZXIoKXtcbnJldHVybiBwcm92aWRlTm90aWZpZXIodGhpcy5mYWNldHMucHVyc2UpO1xuIH0sXG5nZXRBbGxlZ2VkQnJhbmQoKXtcbnJldHVybiBicmFuZDtcbiB9LFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbmdldERlcG9zaXRGYWNldCgpe1xucmV0dXJuIHRoaXMuZmFjZXRzLmRlcG9zaXRGYWNldDtcbiB9LFxuXG5nZXRSZWNvdmVyeVNldCgpe1xucmV0dXJuIHRoaXMuc3RhdGUucmVjb3ZlcnlTZXQuc25hcHNob3QoKTtcbiB9LFxucmVjb3ZlckFsbCgpe1xuY29uc3R7c3RhdGUsZmFjZXRzfT10aGlzO1xubGV0IGFtb3VudD1BbW91bnRNYXRoLm1ha2VFbXB0eShicmFuZCxhc3NldEtpbmQpO1xuZm9yKGNvbnN0IHBheW1lbnQgb2Ygc3RhdGUucmVjb3ZlcnlTZXQua2V5cygpKXtcbi8qIFRoaXMgZG9lcyBjYXVzZSBkZWxldGlvbnMgZnJvbSB0aGUgc2V0IHdoaWxlIGl0ZXJhdGluZywqL1xuLyogYnV0IHRoaXMgc3BlY2lhbCBjYXNlIGlzIGFsbG93ZWQuKi9cbmNvbnN0IGRlbHRhPWZhY2V0cy5wdXJzZS5kZXBvc2l0KHBheW1lbnQpO1xuYW1vdW50PUFtb3VudE1hdGguYWRkKGFtb3VudCxkZWx0YSxicmFuZCk7XG4gfVxuc3RhdGUucmVjb3ZlcnlTZXQuZ2V0U2l6ZSgpPT09MHx8XG5GYWlsIGBpbnRlcm5hbDogUmVtYWluaW5nIHVucmVjb3ZlcmVkIHBheW1lbnRzOiAke2ZhY2V0cy5wdXJzZS5nZXRSZWNvdmVyeVNldCgpfWA7XG5yZXR1cm4gYW1vdW50O1xuIH19LFxuXG5kZXBvc2l0RmFjZXQ6e1xucmVjZWl2ZSguLi5hcmdzKXtcbnJldHVybiB0aGlzLmZhY2V0cy5wdXJzZS5kZXBvc2l0KC4uLmFyZ3MpO1xuIH19fSxcblxuXG57XG5zdGF0ZVNoYXBlOntcbmN1cnJlbnRCYWxhbmNlOmFtb3VudFNoYXBlLFxucmVjb3ZlcnlTZXQ6TS5yZW1vdGFibGUoJ3JlY292ZXJ5U2V0Jyl9fSk7XG5cblxuXG5yZXR1cm4oKT0+bWFrZVB1cnNlS2l0KCkucHVyc2U7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVQdXJzZUtpbmQocHJlcGFyZVB1cnNlS2luZCk7XG5oYXJkZW4ocHJlcGFyZVB1cnNlS2luZCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicHJlcGFyZVB1cnNlS2luZCI6WyJwcmVwYXJlUHVyc2VLaW5kIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAC5JY6kUBgAAFAYAADMAAABAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvdHJhbnNpZW50Tm90aWZpZXIuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9ub3RpZmllciIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsibWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUscHJvdmlkZUxhenksbWFrZU5vdGlmaWVyS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmVcIiwgWyRo4oCNX2EgPT4gKG1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wicHJvdmlkZUxhenlcIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVMYXp5ID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvbm90aWZpZXJcIiwgW1tcIm1ha2VOb3RpZmllcktpdFwiLCBbJGjigI1fYSA9PiAobWFrZU5vdGlmaWVyS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyogTm90ZTogVmlydHVhbCBmb3IgaGlnaCBjYXJkaW5hbGl0eSwgYnV0ICpub3QqIGR1cmFibGUsIGFuZCBzbyovXG4vKiBicm9rZW4gYWNyb3NzIGFuIHVwZ3JhZGUuKi9cbmNvbnN0ICAgICAgICBtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQ9KCk9Pntcbi8qKiBAdHlwZSB7V2Vha01hcFN0b3JlPFB1cnNlLCBOb3RpZmllclJlY29yZDxhbnk+Pn0gKi9cbmNvbnN0IHRyYW5zaWVudE5vdGlmZXJLaXRzPW1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUoXG4ndHJhbnNpZW50Tm90aWZlcktpdHMnKTtcblxuXG5jb25zdCBwcm92aWRlTm90aWZpZXJLaXQ9KGtleSk9PlxucHJvdmlkZUxhenkodHJhbnNpZW50Tm90aWZlcktpdHMsa2V5LCgpPT5cbm1ha2VOb3RpZmllcktpdChrZXkuZ2V0Q3VycmVudEFtb3VudCgpKSk7XG5cblxuY29uc3QgcHJvdmlkZU5vdGlmaWVyPShrZXkpPT5wcm92aWRlTm90aWZpZXJLaXQoa2V5KS5ub3RpZmllcjtcbmNvbnN0IHVwZGF0ZT0oa2V5LG5ld1ZhbHVlKT0+e1xuaWYodHJhbnNpZW50Tm90aWZlcktpdHMuaGFzKGtleSkpe1xuY29uc3R7dXBkYXRlcn09dHJhbnNpZW50Tm90aWZlcktpdHMuZ2V0KGtleSk7XG51cGRhdGVyLnVwZGF0ZVN0YXRlKG5ld1ZhbHVlKTtcbiB9XG4gfTtcblxucmV0dXJue3Byb3ZpZGVOb3RpZmllcix1cGRhdGV9O1xuIH07JGjigI1fb25jZS5tYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQobWFrZVRyYW5zaWVudE5vdGlmaWVyS2l0KTtcbmhhcmRlbihtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VUcmFuc2llbnROb3RpZmllcktpdCI6WyJtYWtlVHJhbnNpZW50Tm90aWZpZXJLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAKO6ePhInAAASJwAALAAAAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy90eXBlR3VhcmRzLmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvc3RvcmUiXSwiZXhwb3J0cyI6WyJBbW91bnRTaGFwZSIsIkFzc2V0S2luZFNoYXBlIiwiQnJhbmRJIiwiQnJhbmRTaGFwZSIsIkRlcG9zaXRGYWNldFNoYXBlIiwiRGlzcGxheUluZm9TaGFwZSIsIklzc3VlcktpdFNoYXBlIiwiSXNzdWVyU2hhcGUiLCJNQVhfQUJTT0xVVEVfREVDSU1BTF9QTEFDRVMiLCJNaW50U2hhcGUiLCJOb3RpZmllclNoYXBlIiwiUGF5bWVudFNoYXBlIiwiUHVyc2VTaGFwZSIsIlJhdGlvU2hhcGUiLCJpc0NvcHlCYWdWYWx1ZSIsImlzQ29weVNldFZhbHVlIiwiaXNOYXRWYWx1ZSIsImlzU2V0VmFsdWUiLCJtYWtlSXNzdWVySW50ZXJmYWNlcyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLG1hdGNoZXM7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV0sW1wibWF0Y2hlc1wiLCBbJGjigI1fYSA9PiAobWF0Y2hlcyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3QgICAgICAgIEJyYW5kU2hhcGU9TS5yZW1vdGFibGUoJ0JyYW5kJyk7JGjigI1fb25jZS5CcmFuZFNoYXBlKEJyYW5kU2hhcGUpO1xuY29uc3QgICAgICAgIElzc3VlclNoYXBlPU0ucmVtb3RhYmxlKCdJc3N1ZXInKTskaOKAjV9vbmNlLklzc3VlclNoYXBlKElzc3VlclNoYXBlKTtcbmNvbnN0ICAgICAgICBQYXltZW50U2hhcGU9TS5yZW1vdGFibGUoJ1BheW1lbnQnKTskaOKAjV9vbmNlLlBheW1lbnRTaGFwZShQYXltZW50U2hhcGUpO1xuY29uc3QgICAgICAgIFB1cnNlU2hhcGU9TS5yZW1vdGFibGUoJ1B1cnNlJyk7JGjigI1fb25jZS5QdXJzZVNoYXBlKFB1cnNlU2hhcGUpO1xuY29uc3QgICAgICAgIERlcG9zaXRGYWNldFNoYXBlPU0ucmVtb3RhYmxlKCdEZXBvc2l0RmFjZXQnKTskaOKAjV9vbmNlLkRlcG9zaXRGYWNldFNoYXBlKERlcG9zaXRGYWNldFNoYXBlKTtcbmNvbnN0ICAgICAgICBOb3RpZmllclNoYXBlPU0ucmVtb3RhYmxlKCdOb3RpZmllcicpOyRo4oCNX29uY2UuTm90aWZpZXJTaGFwZShOb3RpZmllclNoYXBlKTtcbmNvbnN0ICAgICAgICBNaW50U2hhcGU9TS5yZW1vdGFibGUoJ01pbnQnKTtcblxuLyoqXG4gKiBXaGVuIHRoZSBBbW91bnRWYWx1ZSBvZiBhbiBBbW91bnQgZml0cyB0aGUgTmF0VmFsdWVTaGFwZSwgaS5lLiwgd2hlbiBpdCBpc1xuICogYSBub24tbmVnYXRpdmUgYmlnaW50LCB0aGVuIGl0IHJlcHJlc2VudHMgdGhhdCBtYW55IHVuaXRzIG9mIHRoZVxuICogZnVuZ2libGUgYXNzZXQgcmVwcmVzZW50ZWQgYnkgdGhhdCBhbW91bnQuIFRoZSBicmFuZCBvZiB0aGF0IGFtb3VudFxuICogc2hvdWxkIGluZGVlZCByZXByZXNlbnQgYSBraW5kIG9mIGFzc2V0IGNvbnNpc3Rpbmcgb2YgYSBjb3VudGFibGVcbiAqIHNldCBvZiBmdW5naWJsZSB1bml0cy5cbiAqLyRo4oCNX29uY2UuTWludFNoYXBlKE1pbnRTaGFwZSk7XG5jb25zdCBOYXRWYWx1ZVNoYXBlPU0ubmF0KCk7XG5cbi8qKlxuICogV2hlbiB0aGUgQW1vdW50VmFsdWUgb2YgYW4gQW1vdW50IGZpdHMgdGhlIENvcHlTZXRWYWx1ZVNoYXBlLCBpLmUuLCB3aGVuIGl0XG4gKiBpcyBhIENvcHlTZXQsIHRoZW4gaXQgcmVwcmVzZW50cyB0aGUgc2V0IG9mIHRob3NlXG4gKiBrZXlzLCB3aGVyZSBlYWNoIGtleSByZXByZXNlbnRzIHNvbWUgaW5kaXZpZHVhbCBub24tZnVuZ2libGVcbiAqIGl0ZW0sIGxpa2UgYSBjb25jZXJ0IHRpY2tldCwgZnJvbSB0aGUgbm9uLWZ1bmdpYmxlIGFzc2V0IGNsYXNzXG4gKiByZXByZXNlbnRlZCBieSB0aGF0IGFtb3VudCdzIGJyYW5kLiBUaGUgYW1vdW50IGl0c2VsZiByZXByZXNlbnRzXG4gKiB0aGUgc2V0IG9mIHRoZXNlIGl0ZW1zLCBhcyBvcHBvc2VkIHRvIGFueSBvZiB0aGUgb3RoZXIgaXRlbXNcbiAqIGZyb20gdGhlIHNhbWUgYXNzZXQgY2xhc3MuXG4gKlxuICogSWYgYSBnaXZlbiB2YWx1ZSBjbGFzcyByZXByZXNlbnRzIGNvbmNlcnQgdGlja2V0cywgaXQgc2VlbXMgYml6YXJyZVxuICogdGhhdCB3ZSBjYW4gZm9ybSBhbW91bnRzIG9mIGFueSBrZXkuIFRoZSBoYXJkIGNvbnN0cmFpbnQgaXMgdGhhdFxuICogdGhlIGNvZGUgdGhhdCBob2xkcyB0aGUgbWludCBmb3IgdGhhdCBhc3NldCBjbGFzcy0tLXRoZSBvbmUgYXNzb2NpYXRlZFxuICogd2l0aCB0aGF0IGJyYW5kLCBvbmx5IG1pbnRzIHRoZSBpdGVtcyByZXByZXNlbnRpbmcgdGhlIHJlYWwgdW5pdHNcbiAqIG9mIHRoYXQgYXNzZXQgY2xhc3MgYXMgZGVmaW5lZCBieSBpdC4gQW55b25lIGVsc2UgY2FuIHB1dCB0b2dldGhlclxuICogYW4gYW1vdW50IGV4cHJlc3NpbmcsIGZvciBleGFtcGxlLCB0aGF0IHRoZXkgXCJ3YW50XCIgc29tZSBpdGVtcyB0aGF0XG4gKiB3aWxsIG5ldmVyIGJlIG1pbnRlZC4gVGhhdCB3YW50IHdpbGwgbmV2ZXIgYmUgc2F0aXNmaWVkLlxuICogXCJZb3UgY2FuJ3QgYWx3YXlzIGdldC4uLlwiXG4gKi9cbmNvbnN0IENvcHlTZXRWYWx1ZVNoYXBlPU0uc2V0KCk7XG5cbi8qKlxuICogV2hlbiB0aGUgQW1vdW50VmFsdWUgb2YgYW4gQW1vdW50IGZpdHMgdGhlIFNldFZhbHVlU2hhcGUsIGkuZS4sIHdoZW4gaXRcbiAqIGlzIGEgQ29weUFycmF5IG9mIHBhc3NhYmxlIEtleXMuIFRoaXMgcmVwcmVzZW50YXRpb24gaXMgZGVwcmVjYXRlZC5cbiAqXG4gKiBAZGVwcmVjYXRlZCBQbGVhc2UgY2hhbmdlIGZyb20gdXNpbmcgYXJyYXktYmFzZWQgU2V0VmFsdWVzIHRvIENvcHlTZXQtYmFzZWRcbiAqIENvcHlTZXRWYWx1ZXMuXG4gKi9cbmNvbnN0IFNldFZhbHVlU2hhcGU9TS5hcnJheU9mKE0ua2V5KCkpO1xuXG4vKipcbiAqIFdoZW4gdGhlIEFtb3VudFZhbHVlIG9mIGFuIEFtb3VudCBmaXRzIHRoZSBDb3B5QmFnVmFsdWVTaGFwZSwgaS5lLiwgd2hlbiBpdFxuICogaXMgYSBDb3B5QmFnLCB0aGVuIGl0IHJlcHJlc2VudHMgdGhlIGJhZyAobXVsdGlzZXQpIG9mIHRob3NlXG4gKiBrZXlzLCB3aGVyZSBlYWNoIGtleSByZXByZXNlbnRzIHNvbWUgaW5kaXZpZHVhbCBzZW1pLWZ1bmdpYmxlXG4gKiBpdGVtLCBsaWtlIGEgY29uY2VydCB0aWNrZXQsIGZyb20gdGhlIHNlbWktZnVuZ2libGUgYXNzZXQgY2xhc3NcbiAqIHJlcHJlc2VudGVkIGJ5IHRoYXQgYW1vdW50J3MgYnJhbmQuIFRoZSBudW1iZXIgb2YgdGltZXMgdGhhdCBrZXlcbiAqIGFwcGVhcnMgaW4gdGhlIGJhZyBpcyB0aGUgbnVtYmVyIG9mIGZ1bmdpYmxlIHVuaXRzIG9mIHRoYXQga2V5LlxuICogVGhlIGFtb3VudCBpdHNlbGYgcmVwcmVzZW50c1xuICogdGhlIGJhZyBvZiB0aGVzZSBpdGVtcywgYXMgb3Bwb3NlZCB0byBhbnkgb2YgdGhlIG90aGVyIGl0ZW1zXG4gKiBmcm9tIHRoZSBzYW1lIGFzc2V0IGNsYXNzLlxuICpcbiAqIElmIGEgZ2l2ZW4gdmFsdWUgY2xhc3MgcmVwcmVzZW50cyBjb25jZXJ0IHRpY2tldHMsIGl0IHNlZW1zIGJpemFycmVcbiAqIHRoYXQgd2UgY2FuIGZvcm0gYW1vdW50cyBvZiBhbnkga2V5LiBUaGUgaGFyZCBjb25zdHJhaW50IGlzIHRoYXRcbiAqIHRoZSBjb2RlIHRoYXQgaG9sZHMgdGhlIG1pbnQgZm9yIHRoYXQgYXNzZXQgY2xhc3MtLS10aGUgb25lIGFzc29jaWF0ZWRcbiAqIHdpdGggdGhhdCBicmFuZCwgb25seSBtaW50cyB0aGUgaXRlbXMgcmVwcmVzZW50aW5nIHRoZSByZWFsIHVuaXRzXG4gKiBvZiB0aGF0IGFzc2V0IGNsYXNzIGFzIGRlZmluZWQgYnkgaXQuIEFueW9uZSBlbHNlIGNhbiBwdXQgdG9nZXRoZXJcbiAqIGFuIGFtb3VudCBleHByZXNzaW5nLCBmb3IgZXhhbXBsZSwgdGhhdCB0aGV5IFwid2FudFwiIHNvbWUgaXRlbXMgdGhhdFxuICogd2lsbCBuZXZlciBiZSBtaW50ZWQuIFRoYXQgd2FudCB3aWxsIG5ldmVyIGJlIHNhdGlzZmllZC5cbiAqIFwiWW91IGNhbid0IGFsd2F5cyBnZXQuLi5cIlxuICovXG5jb25zdCBDb3B5QmFnVmFsdWVTaGFwZT1NLmJhZygpO1xuXG5jb25zdCBBbW91bnRWYWx1ZVNoYXBlPU0ub3IoXG5OYXRWYWx1ZVNoYXBlLFxuQ29weVNldFZhbHVlU2hhcGUsXG5TZXRWYWx1ZVNoYXBlLFxuQ29weUJhZ1ZhbHVlU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBBbW91bnRTaGFwZT1oYXJkZW4oe1xuYnJhbmQ6QnJhbmRTaGFwZSxcbnZhbHVlOkFtb3VudFZhbHVlU2hhcGV9KTskaOKAjV9vbmNlLkFtb3VudFNoYXBlKEFtb3VudFNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgUmF0aW9TaGFwZT1oYXJkZW4oe1xubnVtZXJhdG9yOkFtb3VudFNoYXBlLFxuZGVub21pbmF0b3I6QW1vdW50U2hhcGV9KTtcblxuXG4vKipcbiAqIFJldHVybnMgdHJ1ZSBpZiB2YWx1ZSBpcyBhIE5hdCBiaWdpbnQuXG4gKlxuICogQHBhcmFtIHtBbW91bnRWYWx1ZX0gdmFsdWVcbiAqIEByZXR1cm5zIHt2YWx1ZSBpcyBYaW1wb3J0KCcuL3R5cGVzLmpzJykuTmF0VmFsdWV9XG4gKi8kaOKAjV9vbmNlLlJhdGlvU2hhcGUoUmF0aW9TaGFwZSk7XG5jb25zdCAgICAgICAgaXNOYXRWYWx1ZT0odmFsdWUpPT5tYXRjaGVzKHZhbHVlLE5hdFZhbHVlU2hhcGUpOyRo4oCNX29uY2UuaXNOYXRWYWx1ZShpc05hdFZhbHVlKTtcbmhhcmRlbihpc05hdFZhbHVlKTtcblxuLyoqXG4gKiBSZXR1cm5zIHRydWUgaWYgdmFsdWUgaXMgYSBDb3B5U2V0XG4gKlxuICogQHBhcmFtIHtBbW91bnRWYWx1ZX0gdmFsdWVcbiAqIEByZXR1cm5zIHt2YWx1ZSBpcyBDb3B5U2V0fVxuICovXG5jb25zdCAgICAgICAgaXNDb3B5U2V0VmFsdWU9KHZhbHVlKT0+bWF0Y2hlcyh2YWx1ZSxDb3B5U2V0VmFsdWVTaGFwZSk7JGjigI1fb25jZS5pc0NvcHlTZXRWYWx1ZShpc0NvcHlTZXRWYWx1ZSk7XG5oYXJkZW4oaXNDb3B5U2V0VmFsdWUpO1xuXG4vKipcbiAqIFJldHVybnMgdHJ1ZSBpZiB2YWx1ZSBpcyBhIHBhc3MgYnkgY29weSBhcnJheSBzdHJ1Y3R1cmUuIERvZXMgbm90XG4gKiBjaGVjayBmb3IgZHVwbGljYXRlcy4gVG8gY2hlY2sgZm9yIGR1cGxpY2F0ZXMsIHVzZSBzZXRNYXRoSGVscGVycy5jb2VyY2UuXG4gKlxuICogQGRlcHJlY2F0ZWQgUGxlYXNlIGNoYW5nZSBmcm9tIHVzaW5nIGFycmF5LWJhc2VkIFNldFZhbHVlcyB0byBDb3B5U2V0LWJhc2VkXG4gKiBDb3B5U2V0VmFsdWVzLlxuICogQHBhcmFtIHtBbW91bnRWYWx1ZX0gdmFsdWVcbiAqIEByZXR1cm5zIHt2YWx1ZSBpcyBTZXRWYWx1ZX1cbiAqL1xuY29uc3QgICAgICAgIGlzU2V0VmFsdWU9KHZhbHVlKT0+bWF0Y2hlcyh2YWx1ZSxTZXRWYWx1ZVNoYXBlKTskaOKAjV9vbmNlLmlzU2V0VmFsdWUoaXNTZXRWYWx1ZSk7XG5oYXJkZW4oaXNTZXRWYWx1ZSk7XG5cbi8qKlxuICogUmV0dXJucyB0cnVlIGlmIHZhbHVlIGlzIGEgQ29weUJhZ1xuICpcbiAqIEBwYXJhbSB7QW1vdW50VmFsdWV9IHZhbHVlXG4gKiBAcmV0dXJucyB7dmFsdWUgaXMgQ29weUJhZ31cbiAqL1xuY29uc3QgICAgICAgIGlzQ29weUJhZ1ZhbHVlPSh2YWx1ZSk9Pm1hdGNoZXModmFsdWUsQ29weUJhZ1ZhbHVlU2hhcGUpOyRo4oCNX29uY2UuaXNDb3B5QmFnVmFsdWUoaXNDb3B5QmFnVmFsdWUpO1xuaGFyZGVuKGlzQ29weUJhZ1ZhbHVlKTtcblxuLyogT25lIEdPT0dPTHRoIHNob3VsZCBiZSBlbm91Z2ggZGVjaW1hbCBwbGFjZXMgZm9yIGFueWJvZHkuKi9cbmNvbnN0ICAgICAgICBNQVhfQUJTT0xVVEVfREVDSU1BTF9QTEFDRVM9MTAwOyRo4oCNX29uY2UuTUFYX0FCU09MVVRFX0RFQ0lNQUxfUExBQ0VTKE1BWF9BQlNPTFVURV9ERUNJTUFMX1BMQUNFUyk7XG5cbmNvbnN0ICAgICAgICBBc3NldEtpbmRTaGFwZT1NLm9yKCduYXQnLCdzZXQnLCdjb3B5U2V0JywnY29weUJhZycpOyRo4oCNX29uY2UuQXNzZXRLaW5kU2hhcGUoQXNzZXRLaW5kU2hhcGUpO1xuXG5jb25zdCAgICAgICAgRGlzcGxheUluZm9TaGFwZT1NLnNwbGl0UmVjb3JkKFxue30sXG57XG5kZWNpbWFsUGxhY2VzOk0uYW5kKFxuTS5ndGUoLU1BWF9BQlNPTFVURV9ERUNJTUFMX1BMQUNFUyksXG5NLmx0ZShNQVhfQUJTT0xVVEVfREVDSU1BTF9QTEFDRVMpKSxcblxuYXNzZXRLaW5kOkFzc2V0S2luZFNoYXBlfSxcblxue1xuLyogSW5jbHVkaW5nIHRoaXMgZW1wdHkgYHJlc3RgIGVuc3VyZXMgdGhhdCB0aGVyZSBhcmUgbm8gb3RoZXIqL1xuLyogcHJvcGVydGllcyBiZXlvbmQgdGhvc2UgaW4gdGhlIGBiYXNlYCByZWNvcmQuKi99KTskaOKAjV9vbmNlLkRpc3BsYXlJbmZvU2hhcGUoRGlzcGxheUluZm9TaGFwZSk7XG5cblxuXG5jb25zdCAgICAgICAgSXNzdWVyS2l0U2hhcGU9aGFyZGVuKHtcbmJyYW5kOkJyYW5kU2hhcGUsXG5taW50Ok1pbnRTaGFwZSxcbm1pbnRSZWNvdmVyeVB1cnNlOlB1cnNlU2hhcGUsXG5pc3N1ZXI6SXNzdWVyU2hhcGUsXG5kaXNwbGF5SW5mbzpEaXNwbGF5SW5mb1NoYXBlfSk7XG5cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIEludGVyZmFjZXMgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qLyRo4oCNX29uY2UuSXNzdWVyS2l0U2hhcGUoSXNzdWVyS2l0U2hhcGUpO1xuXG5jb25zdCAgICAgICAgQnJhbmRJPU0uaW50ZXJmYWNlKCdCcmFuZCcse1xuaXNNeUlzc3VlcjpNLmNhbGxXaGVuKE0uYXdhaXQoSXNzdWVyU2hhcGUpKS5yZXR1cm5zKE0uYm9vbGVhbigpKSxcbmdldEFsbGVnZWROYW1lOk0uY2FsbCgpLnJldHVybnMoTS5zdHJpbmcoKSksXG5nZXREaXNwbGF5SW5mbzpNLmNhbGwoKS5yZXR1cm5zKERpc3BsYXlJbmZvU2hhcGUpLFxuZ2V0QW1vdW50U2hhcGU6TS5jYWxsKCkucmV0dXJucyhNLnBhdHRlcm4oKSl9KTtcblxuXG4vKipcbiAqIEBwYXJhbSB7UGF0dGVybn0gW2JyYW5kU2hhcGVdXG4gKiBAcGFyYW0ge1BhdHRlcm59IFthc3NldEtpbmRTaGFwZV1cbiAqIEBwYXJhbSB7UGF0dGVybn0gW2Ftb3VudFNoYXBlXVxuICovJGjigI1fb25jZS5CcmFuZEkoQnJhbmRJKTtcbmNvbnN0ICAgICAgICBtYWtlSXNzdWVySW50ZXJmYWNlcz0oXG5icmFuZFNoYXBlPUJyYW5kU2hhcGUsXG5hc3NldEtpbmRTaGFwZT1Bc3NldEtpbmRTaGFwZSxcbmFtb3VudFNoYXBlPUFtb3VudFNoYXBlKT0+XG57XG5jb25zdCBJc3N1ZXJJPU0uaW50ZXJmYWNlKCdJc3N1ZXInLHtcbmdldEJyYW5kOk0uY2FsbCgpLnJldHVybnMoYnJhbmRTaGFwZSksXG5nZXRBbGxlZ2VkTmFtZTpNLmNhbGwoKS5yZXR1cm5zKE0uc3RyaW5nKCkpLFxuZ2V0QXNzZXRLaW5kOk0uY2FsbCgpLnJldHVybnMoYXNzZXRLaW5kU2hhcGUpLFxuZ2V0RGlzcGxheUluZm86TS5jYWxsKCkucmV0dXJucyhEaXNwbGF5SW5mb1NoYXBlKSxcbm1ha2VFbXB0eVB1cnNlOk0uY2FsbCgpLnJldHVybnMoUHVyc2VTaGFwZSksXG5cbmlzTGl2ZTpNLmNhbGxXaGVuKE0uYXdhaXQoUGF5bWVudFNoYXBlKSkucmV0dXJucyhNLmJvb2xlYW4oKSksXG5nZXRBbW91bnRPZjpNLmNhbGxXaGVuKE0uYXdhaXQoUGF5bWVudFNoYXBlKSkucmV0dXJucyhhbW91bnRTaGFwZSksXG5idXJuOk0uY2FsbFdoZW4oTS5hd2FpdChQYXltZW50U2hhcGUpKS5cbm9wdGlvbmFsKE0ucGF0dGVybigpKS5cbnJldHVybnMoYW1vdW50U2hhcGUpfSk7XG5cblxuY29uc3QgTWludEk9TS5pbnRlcmZhY2UoJ01pbnQnLHtcbmdldElzc3VlcjpNLmNhbGwoKS5yZXR1cm5zKElzc3VlclNoYXBlKSxcbm1pbnRQYXltZW50Ok0uY2FsbChhbW91bnRTaGFwZSkucmV0dXJucyhQYXltZW50U2hhcGUpfSk7XG5cblxuY29uc3QgUGF5bWVudEk9TS5pbnRlcmZhY2UoJ1BheW1lbnQnLHtcbmdldEFsbGVnZWRCcmFuZDpNLmNhbGwoKS5yZXR1cm5zKGJyYW5kU2hhcGUpfSk7XG5cblxuY29uc3QgUHVyc2VJPU0uaW50ZXJmYWNlKCdQdXJzZScse1xuZ2V0QWxsZWdlZEJyYW5kOk0uY2FsbCgpLnJldHVybnMoYnJhbmRTaGFwZSksXG5nZXRDdXJyZW50QW1vdW50Ok0uY2FsbCgpLnJldHVybnMoYW1vdW50U2hhcGUpLFxuZ2V0Q3VycmVudEFtb3VudE5vdGlmaWVyOk0uY2FsbCgpLnJldHVybnMoTm90aWZpZXJTaGFwZSksXG4vKiBQdXJzZUkgZG9lcyAqbm90KiBkZWxheSBgZGVwb3NpdGAgdW50aWwgYHNyY1BheW1lbnRgIGlzIGZ1bGZ1bGxlZC4qL1xuLyogUmF0aGVyLCB0aGUgc2VtYW50aWNzIG9mIGBkZXBvc2l0YCByZXF1aXJlIGl0IHRvIHByb3ZpZGUgaXRzKi9cbi8qIGNhbGxlcnMgd2l0aCBhIHN0cm9uZyBndWFyYW50ZWUgdGhhdCBgZGVwb3NpdGAgbWVzc2FnZXMgYXJlKi9cbi8qIHByb2Nlc3NlZCB3aXRob3V0IGZ1cnRoZXIgZGVsYXkgaW4gdGhlIG9yZGVyIHRoZXkgYXJyaXZlLiovXG4vKiBQdXJzZUkgdGhlcmVmb3JlIHJlcXVpcmVzIHRoYXQgdGhlIGBzcmNQYXltZW50YCBhcmd1bWVudCBhbHJlYWR5Ki9cbi8qIGJlIGEgcmVtb3RhYmxlLCBub3QgYSBwcm9taXNlLiovXG4vKiBQdXJzZUkgb25seSBjYWxscyB0aGlzIHJhdyBtZXRob2QgYWZ0ZXIgdmFsaWRhdGluZyB0aGF0Ki9cbi8qIGBzcmNQYXltZW50YCBpcyBhIHJlbW90YWJsZSwgbGVhdmluZyBpdCovXG4vKiB0byB0aGlzIHJhdyBtZXRob2QgdG8gdmFsaWRhdGUgdGhhdCB0aGlzIHJlbW90YWJsZSBpcyBhY3R1YWxseSovXG4vKiBhIGxpdmUgcGF5bWVudCBvZiB0aGUgY29ycmVjdCBicmFuZCB3aXRoIHN1ZmZpY2llbnQgZnVuZHMuKi9cbmRlcG9zaXQ6TS5jYWxsKFBheW1lbnRTaGFwZSkub3B0aW9uYWwoTS5wYXR0ZXJuKCkpLnJldHVybnMoYW1vdW50U2hhcGUpLFxuZ2V0RGVwb3NpdEZhY2V0Ok0uY2FsbCgpLnJldHVybnMoRGVwb3NpdEZhY2V0U2hhcGUpLFxud2l0aGRyYXc6TS5jYWxsKGFtb3VudFNoYXBlKS5yZXR1cm5zKFBheW1lbnRTaGFwZSksXG5nZXRSZWNvdmVyeVNldDpNLmNhbGwoKS5yZXR1cm5zKE0uc2V0T2YoUGF5bWVudFNoYXBlKSksXG5yZWNvdmVyQWxsOk0uY2FsbCgpLnJldHVybnMoYW1vdW50U2hhcGUpfSk7XG5cblxuY29uc3QgRGVwb3NpdEZhY2V0ST1NLmludGVyZmFjZSgnRGVwb3NpdEZhY2V0Jyx7XG5yZWNlaXZlOlB1cnNlSS5tZXRob2RHdWFyZHMuZGVwb3NpdH0pO1xuXG5cbmNvbnN0IFB1cnNlSUtpdD1oYXJkZW4oe1xucHVyc2U6UHVyc2VJLFxuZGVwb3NpdEZhY2V0OkRlcG9zaXRGYWNldEl9KTtcblxuXG5yZXR1cm4gaGFyZGVuKHtcbklzc3VlckksXG5NaW50SSxcblBheW1lbnRJLFxuUHVyc2VJS2l0fSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZUlzc3VlckludGVyZmFjZXMobWFrZUlzc3VlckludGVyZmFjZXMpO1xuaGFyZGVuKG1ha2VJc3N1ZXJJbnRlcmZhY2VzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJCcmFuZFNoYXBlIjpbIkJyYW5kU2hhcGUiXSwiSXNzdWVyU2hhcGUiOlsiSXNzdWVyU2hhcGUiXSwiUGF5bWVudFNoYXBlIjpbIlBheW1lbnRTaGFwZSJdLCJQdXJzZVNoYXBlIjpbIlB1cnNlU2hhcGUiXSwiRGVwb3NpdEZhY2V0U2hhcGUiOlsiRGVwb3NpdEZhY2V0U2hhcGUiXSwiTm90aWZpZXJTaGFwZSI6WyJOb3RpZmllclNoYXBlIl0sIk1pbnRTaGFwZSI6WyJNaW50U2hhcGUiXSwiQW1vdW50U2hhcGUiOlsiQW1vdW50U2hhcGUiXSwiUmF0aW9TaGFwZSI6WyJSYXRpb1NoYXBlIl0sImlzTmF0VmFsdWUiOlsiaXNOYXRWYWx1ZSJdLCJpc0NvcHlTZXRWYWx1ZSI6WyJpc0NvcHlTZXRWYWx1ZSJdLCJpc1NldFZhbHVlIjpbImlzU2V0VmFsdWUiXSwiaXNDb3B5QmFnVmFsdWUiOlsiaXNDb3B5QmFnVmFsdWUiXSwiTUFYX0FCU09MVVRFX0RFQ0lNQUxfUExBQ0VTIjpbIk1BWF9BQlNPTFVURV9ERUNJTUFMX1BMQUNFUyJdLCJBc3NldEtpbmRTaGFwZSI6WyJBc3NldEtpbmRTaGFwZSJdLCJEaXNwbGF5SW5mb1NoYXBlIjpbIkRpc3BsYXlJbmZvU2hhcGUiXSwiSXNzdWVyS2l0U2hhcGUiOlsiSXNzdWVyS2l0U2hhcGUiXSwiQnJhbmRJIjpbIkJyYW5kSSJdLCJtYWtlSXNzdWVySW50ZXJmYWNlcyI6WyJtYWtlSXNzdWVySW50ZXJmYWNlcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAsz6lRcD8AAHA/AAAvAAAAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL3R5cGVzLWFtYmllbnQuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAamVzc2llLWNoZWNrKi9cblxuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gW0s9QXNzZXRLaW5kXVxuICogQHR5cGVkZWYge29iamVjdH0gQW1vdW50XG4gKiBBbW91bnRzIGFyZSBkZXNjcmlwdGlvbnMgb2YgZGlnaXRhbCBhc3NldHMsIGFuc3dlcmluZyB0aGUgcXVlc3Rpb25zXG4gKiBcImhvdyBtdWNoXCIgYW5kIFwib2Ygd2hhdCBraW5kXCIuIEFtb3VudHMgYXJlIHZhbHVlcyBsYWJlbGVkIHdpdGggYSBicmFuZC5cbiAqIEFtb3VudE1hdGggZXhlY3V0ZXMgdGhlIGxvZ2ljIG9mIGhvdyBhbW91bnRzIGFyZSBjaGFuZ2VkIHdoZW4gZGlnaXRhbFxuICogYXNzZXRzIGFyZSBtZXJnZWQsIHNlcGFyYXRlZCwgb3Igb3RoZXJ3aXNlIG1hbmlwdWxhdGVkLiBGb3JcbiAqIGV4YW1wbGUsIGEgZGVwb3NpdCBvZiAyIGJ1Y2tzIGludG8gYSBwdXJzZSB0aGF0IGFscmVhZHkgaGFzIDMgYnVja3NcbiAqIGdpdmVzIGEgbmV3IHB1cnNlIGJhbGFuY2Ugb2YgNSBidWNrcy4gQW4gZW1wdHkgcHVyc2UgaGFzIDAgYnVja3MuIEFtb3VudE1hdGhcbiAqIHJlbGllcyBoZWF2aWx5IG9uIHBvbHltb3JwaGljIE1hdGhIZWxwZXJzLCB3aGljaCBtYW5pcHVsYXRlIHRoZSB1bmJyYW5kZWRcbiAqIHBvcnRpb24uXG4gKlxuICogQHByb3BlcnR5IHtCcmFuZDxLPn0gYnJhbmRcbiAqIEBwcm9wZXJ0eSB7QXNzZXRWYWx1ZUZvcktpbmQ8Sz59IHZhbHVlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7TmF0VmFsdWUgfCBTZXRWYWx1ZSB8IENvcHlTZXQgfCBDb3B5QmFnfSBBbW91bnRWYWx1ZVxuICogQW4gYEFtb3VudFZhbHVlYCBkZXNjcmliZXMgYSBzZXQgb3IgcXVhbnRpdHkgb2YgYXNzZXRzIHRoYXQgY2FuIGJlIG93bmVkIG9yXG4gKiBzaGFyZWQuXG4gKlxuICogQSBmdW5naWJsZSBgQW1vdW50VmFsdWVgIHVzZXMgYSBub24tbmVnYXRpdmUgYmlnaW50IHRvIHJlcHJlc2VudCBhIHF1YW50aXR5XG4gKiBvZiB0aGF0IG1hbnkgYXNzZXRzLlxuICpcbiAqIEEgbm9uLWZ1bmdpYmxlIGBBbW91bnRWYWx1ZWAgdXNlcyBhbiBhcnJheSBvciBDb3B5U2V0IG9mIGBLZXlgcyB0byByZXByZXNlbnRcbiAqIGEgc2V0IG9mIHdoYXRldmVyIGFzc2V0IGVhY2gga2V5IHJlcHJlc2VudHMuIEEgYEtleWAgaXMgYSBwYXNzYWJsZSB2YWx1ZVxuICogdGhhdCBjYW4gYmUgdXNlZCBhcyBhbiBlbGVtZW50IGluIGEgc2V0IChTZXRTdG9yZSBvciBDb3B5U2V0KSBvciBhcyB0aGVcbiAqIGtleSBpbiBhIG1hcCAoTWFwU3RvcmUgb3IgQ29weU1hcCkuXG4gKlxuICogYFNldFZhbHVlYCBpcyBmb3IgdGhlIGRlcHJlY2F0ZWQgc2V0IHJlcHJlc2VudGF0aW9uLCB1c2luZyBhbiBhcnJheSBkaXJlY3RseVxuICogdG8gcmVwcmVzZW50IHRoZSBhcnJheSBvZiBpdHMgZWxlbWVudHMuIGBDb3B5U2V0YCBpcyB0aGUgcHJvcGVyXG4gKiByZXByZXNlbnRhdGlvbiB1c2luZyBhIENvcHlTZXQuXG4gKlxuICogQSBzZW1pLWZ1bmdpYmxlIGBDb3B5QmFnYCBpcyByZXByZXNlbnRlZCBhcyBhXG4gKiBgQ29weUJhZ2Agb2YgYEtleWAgb2JqZWN0cy4gXCJCYWdcIiBpcyBzeW5vbnltb3VzIHdpdGggTXVsdGlTZXQsIHdoZXJlIGFuXG4gKiBlbGVtZW50IG9mIGEgYmFnIGNhbiBiZSBwcmVzZW50IG9uY2Ugb3IgbW9yZSB0aW1lcywgaS5lLiwgc29tZSBwb3NpdGl2ZVxuICogYmlnaW50IG51bWJlciBvZiB0aW1lcywgcmVwcmVzZW50aW5nIHRoYXQgcXVhbnRpdHkgb2YgdGhlIGFzc2V0IHJlcHJlc2VudGVkXG4gKiBieSB0aGF0IGtleS5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsnbmF0JyB8ICdzZXQnIHwgJ2NvcHlTZXQnIHwgJ2NvcHlCYWcnIH0gQXNzZXRLaW5kXG4gKlxuICogU2VlIGRvYy1jb21tZW50IGZvciBgQW1vdW50VmFsdWVgLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEB0eXBlZGVmIHtLIGV4dGVuZHMgJ25hdCcgPyBOYXRWYWx1ZSA6XG4gKiBLIGV4dGVuZHMgJ3NldCcgPyBTZXRWYWx1ZSA6XG4gKiBLIGV4dGVuZHMgJ2NvcHlTZXQnID8gQ29weVNldDpcbiAqIEsgZXh0ZW5kcyAnY29weUJhZycgPyBDb3B5QmFnIDpcbiAqIG5ldmVyXG4gKiB9IEFzc2V0VmFsdWVGb3JLaW5kXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Ftb3VudFZhbHVlfSBWXG4gKiBAdHlwZWRlZiB7ViBleHRlbmRzIE5hdFZhbHVlID8gJ25hdCcgOlxuICogIFYgZXh0ZW5kcyBTZXRWYWx1ZSA/ICdzZXQnIDpcbiAqICBWIGV4dGVuZHMgQ29weVNldCA/ICdjb3B5U2V0JyA6XG4gKiAgViBleHRlbmRzIENvcHlCYWcgPyAnY29weUJhZycgOlxuICogIG5ldmVyfSBBc3NldEtpbmRGb3JWYWx1ZVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IFtLPUFzc2V0S2luZF1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IERpc3BsYXlJbmZvXG4gKiBAcHJvcGVydHkge251bWJlcn0gW2RlY2ltYWxQbGFjZXNdIFRlbGxzIHRoZSBkaXNwbGF5IHNvZnR3YXJlIGhvd1xuICogICBtYW55IGRlY2ltYWwgcGxhY2VzIHRvIG1vdmUgdGhlIGRlY2ltYWwgb3ZlciB0byB0aGUgbGVmdCwgb3IgaW5cbiAqICAgb3RoZXIgd29yZHMsIHdoaWNoIHBvc2l0aW9uIGNvcnJlc3BvbmRzIHRvIHdob2xlIG51bWJlcnMuIFdlXG4gKiAgIHJlcXVpcmUgZnVuZ2libGUgZGlnaXRhbCBhc3NldHMgdG8gYmUgcmVwcmVzZW50ZWQgaW4gaW50ZWdlcnMsIGluXG4gKiAgIHRoZSBzbWFsbGVzdCB1bml0IChpLmUuIFVTRCBtaWdodCBiZSByZXByZXNlbnRlZCBpbiBtaWxsLCBhXG4gKiAgIHRob3VzYW5kdGggb2YgYSBkb2xsYXIuIEluIHRoYXQgY2FzZSwgYGRlY2ltYWxQbGFjZXNgIHdvdWxkIGJlXG4gKiAgIDMuKSBUaGlzIHByb3BlcnR5IGlzIG9wdGlvbmFsLCBhbmQgZm9yIG5vbi1mdW5naWJsZSBkaWdpdGFsXG4gKiAgIGFzc2V0cywgc2hvdWxkIG5vdCBiZSBzcGVjaWZpZWQuIFRoZSBkZWNpbWFsUGxhY2VzIHByb3BlcnR5XG4gKiAgIHNob3VsZCBiZSB1c2VkIGZvciAqZGlzcGxheSBwdXJwb3NlcyBvbmx5Ki4gQW55IG90aGVyIHVzZSBpcyBhblxuICogICBhbnRpLXBhdHRlcm4uXG4gKiBAcHJvcGVydHkge0t9IGFzc2V0S2luZCAtIHRoZSBraW5kIG9mIGFzc2V0LCBlaXRoZXJcbiAqICAgQXNzZXRLaW5kLk5BVCAoZnVuZ2libGUpIG9yXG4gKiAgIEFzc2V0S2luZC5TRVQgb3IgQXNzZXRLaW5kLkNPUFlfU0VUIChub24tZnVuZ2libGUpXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gW0s9QXNzZXRLaW5kXVxuICogQHR5cGVkZWYge29iamVjdH0gQnJhbmRcbiAqIFRoZSBicmFuZCBpZGVudGlmaWVzIHRoZSBraW5kIG9mIGlzc3VlciwgYW5kIGhhcyBhIGZ1bmN0aW9uIHRvIGdldCB0aGVcbiAqIGFsbGVnZWQgbmFtZSBmb3IgdGhlIGtpbmQgb2YgYXNzZXQgZGVzY3JpYmVkLiBUaGUgYWxsZWdlZCBuYW1lIChzdWNoXG4gKiBhcyAnQlRDJyBvciAnbW9vbGEnKSBpcyBwcm92aWRlZCBieSB0aGUgbWFrZXIgb2YgdGhlIGlzc3VlciBhbmQgc2hvdWxkXG4gKiBub3QgYmUgdHJ1c3RlZCBhcyBhY2N1cmF0ZS5cbiAqXG4gKiBFdmVyeSBhbW91bnQgY3JlYXRlZCBieSBhIHBhcnRpY3VsYXIgQW1vdW50TWF0aCB3aWxsIHNoYXJlIHRoZSBzYW1lIGJyYW5kLFxuICogYnV0IHJlY2lwaWVudHMgY2Fubm90IHJlbHkgb24gdGhlIGJyYW5kIHRvIHZlcmlmeSB0aGF0IGEgcHVycG9ydGVkIGFtb3VudFxuICogcmVwcmVzZW50cyB0aGUgaXNzdWVyIHRoZXkgaW50ZW5kZWQsIHNpbmNlIHRoZSBzYW1lIGJyYW5kIGNhbiBiZSByZXVzZWQgYnlcbiAqIGEgbWlzYmVoYXZpbmcgaXNzdWVyLlxuICpcbiAqIEBwcm9wZXJ0eSB7KGFsbGVnZWRJc3N1ZXI6IEVSZWY8SXNzdWVyPikgPT4gUHJvbWlzZTxib29sZWFuPn0gaXNNeUlzc3VlclxuICogU2hvdWxkIGJlIHVzZWQgd2l0aCBgaXNzdWVyLmdldEJyYW5kYCB0byBlbnN1cmUgYW4gaXNzdWVyIGFuZCBicmFuZCBtYXRjaC5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gc3RyaW5nfSBnZXRBbGxlZ2VkTmFtZVxuICogQHByb3BlcnR5IHsoKSA9PiBEaXNwbGF5SW5mbzxLPn0gZ2V0RGlzcGxheUluZm9cbiAqIEdpdmUgaW5mb3JtYXRpb24gdG8gVUkgb24gaG93IHRvIGRpc3BsYXkgdGhlIGFtb3VudC5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUGF0dGVybn0gZ2V0QW1vdW50U2hhcGVcbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gSXNzdWVyIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQGNhbGxiYWNrIElzc3VlcklzTGl2ZVxuICpcbiAqIFJldHVybiB0cnVlIGlmIHRoZSBwYXltZW50IGNvbnRpbnVlcyB0byBleGlzdC5cbiAqXG4gKiBJZiB0aGUgcGF5bWVudCBpcyBhIHByb21pc2UsIHRoZSBvcGVyYXRpb24gd2lsbCBwcm9jZWVkIHVwb25cbiAqIHJlc29sdXRpb24uXG4gKlxuICogQHBhcmFtIHtFUmVmPFBheW1lbnQ+fSBwYXltZW50XG4gKiBAcmV0dXJucyB7UHJvbWlzZTxib29sZWFuPn1cbiAqL1xuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gS1xuICogQGNhbGxiYWNrIElzc3VlckdldEFtb3VudE9mXG4gKlxuICogR2V0IHRoZSBhbW91bnQgb2YgZGlnaXRhbCBhc3NldHMgaW4gdGhlIHBheW1lbnQuIEJlY2F1c2UgdGhlXG4gKiBwYXltZW50IGlzIG5vdCB0cnVzdGVkLCB3ZSBjYW5ub3QgY2FsbCBhIG1ldGhvZCBvbiBpdCBkaXJlY3RseSwgYW5kXG4gKiBtdXN0IHVzZSB0aGUgaXNzdWVyIGluc3RlYWQuXG4gKlxuICogSWYgdGhlIHBheW1lbnQgaXMgYSBwcm9taXNlLCB0aGUgb3BlcmF0aW9uIHdpbGwgcHJvY2VlZCB1cG9uXG4gKiByZXNvbHV0aW9uLlxuICpcbiAqIEBwYXJhbSB7RVJlZjxQYXltZW50Pn0gcGF5bWVudFxuICogQHJldHVybnMge1Byb21pc2U8QW1vdW50PEs+Pn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBJc3N1ZXJCdXJuXG4gKlxuICogQnVybiBhbGwgb2YgdGhlIGRpZ2l0YWwgYXNzZXRzIGluIHRoZVxuICogcGF5bWVudC4gYG9wdEFtb3VudGAgaXMgb3B0aW9uYWwuIElmIGBvcHRBbW91bnRgIGlzIHByZXNlbnQsIHRoZVxuICogY29kZSB3aWxsIGluc2lzdCB0aGF0IHRoZSBhbW91bnQgb2YgdGhlIGRpZ2l0YWwgYXNzZXRzIGluIHRoZVxuICogcGF5bWVudCBpcyBlcXVhbCB0byBgb3B0QW1vdW50YCwgdG8gcHJldmVudCBzZW5kaW5nIHRoZSB3cm9uZ1xuICogcGF5bWVudCBhbmQgb3RoZXIgY29uZnVzaW9uLlxuICpcbiAqIElmIHRoZSBwYXltZW50IGlzIGEgcHJvbWlzZSwgdGhlIG9wZXJhdGlvbiB3aWxsIHByb2NlZWQgdXBvblxuICogcmVzb2x1dGlvbi5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8UGF5bWVudD59IHBheW1lbnRcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge1Byb21pc2U8QW1vdW50Pn1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAY2FsbGJhY2sgSXNzdWVyQ2xhaW1cbiAqXG4gKiBUcmFuc2ZlciBhbGwgZGlnaXRhbCBhc3NldHMgZnJvbSB0aGUgcGF5bWVudCB0byBhIG5ldyBwYXltZW50IGFuZFxuICogZGVsZXRlIHRoZSBvcmlnaW5hbC4gYG9wdEFtb3VudGAgaXMgb3B0aW9uYWwuIElmIGBvcHRBbW91bnRgIGlzXG4gKiBwcmVzZW50LCB0aGUgY29kZSB3aWxsIGluc2lzdCB0aGF0IHRoZSBhbW91bnQgb2YgZGlnaXRhbCBhc3NldHMgaW5cbiAqIHRoZSBwYXltZW50IGlzIGVxdWFsIHRvIGBvcHRBbW91bnRgLCB0byBwcmV2ZW50IHNlbmRpbmcgdGhlIHdyb25nXG4gKiBwYXltZW50IGFuZCBvdGhlciBjb25mdXNpb24uXG4gKlxuICogSWYgdGhlIHBheW1lbnQgaXMgYSBwcm9taXNlLCB0aGUgb3BlcmF0aW9uIHdpbGwgcHJvY2VlZCB1cG9uXG4gKiByZXNvbHV0aW9uLlxuICpcbiAqIEBwYXJhbSB7RVJlZjxQYXltZW50PEs+Pn0gcGF5bWVudFxuICogQHBhcmFtIHtQYXR0ZXJufSBbb3B0QW1vdW50U2hhcGVdXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxQYXltZW50PEs+Pn1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAY2FsbGJhY2sgSXNzdWVyQ29tYmluZVxuICpcbiAqIENvbWJpbmUgbXVsdGlwbGUgcGF5bWVudHMgaW50byBvbmUgcGF5bWVudC5cbiAqXG4gKiBJZiBhbnkgb2YgdGhlIHBheW1lbnRzIGlzIGEgcHJvbWlzZSwgdGhlIG9wZXJhdGlvbiB3aWxsIHByb2NlZWRcbiAqIHVwb24gcmVzb2x1dGlvbi5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8UGF5bWVudDxLPj5bXX0gcGF5bWVudHNBcnJheVxuICogQHBhcmFtIHtBbW91bnQ8Sz59IFtvcHRUb3RhbEFtb3VudF1cbiAqIEByZXR1cm5zIHtQcm9taXNlPFBheW1lbnQ8Sz4+fVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IEtcbiAqIEBjYWxsYmFjayBJc3N1ZXJTcGxpdFxuICpcbiAqIFNwbGl0IGEgc2luZ2xlIHBheW1lbnQgaW50byB0d28gcGF5bWVudHMsXG4gKiBBIGFuZCBCLCBhY2NvcmRpbmcgdG8gdGhlIHBheW1lbnRBbW91bnRBIHBhc3NlZCBpbi5cbiAqXG4gKiBJZiB0aGUgcGF5bWVudCBpcyBhIHByb21pc2UsIHRoZSBvcGVyYXRpb24gd2lsbCBwcm9jZWVkIHVwb25cbiAqIHJlc29sdXRpb24uXG4gKlxuICogQHBhcmFtIHtFUmVmPFBheW1lbnQ8Sz4+fSBwYXltZW50XG4gKiBAcGFyYW0ge0Ftb3VudDxLPn0gcGF5bWVudEFtb3VudEFcbiAqIEByZXR1cm5zIHtQcm9taXNlPFBheW1lbnQ8Sz5bXT59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgSXNzdWVyU3BsaXRNYW55XG4gKlxuICogU3BsaXQgYSBzaW5nbGUgcGF5bWVudCBpbnRvIG1hbnkgcGF5bWVudHMsIGFjY29yZGluZyB0byB0aGUgYW1vdW50c1xuICogcGFzc2VkIGluLlxuICpcbiAqIElmIHRoZSBwYXltZW50IGlzIGEgcHJvbWlzZSwgdGhlIG9wZXJhdGlvbiB3aWxsIHByb2NlZWQgdXBvblxuICogcmVzb2x1dGlvbi5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8UGF5bWVudD59IHBheW1lbnRcbiAqIEBwYXJhbSB7QW1vdW50W119IGFtb3VudHNcbiAqIEByZXR1cm5zIHtQcm9taXNlPFBheW1lbnRbXT59XG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gW0s9QXNzZXRLaW5kXVxuICogQHR5cGVkZWYge29iamVjdH0gSXNzdWVyXG4gKlxuICogVGhlIGlzc3VlciBjYW5ub3QgbWludCBhIG5ldyBhbW91bnQsIGJ1dCBpdCBjYW4gY3JlYXRlIGVtcHR5IHB1cnNlc1xuICogYW5kIHBheW1lbnRzLiBUaGUgaXNzdWVyIGNhbiBhbHNvIHRyYW5zZm9ybSBwYXltZW50cyAoc3BsaXR0aW5nXG4gKiBwYXltZW50cywgY29tYmluaW5nIHBheW1lbnRzLCBidXJuaW5nIHBheW1lbnRzLCBhbmQgY2xhaW1pbmdcbiAqIHBheW1lbnRzIGV4Y2x1c2l2ZWx5KS4gVGhlIGlzc3VlciBzaG91bGQgYmUgZ290dGVuIGZyb20gYSB0cnVzdGVkXG4gKiBzb3VyY2UgYW5kIHRoZW4gcmVsaWVkIHVwb24gYXMgdGhlIGRlY2lkZXIgb2Ygd2hldGhlciBhbiB1bnRydXN0ZWRcbiAqIHBheW1lbnQgaXMgdmFsaWQuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBCcmFuZDxLPn0gZ2V0QnJhbmQgR2V0IHRoZSBCcmFuZCBmb3IgdGhpcyBJc3N1ZXIuIFRoZVxuICogQnJhbmQgaW5kaWNhdGVzIHRoZSB0eXBlIG9mIGRpZ2l0YWwgYXNzZXQgYW5kIGlzIHNoYXJlZCBieSB0aGVcbiAqIG1pbnQsIHRoZSBpc3N1ZXIsIGFuZCBhbnkgcHVyc2VzIGFuZCBwYXltZW50cyBvZiB0aGlzIHBhcnRpY3VsYXJcbiAqIGtpbmQuIFRoZSBicmFuZCBpcyBub3QgY2xvc2VseSBoZWxkLCBzbyB0aGlzIGZ1bmN0aW9uIHNob3VsZCBub3QgYmVcbiAqIHRydXN0ZWQgdG8gaWRlbnRpZnkgYW4gaXNzdWVyIGFsb25lLiBGYWtlIGRpZ2l0YWwgYXNzZXRzIGFuZCBhbW91bnRcbiAqIGNhbiB1c2UgYW5vdGhlciBpc3N1ZXIncyBicmFuZC5cbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IHN0cmluZ30gZ2V0QWxsZWdlZE5hbWUgR2V0IHRoZSBhbGxlZ2VkTmFtZSBmb3JcbiAqIHRoaXMgbWludC9pc3N1ZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gQXNzZXRLaW5kfSBnZXRBc3NldEtpbmQgR2V0IHRoZSBraW5kIG9mXG4gKiBNYXRoSGVscGVycyB1c2VkIGJ5IHRoaXMgSXNzdWVyLlxuICogQHByb3BlcnR5IHsoKSA9PiBEaXNwbGF5SW5mbzxLPn0gZ2V0RGlzcGxheUluZm8gR2l2ZSBpbmZvcm1hdGlvbiB0byBVSVxuICogIG9uIGhvdyB0byBkaXNwbGF5IGFtb3VudHMgZm9yIHRoaXMgaXNzdWVyLlxuICogQHByb3BlcnR5IHsoKSA9PiBQdXJzZTxLPn0gbWFrZUVtcHR5UHVyc2UgTWFrZSBhbiBlbXB0eSBwdXJzZSBvZiB0aGlzXG4gKiBicmFuZC5cbiAqIEBwcm9wZXJ0eSB7SXNzdWVySXNMaXZlfSBpc0xpdmVcbiAqIEBwcm9wZXJ0eSB7SXNzdWVyR2V0QW1vdW50T2Y8Sz59IGdldEFtb3VudE9mXG4gKiBAcHJvcGVydHkge0lzc3VlckJ1cm59IGJ1cm5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXltZW50TGVkZ2VyXG4gKiBAcHJvcGVydHkge01pbnQ8Sz59IG1pbnRcbiAqIEBwcm9wZXJ0eSB7UHVyc2U8Sz59IG1pbnRSZWNvdmVyeVB1cnNlXG4gKiBAcHJvcGVydHkge0lzc3VlcjxLPn0gaXNzdWVyXG4gKiBAcHJvcGVydHkge0JyYW5kPEs+fSBicmFuZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IFtLPUFzc2V0S2luZF1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IElzc3VlcktpdFxuICogQHByb3BlcnR5IHtNaW50PEs+fSBtaW50XG4gKiBAcHJvcGVydHkge1B1cnNlPEs+fSBtaW50UmVjb3ZlcnlQdXJzZVxuICogQHByb3BlcnR5IHtJc3N1ZXI8Sz59IGlzc3VlclxuICogQHByb3BlcnR5IHtCcmFuZDxLPn0gYnJhbmRcbiAqIEBwcm9wZXJ0eSB7RGlzcGxheUluZm99IGRpc3BsYXlJbmZvXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBBZGRpdGlvbmFsRGlzcGxheUluZm9cbiAqXG4gKiBAcHJvcGVydHkge251bWJlcn0gW2RlY2ltYWxQbGFjZXNdIFRlbGxzIHRoZSBkaXNwbGF5IHNvZnR3YXJlIGhvd1xuICogICBtYW55IGRlY2ltYWwgcGxhY2VzIHRvIG1vdmUgdGhlIGRlY2ltYWwgb3ZlciB0byB0aGUgbGVmdCwgb3IgaW5cbiAqICAgb3RoZXIgd29yZHMsIHdoaWNoIHBvc2l0aW9uIGNvcnJlc3BvbmRzIHRvIHdob2xlIG51bWJlcnMuIFdlXG4gKiAgIHJlcXVpcmUgZnVuZ2libGUgZGlnaXRhbCBhc3NldHMgdG8gYmUgcmVwcmVzZW50ZWQgaW4gaW50ZWdlcnMsIGluXG4gKiAgIHRoZSBzbWFsbGVzdCB1bml0IChpLmUuIFVTRCBtaWdodCBiZSByZXByZXNlbnRlZCBpbiBtaWxsLCBhXG4gKiAgIHRob3VzYW5kdGggb2YgYSBkb2xsYXIuIEluIHRoYXQgY2FzZSwgYGRlY2ltYWxQbGFjZXNgIHdvdWxkIGJlXG4gKiAgIDMuKSBUaGlzIHByb3BlcnR5IGlzIG9wdGlvbmFsLCBhbmQgZm9yIG5vbi1mdW5naWJsZSBkaWdpdGFsXG4gKiAgIGFzc2V0cywgc2hvdWxkIG5vdCBiZSBzcGVjaWZpZWQuIFRoZSBkZWNpbWFsUGxhY2VzIHByb3BlcnR5XG4gKiAgIHNob3VsZCBiZSB1c2VkIGZvciAqZGlzcGxheSBwdXJwb3NlcyBvbmx5Ki4gQW55IG90aGVyIHVzZSBpcyBhblxuICogICBhbnRpLXBhdHRlcm4uXG4gKiBAcHJvcGVydHkge0Fzc2V0S2luZH0gW2Fzc2V0S2luZF1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3N3aW5nc2V0LXZhdCcpLlNodXRkb3duV2l0aEZhaWx1cmV9IFNodXRkb3duV2l0aEZhaWx1cmVcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBNaW50XG4gKiBIb2xkaW5nIGEgTWludCBjYXJyaWVzIHRoZSByaWdodCB0byBpc3N1ZSBuZXcgZGlnaXRhbCBhc3NldHMuIFRoZXNlXG4gKiBhc3NldHMgYWxsIGhhdmUgdGhlIHNhbWUga2luZCwgd2hpY2ggaXMgY2FsbGVkIGEgQnJhbmQuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBJc3N1ZXI8Sz59IGdldElzc3VlciBHZXRzIHRoZSBJc3N1ZXIgZm9yIHRoaXMgbWludC5cbiAqIEBwcm9wZXJ0eSB7KG5ld0Ftb3VudDogQW1vdW50PEs+KSA9PiBQYXltZW50PEs+fSBtaW50UGF5bWVudFxuICogQ3JlYXRlcyBhIG5ldyBQYXltZW50IGNvbnRhaW5pbmcgbmV3bHkgbWludGVkIGFtb3VudC5cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBEZXBvc2l0RmFjZXRSZWNlaXZlXG4gKiBAcGFyYW0ge1BheW1lbnR9IHBheW1lbnRcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge0Ftb3VudH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IERlcG9zaXRGYWNldFxuICogQHByb3BlcnR5IHtEZXBvc2l0RmFjZXRSZWNlaXZlfSByZWNlaXZlXG4gKiBEZXBvc2l0IGFsbCB0aGUgY29udGVudHMgb2YgcGF5bWVudCBpbnRvIHRoZSBwdXJzZSB0aGF0IG1hZGUgdGhpcyBmYWNldCxcbiAqIHJldHVybmluZyB0aGUgYW1vdW50LiBJZiB0aGUgb3B0aW9uYWwgYXJndW1lbnQgYG9wdEFtb3VudGAgZG9lcyBub3QgZXF1YWwgdGhlXG4gKiBhbW91bnQgb2YgZGlnaXRhbCBhc3NldHMgaW4gdGhlIHBheW1lbnQsIHRocm93IGFuIGVycm9yLlxuICpcbiAqIElmIHBheW1lbnQgaXMgYSBwcm9taXNlLCB0aHJvdyBhbiBlcnJvci5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBLXG4gKiBAY2FsbGJhY2sgUHVyc2VEZXBvc2l0XG4gKiBAcGFyYW0ge1BheW1lbnQ8Sz59IHBheW1lbnRcbiAqIEBwYXJhbSB7UGF0dGVybn0gW29wdEFtb3VudFNoYXBlXVxuICogQHJldHVybnMge0Ftb3VudDxLPn1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQdXJzZVxuICogUHVyc2VzIGhvbGQgYW1vdW50IG9mIGRpZ2l0YWwgYXNzZXRzIG9mIHRoZSBzYW1lIGJyYW5kLCBidXQgdW5saWtlIFBheW1lbnRzLFxuICogdGhleSBhcmUgbm90IG1lYW50IHRvIGJlIHNlbnQgdG8gb3RoZXJzLiBUbyB0cmFuc2ZlciBkaWdpdGFsIGFzc2V0cywgYVxuICogUGF5bWVudCBzaG91bGQgYmUgd2l0aGRyYXduIGZyb20gYSBQdXJzZS4gVGhlIGFtb3VudCBvZiBkaWdpdGFsXG4gKiBhc3NldHMgaW4gYSBwdXJzZSBjYW4gY2hhbmdlIHRocm91Z2ggdGhlIGFjdGlvbiBvZiBkZXBvc2l0KCkgYW5kIHdpdGhkcmF3KCkuXG4gKlxuICogVGhlIHByaW1hcnkgdXNlIGZvciBQdXJzZXMgYW5kIFBheW1lbnRzIGlzIGZvciBjdXJyZW5jeS1saWtlIGFuZCBnb29kcy1saWtlXG4gKiBkaWdpdGFsIGFzc2V0cywgYnV0IHRoZXkgY2FuIGFsc28gYmUgdXNlZCB0byByZXByZXNlbnQgb3RoZXIga2luZHMgb2YgcmlnaHRzLFxuICogc3VjaCBhcyB0aGUgcmlnaHQgdG8gcGFydGljaXBhdGUgaW4gYSBwYXJ0aWN1bGFyIGNvbnRyYWN0LlxuICpcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gQnJhbmQ8Sz59IGdldEFsbGVnZWRCcmFuZCBHZXQgdGhlIGFsbGVnZWQgQnJhbmQgZm9yIHRoaXMgUHVyc2VcbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IEFtb3VudDxLPn0gZ2V0Q3VycmVudEFtb3VudFxuICogR2V0IHRoZSBhbW91bnQgY29udGFpbmVkIGluIHRoaXMgcHVyc2UuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBMYXRlc3RUb3BpYzxBbW91bnQ8Sz4+fSBnZXRDdXJyZW50QW1vdW50Tm90aWZpZXJcbiAqIEdldCBhIGxvc3N5IG5vdGlmaWVyIGZvciBjaGFuZ2VzIHRvIHRoaXMgcHVyc2UncyBiYWxhbmNlLlxuICpcbiAqIEBwcm9wZXJ0eSB7UHVyc2VEZXBvc2l0PEs+fSBkZXBvc2l0XG4gKiBEZXBvc2l0IGFsbCB0aGUgY29udGVudHMgb2YgcGF5bWVudCBpbnRvIHRoaXMgcHVyc2UsIHJldHVybmluZyB0aGVcbiAqIGFtb3VudC4gSWYgdGhlIG9wdGlvbmFsIGFyZ3VtZW50IGBvcHRBbW91bnRgIGRvZXMgbm90IGVxdWFsIHRoZVxuICogYW1vdW50IG9mIGRpZ2l0YWwgYXNzZXRzIGluIHRoZSBwYXltZW50LCB0aHJvdyBhbiBlcnJvci5cbiAqXG4gKiBJZiBwYXltZW50IGlzIGEgcHJvbWlzZSwgdGhyb3cgYW4gZXJyb3IuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBEZXBvc2l0RmFjZXR9IGdldERlcG9zaXRGYWNldFxuICogUmV0dXJuIGFuIG9iamVjdCB3aG9zZSBgcmVjZWl2ZWAgbWV0aG9kIGRlcG9zaXRzIHRvIHRoZSBjdXJyZW50IFB1cnNlLlxuICpcbiAqIEBwcm9wZXJ0eSB7KGFtb3VudDogQW1vdW50PEs+KSA9PiBQYXltZW50PEs+fSB3aXRoZHJhd1xuICogV2l0aGRyYXcgYW1vdW50IGZyb20gdGhpcyBwdXJzZSBpbnRvIGEgbmV3IFBheW1lbnQuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBDb3B5U2V0PFBheW1lbnQ8Sz4+fSBnZXRSZWNvdmVyeVNldFxuICogVGhlIHNldCBvZiBwYXltZW50cyB3aXRoZHJhd24gZnJvbSB0aGlzIHB1cnNlIHRoYXQgYXJlIHN0aWxsIGxpdmUuIFRoZXNlXG4gKiBhcmUgdGhlIHBheW1lbnRzIHRoYXQgY2FuIHN0aWxsIGJlIHJlY292ZXJlZCBpbiBlbWVyZ2VuY2llcyBieSwgZm9yIGV4YW1wbGUsXG4gKiBkZXBvc2l0aW5nIGludG8gdGhpcyBwdXJzZS4gU3VjaCBhIGRlcG9zaXQgYWN0aW9uIGlzIGxpa2UgY2FuY2VsaW5nIGFuXG4gKiBvdXRzdGFuZGluZyBjaGVjayBiZWNhdXNlIHlvdSdyZSB0aXJlZCBvZiB3YWl0aW5nIGZvciBpdC4gT25jZSB5b3VyXG4gKiBjYW5jZWxsYXRpb24gaXMgYWNrbm93bGVkZ2VkLCB5b3UgY2FuIHNwZW5kIHRoZSBhc3NldHMgYXQgc3Rha2Ugb24gb3RoZXJcbiAqIHRoaW5ncy4gQWZ0ZXJ3YXJkcywgaWYgdGhlIHJlY2lwaWVudCBvZiB0aGUgb3JpZ2luYWwgY2hlY2sgZmluYWxseSBnZXRzXG4gKiBhcm91bmQgdG8gZGVwb3NpdGluZyBpdCwgdGhlaXIgZGVwb3NpdCBmYWlscy5cbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IEFtb3VudDxLPn0gcmVjb3ZlckFsbFxuICogRm9yIHVzZSBpbiBlbWVyZ2VuY2llcywgc3VjaCBhcyBjb21pbmcgYmFjayBmcm9tIGEgdHJhdW1hdGljIGNyYXNoIGFuZFxuICogdXBncmFkZS4gVGhpcyBkZXBvc2l0cyBhbGwgdGhlIHBheW1lbnRzIGluIHRoaXMgcHVyc2UncyByZWNvdmVyeSBzZXRcbiAqIGludG8gdGhlIHB1cnNlIGl0c2VsZiwgcmV0dXJuaW5nIHRoZSB0b3RhbCBhbW91bnQgb2YgYXNzZXRzIHJlY292ZXJlZC5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXltZW50XG4gKiBQYXltZW50cyBob2xkIGFtb3VudCBvZiBkaWdpdGFsIGFzc2V0cyBvZiB0aGUgc2FtZSBicmFuZCBpbiB0cmFuc2l0LiBQYXltZW50c1xuICogY2FuIGJlIGRlcG9zaXRlZCBpbiBwdXJzZXMsIHNwbGl0IGludG8gbXVsdGlwbGUgcGF5bWVudHMsIGNvbWJpbmVkLCBhbmRcbiAqIGNsYWltZWQgKGdldHRpbmcgYW4gZXhjbHVzaXZlIHBheW1lbnQpLiBQYXltZW50cyBhcmUgbGluZWFyLCBtZWFuaW5nXG4gKiB0aGF0IGVpdGhlciBhIHBheW1lbnQgaGFzIHRoZSBzYW1lIGFtb3VudCBvZiBkaWdpdGFsIGFzc2V0cyBpdFxuICogc3RhcnRlZCB3aXRoLCBvciBpdCBpcyB1c2VkIHVwIGVudGlyZWx5LiBJdCBpcyBpbXBvc3NpYmxlIHRvIHBhcnRpYWxseSB1c2UgYVxuICogcGF5bWVudC5cbiAqXG4gKiBQYXltZW50cyBhcmUgb2Z0ZW4gcmVjZWl2ZWQgZnJvbSBvdGhlciBhY3RvcnMgYW5kIHRoZXJlZm9yZSBzaG91bGRcbiAqIG5vdCBiZSB0cnVzdGVkIHRoZW1zZWx2ZXMuIFRvIGdldCB0aGUgYW1vdW50IG9mIGRpZ2l0YWwgYXNzZXRzIGluIGEgcGF5bWVudCxcbiAqIHVzZSB0aGUgdHJ1c3RlZCBpc3N1ZXI6IGlzc3Vlci5nZXRBbW91bnRPZihwYXltZW50KSxcbiAqXG4gKiBQYXltZW50cyBjYW4gYmUgY29udmVydGVkIHRvIFB1cnNlcyBieSBnZXR0aW5nIGEgdHJ1c3RlZCBpc3N1ZXIgYW5kXG4gKiBjYWxsaW5nIGBpc3N1ZXIubWFrZUVtcHR5UHVyc2UoKWAgdG8gY3JlYXRlIGEgcHVyc2UsIHRoZW5cbiAqIGBwdXJzZS5kZXBvc2l0KHBheW1lbnQpYC5cbiAqXG4gKiBAcHJvcGVydHkgeygpID0+IEJyYW5kPEs+fSBnZXRBbGxlZ2VkQnJhbmRcbiAqIEdldCB0aGUgYWxsZWdlZEJyYW5kLCBpbmRpY2F0aW5nIHRoZSB0eXBlIG9mIGRpZ2l0YWwgYXNzZXQgdGhpc1xuICogcGF5bWVudCBwdXJwb3J0cyB0byBiZSwgYW5kIHdoaWNoIGlzc3VlciB0byB1c2UuIEJlY2F1c2UgcGF5bWVudHNcbiAqIGFyZSBub3QgdHJ1c3RlZCwgYW55IG1ldGhvZCBjYWxscyBvbiBwYXltZW50cyBzaG91bGQgYmUgdHJlYXRlZFxuICogd2l0aCBzdXNwaWNpb24gYW5kIHZlcmlmaWVkIGVsc2V3aGVyZS5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QW1vdW50VmFsdWV9IFZcbiAqIEB0eXBlZGVmIHtvYmplY3R9IE1hdGhIZWxwZXJzXG4gKiBBbGwgb2YgdGhlIGRpZmZlcmVuY2UgaW4gaG93IGRpZ2l0YWwgYXNzZXQgYW1vdW50IGFyZSBtYW5pcHVsYXRlZCBjYW4gYmVcbiAqIHJlZHVjZWQgdG8gdGhlIGJlaGF2aW9yIG9mIHRoZSBtYXRoIG9uIHZhbHVlcy4gV2UgZXh0cmFjdCB0aGlzXG4gKiBjdXN0b20gbG9naWMgaW50byBtYXRoSGVscGVycy4gTWF0aEhlbHBlcnMgYXJlIGFib3V0IHZhbHVlXG4gKiBhcml0aG1ldGljLCB3aGVyZWFzIEFtb3VudE1hdGggaXMgYWJvdXQgYW1vdW50cywgd2hpY2ggYXJlIHRoZVxuICogdmFsdWVzIGxhYmVsZWQgd2l0aCBhIGJyYW5kLiBBbW91bnRNYXRoIHVzZSBtYXRoSGVscGVycyB0byBkbyB0aGVpciB2YWx1ZVxuICogYXJpdGhtZXRpYywgYW5kIHRoZW4gYnJhbmQgdGhlIHJlc3VsdHMsIG1ha2luZyBhIG5ldyBhbW91bnQuXG4gKlxuICogVGhlIE1hdGhIZWxwZXJzIGFyZSBkZXNpZ25lZCB0byBiZSBjYWxsZWQgb25seSBmcm9tIEFtb3VudE1hdGgsIGFuZCBzb1xuICogYWxsIG1ldGhvZHMgYnV0IGNvZXJjZSBjYW4gYXNzdW1lIHRoZWlyIGlucHV0cyBhcmUgdmFsaWQuIFRoZXkgb25seVxuICogbmVlZCB0byBkbyBvdXRwdXQgdmFsaWRhdGlvbiwgYW5kIG9ubHkgd2hlbiB0aGVyZSBpcyBhIHBvc3NpYmlsaXR5IG9mXG4gKiBpbnZhbGlkIG91dHB1dC5cbiAqXG4gKiBAcHJvcGVydHkgeyhhbGxlZ2VkVmFsdWU6IFYpID0+IFZ9IGRvQ29lcmNlXG4gKiBDaGVjayB0aGUga2luZCBvZiB0aGlzIHZhbHVlIGFuZCB0aHJvdyBpZiBpdCBpcyBub3QgdGhlXG4gKiBleHBlY3RlZCBraW5kLlxuICpcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gVn0gZG9NYWtlRW1wdHlcbiAqIEdldCB0aGUgcmVwcmVzZW50YXRpb24gZm9yIHRoZSBpZGVudGl0eSBlbGVtZW50IChvZnRlbiAwIG9yIGFuXG4gKiBlbXB0eSBhcnJheSlcbiAqXG4gKiBAcHJvcGVydHkgeyh2YWx1ZTogVikgPT4gYm9vbGVhbn0gZG9Jc0VtcHR5XG4gKiBJcyB0aGUgdmFsdWUgdGhlIGlkZW50aXR5IGVsZW1lbnQ/XG4gKlxuICogQHByb3BlcnR5IHsobGVmdDogViwgcmlnaHQ6IFYpID0+IGJvb2xlYW59IGRvSXNHVEVcbiAqIElzIHRoZSBsZWZ0IGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byB0aGUgcmlnaHQ/XG4gKlxuICogQHByb3BlcnR5IHsobGVmdDogViwgcmlnaHQ6IFYpID0+IGJvb2xlYW59IGRvSXNFcXVhbFxuICogRG9lcyBsZWZ0IGVxdWFsIHJpZ2h0P1xuICpcbiAqIEBwcm9wZXJ0eSB7KGxlZnQ6IFYsIHJpZ2h0OiBWKSA9PiBWfSBkb0FkZFxuICogUmV0dXJuIHRoZSBsZWZ0IGNvbWJpbmVkIHdpdGggdGhlIHJpZ2h0LlxuICpcbiAqIEBwcm9wZXJ0eSB7KGxlZnQ6IFYsIHJpZ2h0OiBWKSA9PiBWfSBkb1N1YnRyYWN0XG4gKiBSZXR1cm4gd2hhdCByZW1haW5zIGFmdGVyIHJlbW92aW5nIHRoZSByaWdodCBmcm9tIHRoZSBsZWZ0LiBJZlxuICogc29tZXRoaW5nIGluIHRoZSByaWdodCB3YXMgbm90IGluIHRoZSBsZWZ0LCB3ZSB0aHJvdyBhbiBlcnJvci5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtiaWdpbnR9IE5hdFZhbHVlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7QXJyYXk8S2V5Pn0gU2V0VmFsdWVcbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAD3qap29AMAAPQDAAAxAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnN0YW50cy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiUGFyYW1UeXBlcyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qKlxuICogRW51bSBvZiBwYXJhbWV0ZXIgdHlwZXNcbiAqXG4gKiBVTktOT1dOIGlzIGFuIGVzY2FwZSBoYXRjaCBmb3IgdHlwZXMgd2UgaGF2ZW4ndCBhZGRlZCB5ZXQuIElmIHlvdSBhcmVcbiAqIGRldmVsb3BpbmcgYSBuZXcgY29udHJhY3QgYW5kIHVzZSBVTktOT1dOLCBwbGVhc2UgYWxzbyBmaWxlIGFuIGlzc3VlIHRvIGFza1xuICogdXMgdG8gc3VwcG9ydCB0aGUgbmV3IHR5cGUuXG4gKi9cbmNvbnN0ICAgICAgICBQYXJhbVR5cGVzPS8qKiBAdHlwZSB7Y29uc3R9ICove1xuQU1PVU5UOidhbW91bnQnLFxuQlJBTkQ6J2JyYW5kJyxcbklOU1RBTExBVElPTjonaW5zdGFsbGF0aW9uJyxcbklOU1RBTkNFOidpbnN0YW5jZScsXG5JTlZJVEFUSU9OOidpbnZpdGF0aW9uJyxcbk5BVDonbmF0JyxcblJBVElPOidyYXRpbycsXG5TVFJJTkc6J3N0cmluZycsXG5QQVNTQUJMRV9SRUNPUkQ6J3JlY29yZCcsXG5USU1FU1RBTVA6J3RpbWVzdGFtcCcsXG5SRUxBVElWRV9USU1FOidyZWxhdGl2ZVRpbWUnLFxuVU5LTk9XTjondW5rbm93bid9OyRo4oCNX29uY2UuUGFyYW1UeXBlcyhQYXJhbVR5cGVzKTtcblxuXG5oYXJkZW4oUGFyYW1UeXBlcyk7XG4vKiogQHR5cGVkZWYge3R5cGVvZiBQYXJhbVR5cGVzW2tleW9mIHR5cGVvZiBQYXJhbVR5cGVzXX0gUGFyYW1UeXBlICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiUGFyYW1UeXBlcyI6WyJQYXJhbVR5cGVzIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAADeWcIX8CwAA/AsAAEUAAABAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2Fzc2VydGlvbnMuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvdGltZSIsIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvcmF0aW8uanMiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiYXNzZXJ0UmVsYXRpdmVUaW1lIiwiYXNzZXJ0VGltZXN0YW1wIiwibWFrZUFzc2VydEJyYW5kZWRSYXRpbyIsIm1ha2VBc3NlcnRJbnN0YWxsYXRpb24iLCJtYWtlQXNzZXJ0SW5zdGFuY2UiLCJtYWtlTG9va3NMaWtlQnJhbmQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgaXNSZW1vdGFibGUsYXNzZXJ0SXNSYXRpbyxtdXN0TWF0Y2gsUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUsVGltZXN0YW1wUmVjb3JkU2hhcGU7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiaXNSZW1vdGFibGVcIiwgWyRo4oCNX2EgPT4gKGlzUmVtb3RhYmxlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvcmF0aW8uanNcIiwgW1tcImFzc2VydElzUmF0aW9cIiwgWyRo4oCNX2EgPT4gKGFzc2VydElzUmF0aW8gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy90aW1lXCIsIFtbXCJSZWxhdGl2ZVRpbWVSZWNvcmRTaGFwZVwiLCBbJGjigI1fYSA9PiAoUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlRpbWVzdGFtcFJlY29yZFNoYXBlXCIsIFskaOKAjV9hID0+IChUaW1lc3RhbXBSZWNvcmRTaGFwZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5jb25zdHtGYWlsfT1hc3NlcnQ7XG5cbmNvbnN0IG1ha2VMb29rc0xpa2VCcmFuZD0obmFtZSk9Pntcbi8qKiBAcGFyYW0ge0JyYW5kfSBicmFuZCAqL1xucmV0dXJuKGJyYW5kKT0+e1xuaXNSZW1vdGFibGUoYnJhbmQpfHxGYWlsIGB2YWx1ZSBmb3IgJHtuYW1lfSBtdXN0IGJlIGEgYnJhbmQsIHdhcyAke2JyYW5kfWA7XG4gfTtcbiB9OyRo4oCNX29uY2UubWFrZUxvb2tzTGlrZUJyYW5kKG1ha2VMb29rc0xpa2VCcmFuZCk7XG5oYXJkZW4obWFrZUxvb2tzTGlrZUJyYW5kKTtcblxuY29uc3QgbWFrZUFzc2VydEluc3RhbGxhdGlvbj0obmFtZSk9PntcbnJldHVybihpbnN0YWxsYXRpb24pPT57XG4vKiBUT0RPKDMzNDQpOiBhZGQgYSBiZXR0ZXIgYXNzZXJ0aW9uIG9uY2UgWm9lIHZhbGlkYXRlcyBpbnN0YWxsYXRpb25zKi9cbnR5cGVvZiBpbnN0YWxsYXRpb249PT0nb2JqZWN0J3x8XG5GYWlsIGB2YWx1ZSBmb3IgJHtuYW1lfSBtdXN0IGJlIGFuIEluc3RhbGxhdGlvbiwgd2FzICR7aW5zdGFsbGF0aW9ufWA7XG4gfTtcbiB9OyRo4oCNX29uY2UubWFrZUFzc2VydEluc3RhbGxhdGlvbihtYWtlQXNzZXJ0SW5zdGFsbGF0aW9uKTtcbmhhcmRlbihtYWtlQXNzZXJ0SW5zdGFsbGF0aW9uKTtcblxuY29uc3QgbWFrZUFzc2VydEluc3RhbmNlPShuYW1lKT0+e1xucmV0dXJuKGluc3RhbmNlKT0+e1xuLyogVE9ETygzMzQ0KTogYWRkIGEgYmV0dGVyIGFzc2VydGlvbiBvbmNlIFpvZSB2YWxpZGF0ZXMgaW5zdGFuY2VzKi9cbnR5cGVvZiBpbnN0YW5jZT09PSdvYmplY3QnfHxcbkZhaWwgYHZhbHVlIGZvciAke25hbWV9IG11c3QgYmUgYW4gSW5zdGFuY2UsIHdhcyAke2luc3RhbmNlfWA7XG4gfTtcbiB9OyRo4oCNX29uY2UubWFrZUFzc2VydEluc3RhbmNlKG1ha2VBc3NlcnRJbnN0YW5jZSk7XG5oYXJkZW4obWFrZUFzc2VydEluc3RhbmNlKTtcblxuY29uc3QgbWFrZUFzc2VydEJyYW5kZWRSYXRpbz0obmFtZSxtb2RlbFJhdGlvKT0+e1xucmV0dXJuKHJhdGlvKT0+e1xuYXNzZXJ0SXNSYXRpbyhyYXRpbyk7XG5yYXRpby5udW1lcmF0b3IuYnJhbmQ9PT1tb2RlbFJhdGlvLm51bWVyYXRvci5icmFuZHx8XG5GYWlsIGBOdW1lcmF0b3IgYnJhbmQgZm9yICR7bmFtZX0gbXVzdCBiZSAke21vZGVsUmF0aW8ubnVtZXJhdG9yLmJyYW5kfWA7XG5yYXRpby5kZW5vbWluYXRvci5icmFuZD09PW1vZGVsUmF0aW8uZGVub21pbmF0b3IuYnJhbmR8fFxuRmFpbCBgRGVub21pbmF0b3IgYnJhbmQgZm9yICR7bmFtZX0gbXVzdCBiZSAke21vZGVsUmF0aW8uZGVub21pbmF0b3IuYnJhbmR9YDtcbnJldHVybiB0cnVlO1xuIH07XG4gfTskaOKAjV9vbmNlLm1ha2VBc3NlcnRCcmFuZGVkUmF0aW8obWFrZUFzc2VydEJyYW5kZWRSYXRpbyk7XG5oYXJkZW4obWFrZUFzc2VydEJyYW5kZWRSYXRpbyk7XG5cbmNvbnN0IGFzc2VydFJlbGF0aXZlVGltZT0odmFsdWUpPT57XG5tdXN0TWF0Y2godmFsdWUsUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUpO1xuIH07JGjigI1fb25jZS5hc3NlcnRSZWxhdGl2ZVRpbWUoYXNzZXJ0UmVsYXRpdmVUaW1lKTtcbmhhcmRlbihhc3NlcnRSZWxhdGl2ZVRpbWUpO1xuXG5jb25zdCBhc3NlcnRUaW1lc3RhbXA9KHZhbHVlKT0+e1xubXVzdE1hdGNoKHZhbHVlLFRpbWVzdGFtcFJlY29yZFNoYXBlLCd0aW1lc3RhbXAnKTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0VGltZXN0YW1wKGFzc2VydFRpbWVzdGFtcCk7XG5oYXJkZW4oYXNzZXJ0VGltZXN0YW1wKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlTG9va3NMaWtlQnJhbmQiOlsibWFrZUxvb2tzTGlrZUJyYW5kIl0sIm1ha2VBc3NlcnRJbnN0YWxsYXRpb24iOlsibWFrZUFzc2VydEluc3RhbGxhdGlvbiJdLCJtYWtlQXNzZXJ0SW5zdGFuY2UiOlsibWFrZUFzc2VydEluc3RhbmNlIl0sIm1ha2VBc3NlcnRCcmFuZGVkUmF0aW8iOlsibWFrZUFzc2VydEJyYW5kZWRSYXRpbyJdLCJhc3NlcnRSZWxhdGl2ZVRpbWUiOlsiYXNzZXJ0UmVsYXRpdmVUaW1lIl0sImFzc2VydFRpbWVzdGFtcCI6WyJhc3NlcnRUaW1lc3RhbXAiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAoiNA8nURAAB1EQAARAAAAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuQXBpLmpzeyJpbXBvcnRzIjpbIi4uL3F1ZXN0aW9uLmpzIiwiQGFnb3JpYy9zdG9yZSIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsibWFrZUFwaUludm9jYXRpb25Qb3NpdGlvbnMiLCJzZXR1cEFwaUdvdmVybmFuY2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRSxGYXIsa2V5RVEsQ2hvaWNlTWV0aG9kLFF1b3J1bVJ1bGUsRWxlY3Rpb25UeXBlLGNvZXJjZVF1ZXN0aW9uU3BlYzskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV1dXSxbXCIuLi9xdWVzdGlvbi5qc1wiLCBbW1wiQ2hvaWNlTWV0aG9kXCIsIFskaOKAjV9hID0+IChDaG9pY2VNZXRob2QgPSAkaOKAjV9hKV1dLFtcIlF1b3J1bVJ1bGVcIiwgWyRo4oCNX2EgPT4gKFF1b3J1bVJ1bGUgPSAkaOKAjV9hKV1dLFtcIkVsZWN0aW9uVHlwZVwiLCBbJGjigI1fYSA9PiAoRWxlY3Rpb25UeXBlID0gJGjigI1fYSldXSxbXCJjb2VyY2VRdWVzdGlvblNwZWNcIiwgWyRo4oCNX2EgPT4gKGNvZXJjZVF1ZXN0aW9uU3BlYyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtGYWlsLHF1b3RlOnF9PWFzc2VydDtcblxuLyoqXG4gKiBNYWtlIGEgcGFpciBvZiBwb3NpdGlvbnMgZm9yIGEgcXVlc3Rpb24gYWJvdXQgd2hldGhlciB0byBpbnZva2UgYW4gQVBJLiBJZlxuICogdGhlIHZvdGUgcGFzc2VzLCB0aGUgbWV0aG9kIHdpbGwgYmUgY2FsbGVkIG9uIHRoZSBnb3Zlcm5lZEFwaXMgZmFjZXQgd2l0aCB0aGVcbiAqIGFyZ3VtZW50cyB0aGF0IHdlcmUgcHJvdmlkZWQuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IGFwaU1ldGhvZE5hbWVcbiAqIEBwYXJhbSB7dW5rbm93bltdfSBtZXRob2RBcmdzXG4gKi9cbmNvbnN0IG1ha2VBcGlJbnZvY2F0aW9uUG9zaXRpb25zPShhcGlNZXRob2ROYW1lLG1ldGhvZEFyZ3MpPT57XG5jb25zdCBwb3NpdGl2ZT1oYXJkZW4oe2FwaU1ldGhvZE5hbWUsbWV0aG9kQXJnc30pO1xuY29uc3QgbmVnYXRpdmU9aGFyZGVuKHtkb250SW52b2tlOmFwaU1ldGhvZE5hbWV9KTtcbnJldHVybiBoYXJkZW4oe3Bvc2l0aXZlLG5lZ2F0aXZlfSk7XG4gfTtcblxuLyoqXG4gKiBtYW5hZ2UgY29udHJhY3RzIHRoYXQgYWxsb3cgZ292ZXJuYW5jZSB0byBpbnZva2UgZnVuY3Rpb25zLlxuICpcbiAqIEBwYXJhbSB7RVJlZjx7IFttZXRob2ROYW1lOiBzdHJpbmddOiAoLi4uYXJnczogYW55KSA9PiB1bmtub3duIH0+fSBnb3Zlcm5lZEFwaXNcbiAqIEBwYXJhbSB7QXJyYXk8c3RyaW5nIHwgc3ltYm9sPn0gZ292ZXJuZWROYW1lcyBuYW1lcyBvZiB0aGUgZ292ZXJuZWQgQVBJIG1ldGhvZHNcbiAqIEBwYXJhbSB7RVJlZjxYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXJTZXJ2aWNlPn0gdGltZXJcbiAqIEBwYXJhbSB7KCkgPT4gUHJvbWlzZTxQb3NlckZhY2V0Pn0gZ2V0VXBkYXRlZFBvc2VyRmFjZXRcbiAqIEByZXR1cm5zIHtBcGlHb3Zlcm5vcn1cbiAqLyRo4oCNX29uY2UubWFrZUFwaUludm9jYXRpb25Qb3NpdGlvbnMobWFrZUFwaUludm9jYXRpb25Qb3NpdGlvbnMpO1xuY29uc3Qgc2V0dXBBcGlHb3Zlcm5hbmNlPShcbmdvdmVybmVkQXBpcyxcbmdvdmVybmVkTmFtZXMsXG50aW1lcixcbmdldFVwZGF0ZWRQb3NlckZhY2V0KT0+XG57XG4vKiogQHR5cGUge1dlYWtTZXQ8SW5zdGFuY2U+fSAqL1xuY29uc3Qgdm90ZUNvdW50ZXJzPW5ldyBXZWFrU2V0KCk7XG5cbi8qKiBAdHlwZSB7Vm90ZU9uQXBpSW52b2NhdGlvbn0gKi9cbmNvbnN0IHZvdGVPbkFwaUludm9jYXRpb249YXN5bmMoXG5hcGlNZXRob2ROYW1lLFxubWV0aG9kQXJncyxcbnZvdGVDb3VudGVySW5zdGFsbGF0aW9uLFxuZGVhZGxpbmUpPT5cbntcbmdvdmVybmVkTmFtZXMuaW5jbHVkZXMoYXBpTWV0aG9kTmFtZSl8fFxuRmFpbCBgJHthcGlNZXRob2ROYW1lfSBpcyBub3QgYSBnb3Zlcm5lZCBBUEkuYDtcblxuY29uc3R7cG9zaXRpdmUsbmVnYXRpdmV9PW1ha2VBcGlJbnZvY2F0aW9uUG9zaXRpb25zKFxuYXBpTWV0aG9kTmFtZSxcbm1ldGhvZEFyZ3MpO1xuXG5cbi8qKiBAdHlwZSB7QXBpSW52b2NhdGlvbklzc3VlfSAqL1xuY29uc3QgaXNzdWU9aGFyZGVuKHthcGlNZXRob2ROYW1lLG1ldGhvZEFyZ3N9KTtcbmNvbnN0IHF1ZXN0aW9uU3BlYz1jb2VyY2VRdWVzdGlvblNwZWMoe1xubWV0aG9kOkNob2ljZU1ldGhvZC5VTlJBTktFRCxcbmlzc3VlLFxucG9zaXRpb25zOltwb3NpdGl2ZSxuZWdhdGl2ZV0sXG5lbGVjdGlvblR5cGU6RWxlY3Rpb25UeXBlLkFQSV9JTlZPQ0FUSU9OLFxubWF4Q2hvaWNlczoxLFxubWF4V2lubmVyczoxLFxuY2xvc2luZ1J1bGU6e3RpbWVyLGRlYWRsaW5lfSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZS5NQUpPUklUWSxcbnRpZU91dGNvbWU6bmVnYXRpdmV9KTtcblxuXG5jb25zdHtwdWJsaWNGYWNldDpjb3VudGVyUHVibGljRmFjZXQsaW5zdGFuY2U6dm90ZUNvdW50ZXJ9PWF3YWl0IEUoXG5nZXRVcGRhdGVkUG9zZXJGYWNldCgpKS5cbmFkZFF1ZXN0aW9uKHZvdGVDb3VudGVySW5zdGFsbGF0aW9uLHF1ZXN0aW9uU3BlYyk7XG5cbnZvdGVDb3VudGVycy5hZGQodm90ZUNvdW50ZXIpO1xuXG4vKiBDUlVDSUFMOiBIZXJlIHdlIHdhaXQgZm9yIHRoZSB2b3RlQ291bnRlciB0byBkZWNsYXJlIGFuIG91dGNvbWUsIGFuZCB0aGVuKi9cbi8qIGF0dGVtcHQgdG8gaW52b2tlIHRoZSBBUEkgaWYgdGhhdCdzIHdoYXQgdGhlIHZvdGUgY2FsbGVkIGZvci4gV2UgbmVlZCB0byovXG4vKiBtYWtlIHN1cmUgdGhhdCBvdXRjb21lT2ZVcGRhdGVQIGlzIHVwZGF0ZWQgd2hhdGV2ZXIgaGFwcGVucy4qL1xuLyoqL1xuLyogKiBJZiB0aGUgdm90ZSBwYXNzZWQsIGludm9rZSB0aGUgQVBJLCBhbmQgcmV0dXJuIHRoZSBwb3NpdGl2ZSBwb3NpdGlvbiovXG4vKiAqIElmIHRoZSB2b3RlIHdhcyBuZWdhdGl2ZSwgcmV0dXJuIHRoZSBuZWdhdGl2ZSBwb3NpdGlvbiovXG4vKiAqIElmIHdlIGNhbid0IGRvIGVpdGhlciwgKHRoZSB2b3RlIGZhaWxlZCBvciB0aGUgQVBJIGludm9jYXRpb24gZmFpbGVkKSovXG4vKiByZXR1cm4gYSBicm9rZW4gcHJvbWlzZS4qL1xuY29uc3Qgb3V0Y29tZU9mVXBkYXRlPUUoY291bnRlclB1YmxpY0ZhY2V0KS5cbmdldE91dGNvbWUoKS5cbnRoZW4oXG4vKiogQHR5cGUgeyhvdXRjb21lOiBQb3NpdGlvbikgPT4gRVJlZjxQb3NpdGlvbj59ICovXG4ob3V0Y29tZSk9PntcbmlmKGtleUVRKHBvc2l0aXZlLG91dGNvbWUpKXtcbmtleUVRKG91dGNvbWUsaGFyZGVuKHthcGlNZXRob2ROYW1lLG1ldGhvZEFyZ3N9KSl8fFxuRmFpbCBgVGhlIHF1ZXN0aW9uJ3MgbWV0aG9kIG5hbWUgKCR7cShcbmFwaU1ldGhvZE5hbWUpXG4gfSkgYW5kIGFyZ3MgKCR7bWV0aG9kQXJnc30pIGRpZG4ndCBtYXRjaCB0aGUgb3V0Y29tZSAke291dGNvbWV9YDtcblxuLyogRShyZW1vdGUpW25hbWVdKGFyZ3MpIGludm9rZXMgdGhlIG1ldGhvZCBuYW1lZCAnbmFtZScgb24gcmVtb3RlLiovXG5yZXR1cm4gRShnb3Zlcm5lZEFwaXMpW1xuYXBpTWV0aG9kTmFtZV0oLi4ubWV0aG9kQXJncykuXG50aGVuKCgpPT57XG5yZXR1cm4gcG9zaXRpdmU7XG4gfSk7XG4gfWVsc2V7XG5yZXR1cm4gbmVnYXRpdmU7XG4gfVxuIH0pO1xuXG5cbnJldHVybiBoYXJkZW4oe1xub3V0Y29tZU9mVXBkYXRlLFxuaW5zdGFuY2U6dm90ZUNvdW50ZXIsXG5kZXRhaWxzOkUoY291bnRlclB1YmxpY0ZhY2V0KS5nZXREZXRhaWxzKCl9KTtcblxuIH07XG5cbnJldHVybiBGYXIoJ3BhcmFtR292ZXJub3InLHtcbnZvdGVPbkFwaUludm9jYXRpb24sXG5jcmVhdGVkUXVlc3Rpb246KGIpPT52b3RlQ291bnRlcnMuaGFzKGIpfSk7XG5cbiB9OyRo4oCNX29uY2Uuc2V0dXBBcGlHb3Zlcm5hbmNlKHNldHVwQXBpR292ZXJuYW5jZSk7XG5cbmhhcmRlbihzZXR1cEFwaUdvdmVybmFuY2UpO1xuaGFyZGVuKG1ha2VBcGlJbnZvY2F0aW9uUG9zaXRpb25zKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlQXBpSW52b2NhdGlvblBvc2l0aW9ucyI6WyJtYWtlQXBpSW52b2NhdGlvblBvc2l0aW9ucyJdLCJzZXR1cEFwaUdvdmVybmFuY2UiOlsic2V0dXBBcGlHb3Zlcm5hbmNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABvtXsqrDwAAqw8AAEcAAABAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkZpbHRlci5qc3siaW1wb3J0cyI6WyIuLi9xdWVzdGlvbi5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJtYWtlT2ZmZXJGaWx0ZXJQb3NpdGlvbnMiLCJzZXR1cEZpbHRlckdvdmVybmFuY2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRSxGYXIsbXVzdE1hdGNoLGtleUVRLE0sQ2hvaWNlTWV0aG9kLFF1b3J1bVJ1bGUsRWxlY3Rpb25UeXBlLGNvZXJjZVF1ZXN0aW9uU3BlYzskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJrZXlFUVwiLCBbJGjigI1fYSA9PiAoa2V5RVEgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV1dXSxbXCIuLi9xdWVzdGlvbi5qc1wiLCBbW1wiQ2hvaWNlTWV0aG9kXCIsIFskaOKAjV9hID0+IChDaG9pY2VNZXRob2QgPSAkaOKAjV9hKV1dLFtcIlF1b3J1bVJ1bGVcIiwgWyRo4oCNX2EgPT4gKFF1b3J1bVJ1bGUgPSAkaOKAjV9hKV1dLFtcIkVsZWN0aW9uVHlwZVwiLCBbJGjigI1fYSA9PiAoRWxlY3Rpb25UeXBlID0gJGjigI1fYSldXSxbXCJjb2VyY2VRdWVzdGlvblNwZWNcIiwgWyRo4oCNX2EgPT4gKGNvZXJjZVF1ZXN0aW9uU3BlYyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKlxuICogTWFrZSBhIHBhaXIgb2YgcG9zaXRpb25zIGZvciBhIHF1ZXN0aW9uIGFib3V0IHdoZXRoZXIgdG8gdXBkYXRlIHRoZSBvZmZlclxuICogZmlsdGVyLiBJZiB0aGUgdm90ZSBwYXNzZXMsIHRoZSBsaXN0IG9mIGJsb2NrZWQgaW52aXRhdGlvbiBzdHJpbmdzIHdpbGwgYmVcbiAqIHVwZGF0ZWQuXG4gKlxuICogQHBhcmFtIHtzdHJpbmdbXX0gc3RyaW5nc1xuICovXG5jb25zdCBtYWtlT2ZmZXJGaWx0ZXJQb3NpdGlvbnM9KHN0cmluZ3MpPT57XG5jb25zdCBwb3NpdGl2ZT1oYXJkZW4oe3N0cmluZ3N9KTtcbmNvbnN0IG5lZ2F0aXZlPWhhcmRlbih7ZG9udFVwZGF0ZTpzdHJpbmdzfSk7XG5yZXR1cm57cG9zaXRpdmUsbmVnYXRpdmV9O1xuIH07XG5cbi8qKlxuICogU2V0dXAgdG8gYWxsb3cgZ292ZXJuYW5jZSB0byBibG9jayBzb21lIGludml0YXRpb25zLlxuICpcbiAqIEBwYXJhbSB7RVJlZjxYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXJTZXJ2aWNlPn0gdGltZXJcbiAqIEBwYXJhbSB7KCkgPT4gUHJvbWlzZTxQb3NlckZhY2V0Pn0gZ2V0VXBkYXRlZFBvc2VyRmFjZXRcbiAqIEBwYXJhbSB7R292ZXJuZWRDcmVhdG9yRmFjZXQ8e30+fSBnb3Zlcm5lZENGXG4gKiBAcmV0dXJucyB7RmlsdGVyR292ZXJub3J9XG4gKi8kaOKAjV9vbmNlLm1ha2VPZmZlckZpbHRlclBvc2l0aW9ucyhtYWtlT2ZmZXJGaWx0ZXJQb3NpdGlvbnMpO1xuY29uc3Qgc2V0dXBGaWx0ZXJHb3Zlcm5hbmNlPSh0aW1lcixnZXRVcGRhdGVkUG9zZXJGYWNldCxnb3Zlcm5lZENGKT0+e1xuLyoqIEB0eXBlIHtXZWFrU2V0PEluc3RhbmNlPn0gKi9cbmNvbnN0IHZvdGVDb3VudGVycz1uZXcgV2Vha1NldCgpO1xuXG4vKiogQHR5cGUge1ZvdGVPbk9mZmVyRmlsdGVyfSAqL1xuY29uc3Qgdm90ZU9uRmlsdGVyPWFzeW5jKHZvdGVDb3VudGVySW5zdGFsbGF0aW9uLGRlYWRsaW5lLHN0cmluZ3MpPT57XG5tdXN0TWF0Y2goc3RyaW5ncyxNLmFycmF5T2YoTS5zdHJpbmcoKSkpO1xuY29uc3R7cG9zaXRpdmUsbmVnYXRpdmV9PW1ha2VPZmZlckZpbHRlclBvc2l0aW9ucyhzdHJpbmdzKTtcblxuLyoqIEB0eXBlIHtPZmZlckZpbHRlcklzc3VlfSAqL1xuY29uc3QgaXNzdWU9aGFyZGVuKHtzdHJpbmdzfSk7XG5jb25zdCBxdWVzdGlvblNwZWM9Y29lcmNlUXVlc3Rpb25TcGVjKHtcbm1ldGhvZDpDaG9pY2VNZXRob2QuVU5SQU5LRUQsXG5pc3N1ZSxcbnBvc2l0aW9uczpbcG9zaXRpdmUsbmVnYXRpdmVdLFxuZWxlY3Rpb25UeXBlOkVsZWN0aW9uVHlwZS5PRkZFUl9GSUxURVIsXG5tYXhDaG9pY2VzOjEsXG5tYXhXaW5uZXJzOjEsXG5jbG9zaW5nUnVsZTp7dGltZXIsZGVhZGxpbmV9LFxucXVvcnVtUnVsZTpRdW9ydW1SdWxlLk1BSk9SSVRZLFxudGllT3V0Y29tZTpuZWdhdGl2ZX0pO1xuXG5cbmNvbnN0e3B1YmxpY0ZhY2V0OmNvdW50ZXJQdWJsaWNGYWNldCxpbnN0YW5jZTp2b3RlQ291bnRlcn09YXdhaXQgRShcbmdldFVwZGF0ZWRQb3NlckZhY2V0KCkpLlxuYWRkUXVlc3Rpb24odm90ZUNvdW50ZXJJbnN0YWxsYXRpb24scXVlc3Rpb25TcGVjKTtcblxudm90ZUNvdW50ZXJzLmFkZCh2b3RlQ291bnRlcik7XG5cbi8qIENSVUNJQUw6IEhlcmUgd2Ugd2FpdCBmb3IgdGhlIHZvdGVDb3VudGVyIHRvIGRlY2xhcmUgYW4gb3V0Y29tZSwgYW5kIHRoZW4qL1xuLyogYXR0ZW1wdCB0byBpbnZva2UgdGhlIEFQSSBpZiB0aGF0J3Mgd2hhdCB0aGUgdm90ZSBjYWxsZWQgZm9yLiBXZSBuZWVkIHRvKi9cbi8qIG1ha2Ugc3VyZSB0aGF0IG91dGNvbWVPZlVwZGF0ZVAgaXMgdXBkYXRlZCB3aGF0ZXZlciBoYXBwZW5zLiovXG4vKiovXG4vKiAqIElmIHRoZSB2b3RlIHBhc3NlZCwgaW52b2tlIHRoZSBBUEksIGFuZCByZXR1cm4gdGhlIHBvc2l0aXZlIHBvc2l0aW9uKi9cbi8qICogSWYgdGhlIHZvdGUgd2FzIG5lZ2F0aXZlLCByZXR1cm4gdGhlIG5lZ2F0aXZlIHBvc2l0aW9uKi9cbi8qICogSWYgd2UgY2FuJ3QgZG8gZWl0aGVyLCAodGhlIHZvdGUgZmFpbGVkIG9yIHRoZSBBUEkgaW52b2NhdGlvbiBmYWlsZWQpKi9cbi8qIHJldHVybiBhIGJyb2tlbiBwcm9taXNlLiovXG5jb25zdCBvdXRjb21lT2ZVcGRhdGU9RShjb3VudGVyUHVibGljRmFjZXQpLlxuZ2V0T3V0Y29tZSgpLlxudGhlbihcbi8qKiBAdHlwZSB7KG91dGNvbWU6IFBvc2l0aW9uKSA9PiBFUmVmPFBvc2l0aW9uPn0gKi9cbihvdXRjb21lKT0+e1xuaWYoa2V5RVEob3V0Y29tZSxwb3NpdGl2ZSkpe1xucmV0dXJuIEUoZ292ZXJuZWRDRikuXG5zZXRPZmZlckZpbHRlcihzdHJpbmdzKS5cbnRoZW4oKCk9PntcbnJldHVybiBwb3NpdGl2ZTtcbiB9KTtcbiB9ZWxzZSBpZihrZXlFUShvdXRjb21lLG5lZ2F0aXZlKSl7XG5yZXR1cm4gbmVnYXRpdmU7XG4gfWVsc2V7XG5hc3NlcnQuZmFpbCgndW5yZWNvZ25pemVkIG91dGNvbWUnKTtcbiB9XG4gfSk7XG5cblxucmV0dXJuIGhhcmRlbih7XG5vdXRjb21lT2ZVcGRhdGUsXG5pbnN0YW5jZTp2b3RlQ291bnRlcixcbmRldGFpbHM6RShjb3VudGVyUHVibGljRmFjZXQpLmdldERldGFpbHMoKX0pO1xuXG4gfTtcblxucmV0dXJuIEZhcignZmlsdGVyR292ZXJub3InLHtcbnZvdGVPbkZpbHRlcixcbmNyZWF0ZWRRdWVzdGlvbjooYik9PnZvdGVDb3VudGVycy5oYXMoYil9KTtcblxuIH07JGjigI1fb25jZS5zZXR1cEZpbHRlckdvdmVybmFuY2Uoc2V0dXBGaWx0ZXJHb3Zlcm5hbmNlKTtcblxuaGFyZGVuKHNldHVwRmlsdGVyR292ZXJuYW5jZSk7XG5oYXJkZW4obWFrZU9mZmVyRmlsdGVyUG9zaXRpb25zKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlT2ZmZXJGaWx0ZXJQb3NpdGlvbnMiOlsibWFrZU9mZmVyRmlsdGVyUG9zaXRpb25zIl0sInNldHVwRmlsdGVyR292ZXJuYW5jZSI6WyJzZXR1cEZpbHRlckdvdmVybmFuY2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAARg+KNUgWAABIFgAARgAAAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanN7ImltcG9ydHMiOlsiLi4vcXVlc3Rpb24uanMiLCIuLi90eXBlR3VhcmRzLmpzIiwiQGFnb3JpYy9zdG9yZSIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiQ09OVFJBQ1RfRUxFQ1RPUkFURSIsImFzc2VydEJhbGxvdENvbmNlcm5zUGFyYW0iLCJtYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMiLCJzZXR1cFBhcmFtR292ZXJuYW5jZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLGRlZXBseUZ1bGZpbGxlZCxGYXIsbXVzdE1hdGNoLGtleUVRLENob2ljZU1ldGhvZCxjb2VyY2VRdWVzdGlvblNwZWMsRWxlY3Rpb25UeXBlLFF1b3J1bVJ1bGUsUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGU7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJkZWVwbHlGdWxmaWxsZWRcIiwgWyRo4oCNX2EgPT4gKGRlZXBseUZ1bGZpbGxlZCA9ICRo4oCNX2EpXV0sW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dLFtcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV1dXSxbXCIuLi9xdWVzdGlvbi5qc1wiLCBbW1wiQ2hvaWNlTWV0aG9kXCIsIFskaOKAjV9hID0+IChDaG9pY2VNZXRob2QgPSAkaOKAjV9hKV1dLFtcImNvZXJjZVF1ZXN0aW9uU3BlY1wiLCBbJGjigI1fYSA9PiAoY29lcmNlUXVlc3Rpb25TcGVjID0gJGjigI1fYSldXSxbXCJFbGVjdGlvblR5cGVcIiwgWyRo4oCNX2EgPT4gKEVsZWN0aW9uVHlwZSA9ICRo4oCNX2EpXV0sW1wiUXVvcnVtUnVsZVwiLCBbJGjigI1fYSA9PiAoUXVvcnVtUnVsZSA9ICRo4oCNX2EpXV1dXSxbXCIuLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZVwiLCBbJGjigI1fYSA9PiAoUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtGYWlsfT1hc3NlcnQ7XG5cbi8qKlxuICogVGhlIGVsZWN0b3JhdGUgdGhhdCBnb3Zlcm5zIGNoYW5nZXMgdG8gdGhlIGNvbnRyYWN0J3MgcGFyYW1ldGVycy4gSXQgbXVzdCBiZVxuICogZGVjbGFyZWQgaW4gdGhlIGdvdmVybmVkIGNvbnRyYWN0LlxuICovXG5jb25zdCBDT05UUkFDVF9FTEVDVE9SQVRFPSdFbGVjdG9yYXRlJztcblxuLyoqXG4gKiBSZXR1cm4gYSByZWNvcmQgY29udGFpbmluZyB0aGUgcG9zaXRpdmUgYW5kIG5lZ2F0aXZlIHBvc2l0aW9ucyBmb3IgYVxuICogcXVlc3Rpb24gb24gY2hhbmdpbmcgdGhlIHBhcmFtIHRvIHRoZSBwcm9wb3NlZFZhbHVlLlxuICpcbiAqIEBwYXJhbSB7UmVjb3JkPHN0cmluZywgUGFyYW1WYWx1ZT59IGNoYW5nZXNcbiAqIEByZXR1cm5zIHtQYXJhbUNoYW5nZVBvc2l0aW9uc31cbiAqLyRo4oCNX29uY2UuQ09OVFJBQ1RfRUxFQ1RPUkFURShDT05UUkFDVF9FTEVDVE9SQVRFKTtcbmNvbnN0IG1ha2VQYXJhbUNoYW5nZVBvc2l0aW9ucz0oY2hhbmdlcyk9Pntcbi8qKiBAdHlwZSB7Q2hhbmdlUGFyYW1zUG9zaXRpb259ICovXG5jb25zdCBwb3NpdGl2ZT17Y2hhbmdlc307XG5jb25zdCBuYW1lc09ubHk9T2JqZWN0LmtleXMoY2hhbmdlcyk7XG5jb25zdCBuZWdhdGl2ZT17bm9DaGFuZ2U6bmFtZXNPbmx5fTtcbnJldHVybiBoYXJkZW4oe3Bvc2l0aXZlLG5lZ2F0aXZlfSk7XG4gfTtcblxuLyoqXG4gKiBhc3NlcnQgdGhhdCB0aGUgcGFyYW1ldGVyIGRlc2NyaWJlZCBieSBwYXJhbVNwZWMgaXMgcHJvcG9zZWQgdG8gYmUgY2hhbmdlZCBpblxuICogdGhlIHF1ZXN0aW9uIGRlc2NyaWJlZCBieSBxdWVzdGlvblNwZWMuXG4gKlxuICogQHBhcmFtIHt7IHBhcmFtZXRlck5hbWU6IHN0cmluZywgcGFyYW1QYXRoOiB1bmtub3dufX0gcGFyYW1TcGVjXG4gKiBAcGFyYW0ge1F1ZXN0aW9uU3BlYzxQYXJhbUNoYW5nZUlzc3VlPHVua25vd24+Pn0gcXVlc3Rpb25TcGVjXG4gKi8kaOKAjV9vbmNlLm1ha2VQYXJhbUNoYW5nZVBvc2l0aW9ucyhtYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMpO1xuY29uc3QgYXNzZXJ0QmFsbG90Q29uY2VybnNQYXJhbT0ocGFyYW1TcGVjLHF1ZXN0aW9uU3BlYyk9Pntcbm11c3RNYXRjaChxdWVzdGlvblNwZWMsUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUpO1xuXG5jb25zdHtwYXJhbWV0ZXJOYW1lLHBhcmFtUGF0aH09cGFyYW1TcGVjO1xuY29uc3R7aXNzdWV9PXF1ZXN0aW9uU3BlYztcbmlzc3VlLnNwZWMuY2hhbmdlc1twYXJhbWV0ZXJOYW1lXXx8XG5GYWlsIGBRdWVzdGlvbiAoJHtpc3N1ZS5zcGVjLmNoYW5nZXN9KSBkb2VzIG5vdCBjb25jZXJuICR7cGFyYW1ldGVyTmFtZX1gO1xua2V5RVEoaXNzdWUuc3BlYy5wYXJhbVBhdGgscGFyYW1QYXRoKXx8XG5GYWlsIGBRdWVzdGlvbiBwYXRoICgke2lzc3VlLnNwZWMucGFyYW1QYXRofSkgZG9lc24ndCBtYXRjaCByZXF1ZXN0ICgke3BhcmFtUGF0aH0pYDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7RVJlZjxQYXJhbU1hbmFnZXJSZXRyaWV2ZXI+fSBwYXJhbU1hbmFnZXJSZXRyaWV2ZXJcbiAqIEBwYXJhbSB7SW5zdGFuY2V9IGNvbnRyYWN0SW5zdGFuY2VcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVyU2VydmljZX0gdGltZXJcbiAqIEBwYXJhbSB7KCkgPT4gUHJvbWlzZTxQb3NlckZhY2V0Pn0gZ2V0VXBkYXRlZFBvc2VyRmFjZXRcbiAqIEByZXR1cm5zIHtQYXJhbUdvdmVybm9yfVxuICovJGjigI1fb25jZS5hc3NlcnRCYWxsb3RDb25jZXJuc1BhcmFtKGFzc2VydEJhbGxvdENvbmNlcm5zUGFyYW0pO1xuY29uc3Qgc2V0dXBQYXJhbUdvdmVybmFuY2U9KFxucGFyYW1NYW5hZ2VyUmV0cmlldmVyLFxuY29udHJhY3RJbnN0YW5jZSxcbnRpbWVyLFxuZ2V0VXBkYXRlZFBvc2VyRmFjZXQpPT5cbntcbi8qKiBAdHlwZSB7V2Vha1NldDxJbnN0YW5jZT59ICovXG5jb25zdCB2b3RlQ291bnRlcnM9bmV3IFdlYWtTZXQoKTtcblxuLyoqIEB0eXBlIHtWb3RlT25QYXJhbUNoYW5nZXN9ICovXG5jb25zdCB2b3RlT25QYXJhbUNoYW5nZXM9YXN5bmMoXG52b3RlQ291bnRlckluc3RhbGxhdGlvbixcbmRlYWRsaW5lLFxucGFyYW1TcGVjKT0+XG57XG5jb25zdCBwYXJhbU1ncj1hd2FpdCBFKHBhcmFtTWFuYWdlclJldHJpZXZlcikuZ2V0KHBhcmFtU3BlYy5wYXJhbVBhdGgpO1xuY29uc3QgY2hhbmdlUHM9e307XG5mb3IoY29uc3QgbmFtZSBvZiBPYmplY3Qua2V5cyhwYXJhbVNwZWMuY2hhbmdlcykpe1xuY29uc3QgcHJvcG9zZWRWYWx1ZT1FKHBhcmFtTWdyKS5nZXRWaXNpYmxlVmFsdWUoXG5uYW1lLFxucGFyYW1TcGVjLmNoYW5nZXNbbmFtZV0pO1xuXG5jaGFuZ2VQc1tuYW1lXT1wcm9wb3NlZFZhbHVlO1xuIH1cbmNvbnN0IGNoYW5nZXM9YXdhaXQgZGVlcGx5RnVsZmlsbGVkKGhhcmRlbihjaGFuZ2VQcykpO1xuXG5jb25zdHtwb3NpdGl2ZSxuZWdhdGl2ZX09bWFrZVBhcmFtQ2hhbmdlUG9zaXRpb25zKGNoYW5nZXMpO1xuXG4vKiogQHR5cGUge1BhcmFtQ2hhbmdlSXNzdWU8dW5rbm93bj59ICovXG5jb25zdCBpc3N1ZT1oYXJkZW4oe1xuc3BlYzp7XG5wYXJhbVBhdGg6cGFyYW1TcGVjLnBhcmFtUGF0aCxcbmNoYW5nZXN9LFxuXG5jb250cmFjdDpjb250cmFjdEluc3RhbmNlfSk7XG5cblxuY29uc3QgcXVlc3Rpb25TcGVjPWNvZXJjZVF1ZXN0aW9uU3BlYyh7XG5tZXRob2Q6Q2hvaWNlTWV0aG9kLlVOUkFOS0VELFxuaXNzdWUsXG5wb3NpdGlvbnM6W3Bvc2l0aXZlLG5lZ2F0aXZlXSxcbmVsZWN0aW9uVHlwZTpFbGVjdGlvblR5cGUuUEFSQU1fQ0hBTkdFLFxubWF4Q2hvaWNlczoxLFxubWF4V2lubmVyczoxLFxuY2xvc2luZ1J1bGU6e3RpbWVyLGRlYWRsaW5lfSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZS5NQUpPUklUWSxcbnRpZU91dGNvbWU6bmVnYXRpdmV9KTtcblxuXG5jb25zdHtwdWJsaWNGYWNldDpjb3VudGVyUHVibGljRmFjZXQsaW5zdGFuY2U6dm90ZUNvdW50ZXJ9PWF3YWl0IEUoXG5nZXRVcGRhdGVkUG9zZXJGYWNldCgpKS5cbmFkZFF1ZXN0aW9uKHZvdGVDb3VudGVySW5zdGFsbGF0aW9uLHF1ZXN0aW9uU3BlYyk7XG5cbnZvdGVDb3VudGVycy5hZGQodm90ZUNvdW50ZXIpO1xuXG4vKiBDUlVDSUFMOiBIZXJlIHdlIHdhaXQgZm9yIHRoZSB2b3RlQ291bnRlciB0byBkZWNsYXJlIGFuIG91dGNvbWUsIGFuZCB0aGVuKi9cbi8qIGF0dGVtcHQgdG8gdXBkYXRlIHRoZSB2YWx1ZSBvZiB0aGUgcGFyYW1ldGVyIGlmIHRoYXQncyB3aGF0IHRoZSB2b3RlKi9cbi8qIGRlY2lkZWQuIFdlIG5lZWQgdG8gbWFrZSBzdXJlIHRoYXQgb3V0Y29tZU9mVXBkYXRlUCBpcyB1cGRhdGVkIHdoYXRldmVyKi9cbi8qIGhhcHBlbnMuKi9cbi8qICogSWYgdGhlIHZvdGUgd2FzIG5lZ2F0aXZlLCByZXNvbHZlIHRvIHRoZSBvdXRjb21lKi9cbi8qICogSWYgd2UgdXBkYXRlIHRoZSB2YWx1ZSwgc2F5IHNvKi9cbi8qICogSWYgdGhlIHVwZGF0ZSBmYWlscywgcmVqZWN0IHRoZSBwcm9taXNlKi9cbi8qICogaWYgdGhlIHZvdGUgb3V0Y29tZSBmYWlsZWQsIHJlamVjdCB0aGUgcHJvbWlzZS4qL1xuY29uc3Qgb3V0Y29tZU9mVXBkYXRlPUUoY291bnRlclB1YmxpY0ZhY2V0KS5cbmdldE91dGNvbWUoKS5cbnRoZW4oYXN5bmMob3V0Y29tZSk9PntcbmlmKGtleUVRKHBvc2l0aXZlLG91dGNvbWUpKXtcbnJldHVybiBFLndoZW4oXG5FKHBhcmFtTWdyKS51cGRhdGVQYXJhbXMocGFyYW1TcGVjLmNoYW5nZXMpLFxuKCk9PnBvc2l0aXZlKTtcblxuIH1cbnJldHVybiBuZWdhdGl2ZTtcbiB9KTtcblxucmV0dXJue1xub3V0Y29tZU9mVXBkYXRlLFxuaW5zdGFuY2U6dm90ZUNvdW50ZXIsXG5kZXRhaWxzOkUoY291bnRlclB1YmxpY0ZhY2V0KS5nZXREZXRhaWxzKCl9O1xuXG4gfTtcblxucmV0dXJuIEZhcigncGFyYW1Hb3Zlcm5vcicse1xudm90ZU9uUGFyYW1DaGFuZ2VzLFxuY3JlYXRlZFF1ZXN0aW9uOihiKT0+dm90ZUNvdW50ZXJzLmhhcyhiKX0pO1xuXG4gfTskaOKAjV9vbmNlLnNldHVwUGFyYW1Hb3Zlcm5hbmNlKHNldHVwUGFyYW1Hb3Zlcm5hbmNlKTtcblxuaGFyZGVuKHNldHVwUGFyYW1Hb3Zlcm5hbmNlKTtcbmhhcmRlbihtYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMpO1xuaGFyZGVuKGFzc2VydEJhbGxvdENvbmNlcm5zUGFyYW0pO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNPTlRSQUNUX0VMRUNUT1JBVEUiOlsiQ09OVFJBQ1RfRUxFQ1RPUkFURSJdLCJtYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMiOlsibWFrZVBhcmFtQ2hhbmdlUG9zaXRpb25zIl0sImFzc2VydEJhbGxvdENvbmNlcm5zUGFyYW0iOlsiYXNzZXJ0QmFsbG90Q29uY2VybnNQYXJhbSJdLCJzZXR1cFBhcmFtR292ZXJuYW5jZSI6WyJzZXR1cFBhcmFtR292ZXJuYW5jZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABjU9t7B0IAAAdCAABHAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJuYW5jZS9wYXJhbU1hbmFnZXIuanN7ImltcG9ydHMiOlsiLi4vY29uc3RhbnRzLmpzIiwiLi9hc3NlcnRpb25zLmpzIiwiLi9nb3Zlcm5QYXJhbS5qcyIsIkBhZ29yaWMvZXJ0cCIsIkBhZ29yaWMvaW50ZXJuYWwiLCJAYWdvcmljL3N0b3JlIiwiQGFnb3JpYy96b2Uvc3JjL2NsZWFuUHJvcG9zYWwuanMiLCJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vbWFyc2hhbCIsIkBlbmRvL25hdCJdLCJleHBvcnRzIjpbImFzc2VydEVsZWN0b3JhdGVNYXRjaGVzIiwibWFrZVBhcmFtTWFuYWdlckJ1aWxkZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRmFyLHBhc3NTdHlsZU9mLEFtb3VudE1hdGgsYXNzZXJ0S2V5d29yZE5hbWUsTmF0LGtleUVRLG1ha2VTY2FsYXJNYXBTdG9yZSxFLGFzc2VydEFsbERlZmluZWQsUGFyYW1UeXBlcyxhc3NlcnRUaW1lc3RhbXAsYXNzZXJ0UmVsYXRpdmVUaW1lLG1ha2VBc3NlcnRCcmFuZGVkUmF0aW8sbWFrZUFzc2VydEluc3RhbGxhdGlvbixtYWtlQXNzZXJ0SW5zdGFuY2UsbWFrZUxvb2tzTGlrZUJyYW5kLENPTlRSQUNUX0VMRUNUT1JBVEU7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL2VydHBcIiwgW1tcIkFtb3VudE1hdGhcIiwgWyRo4oCNX2EgPT4gKEFtb3VudE1hdGggPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy96b2Uvc3JjL2NsZWFuUHJvcG9zYWwuanNcIiwgW1tcImFzc2VydEtleXdvcmROYW1lXCIsIFskaOKAjV9hID0+IChhc3NlcnRLZXl3b3JkTmFtZSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9uYXRcIiwgW1tcIk5hdFwiLCBbJGjigI1fYSA9PiAoTmF0ID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV0sW1wibWFrZVNjYWxhck1hcFN0b3JlXCIsIFskaOKAjV9hID0+IChtYWtlU2NhbGFyTWFwU3RvcmUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL2ludGVybmFsXCIsIFtbXCJhc3NlcnRBbGxEZWZpbmVkXCIsIFskaOKAjV9hID0+IChhc3NlcnRBbGxEZWZpbmVkID0gJGjigI1fYSldXV1dLFtcIi4uL2NvbnN0YW50cy5qc1wiLCBbW1wiUGFyYW1UeXBlc1wiLCBbJGjigI1fYSA9PiAoUGFyYW1UeXBlcyA9ICRo4oCNX2EpXV1dXSxbXCIuL2Fzc2VydGlvbnMuanNcIiwgW1tcImFzc2VydFRpbWVzdGFtcFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0VGltZXN0YW1wID0gJGjigI1fYSldXSxbXCJhc3NlcnRSZWxhdGl2ZVRpbWVcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlbGF0aXZlVGltZSA9ICRo4oCNX2EpXV0sW1wibWFrZUFzc2VydEJyYW5kZWRSYXRpb1wiLCBbJGjigI1fYSA9PiAobWFrZUFzc2VydEJyYW5kZWRSYXRpbyA9ICRo4oCNX2EpXV0sW1wibWFrZUFzc2VydEluc3RhbGxhdGlvblwiLCBbJGjigI1fYSA9PiAobWFrZUFzc2VydEluc3RhbGxhdGlvbiA9ICRo4oCNX2EpXV0sW1wibWFrZUFzc2VydEluc3RhbmNlXCIsIFskaOKAjV9hID0+IChtYWtlQXNzZXJ0SW5zdGFuY2UgPSAkaOKAjV9hKV1dLFtcIm1ha2VMb29rc0xpa2VCcmFuZFwiLCBbJGjigI1fYSA9PiAobWFrZUxvb2tzTGlrZUJyYW5kID0gJGjigI1fYSldXV1dLFtcIi4vZ292ZXJuUGFyYW0uanNcIiwgW1tcIkNPTlRSQUNUX0VMRUNUT1JBVEVcIiwgWyRo4oCNX2EgPT4gKENPTlRSQUNUX0VMRUNUT1JBVEUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e0ZhaWwscXVvdGU6cX09YXNzZXJ0O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFyYW1NYW5hZ2VyQmFzZX0gcGFyYW1NYW5hZ2VyXG4gKiBAcGFyYW0ge3tbQ09OVFJBQ1RfRUxFQ1RPUkFURV06IFBhcmFtVmFsdWVUeXBlZDwnaW52aXRhdGlvbic+fX0gZ292ZXJuZWRQYXJhbXNcbiAqL1xuY29uc3QgYXNzZXJ0RWxlY3RvcmF0ZU1hdGNoZXM9KHBhcmFtTWFuYWdlcixnb3Zlcm5lZFBhcmFtcyk9PntcbmNvbnN0IG1hbmFnZXJFbGVjdG9yYXRlPVxucGFyYW1NYW5hZ2VyLmdldEludml0YXRpb25BbW91bnQoQ09OVFJBQ1RfRUxFQ1RPUkFURSk7XG5jb25zdHtcbltDT05UUkFDVF9FTEVDVE9SQVRFXTp7dmFsdWU6cGFyYW1FbGVjdG9yYXRlfX09XG5nb3Zlcm5lZFBhcmFtcztcbnBhcmFtRWxlY3RvcmF0ZXx8XG5GYWlsIGBNaXNzaW5nICR7cShDT05UUkFDVF9FTEVDVE9SQVRFKX0gdGVybSBpbiAke3EoZ292ZXJuZWRQYXJhbXMpfWA7XG5rZXlFUShtYW5hZ2VyRWxlY3RvcmF0ZSxwYXJhbUVsZWN0b3JhdGUpfHxcbkZhaWwgYEVsZWN0b3JhdGUgaW4gbWFuYWdlciAoJHttYW5hZ2VyRWxlY3RvcmF0ZX0pfSBpbmNvbXBhdGlibGUgd2l0aCB0ZXJtcyAoJHtwYXJhbUVsZWN0b3JhdGV9YDtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFBhcmFtTWFuYWdlckJ1aWxkZXJcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IEFtb3VudCkgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gYWRkQW1vdW50XG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBCcmFuZCkgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gYWRkQnJhbmRcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IEluc3RhbGxhdGlvbikgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gYWRkSW5zdGFsbGF0aW9uXG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBJbnN0YW5jZSkgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gYWRkSW5zdGFuY2VcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IEludml0YXRpb24pID0+IFBhcmFtTWFuYWdlckJ1aWxkZXJ9IGFkZEludml0YXRpb25cbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IGJpZ2ludCkgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gYWRkTmF0XG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBSYXRpbykgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gYWRkUmF0aW9cbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IFhpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5Db3B5UmVjb3JkPHVua25vd24+KSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSBhZGRSZWNvcmRcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IHN0cmluZykgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gYWRkU3RyaW5nXG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wKSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSBhZGRUaW1lc3RhbXBcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IFhpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5SZWxhdGl2ZVRpbWUpID0+IFBhcmFtTWFuYWdlckJ1aWxkZXJ9IGFkZFJlbGF0aXZlVGltZVxuICogQHByb3BlcnR5IHsobmFtZTogc3RyaW5nLCB2YWx1ZTogYW55KSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSBhZGRVbmtub3duXG4gKiBAcHJvcGVydHkgeygpID0+IEFueVBhcmFtTWFuYWdlcn0gYnVpbGRcbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy9ub3RpZmllcicpLlN0b3JlZFB1Ymxpc2hlcktpdDxHb3Zlcm5hbmNlU3Vic2NyaXB0aW9uU3RhdGU+fSBwdWJsaXNoZXJLaXRcbiAqIEBwYXJhbSB7RVJlZjxab2VTZXJ2aWNlPn0gW3pvZV1cbiAqLyRo4oCNX29uY2UuYXNzZXJ0RWxlY3RvcmF0ZU1hdGNoZXMoYXNzZXJ0RWxlY3RvcmF0ZU1hdGNoZXMpO1xuY29uc3QgbWFrZVBhcmFtTWFuYWdlckJ1aWxkZXI9KHB1Ymxpc2hlcktpdCx6b2UpPT57XG4vKiogQHR5cGUge01hcFN0b3JlPEtleXdvcmQsIGFueT59ICovXG5jb25zdCBuYW1lc1RvUGFyYW1zPW1ha2VTY2FsYXJNYXBTdG9yZSgnUGFyYW1ldGVyIE5hbWUnKTtcbmNvbnN0e3B1Ymxpc2hlcixzdWJzY3JpYmVyfT1wdWJsaXNoZXJLaXQ7XG5hc3NlcnRBbGxEZWZpbmVkKHtwdWJsaXNoZXIsc3Vic2NyaWJlcn0pO1xuXG5jb25zdCBnZXR0ZXJzPXt9O1xuY29uc3Qgc2V0dGVycz17fTtcbmNvbnN0IHVuZmluaXNoZWRQYXJhbXM9W107XG5cbi8qIFhYWCBsZXQgcGFyYW1zIGJlIGZpbmlzaGVkIGFzeW5jLiBBIGNvbmNlc3Npb24gdG8gdXBncmFkYWJpbGl0eSovXG4vKiBVTlRJTCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzNDMqL1xuY29uc3QgZmluaXNoQnVpbGRpbmc9YXN5bmMoKT0+e1xuYXdhaXQgUHJvbWlzZS5hbGwodW5maW5pc2hlZFBhcmFtcyk7XG51bmZpbmlzaGVkUGFyYW1zLmxlbmd0aD0wO1xuIH07XG5cbmNvbnN0IHB1Ymxpc2g9KCk9Pntcbi8qKiBAdHlwZSB7UGFyYW1TdGF0ZVJlY29yZH0gKi9cbmNvbnN0IGN1cnJlbnQ9T2JqZWN0LmZyb21FbnRyaWVzKFxuWy4uLm5hbWVzVG9QYXJhbXMuZW50cmllcygpXS5tYXAoKFtrLHZdKT0+W2ssdi5tYWtlRGVzY3JpcHRpb24oKV0pKTtcblxucHVibGlzaGVyLnVwZGF0ZVN0YXRlKHtjdXJyZW50fSk7XG4gfTtcblxuLyoqXG4gKiBTdXBwb3J0IGZvciBwYXJhbWV0ZXJzIHRoYXQgYXJlIGNvcHkgb2JqZWN0c1xuICpcbiAqIEBzZWUgYnVpbGRJbnZpdGF0aW9uUGFyYW1cbiAqXG4gKiBAcGFyYW0ge0tleXdvcmR9IG5hbWVcbiAqIEBwYXJhbSB7dW5rbm93bn0gdmFsdWVcbiAqIEBwYXJhbSB7KHZhbCkgPT4gdm9pZH0gYXNzZXJ0aW9uXG4gKiBAcGFyYW0ge1BhcmFtVHlwZX0gdHlwZVxuICovXG5jb25zdCBidWlsZENvcHlQYXJhbT0obmFtZSx2YWx1ZSxhc3NlcnRpb24sdHlwZSk9PntcbmxldCBjdXJyZW50O1xuYXNzZXJ0S2V5d29yZE5hbWUobmFtZSk7XG52YWx1ZSE9PXVuZGVmaW5lZHx8RmFpbCBgcGFyYW0gJHtxKG5hbWUpfSBtdXN0IGJlIGRlZmluZWRgO1xuXG5jb25zdCBzZXRQYXJhbVZhbHVlPShuZXdWYWx1ZSk9PntcbmFzc2VydGlvbihuZXdWYWx1ZSk7XG5jdXJyZW50PW5ld1ZhbHVlO1xucmV0dXJuIGhhcmRlbih7W25hbWVdOm5ld1ZhbHVlfSk7XG4gfTtcbnNldFBhcmFtVmFsdWUodmFsdWUpO1xuXG5jb25zdCBnZXRWaXNpYmxlVmFsdWU9KHByb3Bvc2VkKT0+e1xuYXNzZXJ0aW9uKHByb3Bvc2VkKTtcbnJldHVybiBwcm9wb3NlZDtcbiB9O1xuXG5jb25zdCBwdWJsaWNNZXRob2RzPUZhciggYFBhcmFtZXRlciAke25hbWV9YCx7XG5nZXRWYWx1ZTooKT0+Y3VycmVudCxcbmFzc2VydFR5cGU6YXNzZXJ0aW9uLFxubWFrZURlc2NyaXB0aW9uOigpPT4oe3R5cGUsdmFsdWU6Y3VycmVudH0pLFxuZ2V0VmlzaWJsZVZhbHVlLFxuZ2V0VHlwZTooKT0+dHlwZX0pO1xuXG5cbi8qIG5hbWVzIGFyZSBrZXl3b3JkcyBzbyB0aGV5IHdpbGwgbmVjZXNzYXJpbHkgYmUgVGl0bGVDYXNlKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5nZXR0ZXJzWyBgZ2V0JHtuYW1lfWBdPSgpPT5nZXRUeXBlZFBhcmFtKHR5cGUsbmFtZSk7XG4vKiBDUlVDSUFMOiBoZXJlIHdlJ3JlIGNyZWF0aW5nIHRoZSB1cGRhdGUgZnVuY3Rpb25zIHRoYXQgY2FuIGNoYW5nZSB0aGUqL1xuLyogdmFsdWVzIG9mIHRoZSBnb3Zlcm5lZCBjb250cmFjdCdzIHBhcmFtZXRlcnMuIFdlJ2xsIHJldHVybiB0aGUgdXBkYXRlRm5zKi9cbi8qIHRvIG91ciBjYWxsZXIuIFRoZXkgbXVzdCBoYW5kbGUgdGhlbSBjYXJlZnVsbHkgdG8gZW5zdXJlIHRoYXQgdGhleSBlbmQgdXAqL1xuLyogaW4gYXBwcm9wcmlhdGUgaGFuZHMuKi9cbnNldHRlcnNbIGB1cGRhdGUke25hbWV9YF09c2V0UGFyYW1WYWx1ZTtcbnNldHRlcnNbIGBwcmVwYXJlVG9VcGRhdGUke25hbWV9YF09KHByb3Bvc2VkVmFsdWUpPT5wcm9wb3NlZFZhbHVlO1xubmFtZXNUb1BhcmFtcy5pbml0KG5hbWUscHVibGljTWV0aG9kcyk7XG4gfTtcblxuLyogSEFORExFUlMgRk9SIEVBQ0ggUEFSQU1FVEVSIFRZUEUgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiogQHR5cGUgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBBbW91bnQsIGJ1aWxkZXI6IFBhcmFtTWFuYWdlckJ1aWxkZXIpID0+IFBhcmFtTWFuYWdlckJ1aWxkZXJ9ICovXG5jb25zdCBhZGRBbW91bnQ9KG5hbWUsdmFsdWUsYnVpbGRlcik9PntcbmNvbnN0IGFzc2VydEFtb3VudD0oYSk9PntcbmEuYnJhbmR8fEZhaWwgYEV4cGVjdGVkIGFuIEFtb3VudCBmb3IgJHtxKG5hbWUpfSwgZ290OiAke2F9YDtcbnJldHVybiBBbW91bnRNYXRoLmNvZXJjZSh2YWx1ZS5icmFuZCxhKTtcbiB9O1xuYnVpbGRDb3B5UGFyYW0obmFtZSx2YWx1ZSxhc3NlcnRBbW91bnQsUGFyYW1UeXBlcy5BTU9VTlQpO1xucmV0dXJuIGJ1aWxkZXI7XG4gfTtcblxuLyoqIEB0eXBlIHsobmFtZTogc3RyaW5nLCB2YWx1ZTogQnJhbmQsIGJ1aWxkZXI6IFBhcmFtTWFuYWdlckJ1aWxkZXIpID0+IFBhcmFtTWFuYWdlckJ1aWxkZXJ9ICovXG5jb25zdCBhZGRCcmFuZD0obmFtZSx2YWx1ZSxidWlsZGVyKT0+e1xuY29uc3QgYXNzZXJ0QnJhbmQ9bWFrZUxvb2tzTGlrZUJyYW5kKG5hbWUpO1xuYnVpbGRDb3B5UGFyYW0obmFtZSx2YWx1ZSxhc3NlcnRCcmFuZCxQYXJhbVR5cGVzLkJSQU5EKTtcbnJldHVybiBidWlsZGVyO1xuIH07XG5cbi8qKiBAdHlwZSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IEluc3RhbGxhdGlvbjx1bmtub3duPiwgYnVpbGRlcjogUGFyYW1NYW5hZ2VyQnVpbGRlcikgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gKi9cbmNvbnN0IGFkZEluc3RhbGxhdGlvbj0obmFtZSx2YWx1ZSxidWlsZGVyKT0+e1xuY29uc3QgYXNzZXJ0SW5zdGFsbGF0aW9uPW1ha2VBc3NlcnRJbnN0YWxsYXRpb24obmFtZSk7XG5idWlsZENvcHlQYXJhbShuYW1lLHZhbHVlLGFzc2VydEluc3RhbGxhdGlvbixQYXJhbVR5cGVzLklOU1RBTExBVElPTik7XG5yZXR1cm4gYnVpbGRlcjtcbiB9O1xuXG4vKiogQHR5cGUgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBJbnN0YW5jZSwgYnVpbGRlcjogUGFyYW1NYW5hZ2VyQnVpbGRlcikgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gKi9cbmNvbnN0IGFkZEluc3RhbmNlPShuYW1lLHZhbHVlLGJ1aWxkZXIpPT57XG5jb25zdCBhc3NlcnRJbnN0YW5jZT1tYWtlQXNzZXJ0SW5zdGFuY2UobmFtZSk7XG5idWlsZENvcHlQYXJhbShuYW1lLHZhbHVlLGFzc2VydEluc3RhbmNlLFBhcmFtVHlwZXMuSU5TVEFOQ0UpO1xucmV0dXJuIGJ1aWxkZXI7XG4gfTtcblxuLyoqIEB0eXBlIHsobmFtZTogc3RyaW5nLCB2YWx1ZTogYmlnaW50LCBidWlsZGVyOiBQYXJhbU1hbmFnZXJCdWlsZGVyKSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSAqL1xuY29uc3QgYWRkTmF0PShuYW1lLHZhbHVlLGJ1aWxkZXIpPT57XG5jb25zdCBhc3NlcnROYXQ9KHYpPT57XG5hc3NlcnQudHlwZW9mKHYsJ2JpZ2ludCcpO1xuTmF0KHYpO1xucmV0dXJuIHRydWU7XG4gfTtcbmJ1aWxkQ29weVBhcmFtKG5hbWUsdmFsdWUsYXNzZXJ0TmF0LFBhcmFtVHlwZXMuTkFUKTtcbnJldHVybiBidWlsZGVyO1xuIH07XG5cbi8qKiBAdHlwZSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IFJhdGlvLCBidWlsZGVyOiBQYXJhbU1hbmFnZXJCdWlsZGVyKSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSAqL1xuY29uc3QgYWRkUmF0aW89KG5hbWUsdmFsdWUsYnVpbGRlcik9PntcbmNvbnN0IGFzc2VydEJyYW5kZWRSYXRpbz1tYWtlQXNzZXJ0QnJhbmRlZFJhdGlvKG5hbWUsdmFsdWUpO1xuYnVpbGRDb3B5UGFyYW0obmFtZSx2YWx1ZSxhc3NlcnRCcmFuZGVkUmF0aW8sUGFyYW1UeXBlcy5SQVRJTyk7XG5yZXR1cm4gYnVpbGRlcjtcbiB9O1xuXG4vKiogQHR5cGUgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ29weVJlY29yZDx1bmtub3duPiwgYnVpbGRlcjogUGFyYW1NYW5hZ2VyQnVpbGRlcikgPT4gUGFyYW1NYW5hZ2VyQnVpbGRlcn0gKi9cbmNvbnN0IGFkZFJlY29yZD0obmFtZSx2YWx1ZSxidWlsZGVyKT0+e1xuY29uc3QgYXNzZXJ0UmVjb3JkPSh2KT0+e1xucGFzc1N0eWxlT2Yodik7XG5hc3NlcnQudHlwZW9mKHYsJ29iamVjdCcpO1xuIH07XG5idWlsZENvcHlQYXJhbShuYW1lLHZhbHVlLGFzc2VydFJlY29yZCxQYXJhbVR5cGVzLlBBU1NBQkxFX1JFQ09SRCk7XG5yZXR1cm4gYnVpbGRlcjtcbiB9O1xuXG4vKiogQHR5cGUgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcsIGJ1aWxkZXI6IFBhcmFtTWFuYWdlckJ1aWxkZXIpID0+IFBhcmFtTWFuYWdlckJ1aWxkZXJ9ICovXG5jb25zdCBhZGRTdHJpbmc9KG5hbWUsdmFsdWUsYnVpbGRlcik9PntcbmNvbnN0IGFzc2VydFN0cmluZz0odik9PmFzc2VydC50eXBlb2Yodiwnc3RyaW5nJyk7XG5idWlsZENvcHlQYXJhbShuYW1lLHZhbHVlLGFzc2VydFN0cmluZyxQYXJhbVR5cGVzLlNUUklORyk7XG5yZXR1cm4gYnVpbGRlcjtcbiB9O1xuXG4vKiogQHR5cGUgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wLCBidWlsZGVyOiBQYXJhbU1hbmFnZXJCdWlsZGVyKSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSAqL1xuY29uc3QgYWRkVGltZXN0YW1wPShuYW1lLHZhbHVlLGJ1aWxkZXIpPT57XG5idWlsZENvcHlQYXJhbShuYW1lLHZhbHVlLGFzc2VydFRpbWVzdGFtcCxQYXJhbVR5cGVzLlRJTUVTVEFNUCk7XG5yZXR1cm4gYnVpbGRlcjtcbiB9O1xuXG4vKiogQHR5cGUgeyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuUmVsYXRpdmVUaW1lLCBidWlsZGVyOiBQYXJhbU1hbmFnZXJCdWlsZGVyKSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSAqL1xuY29uc3QgYWRkUmVsYXRpdmVUaW1lPShuYW1lLHZhbHVlLGJ1aWxkZXIpPT57XG5idWlsZENvcHlQYXJhbShuYW1lLHZhbHVlLGFzc2VydFJlbGF0aXZlVGltZSxQYXJhbVR5cGVzLlJFTEFUSVZFX1RJTUUpO1xucmV0dXJuIGJ1aWxkZXI7XG4gfTtcblxuLyoqIEB0eXBlIHsobmFtZTogc3RyaW5nLCB2YWx1ZTogYW55LCBidWlsZGVyOiBQYXJhbU1hbmFnZXJCdWlsZGVyKSA9PiBQYXJhbU1hbmFnZXJCdWlsZGVyfSAqL1xuY29uc3QgYWRkVW5rbm93bj0obmFtZSx2YWx1ZSxidWlsZGVyKT0+e1xuY29uc3QgYXNzZXJ0VW5rbm93bj0oX3YpPT50cnVlO1xuYnVpbGRDb3B5UGFyYW0obmFtZSx2YWx1ZSxhc3NlcnRVbmtub3duLFBhcmFtVHlwZXMuVU5LTk9XTik7XG5yZXR1cm4gYnVpbGRlcjtcbiB9O1xuXG5jb25zdCBhc3NlcnRJbnZpdGF0aW9uPWFzeW5jKGkpPT57XG5pZighem9lKXtcbnRocm93IEZhaWwgYHpvZSBtdXN0IGJlIHByb3ZpZGVkIGZvciBnb3Zlcm5lZCBJbnZpdGF0aW9ucyAke3pvZX1gO1xuIH1cbmNvbnN0e2luc3RhbmNlLGluc3RhbGxhdGlvbn09YXdhaXQgRSh6b2UpLmdldEludml0YXRpb25EZXRhaWxzKGkpO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9wcmVmZXItdHMtZXhwZWN0LWVycm9yIC0tIHRoZSBidWlsZCBjb25maWcgZG9lc24ndCBleHBlY3QgYW4gZXJyb3IgaGVyZSovXG4vKiBAdHMtaWdub3JlIHR5cGVkZWZzIHNheSB0aGV5J3JlIGd1YXJhbnRlZWQgdHJ1dGh5IGJ1dCBqdXN0IHRvIGJlIHNhZmUqL1xuYXNzZXJ0KGluc3RhbmNlJiZpbnN0YWxsYXRpb24sJ211c3QgYmUgYW4gaW52aXRhdGlvbicpO1xuIH07XG5cbi8qKlxuICogSW52aXRhdGlvbnMgYXJlIGNsb3NlbHkgaGVsZCwgc28gd2Ugc2hvdWxkIHB1YmxpY2x5IHJldmVhbCBvbmx5IHRoZSBhbW91bnQuXG4gKiBUaGUgYXBwcm9hY2ggaGVyZSBtYWtlcyBpdCBwb3NzaWJsZSBmb3IgY29udHJhY3RzIHRvIGdldCB0aGUgYWN0dWFsXG4gKiBpbnZpdGF0aW9uIHByaXZhdGVseSwgYW5kIGxlZ2libHkgYXNzdXJlIGNsaWVudHMgdGhhdCBpdCBtYXRjaGVzIHRoZVxuICogcHVibGljbHkgdmlzaWJsZSBpbnZpdGF0aW9uIGFtb3VudC4gQ29udHJhY3QgcmV2aWV3ZXJzIHN0aWxsIGhhdmUgdG9cbiAqIG1hbnVhbGx5IHZlcmlmeSB0aGF0IHRoZSBhY3R1YWwgaW52aXRhdGlvbiBpcyBoYW5kbGVkIGNhcmVmdWxseS5cbiAqIGBnZXRJbnRlcm5hbFZhbHVlKClgIHdpbGwgb25seSBiZSBhY2Nlc3NpYmxlIHdpdGhpbiB0aGUgY29udHJhY3QuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IG5hbWVcbiAqIEBwYXJhbSB7SW52aXRhdGlvbn0gaW52aXRhdGlvblxuICovXG5jb25zdCBidWlsZEludml0YXRpb25QYXJhbT0obmFtZSxpbnZpdGF0aW9uKT0+e1xuaWYoIXpvZSl7XG50aHJvdyBGYWlsIGB6b2UgbXVzdCBiZSBwcm92aWRlZCBmb3IgZ292ZXJuZWQgSW52aXRhdGlvbnMgJHt6b2V9YDtcbiB9XG5sZXQgY3VycmVudEludml0YXRpb247XG5sZXQgY3VycmVudEFtb3VudDtcblxuLyoqXG4gKiBAdHlwZWRlZiB7W0ludml0YXRpb24sIEFtb3VudF19IFNldEludml0YXRpb25QYXJhbVxuICovXG5cbi8qKlxuICogQXN5bmMgcGhhc2UgdG8gcHJlcGFyZSBmb3Igc3luY2hyb25vdXMgc2V0dGluZ1xuICpcbiAqIEBwYXJhbSB7SW52aXRhdGlvbn0gaW52aXRlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxTZXRJbnZpdGF0aW9uUGFyYW0+fVxuICovXG5jb25zdCBwcmVwYXJlVG9TZXRJbnZpdGF0aW9uPWFzeW5jKGludml0ZSk9PntcbmNvbnN0W3ByZXBhcmVkQW1vdW50XT1hd2FpdCBQcm9taXNlLmFsbChbXG5FKEUoem9lKS5nZXRJbnZpdGF0aW9uSXNzdWVyKCkpLmdldEFtb3VudE9mKGludml0ZSksXG5hc3NlcnRJbnZpdGF0aW9uKGludml0ZSldKTtcblxuXG5yZXR1cm5baW52aXRlLHByZXBhcmVkQW1vdW50XTtcbiB9O1xuXG4vKipcbiAqIFN5bmNocm9ub3VzIHBoYXNlIG9mIHZhbHVlIHNldHRpbmdcbiAqXG4gKiBAcGFyYW0ge1NldEludml0YXRpb25QYXJhbX0gcGFyYW0wXG4gKi9cbmNvbnN0IHNldEludml0YXRpb249KFtuZXdJbnZpdGF0aW9uLGFtb3VudF0pPT57XG5jdXJyZW50QW1vdW50PWFtb3VudDtcbmN1cnJlbnRJbnZpdGF0aW9uPW5ld0ludml0YXRpb247XG5yZXR1cm4gaGFyZGVuKHtbbmFtZV06Y3VycmVudEFtb3VudH0pO1xuIH07XG5cbmNvbnN0IG1ha2VEZXNjcmlwdGlvbj0oKT0+e1xucmV0dXJue3R5cGU6UGFyYW1UeXBlcy5JTlZJVEFUSU9OLHZhbHVlOmN1cnJlbnRBbW91bnR9O1xuIH07XG5cbmNvbnN0IGdldFZpc2libGVWYWx1ZT1hc3luYyhhbGxlZ2VkSW52aXRhdGlvbik9PlxuRShFKHpvZSkuZ2V0SW52aXRhdGlvbklzc3VlcigpKS5nZXRBbW91bnRPZihhbGxlZ2VkSW52aXRhdGlvbik7XG5cbmNvbnN0IHB1YmxpY01ldGhvZHM9RmFyKCBgUGFyYW1ldGVyICR7bmFtZX1gLHtcbmdldFZhbHVlOigpPT5jdXJyZW50QW1vdW50LFxuZ2V0SW50ZXJuYWxWYWx1ZTooKT0+Y3VycmVudEludml0YXRpb24sXG5hc3NlcnRUeXBlOmFzc2VydEludml0YXRpb24sXG5tYWtlRGVzY3JpcHRpb24sXG5nZXRUeXBlOigpPT5QYXJhbVR5cGVzLklOVklUQVRJT04sXG5nZXRWaXNpYmxlVmFsdWV9KTtcblxuXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuZ2V0dGVyc1sgYGdldCR7bmFtZX1gXT0oKT0+Z2V0VHlwZWRQYXJhbShQYXJhbVR5cGVzLklOVklUQVRJT04sbmFtZSk7XG4vKiBDUlVDSUFMOiBoZXJlIHdlJ3JlIGNyZWF0aW5nIHRoZSB1cGRhdGUgZnVuY3Rpb25zIHRoYXQgY2FuIGNoYW5nZSB0aGUqL1xuLyogdmFsdWVzIG9mIHRoZSBnb3Zlcm5lZCBjb250cmFjdCdzIHBhcmFtZXRlcnMuIFdlJ2xsIHJldHVybiB1cGRhdGVQYXJhbXMqL1xuLyogKHdoaWNoIGNhbiBpbnZva2UgYWxsIG9mIHRoZW0pIHRvIG91ciBjYWxsZXIuIFRoZXkgbXVzdCBoYW5kbGUgaXQqL1xuLyogY2FyZWZ1bGx5IHRvIGVuc3VyZSB0aGF0IHRoZXkgZW5kIHVwIGluIGFwcHJvcHJpYXRlIGhhbmRzLiovXG5zZXR0ZXJzWyBgcHJlcGFyZVRvVXBkYXRlJHtuYW1lfWBdPXByZXBhcmVUb1NldEludml0YXRpb247XG5zZXR0ZXJzWyBgdXBkYXRlJHtuYW1lfWBdPXNldEludml0YXRpb247XG5cbi8qIFhYWCBsZXQgdGhlIHZhbHVlIGJlIHNldCBhc3luYy4gQSBjb25jZXNzaW9uIHRvIHVwZ3JhZGFiaWxpdHkqL1xuLyogVU5USUwgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy80MzQzKi9cbmNvbnN0IGZpbmlzaEludml0YXRpb25QYXJhbT1FLndoZW4oXG5wcmVwYXJlVG9TZXRJbnZpdGF0aW9uKGludml0YXRpb24pLFxuKGludml0YXRpb25BbmRBbW91bnQpPT57XG5zZXRJbnZpdGF0aW9uKGludml0YXRpb25BbmRBbW91bnQpO1xuLyogZGVsYXkgdW50aWwgY3VycmVudEFtb3VudCBpcyBkZWZpbmVkIGJlY2F1c2UgcmVhZGVycyBleHBlY3QgYSB2YWxpZCB2YWx1ZSovXG5uYW1lc1RvUGFyYW1zLmluaXQobmFtZSxwdWJsaWNNZXRob2RzKTtcbiB9KTtcblxudW5maW5pc2hlZFBhcmFtcy5wdXNoKGZpbmlzaEludml0YXRpb25QYXJhbSk7XG5cbnJldHVybiBuYW1lO1xuIH07XG5cbi8qKiBAdHlwZSB7KG5hbWU6IHN0cmluZywgdmFsdWU6IEludml0YXRpb24sIGJ1aWxkZXI6IFBhcmFtTWFuYWdlckJ1aWxkZXIpID0+IFBhcmFtTWFuYWdlckJ1aWxkZXJ9ICovXG5jb25zdCBhZGRJbnZpdGF0aW9uPShuYW1lLHZhbHVlLGJ1aWxkZXIpPT57XG5hc3NlcnRLZXl3b3JkTmFtZShuYW1lKTtcbnZhbHVlIT09bnVsbHx8RmFpbCBgcGFyYW0gJHtxKG5hbWUpfSBtdXN0IGJlIGRlZmluZWRgO1xuXG5idWlsZEludml0YXRpb25QYXJhbShuYW1lLHZhbHVlKTtcblxucmV0dXJuIGJ1aWxkZXI7XG4gfTtcblxuLyogUEFSQU0gTUFOQUdFUiBNRVRIT0RTIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG5jb25zdCBnZXRUeXBlZFBhcmFtPSh0eXBlLG5hbWUpPT57XG5jb25zdCBwYXJhbT1uYW1lc1RvUGFyYW1zLmdldChuYW1lKTtcbnR5cGU9PT1wYXJhbS5nZXRUeXBlKCl8fEZhaWwgYCR7bmFtZX0gaXMgbm90ICR7dHlwZX1gO1xucmV0dXJuIHBhcmFtLmdldFZhbHVlKCk7XG4gfTtcblxuY29uc3QgZ2V0VmlzaWJsZVZhbHVlPShuYW1lLHByb3Bvc2VkKT0+e1xuY29uc3QgcGFyYW09bmFtZXNUb1BhcmFtcy5nZXQobmFtZSk7XG5yZXR1cm4gcGFyYW0uZ2V0VmlzaWJsZVZhbHVlKHByb3Bvc2VkKTtcbiB9O1xuXG4vKiBzaG91bGQgYmUgZXhwb3NlZCB3aXRoaW4gY29udHJhY3RzLCBhbmQgbm90IGV4dGVybmFsbHksIGZvciBpbnZpdGF0aW9ucyovXG4vKiogQHR5cGUgeyhuYW1lOiBzdHJpbmcpID0+IFByb21pc2U8SW52aXRhdGlvbj59ICovXG5jb25zdCBnZXRJbnRlcm5hbFBhcmFtVmFsdWU9YXN5bmMobmFtZSk9PntcbmF3YWl0IGZpbmlzaEJ1aWxkaW5nKCk7XG5yZXR1cm4gbmFtZXNUb1BhcmFtcy5nZXQobmFtZSkuZ2V0SW50ZXJuYWxWYWx1ZSgpO1xuIH07XG5cbmNvbnN0IGdldFBhcmFtcz1hc3luYygpPT57XG5hd2FpdCBmaW5pc2hCdWlsZGluZygpO1xuLyoqIEB0eXBlIHtQYXJhbVN0YXRlUmVjb3JkfSAqL1xuY29uc3QgZGVzY3JpcHRpb25zPXt9O1xuZm9yKGNvbnN0W25hbWUscGFyYW1db2YgbmFtZXNUb1BhcmFtcy5lbnRyaWVzKCkpe1xuZGVzY3JpcHRpb25zW25hbWVdPXBhcmFtLm1ha2VEZXNjcmlwdGlvbigpO1xuIH1cbnJldHVybiBoYXJkZW4oZGVzY3JpcHRpb25zKTtcbiB9O1xuXG4vKiogQHR5cGUge1VwZGF0ZVBhcmFtc30gKi9cbmNvbnN0IHVwZGF0ZVBhcmFtcz1hc3luYyhwYXJhbUNoYW5nZXMpPT57XG5hd2FpdCBmaW5pc2hCdWlsZGluZygpO1xuY29uc3QgcGFyYW1OYW1lcz1PYmplY3Qua2V5cyhwYXJhbUNoYW5nZXMpO1xuXG4vKiBwcm9taXNlcyB0byBwcmVwYXJlIGV2ZXJ5IHVwZGF0ZSovXG5jb25zdCBhc3luY1Jlc3VsdHM9cGFyYW1OYW1lcy5tYXAoKG5hbWUpPT5cbnNldHRlcnNbIGBwcmVwYXJlVG9VcGRhdGUke25hbWV9YF0ocGFyYW1DaGFuZ2VzW25hbWVdKSk7XG5cbi8qIGlmIGFueSB1cGRhdGUgZG9lc24ndCBzdWNjZWVkLCBmYWlsIHRoZSByZXF1ZXN0Ki9cbmNvbnN0IHByZXBhcmVkPWF3YWl0IFByb21pc2UuYWxsKGFzeW5jUmVzdWx0cyk7XG5cbi8qIGFjdHVhbGx5IHVwZGF0ZSovXG5wYXJhbU5hbWVzLmZvckVhY2goKG5hbWUsaSk9PntcbmNvbnN0IHNldEZuPXNldHRlcnNbIGB1cGRhdGUke25hbWV9YF07XG5zZXRGbihwcmVwYXJlZFtpXSk7XG4gfSk7XG5wdWJsaXNoKCk7XG4gfTtcblxuLyogQ2FsbGVkIGFmdGVyIGFsbCBwYXJhbXMgaGF2ZSBiZWVuIGFkZGVkIHdpdGggdGhlaXIgaW5pdGlhbCB2YWx1ZXMqL1xuY29uc3QgYnVpbGQ9KCk9Pntcbi8qIFhYWCBsZXQgcGFyYW1zIGJlIGZpbmlzaGVkIGFzeW5jLiBBIGNvbmNlc3Npb24gdG8gdXBncmFkYWJpbGl0eSovXG4vKiBVTlRJTCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzNDMqL1xuRS53aGVuKGZpbmlzaEJ1aWxkaW5nKCksKCk9PnB1Ymxpc2goKSk7XG5cbi8qIENSVUNJQUw6IENvbnRyYWN0cyB0aGF0IGNhbGwgYnVpbGRQYXJhbU1hbmFnZXIgc2hvdWxkIG9ubHkgZXhwb3J0IHRoZSovXG4vKiByZXN1bHRpbmcgcGFyYW1NYW5hZ2VyIHRvIHRoZWlyIGNyZWF0b3JGYWNldCwgd2hlcmUgaXQgd2lsbCBiZSBwaWNrZWQgdXAgYnkqL1xuLyogY29udHJhY3RHb3Zlcm5vci4gVGhlIGdldFBhcmFtcyBtZXRob2QgY2FuIGJlIHNoYXJlZCB3aWRlbHkuKi9cbnJldHVybiBGYXIoJ3BhcmFtIG1hbmFnZXInLHtcbmdldFBhcmFtcyxcbmdldFN1YnNjcmlwdGlvbjooKT0+c3Vic2NyaWJlcixcbmdldEFtb3VudDoobmFtZSk9PmdldFR5cGVkUGFyYW0oUGFyYW1UeXBlcy5BTU9VTlQsbmFtZSksXG5nZXRCcmFuZDoobmFtZSk9PmdldFR5cGVkUGFyYW0oUGFyYW1UeXBlcy5CUkFORCxuYW1lKSxcbmdldEluc3RhbmNlOihuYW1lKT0+Z2V0VHlwZWRQYXJhbShQYXJhbVR5cGVzLklOU1RBTkNFLG5hbWUpLFxuZ2V0SW5zdGFsbGF0aW9uOihuYW1lKT0+Z2V0VHlwZWRQYXJhbShQYXJhbVR5cGVzLklOU1RBTExBVElPTixuYW1lKSxcbmdldEludml0YXRpb25BbW91bnQ6KG5hbWUpPT5nZXRUeXBlZFBhcmFtKFBhcmFtVHlwZXMuSU5WSVRBVElPTixuYW1lKSxcbmdldE5hdDoobmFtZSk9PmdldFR5cGVkUGFyYW0oUGFyYW1UeXBlcy5OQVQsbmFtZSksXG5nZXRSYXRpbzoobmFtZSk9PmdldFR5cGVkUGFyYW0oUGFyYW1UeXBlcy5SQVRJTyxuYW1lKSxcbmdldFJlY29yZDoobmFtZSk9PmdldFR5cGVkUGFyYW0oUGFyYW1UeXBlcy5QQVNTQUJMRV9SRUNPUkQsbmFtZSksXG5nZXRTdHJpbmc6KG5hbWUpPT5nZXRUeXBlZFBhcmFtKFBhcmFtVHlwZXMuU1RSSU5HLG5hbWUpLFxuZ2V0VGltZXN0YW1wOihuYW1lKT0+Z2V0VHlwZWRQYXJhbShQYXJhbVR5cGVzLlRJTUVTVEFNUCxuYW1lKSxcbmdldFJlbGF0aXZlVGltZToobmFtZSk9PmdldFR5cGVkUGFyYW0oUGFyYW1UeXBlcy5SRUxBVElWRV9USU1FLG5hbWUpLFxuZ2V0VW5rbm93bjoobmFtZSk9PmdldFR5cGVkUGFyYW0oUGFyYW1UeXBlcy5VTktOT1dOLG5hbWUpLFxuZ2V0VmlzaWJsZVZhbHVlLFxuZ2V0SW50ZXJuYWxQYXJhbVZhbHVlLFxuLyogR2V0dGVycyBhbmQgc2V0dGVycyBmb3IgZWFjaCBwYXJhbSB2YWx1ZSovXG4uLi5nZXR0ZXJzLFxudXBkYXRlUGFyYW1zLFxuLyogQ29sbGVjdGlvbiBvZiBhbGwgZ2V0dGVycyBmb3IgcGFzc2luZyB0byByZWFkLW9ubHkgY29udGV4dHMqL1xucmVhZG9ubHk6KCk9PmhhcmRlbihnZXR0ZXJzKX0pO1xuXG4gfTtcblxuLyoqIEB0eXBlIHtQYXJhbU1hbmFnZXJCdWlsZGVyfSAqL1xuY29uc3QgYnVpbGRlcj17XG5hZGRBbW91bnQ6KG4sdik9PmFkZEFtb3VudChuLHYsYnVpbGRlciksXG5hZGRCcmFuZDoobix2KT0+YWRkQnJhbmQobix2LGJ1aWxkZXIpLFxuYWRkSW5zdGFsbGF0aW9uOihuLHYpPT5hZGRJbnN0YWxsYXRpb24obix2LGJ1aWxkZXIpLFxuYWRkSW5zdGFuY2U6KG4sdik9PmFkZEluc3RhbmNlKG4sdixidWlsZGVyKSxcbmFkZFVua25vd246KG4sdik9PmFkZFVua25vd24obix2LGJ1aWxkZXIpLFxuYWRkSW52aXRhdGlvbjoobix2KT0+YWRkSW52aXRhdGlvbihuLHYsYnVpbGRlciksXG5hZGROYXQ6KG4sdik9PmFkZE5hdChuLHYsYnVpbGRlciksXG5hZGRSYXRpbzoobix2KT0+YWRkUmF0aW8obix2LGJ1aWxkZXIpLFxuYWRkUmVjb3JkOihuLHYpPT5hZGRSZWNvcmQobix2LGJ1aWxkZXIpLFxuYWRkU3RyaW5nOihuLHYpPT5hZGRTdHJpbmcobix2LGJ1aWxkZXIpLFxuYWRkUmVsYXRpdmVUaW1lOihuLHYpPT5hZGRSZWxhdGl2ZVRpbWUobix2LGJ1aWxkZXIpLFxuYWRkVGltZXN0YW1wOihuLHYpPT5hZGRUaW1lc3RhbXAobix2LGJ1aWxkZXIpLFxuYnVpbGR9O1xuXG5yZXR1cm4gYnVpbGRlcjtcbiB9OyRo4oCNX29uY2UubWFrZVBhcmFtTWFuYWdlckJ1aWxkZXIobWFrZVBhcmFtTWFuYWdlckJ1aWxkZXIpO1xuXG5oYXJkZW4oYXNzZXJ0RWxlY3RvcmF0ZU1hdGNoZXMpO1xuaGFyZGVuKG1ha2VQYXJhbU1hbmFnZXJCdWlsZGVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRFbGVjdG9yYXRlTWF0Y2hlcyI6WyJhc3NlcnRFbGVjdG9yYXRlTWF0Y2hlcyJdLCJtYWtlUGFyYW1NYW5hZ2VyQnVpbGRlciI6WyJtYWtlUGFyYW1NYW5hZ2VyQnVpbGRlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABDqMRm5xcAAOcXAABMAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlci5qc3siaW1wb3J0cyI6WyIuLi9jb25zdGFudHMuanMiLCIuL2dvdmVyblBhcmFtLmpzIiwiLi9wYXJhbU1hbmFnZXIuanMiLCJAZW5kby9ldmVudHVhbC1zZW5kIl0sImV4cG9ydHMiOlsibWFrZVBhcmFtTWFuYWdlciIsIm1ha2VQYXJhbU1hbmFnZXJGcm9tVGVybXMiLCJtYWtlUGFyYW1NYW5hZ2VyU3luYyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLFBhcmFtVHlwZXMsQ09OVFJBQ1RfRUxFQ1RPUkFURSxtYWtlUGFyYW1NYW5hZ2VyQnVpbGRlcjskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIi4uL2NvbnN0YW50cy5qc1wiLCBbW1wiUGFyYW1UeXBlc1wiLCBbJGjigI1fYSA9PiAoUGFyYW1UeXBlcyA9ICRo4oCNX2EpXV1dXSxbXCIuL2dvdmVyblBhcmFtLmpzXCIsIFtbXCJDT05UUkFDVF9FTEVDVE9SQVRFXCIsIFskaOKAjV9hID0+IChDT05UUkFDVF9FTEVDVE9SQVRFID0gJGjigI1fYSldXV1dLFtcIi4vcGFyYW1NYW5hZ2VyLmpzXCIsIFtbXCJtYWtlUGFyYW1NYW5hZ2VyQnVpbGRlclwiLCBbJGjigI1fYSA9PiAobWFrZVBhcmFtTWFuYWdlckJ1aWxkZXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5cbi8qKlxuICogQHR5cGVkZWYge1JlY29yZDxLZXl3b3JkLCBQYXJhbVR5cGU+fSBQYXJhbVR5cGVzTWFwXG4gKi9cbi8qKlxuICogQHRlbXBsYXRlIHtQYXJhbVN0YXRlUmVjb3JkfSBNXG4gKiBAdHlwZWRlZiB7eyBbUiBpbiBrZXlvZiBNXTogTVtSXVsndHlwZSddfX0gUGFyYW1UeXBlc01hcEZyb21SZWNvcmRcbiAqL1xuLyoqXG4gKiBAdGVtcGxhdGUge1BhcmFtVHlwZXNNYXB9IE1cbiAqIEB0eXBlZGVmIHt7IFtUIGluIGtleW9mIE1dOiB7IHR5cGU6IE1bVF0sIHZhbHVlOiBQYXJhbVZhbHVlRm9yVHlwZTxNW1RdPiB9IH19IFBhcmFtUmVjb3Jkc0Zyb21UeXBlc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtQYXJhbVR5cGVzTWFwfSBNXG4gKiBAdHlwZWRlZiB7e1xuICogICBbSyBpbiBrZXlvZiBNIGFzIGBnZXQke3N0cmluZyAmIEt9YF06ICgpID0+IFBhcmFtVmFsdWVGb3JUeXBlPE1bS10+XG4gKiB9fSBHZXR0ZXJzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge1BhcmFtVHlwZXNNYXB9IFRcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIFtLIGluIGtleW9mIFQgYXMgYHVwZGF0ZSR7c3RyaW5nICYgS31gXTogKHZhbHVlOiBQYXJhbVZhbHVlRm9yVHlwZTxUW0tdPikgPT4gdm9pZFxuICogfX0gVXBkYXRlcnNcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UGFyYW1UeXBlc01hcH0gTVxuICogQHR5cGVkZWYge1BhcmFtTWFuYWdlckJhc2UgJiBHZXR0ZXJzPE0+ICYgVXBkYXRlcnM8TT4gJiB7cmVhZG9ubHk6ICgpID0+IEdldHRlcnM8TT59ICYge3VwZGF0ZVBhcmFtczogVXBkYXRlUGFyYW1zfX0gVHlwZWRQYXJhbU1hbmFnZXJcbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7UGFyYW1UeXBlfSB0eXBlXG4gKi9cbmNvbnN0IGJ1aWxkZXJNZXRob2ROYW1lPSh0eXBlKT0+XG4gYGFkZCR7dHlwZVswXS50b1VwcGVyQ2FzZSgpK3R5cGUuc3Vic3RyaW5nKDEpfWA7XG5cbi8qKiBAdHlwZSB7UGFydGlhbDxSZWNvcmQ8UGFyYW1UeXBlLCBib29sZWFuPj59ICovXG5jb25zdCBpc0FzeW5jPXtcbmludml0YXRpb246dHJ1ZX07XG5cblxuLyoqXG4gKiBAdGVtcGxhdGUge1BhcmFtVHlwZX0gVFxuICogQHR5cGVkZWYge1t0eXBlOiBULCB2YWx1ZTogUGFyYW1WYWx1ZUZvclR5cGU8VD5dfSBTVCBwYXJhbSBzcGVjIHR1cGxlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7eyB0eXBlOiAnaW52aXRhdGlvbicsIHZhbHVlOiBBbW91bnQ8J3NldCc+IH19IEludml0YXRpb25QYXJhbVxuICovXG5cbi8qIFhYWCBiZXR0ZXIgdG8gdXNlIHRoZSBtYW5pZmVzdCBjb25zdGFudCBQYXJhbVR5cGVzKi9cbi8qIGJ1dCBpbXBvcnRpbmcgdGhhdCBoZXJlIHR1cm5zIHRoaXMgZmlsZSBpbnRvIGEgbW9kdWxlLCovXG4vKiBicmVha2luZyB0aGUgYW1iaWVudCB0eXBpbmcqL1xuLyoqXG4gKiBAdHlwZWRlZiB7U1Q8J2Ftb3VudCc+XG4gKiB8IFNUPCdicmFuZCc+XG4gKiB8IFNUPCdpbnN0YWxsYXRpb24nPlxuICogfCBTVDwnaW5zdGFuY2UnPlxuICogfCBTVDwnbmF0Jz5cbiAqIHwgU1Q8J3JhdGlvJz5cbiAqIHwgU1Q8J3N0cmluZyc+XG4gKiB8IFNUPCd0aW1lc3RhbXAnPlxuICogfCBTVDwncmVsYXRpdmVUaW1lJz5cbiAqIHwgU1Q8J3Vua25vd24nPn0gU3luY1NwZWNUdXBsZVxuICpcbiAqIEB0eXBlZGVmIHtbJ2ludml0YXRpb24nLCBJbnZpdGF0aW9uXX0gQXN5bmNTcGVjVHVwbGVcbiAqL1xuXG4vKipcbiAqIEBzZWUgbWFrZVBhcmFtTWFuYWdlclN5bmNcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPEtleXdvcmQsIEFzeW5jU3BlY1R1cGxlIHwgU3luY1NwZWNUdXBsZT59IFRcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy9ub3RpZmllcicpLlN0b3JlZFB1Ymxpc2hlcktpdDxHb3Zlcm5hbmNlU3Vic2NyaXB0aW9uU3RhdGU+fSBwdWJsaXNoZXJLaXRcbiAqIEBwYXJhbSB7VH0gc3BlY1xuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHJldHVybnMge1R5cGVkUGFyYW1NYW5hZ2VyPHtbSyBpbiBrZXlvZiBUXTogVFtLXVswXX0+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVBhcmFtTWFuYWdlcj0ocHVibGlzaGVyS2l0LHNwZWMsemNmKT0+e1xuY29uc3QgYnVpbGRlcj1tYWtlUGFyYW1NYW5hZ2VyQnVpbGRlcihwdWJsaXNoZXJLaXQsemNmLmdldFpvZVNlcnZpY2UoKSk7XG5cbmNvbnN0IHByb21pc2VzPVtdO1xuZm9yKGNvbnN0W25hbWUsW3R5cGUsdmFsdWVdXW9mIE9iamVjdC5lbnRyaWVzKHNwZWMpKXtcbmNvbnN0IGFkZD1idWlsZGVyW2J1aWxkZXJNZXRob2ROYW1lKHR5cGUpXTtcbmlmKGlzQXN5bmNbdHlwZV0pe1xucHJvbWlzZXMucHVzaChhZGQobmFtZSx2YWx1ZSkpO1xuIH1lbHNle1xuYWRkKG5hbWUsdmFsdWUpO1xuIH1cbiB9XG4vKiBYWFgga2ljayBvZmYgcHJvbWlzZXMgYnV0IGRvbid0IGJsb2NrLiBUaGlzIGlzIGEgY29uY2Vzc2lvbiB0byBjb250cmFjdCByZWluY2FybmF0aW9uKi9cbi8qIHdoaWNoIGNhbm5vdCBibG9jayBvbiBhIHJlbW90ZSBjYWxsLiovXG4vKiBVTlRJTCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQzNDMqL1xudm9pZCBFLndoZW4oUHJvbWlzZS5hbGwocHJvbWlzZXMpLHVuZGVmaW5lZCwocmVhc29uKT0+XG56Y2Yuc2h1dGRvd25XaXRoRmFpbHVyZShyZWFzb24pKTtcblxuXG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xucmV0dXJuIGJ1aWxkZXIuYnVpbGQoKTtcbiB9OyRo4oCNX29uY2UubWFrZVBhcmFtTWFuYWdlcihtYWtlUGFyYW1NYW5hZ2VyKTtcbmhhcmRlbihtYWtlUGFyYW1NYW5hZ2VyKTtcblxuLyoqXG4gKiBVc2VkIG9ubHkgd2hlbiB0aGUgY29udHJhY3QgaGFzIG11bHRpcGxlIHBhcmFtIG1hbmFnZXJzLlxuICogRXhhY3RseSBvbmUgbXVzdCBtYW5hZ2UgdGhlIGVsZWN0b3JhdGUsIHdoaWNoIHJlcXVpcmVzIHRoZSBhc3luYyB2ZXJzaW9uLlxuICpcbiAqIEBzZWUgbWFrZVBhcmFtTWFuYWdlclxuICogQHRlbXBsYXRlIHtSZWNvcmQ8S2V5d29yZCwgU3luY1NwZWNUdXBsZT59IFRcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy9ub3RpZmllcicpLlN0b3JlZFB1Ymxpc2hlcktpdDxHb3Zlcm5hbmNlU3Vic2NyaXB0aW9uU3RhdGU+fSBwdWJsaXNoZXJLaXRcbiAqIEBwYXJhbSB7VH0gc3BlY1xuICogQHJldHVybnMge1R5cGVkUGFyYW1NYW5hZ2VyPHtbSyBpbiBrZXlvZiBUXTogVFtLXVswXX0+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVBhcmFtTWFuYWdlclN5bmM9KHB1Ymxpc2hlcktpdCxzcGVjKT0+e1xuY29uc3QgYnVpbGRlcj1tYWtlUGFyYW1NYW5hZ2VyQnVpbGRlcihwdWJsaXNoZXJLaXQpO1xuXG5mb3IoY29uc3RbbmFtZSxbdHlwZSx2YWx1ZV1db2YgT2JqZWN0LmVudHJpZXMoc3BlYykpe1xuY29uc3QgYWRkPWJ1aWxkZXJbYnVpbGRlck1ldGhvZE5hbWUodHlwZSldO1xuYWRkfHxGYWlsIGBObyBidWlsZGVyIG1ldGhvZCBmb3IgcGFyYW0gdHlwZSAke3EodHlwZSl9YDtcbmFkZChuYW1lLHZhbHVlKTtcbiB9XG5cbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCovXG5yZXR1cm4gYnVpbGRlci5idWlsZCgpO1xuIH07JGjigI1fb25jZS5tYWtlUGFyYW1NYW5hZ2VyU3luYyhtYWtlUGFyYW1NYW5hZ2VyU3luYyk7XG5oYXJkZW4obWFrZVBhcmFtTWFuYWdlclN5bmMpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgSW52aXRhdGlvbj4gJiB7RWxlY3RvcmF0ZTogSW52aXRhdGlvbn19IEkgUHJpdmF0ZSBpbnZpdGF0aW9uIHZhbHVlc1xuICogQHRlbXBsYXRlIHtQYXJhbVR5cGVzTWFwfSBNIE1hcCBvZiB0eXBlcyBvZiBjdXN0b20gZ292ZXJuZWQgdGVybXNcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy9ub3RpZmllcicpLlN0b3JlZFB1Ymxpc2hlcktpdDxHb3Zlcm5hbmNlU3Vic2NyaXB0aW9uU3RhdGU+fSBwdWJsaXNoZXJLaXRcbiAqIEBwYXJhbSB7WkNGPEdvdmVybmFuY2VUZXJtczxNPj59IHpjZlxuICogQHBhcmFtIHtJfSBpbnZpdGF0aW9ucyBpbnZpdGF0aW9uIG9iamVjdHMsIHdoaWNoIG11c3QgY29tZSBmcm9tIHByaXZhdGVBcmdzXG4gKiBAcGFyYW0ge019IHBhcmFtVHlwZXNNYXBcbiAqIEByZXR1cm5zIHtUeXBlZFBhcmFtTWFuYWdlcjxNICYge1tLIGluIGtleW9mIEldOiAnaW52aXRhdGlvbid9Pn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VQYXJhbU1hbmFnZXJGcm9tVGVybXM9KFxucHVibGlzaGVyS2l0LFxuemNmLFxuaW52aXRhdGlvbnMsXG5wYXJhbVR5cGVzTWFwKT0+XG57XG5jb25zdHtnb3Zlcm5lZFBhcmFtc309emNmLmdldFRlcm1zKCk7XG4vKiogQHR5cGUge0FycmF5PFtLZXl3b3JkLCBTeW5jU3BlY1R1cGxlIHwgQXN5bmNTcGVjVHVwbGVdPn0gKi9cbmNvbnN0IG1ha2VyU3BlY0VudHJpZXM9T2JqZWN0LmVudHJpZXMocGFyYW1UeXBlc01hcCkubWFwKFxuKFtwYXJhbUtleSxwYXJhbVR5cGVdKT0+W1xucGFyYW1LZXksXG4vKiogQHR5cGUge1N5bmNTcGVjVHVwbGV9ICovW1xucGFyYW1UeXBlLFxuZ292ZXJuZWRQYXJhbXNbcGFyYW1LZXldLnZhbHVlXV0pO1xuXG5cblxuLyogRXZlcnkgZ292ZXJuZWQgY29udHJhY3QgaGFzIGFuIEVsZWN0b3JhdGUgcGFyYW0gdGhhdCBzdGFydHMgYXMgYGluaXRpYWxQb3Nlckludml0YXRpb25gIHByaXZhdGUgYXJnKi9cbmZvcihjb25zdFtuYW1lLGludml0YXRpb25db2YgT2JqZWN0LmVudHJpZXMoaW52aXRhdGlvbnMpKXtcbm1ha2VyU3BlY0VudHJpZXMucHVzaChbbmFtZSxbUGFyYW1UeXBlcy5JTlZJVEFUSU9OLGludml0YXRpb25dXSk7XG4gfVxuY29uc3QgbWFrZXJTcGVjPU9iamVjdC5mcm9tRW50cmllcyhtYWtlclNwZWNFbnRyaWVzKTtcbm1ha2VyU3BlY1tDT05UUkFDVF9FTEVDVE9SQVRFXXx8XG5GYWlsIGBtaXNzaW5nIEVsZWN0b3JhdGUgaW52aXRhdGlvbiBwYXJhbSB2YWx1ZWA7XG5cbi8qIEB0cy1leHBlY3QtZXJyb3IgY2FzdCovXG5yZXR1cm4gbWFrZVBhcmFtTWFuYWdlcihwdWJsaXNoZXJLaXQsbWFrZXJTcGVjLHpjZik7XG4gfTskaOKAjV9vbmNlLm1ha2VQYXJhbU1hbmFnZXJGcm9tVGVybXMobWFrZVBhcmFtTWFuYWdlckZyb21UZXJtcyk7XG5oYXJkZW4obWFrZVBhcmFtTWFuYWdlckZyb21UZXJtcyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVBhcmFtTWFuYWdlciI6WyJtYWtlUGFyYW1NYW5hZ2VyIl0sIm1ha2VQYXJhbU1hbmFnZXJTeW5jIjpbIm1ha2VQYXJhbU1hbmFnZXJTeW5jIl0sIm1ha2VQYXJhbU1hbmFnZXJGcm9tVGVybXMiOlsibWFrZVBhcmFtTWFuYWdlckZyb21UZXJtcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABQmJSYDyMAAA8jAAA4AAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJub3IuanN7ImltcG9ydHMiOlsiLi9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanMiLCIuL2NvbnRyYWN0R292ZXJub3JLaXQuanMiLCIuL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL2ludGVybmFsIiwiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvZHVyYWJpbGl0eS5qcyIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiXSwiZXhwb3J0cyI6WyJwcmVwYXJlIiwidmFsaWRhdGVRdWVzdGlvbkRldGFpbHMiLCJ2YWxpZGF0ZVF1ZXN0aW9uRnJvbUNvdW50ZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbXVzdE1hdGNoLEUsbWFrZVRyYWNlcixwcm92aWRlU2luZ2xldG9uLENPTlRSQUNUX0VMRUNUT1JBVEUscHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQsUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGU7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL2ludGVybmFsXCIsIFtbXCJtYWtlVHJhY2VyXCIsIFskaOKAjV9hID0+IChtYWtlVHJhY2VyID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvZHVyYWJpbGl0eS5qc1wiLCBbW1wicHJvdmlkZVNpbmdsZXRvblwiLCBbJGjigI1fYSA9PiAocHJvdmlkZVNpbmdsZXRvbiA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5QYXJhbS5qc1wiLCBbW1wiQ09OVFJBQ1RfRUxFQ1RPUkFURVwiLCBbJGjigI1fYSA9PiAoQ09OVFJBQ1RfRUxFQ1RPUkFURSA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvbnRyYWN0R292ZXJub3JLaXQuanNcIiwgW1tcInByZXBhcmVDb250cmFjdEdvdmVybm9yS2l0XCIsIFskaOKAjV9hID0+IChwcmVwYXJlQ29udHJhY3RHb3Zlcm5vcktpdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVHdWFyZHMuanNcIiwgW1tcIlBhcmFtQ2hhbmdlc1F1ZXN0aW9uRGV0YWlsc1NoYXBlXCIsIFskaOKAjV9hID0+IChQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuY29uc3QgdHJhY2U9bWFrZVRyYWNlcignQ0dvdicsZmFsc2UpO1xuXG4vKipcbiAqIFZhbGlkYXRlIHRoYXQgdGhlIHF1ZXN0aW9uIGRldGFpbHMgY29ycmVzcG9uZCB0byBhIHBhcmFtZXRlciBjaGFuZ2UgcXVlc3Rpb25cbiAqIHRoYXQgdGhlIGVsZWN0b3JhdGUgaG9zdHMsIGFuZCB0aGF0IHRoZSB2b3RlQ291bnRlciBhbmQgb3RoZXIgZGV0YWlscyBhcmVcbiAqIGNvbnNpc3RlbnQgd2l0aCBpdC5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8Wm9lU2VydmljZT59IHpvZVxuICogQHBhcmFtIHtJbnN0YW5jZX0gZWxlY3RvcmF0ZVxuICogQHBhcmFtIHtQYXJhbUNoYW5nZUlzc3VlRGV0YWlsc30gZGV0YWlsc1xuICovXG5jb25zdCAgICAgICAgdmFsaWRhdGVRdWVzdGlvbkRldGFpbHM9YXN5bmMoem9lLGVsZWN0b3JhdGUsZGV0YWlscyk9PntcbmNvbnN0e1xuY291bnRlckluc3RhbmNlLFxuaXNzdWU6e2NvbnRyYWN0OmdvdmVybmVkSW5zdGFuY2V9fT1cbmRldGFpbHM7XG5tdXN0TWF0Y2goZGV0YWlscyxQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZSk7XG5cbmNvbnN0IGdvdmVybm9ySW5zdGFuY2U9YXdhaXQgRS5nZXQoRSh6b2UpLmdldFRlcm1zKGdvdmVybmVkSW5zdGFuY2UpKS5cbmVsZWN0aW9uTWFuYWdlcjtcbmNvbnN0IGdvdmVybm9yUHVibGljPUUoem9lKS5nZXRQdWJsaWNGYWNldChnb3Zlcm5vckluc3RhbmNlKTtcblxucmV0dXJuIFByb21pc2UuYWxsKFtcbkUoZ292ZXJub3JQdWJsaWMpLnZhbGlkYXRlVm90ZUNvdW50ZXIoY291bnRlckluc3RhbmNlKSxcbkUoZ292ZXJub3JQdWJsaWMpLnZhbGlkYXRlRWxlY3RvcmF0ZShlbGVjdG9yYXRlKSxcbkUoZ292ZXJub3JQdWJsaWMpLnZhbGlkYXRlVGltZXIoZGV0YWlscy5jbG9zaW5nUnVsZSldKTtcblxuIH07JGjigI1fb25jZS52YWxpZGF0ZVF1ZXN0aW9uRGV0YWlscyh2YWxpZGF0ZVF1ZXN0aW9uRGV0YWlscyk7XG5oYXJkZW4odmFsaWRhdGVRdWVzdGlvbkRldGFpbHMpO1xuXG4vKipcbiAqIFZhbGlkYXRlIHRoYXQgdGhlIHF1ZXN0aW9ucyBjb3VudGVkIGJ5IHRoZSB2b3RlQ291bnRlciBjb3JyZXNwb25kIHRvIGFcbiAqIHBhcmFtZXRlciBjaGFuZ2UgcXVlc3Rpb24gdGhhdCB0aGUgZWxlY3RvcmF0ZSBob3N0cywgYW5kIHRoYXQgdGhlXG4gKiB2b3RlQ291bnRlciBhbmQgb3RoZXIgZGV0YWlscyBhcmUgY29uc2lzdGVudC5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8Wm9lU2VydmljZT59IHpvZVxuICogQHBhcmFtIHtJbnN0YW5jZX0gZWxlY3RvcmF0ZVxuICogQHBhcmFtIHtJbnN0YW5jZX0gdm90ZUNvdW50ZXJcbiAqL1xuY29uc3QgICAgICAgIHZhbGlkYXRlUXVlc3Rpb25Gcm9tQ291bnRlcj1hc3luYyhcbnpvZSxcbmVsZWN0b3JhdGUsXG52b3RlQ291bnRlcik9Plxue1xuY29uc3QgY291bnRlclB1YmxpY1A9RSh6b2UpLmdldFB1YmxpY0ZhY2V0KHZvdGVDb3VudGVyKTtcbmNvbnN0IHF1ZXN0aW9uRGV0YWlscz1hd2FpdCBFKGNvdW50ZXJQdWJsaWNQKS5nZXREZXRhaWxzKCk7XG5cbnJldHVybiB2YWxpZGF0ZVF1ZXN0aW9uRGV0YWlscyh6b2UsZWxlY3RvcmF0ZSxxdWVzdGlvbkRldGFpbHMpO1xuIH07JGjigI1fb25jZS52YWxpZGF0ZVF1ZXN0aW9uRnJvbUNvdW50ZXIodmFsaWRhdGVRdWVzdGlvbkZyb21Db3VudGVyKTtcbmhhcmRlbih2YWxpZGF0ZVF1ZXN0aW9uRnJvbUNvdW50ZXIpO1xuXG4vKipcbiAqIEB0eXBlZGVmIHtTdGFuZGFyZFRlcm1zfSBDb250cmFjdEdvdmVybm9yVGVybXNcbiAqIEBwcm9wZXJ0eSB7WGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVyU2VydmljZX0gdGltZXJcbiAqIEBwcm9wZXJ0eSB7SW5zdGFsbGF0aW9ufSBnb3Zlcm5lZENvbnRyYWN0SW5zdGFsbGF0aW9uXG4gKi9cblxuLyoqXG4gKiBDb250cmFjdEdvdmVybm9yIGlzIGFuIEVsZWN0aW9uTWFuYWdlciB0aGF0IHN0YXJ0cyB1cCBhIGNvbnRyYWN0IGFuZCBoYW5kc1xuICogaXRzIG93biBjcmVhdG9yIGEgZmFjZXQgdGhhdCBhbGxvd3MgdGhlbSB0byBtYW5hZ2UgdGhhdCBjb250cmFjdCdzIEFQSXMsXG4gKiBvZmZlciBmaWx0ZXJzLCBhbmQgcGFyYW1ldGVycy5cbiAqXG4gKiBUaGUgdGVybXMgZm9yIHRoaXMgY29udHJhY3QgaW5jbHVkZSB0aGUgVGltZXIsIGFuZCB0aGUgSW5zdGFsbGF0aW9uIHRvIGJlXG4gKiBzdGFydGVkLCBhcyB3ZWxsIGFzIGFuIGlzc3VlcktleXdvcmRSZWNvcmQgb3IgdGVybXMgbmVlZGVkIGJ5IHRoZSBnb3Zlcm5lZFxuICogY29udHJhY3QuIFRob3NlIGRldGFpbHMgZm9yIHRoZSBnb3Zlcm5lZCBjb250cmFjdCBhcmUgaW5jbHVkZWQgaW4gdGhpc1xuICogY29udHJhY3QncyB0ZXJtcyBhcyBhIFwiZ292ZXJuZWRcIiByZWNvcmQuIElmIHRoZSBjb250cmFjdCBleHBlY3RzIHByaXZhdGVBcmdzLFxuICogdGhvc2Ugd2lsbCBiZSBwcm92aWRlZCBpbiB0aGlzIGNvbnRyYWN0J3MgYHByaXZhdGVBcmdzYCB1bmRlciAnZ292ZXJuZWQ6Jy5cbiAqXG4gKiB0ZXJtcyA9IHtcbiAqICAgIHRpbWVyLFxuICogICAgZ292ZXJuZWRDb250cmFjdEluc3RhbGxhdGlvbixcbiAqICAgIGdvdmVybmVkOiB7IGlzc3VlcktleXdvcmRSZWNvcmQsIHRlcm1zIH0sXG4gKiB9O1xuICpcbiAqIFRoZSBlbGVjdG9yYXRlIHRoYXQgd2lsbCB2b3RlIG9uIGdvdmVybmFuY2UgcXVlc3Rpb25zIGlzIGl0c2VsZiBhIGdvdmVybmVkXG4gKiBwYXJhbWV0ZXIuIEl0cyB2YWx1ZSBpcyBhdmFpbGFibGUgZnJvbSB0aGUgcHVibGljRmFjZXQgdXNpbmdcbiAqIGdldEVsZWN0b3JhdGVJbnN0YW5jZSgpLiBXaGVuIGNyZWF0aW5nIG5ldyBxdWVzdGlvbnMsIHdlIHVzZVxuICogZ2V0VXBkYXRlZFBvc2VyRmFjZXQoKSB0byBpbmZvcm0gdGhlIGVsZWN0b3JhdGUgYWJvdXQgdGhlIG5ldyBxdWVzdGlvbi5cbiAqXG4gKiBUaGUgZ292ZXJuZWRDb250cmFjdCBpcyByZXNwb25zaWJsZSBmb3Igc3VwcGx5aW5nIGdldFBhcmFtTWdyUmV0cmlldmVyKCkgaW5cbiAqIGl0cyBjcmVhdG9yRmFjZXQuIGdldFBhcmFtTWdyUmV0cmlldmVyKCkgdGFrZXMgYSBQYXJhbVNwZWNpZmljYXRpb24sIHdoaWNoXG4gKiBpZGVudGlmaWVzIHRoZSBwYXJhbWV0ZXIgdG8gYmUgdm90ZWQgb24uIEEgbWluaW1hbCBQYXJhbVNwZWNpZmljYXRpb25cbiAqIHNwZWNpZmllcyB0aGUga2V5IHdoaWNoIGlkZW50aWZpZXMgYSBwYXJ0aWN1bGFyIHBhcmFtTWFuYWdlciAoZXZlbiBpZiB0aGVyZSdzXG4gKiBvbmx5IG9uZSkgYW5kIHRoZSBwYXJhbWV0ZXJOYW1lLiBUaGUgaW50ZXJwcmV0YXRpb24gb2YgUGFyYW1TcGVjaWZpY2F0aW9uIGlzXG4gKiB1cCB0byB0aGUgY29udHJhY3QuXG4gKlxuICogVGhlIGNvbnRyYWN0R292ZXJub3IgY3JlYXRvckZhY2V0IGluY2x1ZGVzIGB2b3RlT25QYXJhbUNoYW5nZXNgLFxuICogYHZvdGVPbkZpbHRlcmAsIGFuZCBgdm90ZU9uQXBpSW52b2NhdGlvbmAuIGB2b3RlT25QYXJhbUNoYW5nZXNgIGlzIHVzZWQgdG9cbiAqIGNyZWF0ZSBxdWVzdGlvbnMgdGhhdCB3aWxsIGF1dG9tYXRpY2FsbHkgdXBkYXRlIGNvbnRyYWN0IHBhcmFtZXRlcnMgaWZcbiAqIHBhc3NlZC4gYHZvdGVPbkZpbHRlcmAgY2FuIGJlIHVzZWQgdG8gY3JlYXRlIHF1ZXN0aW9ucyB0aGF0IHdpbGwgcHJldmVudCB0aGVcbiAqIGV4ZXJjaXNlIG9mIGNlcnRhaW4gaW52aXRhdGlvbnMgaWYgcGFzc2VkLiBgdm90ZU9uQXBpSW52b2NhdGlvbmAgY3JlYXRlc1xuICogcXVlc3Rpb25zIHRoYXQgd2lsbCBpbnZva2UgcHJlLWRlZmluZWQgQVBJcyBpbiB0aGUgY29udHJhY3QuXG4gKlxuICogVGhpcyBmYWNldCB3aWxsIHVzdWFsbHkgYmUgY2xvc2VseSBoZWxkLiBUaGUgY3JlYXRvckZhY2V0IGNhbiBhbHNvIGJlIHVzZWQgdG9cbiAqIHJldHJpZXZlIHRoZSBnb3Zlcm5lZCBpbnN0YW5jZSwgcHVibGljRmFjZXQsIGFuZCBpdHMgY3JlYXRvckZhY2V0IHdpdGhcbiAqIHRoZSB2b3RlT24qKCkgbWV0aG9kcyBvbWl0dGVkLlxuICpcbiAqIFRoZSBnb3Zlcm5lZCBjb250cmFjdCdzIHRlcm1zIGluY2x1ZGUgdGhlIGluc3RhbmNlIG9mIHRoaXMgKGdvdmVybmluZylcbiAqIGNvbnRyYWN0IChhcyBlbGVjdGlvbk1hbmFnZXIpIHNvIGNsaWVudHMgd2lsbCBiZSBhYmxlIHRvIGxvb2sgdXAgdGhlIHN0YXRlXG4gKiBvZiB0aGUgZ292ZXJuZWQgcGFyYW1ldGVycy5cbiAqXG4gKiB0ZW1wbGF0ZSB7e319IFBGIFB1YmxpYyBmYWNldCBvZiBnb3Zlcm5lZFxuICogdGVtcGxhdGUge0NvbnRyYWN0UG93ZXJmdWxDcmVhdG9yRmFjZXR9IENGIENyZWF0b3IgZmFjZXQgb2YgZ292ZXJuZWRcbiAqIHR5cGUge0NvbnRyYWN0U3RhcnRGbjxcbiAqIEdvdmVybm9yUHVibGljLFxuICogR292ZXJub3JDcmVhdG9yRmFjZXQ8UEYsQ0Y+LFxuICoge1xuICogICB0aW1lcjogWGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVyU2VydmljZSxcbiAqICAgZ292ZXJuZWRDb250cmFjdEluc3RhbGxhdGlvbjogSW5zdGFsbGF0aW9uPENGPixcbiAqICAgZ292ZXJuZWQ6IHtcbiAqICAgICBpc3N1ZXJLZXl3b3JkUmVjb3JkOiBJc3N1ZXJLZXl3b3JkUmVjb3JkLFxuICogICAgIHRlcm1zOiB7Z292ZXJuZWRQYXJhbXM6IHtbQ09OVFJBQ1RfRUxFQ1RPUkFURV06IEludml0YXRpb25QYXJhbX19LFxuICogICB9XG4gKiB9Pn1cbiAqL1xuXG4vKipcbiAqIFN0YXJ0IGFuIGluc3RhbmNlIG9mIGEgZ292ZXJub3IsIGdvdmVybmluZyBhIFwiZ292ZXJuZWRcIiBjb250cmFjdCBzcGVjaWZpZWQgaW4gdGVybXMuXG4gKlxuICogQHRlbXBsYXRlIHtHb3Zlcm5hYmxlU3RhcnRGbn0gU0YgU3RhcnQgZnVuY3Rpb24gb2YgZ292ZXJuZWQgY29udHJhY3RcbiAqIEBwYXJhbSB7WkNGPHtcbiAqICAgdGltZXI6IFhpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lclNlcnZpY2UsXG4gKiAgIGdvdmVybmVkQ29udHJhY3RJbnN0YWxsYXRpb246IEluc3RhbGxhdGlvbjxTRj4sXG4gKiAgIGdvdmVybmVkOiB7XG4gKiAgICAgaXNzdWVyS2V5d29yZFJlY29yZDogSXNzdWVyS2V5d29yZFJlY29yZCxcbiAqICAgICB0ZXJtczoge2dvdmVybmVkUGFyYW1zOiB7W0NPTlRSQUNUX0VMRUNUT1JBVEVdOiBYaW1wb3J0KCcuL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlci5qcycpLkludml0YXRpb25QYXJhbX19LFxuICogICAgIGxhYmVsPzogc3RyaW5nLFxuICogICB9XG4gKiB9Pn0gemNmXG4gKiBAcGFyYW0ge3tcbiAqICAgZ292ZXJuZWQ6IFJlY29yZDxzdHJpbmcsIHVua25vd24+XG4gKiB9fSBwcml2YXRlQXJnc1xuICogQHJldHVybnMge1Byb21pc2U8e1xuICogICBjcmVhdG9yRmFjZXQ6IEdvdmVybm9yQ3JlYXRvckZhY2V0PFNGPixcbiAqICAgcHVibGljRmFjZXQ6IEdvdmVybm9yUHVibGljLFxuICogfT59XG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlPWFzeW5jKHpjZixwcml2YXRlQXJncyxiYWdnYWdlKT0+e1xudHJhY2UoJ3ByZXBhcmUnKTtcbmNvbnN0IHpvZT16Y2YuZ2V0Wm9lU2VydmljZSgpO1xudHJhY2UoJ2dldFRlcm1zJyx6Y2YuZ2V0VGVybXMoKSk7XG5jb25zdHtcbnRpbWVyLFxuZ292ZXJuZWRDb250cmFjdEluc3RhbGxhdGlvbixcbmdvdmVybmVkOntcbmlzc3VlcktleXdvcmRSZWNvcmQ6Z292ZXJuZWRJc3N1ZXJLZXl3b3JkUmVjb3JkLFxudGVybXM6Y29udHJhY3RUZXJtcyxcbmxhYmVsOmdvdmVybmVkQ29udHJhY3RMYWJlbH19PVxuXG56Y2YuZ2V0VGVybXMoKTtcbnRyYWNlKCdjb250cmFjdFRlcm1zJyxjb250cmFjdFRlcm1zKTtcbmNvbnRyYWN0VGVybXMuZ292ZXJuZWRQYXJhbXNbQ09OVFJBQ1RfRUxFQ1RPUkFURV18fFxuRmFpbCBgQ29udHJhY3QgbXVzdCBkZWNsYXJlICR7Q09OVFJBQ1RfRUxFQ1RPUkFURX0gYXMgYSBnb3Zlcm5lZCBwYXJhbWV0ZXJgO1xuXG5jb25zdCBtYWtlQ29udHJhY3RHb3Zlcm5vcktpdD1wcmVwYXJlQ29udHJhY3RHb3Zlcm5vcktpdChiYWdnYWdlLHtcbnRpbWVyLFxuem9lfSk7XG5cblxudHJhY2UoJ2F3YWl0aW5nIHByb3ZpZGVTaW5nbGV0b24oKScpO1xuY29uc3QgZ292ZXJub3JLaXQ9YXdhaXQgcHJvdmlkZVNpbmdsZXRvbihcbmJhZ2dhZ2UsXG4nY29udHJhY3RHb3Zlcm5vcktpdCcsXG5hc3luYygpPT57XG5jb25zdCBhdWdtZW50ZWRUZXJtcz1oYXJkZW4oe1xuLi4uY29udHJhY3RUZXJtcyxcbmVsZWN0aW9uTWFuYWdlcjp6Y2YuZ2V0SW5zdGFuY2UoKX0pO1xuXG5cbnRyYWNlKCdzdGFydGluZyBnb3Zlcm5lZENvbnRyYWN0SW5zdGFsbGF0aW9uIG9mJyxnb3Zlcm5lZENvbnRyYWN0TGFiZWwpO1xuY29uc3Qgc3RhcnRlZEluc3RhbmNlS2l0PWF3YWl0IEUoem9lKS5zdGFydEluc3RhbmNlKFxuZ292ZXJuZWRDb250cmFjdEluc3RhbGxhdGlvbixcbmdvdmVybmVkSXNzdWVyS2V5d29yZFJlY29yZCxcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvcHJlZmVyLXRzLWV4cGVjdC1lcnJvciAtLSB0aGUgYnVpbGQgY29uZmlnIGRvZXNuJ3QgZXhwZWN0IGFuIGVycm9yIGhlcmUqL1xuLyogQHRzLWlnbm9yZSBYWFggZ292ZXJuYW5jZSB0eXBlcyBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzcxNzgqL1xuYXVnbWVudGVkVGVybXMsXG5wcml2YXRlQXJncy5nb3Zlcm5lZCxcbmdvdmVybmVkQ29udHJhY3RMYWJlbCk7XG5cbnRyYWNlKCdhd2FpdGluZyByZW1vdGUgbGltaXRlZENyZWF0b3JGYWNldCcpO1xuY29uc3QgbGltaXRlZENyZWF0b3JGYWNldD1hd2FpdCBFKFxuc3RhcnRlZEluc3RhbmNlS2l0LmNyZWF0b3JGYWNldCkuXG5nZXRMaW1pdGVkQ3JlYXRvckZhY2V0KCk7XG5cbnJldHVybiBtYWtlQ29udHJhY3RHb3Zlcm5vcktpdChzdGFydGVkSW5zdGFuY2VLaXQsbGltaXRlZENyZWF0b3JGYWNldCk7XG4gfSk7XG5cblxuLyogQXQgdGhpcyBwb2ludCwgc29tZSByZW1vdGUgY2FsbHMgc3RpbGwgbmVlZCB0byBiZSBtYWRlIHdpdGhpbiB0aGUgZ292ZXJub3JLaXQuKi9cbi8qIFNwZWNpZmljYWxseSwgdG8gdGhlIHZhdCBvZiB0aGUgZ292ZXJuZWQgY29udHJhY3QgZm9yIGl0cyBBUEkgbmFtZXMuIFRoZSBleG8qL1xuLyogZGVmZXJzIHRoYXQgdW50aWwgQVBJIGdvdmVybmFuY2UgaXMgcmVxdWVzdGVkIHRvIGJlIGludm9rZWQgb3IgdmFsaWRhdGVkLiovXG5cbnRyYWNlKCdwcmVwYXJlIGNvbXBsZXRlJyk7XG5cbi8qIENSVUNJQUw6IG9ubHkgY29udHJhY3RHb3Zlcm5vciBzaG91bGQgZ2V0IHRoZSBhYmlsaXR5IHRvIHVwZGF0ZSBwYXJhbXMqL1xucmV0dXJue2NyZWF0b3JGYWNldDpnb3Zlcm5vcktpdC5jcmVhdG9yLHB1YmxpY0ZhY2V0OmdvdmVybm9yS2l0LnB1YmxpY307XG4gfTskaOKAjV9vbmNlLnByZXBhcmUocHJlcGFyZSk7XG5oYXJkZW4ocHJlcGFyZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsidmFsaWRhdGVRdWVzdGlvbkRldGFpbHMiOlsidmFsaWRhdGVRdWVzdGlvbkRldGFpbHMiXSwidmFsaWRhdGVRdWVzdGlvbkZyb21Db3VudGVyIjpbInZhbGlkYXRlUXVlc3Rpb25Gcm9tQ291bnRlciJdLCJwcmVwYXJlIjpbInByZXBhcmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAa2BKrnsdAAB7HQAAOwAAAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybm9yS2l0LmpzeyJpbXBvcnRzIjpbIi4vY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkFwaS5qcyIsIi4vY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkZpbHRlci5qcyIsIi4vY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVyblBhcmFtLmpzIiwiQGFnb3JpYy9hc3NlcnQiLCJAYWdvcmljL2ludGVybmFsIiwiQGFnb3JpYy92YXQtZGF0YSIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiXSwiZXhwb3J0cyI6WyJwcmVwYXJlQ29udHJhY3RHb3Zlcm5vcktpdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYWlsLG1ha2VUcmFjZXIscHJlcGFyZUV4b0NsYXNzS2l0LEUsc2V0dXBBcGlHb3Zlcm5hbmNlLHNldHVwRmlsdGVyR292ZXJuYW5jZSxDT05UUkFDVF9FTEVDVE9SQVRFLHNldHVwUGFyYW1Hb3Zlcm5hbmNlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJGYWlsXCIsIFskaOKAjV9hID0+IChGYWlsID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvaW50ZXJuYWxcIiwgW1tcIm1ha2VUcmFjZXJcIiwgWyRo4oCNX2EgPT4gKG1ha2VUcmFjZXIgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wicHJlcGFyZUV4b0NsYXNzS2l0XCIsIFskaOKAjV9hID0+IChwcmVwYXJlRXhvQ2xhc3NLaXQgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvbnRyYWN0R292ZXJuYW5jZS9nb3Zlcm5BcGkuanNcIiwgW1tcInNldHVwQXBpR292ZXJuYW5jZVwiLCBbJGjigI1fYSA9PiAoc2V0dXBBcGlHb3Zlcm5hbmNlID0gJGjigI1fYSldXV1dLFtcIi4vY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkZpbHRlci5qc1wiLCBbW1wic2V0dXBGaWx0ZXJHb3Zlcm5hbmNlXCIsIFskaOKAjV9hID0+IChzZXR1cEZpbHRlckdvdmVybmFuY2UgPSAkaOKAjV9hKV1dXV0sW1wiLi9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanNcIiwgW1tcIkNPTlRSQUNUX0VMRUNUT1JBVEVcIiwgWyRo4oCNX2EgPT4gKENPTlRSQUNUX0VMRUNUT1JBVEUgPSAkaOKAjV9hKV1dLFtcInNldHVwUGFyYW1Hb3Zlcm5hbmNlXCIsIFskaOKAjV9hID0+IChzZXR1cFBhcmFtR292ZXJuYW5jZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdCB0cmFjZT1tYWtlVHJhY2VyKCdDR0snLGZhbHNlKTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHt7XG4gKiAgIHRpbWVyOiBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXJTZXJ2aWNlLFxuICogICB6b2U6IEVSZWY8Wm9lU2VydmljZT4sXG4gKiB9fSBwb3dlcnNcbiAqL1xuY29uc3QgICAgICAgIHByZXBhcmVDb250cmFjdEdvdmVybm9yS2l0PShiYWdnYWdlLHBvd2Vycyk9Pntcbi8qIFRoZXNlIGFyZSBwcm9kdWNlZCBqdXN0LWluLXRpbWUgYmVjYXVzZSBBUEkgZ292ZXJuYW5jZSBtYWtlcyByZW1vdGUgY2FsbHMsIHdoaWNoIHByZXZlbnQgdmF0IHJlc3RhcnQuKi9cbi8qIFRoZSBvdGhlciB0d28gY291bGQgaGFwcGVuIGR1cmluZyByZXN0YXJ0IGJ1dCB0aGV5J2QgbmVlZCB0byBoYXZlIGEgc2VwYXJhdGUgaG9vaywgc28gZm9yIGNvbnNpc3RlbmN5Ki9cbi8qIHRoZXkncmUgYWxsIGxhenkuKi9cbi8qKiBAdHlwZSB7UmV0dXJuVHlwZTx0eXBlb2Ygc2V0dXBGaWx0ZXJHb3Zlcm5hbmNlPn0gKi9cbmxldCBmaWx0ZXJHb3Zlcm5hbmNlO1xuLyoqIEB0eXBlIHtSZXR1cm5UeXBlPHR5cGVvZiBzZXR1cFBhcmFtR292ZXJuYW5jZT59ICovXG5sZXQgcGFyYW1Hb3Zlcm5hbmNlO1xuLyoqIEB0eXBlIHtBd2FpdGVkPFJldHVyblR5cGU8dHlwZW9mIHNldHVwQXBpR292ZXJuYW5jZT4+fSAqL1xubGV0IGFwaUdvdmVybmFuY2U7XG5cbi8qKiBAdHlwZSB7YW55fSAqL1xubGV0IHBvc2VyRmFjZXQ7XG5cbmNvbnN0IG1ha2VDb250cmFjdEdvdmVybm9yS2l0PXByZXBhcmVFeG9DbGFzc0tpdChcbmJhZ2dhZ2UsXG4nQ29udHJhY3RHb3Zlcm5vcktpdCcsXG51bmRlZmluZWQsXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy96b2Uvc3JjL3pvZVNlcnZpY2UvdXRpbHMuanMnKS5TdGFydGVkSW5zdGFuY2VLaXQ8R292ZXJuYWJsZVN0YXJ0Rm4+fSBzdGFydGVkSW5zdGFuY2VLaXRcbiAqIEBwYXJhbSB7TGltaXRlZENGPHVua25vd24+fSBsaW1pdGVkQ3JlYXRvckZhY2V0XG4gKi9cbihzdGFydGVkSW5zdGFuY2VLaXQsbGltaXRlZENyZWF0b3JGYWNldCk9PntcbnJldHVybntcbi4uLnN0YXJ0ZWRJbnN0YW5jZUtpdCxcbmxpbWl0ZWRDcmVhdG9yRmFjZXQsXG5jdXJyZW50SW52aXRhdGlvbjovKiogQHR5cGUge0ludml0YXRpb248dW5rbm93biwgbmV2ZXI+P30gKi9udWxsfTtcblxuIH0sXG57XG5oZWxwZXI6e1xuLyoqIEB0eXBlIHsoKSA9PiBQcm9taXNlPEluc3RhbmNlPn0gKi9cbiAgICAgIGFzeW5jIGdldEVsZWN0b3JhdGVJbnN0YW5jZSgpe1xuY29uc3R7cHVibGljRmFjZXR9PXRoaXMuc3RhdGU7XG5jb25zdCBpbnZpdGF0aW9uQW1vdW50PWF3YWl0IEUocHVibGljRmFjZXQpLmdldEludml0YXRpb25BbW91bnQoXG5DT05UUkFDVF9FTEVDVE9SQVRFKTtcblxucmV0dXJuIGludml0YXRpb25BbW91bnQudmFsdWVbMF0uaW5zdGFuY2U7XG4gfSxcbi8qKiBAdHlwZSB7KCkgPT4gUHJvbWlzZTxQb3NlckZhY2V0Pn0gKi9cbiAgICAgIGFzeW5jIGdldFVwZGF0ZWRQb3NlckZhY2V0KCl7XG5jb25zdHtjcmVhdG9yRmFjZXR9PXRoaXMuc3RhdGU7XG5jb25zdCBuZXdJbnZpdGF0aW9uPWF3YWl0IEUoXG5FKEUoY3JlYXRvckZhY2V0KS5nZXRQYXJhbU1nclJldHJpZXZlcigpKS5nZXQoe1xua2V5Oidnb3Zlcm5lZFBhcmFtcyd9KSkuXG5cbmdldEludGVybmFsUGFyYW1WYWx1ZShDT05UUkFDVF9FTEVDVE9SQVRFKTtcblxuaWYobmV3SW52aXRhdGlvbiE9PXRoaXMuc3RhdGUuY3VycmVudEludml0YXRpb24pe1xucG9zZXJGYWNldD1FKEUocG93ZXJzLnpvZSkub2ZmZXIobmV3SW52aXRhdGlvbikpLmdldE9mZmVyUmVzdWx0KCk7XG50aGlzLnN0YXRlLmN1cnJlbnRJbnZpdGF0aW9uPW5ld0ludml0YXRpb247XG4gfVxucmV0dXJuIHBvc2VyRmFjZXQ7XG4gfSxcbiAgICAgIGFzeW5jIHByb3ZpZGVBcGlHb3Zlcm5hbmNlKCl7XG5jb25zdHt0aW1lcn09cG93ZXJzO1xuY29uc3R7Y3JlYXRvckZhY2V0fT10aGlzLnN0YXRlO1xuaWYoIWFwaUdvdmVybmFuY2Upe1xudHJhY2UoJ2F3YWl0aW5nIGdvdmVybmVkIEFQSSBkZXBlbmRlbmNpZXMnKTtcbmNvbnN0W2dvdmVybmVkQXBpcyxnb3Zlcm5lZE5hbWVzXT1hd2FpdCBQcm9taXNlLmFsbChbXG5FKGNyZWF0b3JGYWNldCkuZ2V0R292ZXJuZWRBcGlzKCksXG5FKGNyZWF0b3JGYWNldCkuZ2V0R292ZXJuZWRBcGlOYW1lcygpXSk7XG5cbnRyYWNlKCdzZXR1cEFwaUdvdmVybmFuY2UnKTtcbmFwaUdvdmVybmFuY2U9Z292ZXJuZWROYW1lcy5sZW5ndGg/XG5zZXR1cEFwaUdvdmVybmFuY2UoZ292ZXJuZWRBcGlzLGdvdmVybmVkTmFtZXMsdGltZXIsKCk9PlxudGhpcy5mYWNldHMuaGVscGVyLmdldFVwZGF0ZWRQb3NlckZhY2V0KCkpOlxuXG57XG4vKiBpZiB3ZSBhcmVuJ3QgZ292ZXJuaW5nIEFQSXMsIHZvdGVPbkFwaUludm9jYXRpb24gc2hvdWxkbid0IGJlIGNhbGxlZCovXG52b3RlT25BcGlJbnZvY2F0aW9uOigpPT57XG50aHJvdyBFcnJvcignYXBpIGdvdmVybmFuY2Ugbm90IGNvbmZpZ3VyZWQnKTtcbiB9LFxuY3JlYXRlZFF1ZXN0aW9uOigpPT5mYWxzZX07XG5cbiB9XG5yZXR1cm4gYXBpR292ZXJuYW5jZTtcbiB9LFxucHJvdmlkZUZpbHRlckdvdmVybmFuY2UoKXtcbmlmKCFmaWx0ZXJHb3Zlcm5hbmNlKXtcbmNvbnN0e3RpbWVyfT1wb3dlcnM7XG5jb25zdHtjcmVhdG9yRmFjZXR9PXRoaXMuc3RhdGU7XG5maWx0ZXJHb3Zlcm5hbmNlPXNldHVwRmlsdGVyR292ZXJuYW5jZShcbnRpbWVyLFxuKCk9PnRoaXMuZmFjZXRzLmhlbHBlci5nZXRVcGRhdGVkUG9zZXJGYWNldCgpLFxuY3JlYXRvckZhY2V0KTtcblxuIH1cbnJldHVybiBmaWx0ZXJHb3Zlcm5hbmNlO1xuIH0sXG5wcm92aWRlUGFyYW1Hb3Zlcm5hbmNlKCl7XG5pZighcGFyYW1Hb3Zlcm5hbmNlKXtcbmNvbnN0e3RpbWVyfT1wb3dlcnM7XG5jb25zdHtjcmVhdG9yRmFjZXQsaW5zdGFuY2V9PXRoaXMuc3RhdGU7XG5wYXJhbUdvdmVybmFuY2U9c2V0dXBQYXJhbUdvdmVybmFuY2UoXG5FKGNyZWF0b3JGYWNldCkuZ2V0UGFyYW1NZ3JSZXRyaWV2ZXIoKSxcbmluc3RhbmNlLFxudGltZXIsXG4oKT0+dGhpcy5mYWNldHMuaGVscGVyLmdldFVwZGF0ZWRQb3NlckZhY2V0KCkpO1xuXG4gfVxucmV0dXJuIHBhcmFtR292ZXJuYW5jZTtcbiB9fSxcblxuY3JlYXRvcjp7XG4vKipcbiAqIEBwYXJhbSB7SW52aXRhdGlvbn0gcG9zZXJJbnZpdGF0aW9uXG4gKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn1cbiAqL1xucmVwbGFjZUVsZWN0b3JhdGUocG9zZXJJbnZpdGF0aW9uKXtcbmNvbnN0e2NyZWF0b3JGYWNldH09dGhpcy5zdGF0ZTtcbi8qKiBAdHlwZSB7UHJvbWlzZTxYaW1wb3J0KCcuL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlci5qcycpLlR5cGVkUGFyYW1NYW5hZ2VyPHsnRWxlY3RvcmF0ZSc6ICdpbnZpdGF0aW9uJ30+Pn0gKi9cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvcHJlZmVyLXRzLWV4cGVjdC1lcnJvciAtLSB0aGUgYnVpbGQgY29uZmlnIGRvZXNuJ3QgZXhwZWN0IGFuIGVycm9yIGhlcmUqL1xuLyogQHRzLWlnbm9yZSBjYXN0Ki9cbmNvbnN0IHBhcmFtTWdyPUUoRShjcmVhdG9yRmFjZXQpLmdldFBhcmFtTWdyUmV0cmlldmVyKCkpLmdldCh7XG5rZXk6J2dvdmVybmVkUGFyYW1zJ30pO1xuXG5cbi8qIFRPRE8gdXNlIHVwZGF0ZUVsZWN0b3JhdGUqL1xucmV0dXJuIEUocGFyYW1NZ3IpLnVwZGF0ZVBhcmFtcyh7XG5FbGVjdG9yYXRlOnBvc2VySW52aXRhdGlvbn0pO1xuXG4gfSxcbi8qKiBAdHlwZSB7Vm90ZU9uUGFyYW1DaGFuZ2VzfSAqL1xudm90ZU9uUGFyYW1DaGFuZ2VzKHZvdGVDb3VudGVySW5zdGFsbGF0aW9uLGRlYWRsaW5lLHBhcmFtU3BlYyl7XG5jb25zdHtoZWxwZXJ9PXRoaXMuZmFjZXRzO1xucmV0dXJuIGhlbHBlci5cbnByb3ZpZGVQYXJhbUdvdmVybmFuY2UoKS5cbnZvdGVPblBhcmFtQ2hhbmdlcyh2b3RlQ291bnRlckluc3RhbGxhdGlvbixkZWFkbGluZSxwYXJhbVNwZWMpO1xuIH0sXG4vKiogQHR5cGUge1ZvdGVPbkFwaUludm9jYXRpb259ICovXG52b3RlT25BcGlJbnZvY2F0aW9uKFxuYXBpTWV0aG9kTmFtZSxcbm1ldGhvZEFyZ3MsXG52b3RlQ291bnRlckluc3RhbGxhdGlvbixcbmRlYWRsaW5lKVxue1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcbnJldHVybiBFKGhlbHBlci5wcm92aWRlQXBpR292ZXJuYW5jZSgpKS52b3RlT25BcGlJbnZvY2F0aW9uKFxuYXBpTWV0aG9kTmFtZSxcbm1ldGhvZEFyZ3MsXG52b3RlQ291bnRlckluc3RhbGxhdGlvbixcbmRlYWRsaW5lKTtcblxuIH0sXG4vKiogQHR5cGUge1ZvdGVPbk9mZmVyRmlsdGVyfSAqL1xudm90ZU9uT2ZmZXJGaWx0ZXIodm90ZUNvdW50ZXJJbnN0YWxsYXRpb24sZGVhZGxpbmUsc3RyaW5ncyl7XG5jb25zdHtoZWxwZXJ9PXRoaXMuZmFjZXRzO1xucmV0dXJuIGhlbHBlci5cbnByb3ZpZGVGaWx0ZXJHb3Zlcm5hbmNlKCkuXG52b3RlT25GaWx0ZXIodm90ZUNvdW50ZXJJbnN0YWxsYXRpb24sZGVhZGxpbmUsc3RyaW5ncyk7XG4gfSxcbmdldENyZWF0b3JGYWNldCgpe1xucmV0dXJuIHRoaXMuc3RhdGUubGltaXRlZENyZWF0b3JGYWNldDtcbiB9LFxuZ2V0QWRtaW5GYWNldCgpe1xucmV0dXJuIHRoaXMuc3RhdGUuYWRtaW5GYWNldDtcbiB9LFxuZ2V0SW5zdGFuY2UoKXtcbnJldHVybiB0aGlzLnN0YXRlLmluc3RhbmNlO1xuIH0sXG5nZXRQdWJsaWNGYWNldCgpe1xucmV0dXJuIHRoaXMuc3RhdGUucHVibGljRmFjZXQ7XG4gfX0sXG5cbnB1YmxpYzp7XG5nZXRFbGVjdG9yYXRlKCl7XG5jb25zdHtoZWxwZXJ9PXRoaXMuZmFjZXRzO1xucmV0dXJuIGhlbHBlci5nZXRFbGVjdG9yYXRlSW5zdGFuY2UoKTtcbiB9LFxuZ2V0R292ZXJuZWRDb250cmFjdCgpe1xucmV0dXJuIHRoaXMuc3RhdGUuaW5zdGFuY2U7XG4gfSxcbi8qKiBAcGFyYW0ge0luc3RhbmNlfSBjb3VudGVyICovXG4gICAgICBhc3luYyB2YWxpZGF0ZVZvdGVDb3VudGVyKGNvdW50ZXIpe1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcbmNvbnN0IHZhbGlkYXRvcnM9W1xuRS5nZXQoaGVscGVyLnByb3ZpZGVBcGlHb3Zlcm5hbmNlKCkpLFxuaGVscGVyLnByb3ZpZGVGaWx0ZXJHb3Zlcm5hbmNlKCksXG5oZWxwZXIucHJvdmlkZVBhcmFtR292ZXJuYW5jZSgpXTtcblxuY29uc3QgY2hlY2tzPWF3YWl0IFByb21pc2UuYWxsKFxudmFsaWRhdG9ycy5tYXAoKHZhbGlkYXRlKT0+RSh2YWxpZGF0ZS5jcmVhdGVkUXVlc3Rpb24pKGNvdW50ZXIpKSk7XG5cblxuY2hlY2tzLnNvbWUoQm9vbGVhbil8fFxuRmFpbCBgVm90ZUNvdW50ZXIgd2FzIG5vdCBjcmVhdGVkIGJ5IHRoaXMgY29udHJhY3RHb3Zlcm5vcmA7XG4gfSxcbi8qKiBAcGFyYW0ge0luc3RhbmNlfSByZWdQICovXG52YWxpZGF0ZUVsZWN0b3JhdGUocmVnUCl7XG5jb25zdHtoZWxwZXJ9PXRoaXMuZmFjZXRzO1xucmV0dXJuIEUud2hlbihyZWdQLGFzeW5jKHJlZyk9PntcbmNvbnN0IGVsZWN0b3JhdGVJbnN0YW5jZT1hd2FpdCBoZWxwZXIuZ2V0RWxlY3RvcmF0ZUluc3RhbmNlKCk7XG5hc3NlcnQoXG5yZWc9PT1lbGVjdG9yYXRlSW5zdGFuY2UsXG5cIkVsZWN0b3JhdGUgZG9lc24ndCBtYXRjaCBteSBFbGVjdG9yYXRlXCIpO1xuXG4gfSk7XG4gfSxcbi8qKiBAcGFyYW0ge0Nsb3NpbmdSdWxlfSBjbG9zaW5nUnVsZSAqL1xudmFsaWRhdGVUaW1lcihjbG9zaW5nUnVsZSl7XG5hc3NlcnQoXG5jbG9zaW5nUnVsZS50aW1lcj09PXBvd2Vycy50aW1lcixcbidjbG9zaW5nIHJ1bGUgbXVzdCB1c2UgbXkgdGltZXInKTtcblxuIH19fSk7XG5cblxuXG5cbnJldHVybiBtYWtlQ29udHJhY3RHb3Zlcm5vcktpdDtcbiB9O1xuXG4vKiogQHR5cGVkZWYge1JldHVyblR5cGU8UmV0dXJuVHlwZTx0eXBlb2YgcHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQ+Pn0gQ29udHJhY3RHb3Zlcm5vcktpdCAqLyRo4oCNX29uY2UucHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQocHJlcGFyZUNvbnRyYWN0R292ZXJub3JLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVDb250cmFjdEdvdmVybm9yS2l0IjpbInByZXBhcmVDb250cmFjdEdvdmVybm9yS2l0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMUCKeCTKwAAkysAADYAAABAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29udHJhY3RIZWxwZXIuanN7ImltcG9ydHMiOlsiLi9jb250cmFjdEdvdmVybmFuY2UvcGFyYW1NYW5hZ2VyLmpzIiwiLi9jb250cmFjdEdvdmVybmFuY2UvdHlwZWRQYXJhbU1hbmFnZXIuanMiLCIuL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL2VydHAiLCJAYWdvcmljL2ludGVybmFsIiwiQGFnb3JpYy9ub3RpZmllciIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3RpbWUiLCJAYWdvcmljL3ZhdC1kYXRhIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJHT1ZFUk5BTkNFX1NUT1JBR0VfS0VZIiwiaGFuZGxlUGFyYW1Hb3Zlcm5hbmNlIiwicHVibGljTWl4aW5BUEkiLCJ2YWxpZGF0ZUVsZWN0b3JhdGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRmFyLG1ha2VTdG9yZWRQdWJsaXNoZXJLaXQsZ2V0TWV0aG9kTmFtZXMsb2JqZWN0TWFwLGlnbm9yZUNvbnRleHQscHJlcGFyZUV4byxrZXlFUSxNLEFtb3VudFNoYXBlLEJyYW5kU2hhcGUsUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUsVGltZXN0YW1wUmVjb3JkU2hhcGUsRSxhc3NlcnRFbGVjdG9yYXRlTWF0Y2hlcyxtYWtlUGFyYW1NYW5hZ2VyRnJvbVRlcm1zLEdvdmVybm9yRmFjZXRTaGFwZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL25vdGlmaWVyXCIsIFtbXCJtYWtlU3RvcmVkUHVibGlzaGVyS2l0XCIsIFskaOKAjV9hID0+IChtYWtlU3RvcmVkUHVibGlzaGVyS2l0ID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvaW50ZXJuYWxcIiwgW1tcImdldE1ldGhvZE5hbWVzXCIsIFskaOKAjV9hID0+IChnZXRNZXRob2ROYW1lcyA9ICRo4oCNX2EpXV0sW1wib2JqZWN0TWFwXCIsIFskaOKAjV9hID0+IChvYmplY3RNYXAgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wiaWdub3JlQ29udGV4dFwiLCBbJGjigI1fYSA9PiAoaWdub3JlQ29udGV4dCA9ICRo4oCNX2EpXV0sW1wicHJlcGFyZUV4b1wiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4byA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJrZXlFUVwiLCBbJGjigI1fYSA9PiAoa2V5RVEgPSAkaOKAjV9hKV1dLFtcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBbW91bnRTaGFwZVwiLCBbJGjigI1fYSA9PiAoQW1vdW50U2hhcGUgPSAkaOKAjV9hKV1dLFtcIkJyYW5kU2hhcGVcIiwgWyRo4oCNX2EgPT4gKEJyYW5kU2hhcGUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy90aW1lXCIsIFtbXCJSZWxhdGl2ZVRpbWVSZWNvcmRTaGFwZVwiLCBbJGjigI1fYSA9PiAoUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlRpbWVzdGFtcFJlY29yZFNoYXBlXCIsIFskaOKAjV9hID0+IChUaW1lc3RhbXBSZWNvcmRTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIi4vY29udHJhY3RHb3Zlcm5hbmNlL3BhcmFtTWFuYWdlci5qc1wiLCBbW1wiYXNzZXJ0RWxlY3RvcmF0ZU1hdGNoZXNcIiwgWyRo4oCNX2EgPT4gKGFzc2VydEVsZWN0b3JhdGVNYXRjaGVzID0gJGjigI1fYSldXV1dLFtcIi4vY29udHJhY3RHb3Zlcm5hbmNlL3R5cGVkUGFyYW1NYW5hZ2VyLmpzXCIsIFtbXCJtYWtlUGFyYW1NYW5hZ2VyRnJvbVRlcm1zXCIsIFskaOKAjV9hID0+IChtYWtlUGFyYW1NYW5hZ2VyRnJvbVRlcm1zID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZUd1YXJkcy5qc1wiLCBbW1wiR292ZXJub3JGYWNldFNoYXBlXCIsIFskaOKAjV9hID0+IChHb3Zlcm5vckZhY2V0U2hhcGUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtGYWlsLHF1b3RlOnF9PWFzc2VydDtcblxuY29uc3QgICAgICAgIEdPVkVSTkFOQ0VfU1RPUkFHRV9LRVk9J2dvdmVybmFuY2UnOyRo4oCNX29uY2UuR09WRVJOQU5DRV9TVE9SQUdFX0tFWShHT1ZFUk5BTkNFX1NUT1JBR0VfS0VZKTtcblxuY29uc3QgcHVibGljTWl4aW5BUEk9aGFyZGVuKHtcbmdldFN1YnNjcmlwdGlvbjpNLmNhbGwoKS5yZXR1cm5zKE0ucmVtb3RhYmxlKCdTdG9yZWRTdWJzY3JpcHRpb24nKSksXG5nZXRHb3Zlcm5lZFBhcmFtczpNLmNhbGwoKS5yZXR1cm5zKE0ub3IoTS5yZWNvcmQoKSxNLnByb21pc2UoKSkpLFxuZ2V0QW1vdW50Ok0uY2FsbCgpLnJldHVybnMoQW1vdW50U2hhcGUpLFxuZ2V0QnJhbmQ6TS5jYWxsKCkucmV0dXJucyhCcmFuZFNoYXBlKSxcbmdldEluc3RhbmNlOk0uY2FsbCgpLnJldHVybnMoTS5yZW1vdGFibGUoJ0luc3RhbmNlJykpLFxuZ2V0SW5zdGFsbGF0aW9uOk0uY2FsbCgpLnJldHVybnMoTS5yZW1vdGFibGUoJ0luc3RhbGxhdGlvbicpKSxcbmdldEludml0YXRpb25BbW91bnQ6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXROYXQ6TS5jYWxsKCkucmV0dXJucyhNLmJpZ2ludCgpKSxcbmdldFJhdGlvOk0uY2FsbCgpLnJldHVybnMoTS5yZWNvcmQoKSksXG5nZXRTdHJpbmc6TS5jYWxsKCkucmV0dXJucyhNLnN0cmluZygpKSxcbmdldFRpbWVzdGFtcDpNLmNhbGwoKS5yZXR1cm5zKFRpbWVzdGFtcFJlY29yZFNoYXBlKSxcbmdldFJlbGF0aXZlVGltZTpNLmNhbGwoKS5yZXR1cm5zKFJlbGF0aXZlVGltZVJlY29yZFNoYXBlKSxcbmdldFVua25vd246TS5jYWxsKCkucmV0dXJucyhNLmFueSgpKX0pO1xuXG5cbi8qKlxuICogQHBhcmFtIHtaQ0Y8R292ZXJuYW5jZVRlcm1zPHt9PiAmIHt9Pn0gemNmXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vY29udHJhY3RHb3Zlcm5hbmNlL3R5cGVkUGFyYW1NYW5hZ2VyJykuVHlwZWRQYXJhbU1hbmFnZXI8dW5rbm93bj59IHBhcmFtTWFuYWdlclxuICovJGjigI1fb25jZS5wdWJsaWNNaXhpbkFQSShwdWJsaWNNaXhpbkFQSSk7XG5jb25zdCAgICAgICAgdmFsaWRhdGVFbGVjdG9yYXRlPSh6Y2YscGFyYW1NYW5hZ2VyKT0+e1xuY29uc3R7Z292ZXJuZWRQYXJhbXN9PXpjZi5nZXRUZXJtcygpO1xucmV0dXJuIEUud2hlbihwYXJhbU1hbmFnZXIuZ2V0UGFyYW1zKCksKGZpbmlzaGVkUGFyYW1zKT0+e1xudHJ5e1xua2V5RVEoZ292ZXJuZWRQYXJhbXMsZmluaXNoZWRQYXJhbXMpfHxcbkZhaWwgYFRoZSAnZ292ZXJuZWRQYXJhbXMnIHRlcm0gbXVzdCBiZSBhbiBvYmplY3QgbGlrZSAke3EoXG5maW5pc2hlZFBhcmFtcylcbiB9LCBidXQgd2FzICR7cShnb3Zlcm5lZFBhcmFtcyl9YDtcbmFzc2VydEVsZWN0b3JhdGVNYXRjaGVzKHBhcmFtTWFuYWdlcixnb3Zlcm5lZFBhcmFtcyk7XG4gfWNhdGNoKGVycil7XG56Y2Yuc2h1dGRvd25XaXRoRmFpbHVyZShlcnIpO1xuIH1cbiB9KTtcbiB9OyRo4oCNX29uY2UudmFsaWRhdGVFbGVjdG9yYXRlKHZhbGlkYXRlRWxlY3RvcmF0ZSk7XG5oYXJkZW4odmFsaWRhdGVFbGVjdG9yYXRlKTtcblxuLyoqXG4gKiBVdGlsaXR5IGZ1bmN0aW9uIGZvciBgbWFrZVBhcmFtR292ZXJuYW5jZWAuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7WkNGPEdvdmVybmFuY2VUZXJtczx7fT4gJiB7fT59IHpjZlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlcicpLlR5cGVkUGFyYW1NYW5hZ2VyPFQ+fSBwYXJhbU1hbmFnZXJcbiAqL1xuY29uc3QgZmFjZXRIZWxwZXJzPSh6Y2YscGFyYW1NYW5hZ2VyKT0+e1xuLyogdmFsaWRhdGUgYXN5bmMgdG8gd2FpdCBmb3IgcGFyYW1zIHRvIGJlIGZpbmlzaGVkKi9cbi8qIFVOVElMIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDM0MyovXG52b2lkIHZhbGlkYXRlRWxlY3RvcmF0ZSh6Y2YscGFyYW1NYW5hZ2VyKTtcblxuY29uc3QgdHlwZWRBY2Nlc3NvcnM9e1xuZ2V0QW1vdW50OnBhcmFtTWFuYWdlci5nZXRBbW91bnQsXG5nZXRCcmFuZDpwYXJhbU1hbmFnZXIuZ2V0QnJhbmQsXG5nZXRJbnN0YW5jZTpwYXJhbU1hbmFnZXIuZ2V0SW5zdGFuY2UsXG5nZXRJbnN0YWxsYXRpb246cGFyYW1NYW5hZ2VyLmdldEluc3RhbGxhdGlvbixcbmdldEludml0YXRpb25BbW91bnQ6cGFyYW1NYW5hZ2VyLmdldEludml0YXRpb25BbW91bnQsXG5nZXROYXQ6cGFyYW1NYW5hZ2VyLmdldE5hdCxcbmdldFJhdGlvOnBhcmFtTWFuYWdlci5nZXRSYXRpbyxcbmdldFN0cmluZzpwYXJhbU1hbmFnZXIuZ2V0U3RyaW5nLFxuZ2V0VGltZXN0YW1wOnBhcmFtTWFuYWdlci5nZXRUaW1lc3RhbXAsXG5nZXRSZWxhdGl2ZVRpbWU6cGFyYW1NYW5hZ2VyLmdldFJlbGF0aXZlVGltZSxcbmdldFVua25vd246cGFyYW1NYW5hZ2VyLmdldFVua25vd259O1xuXG5cbmNvbnN0IGNvbW1vblB1YmxpY01ldGhvZHM9e1xuZ2V0U3Vic2NyaXB0aW9uOigpPT5wYXJhbU1hbmFnZXIuZ2V0U3Vic2NyaXB0aW9uKCksXG5nZXRHb3Zlcm5lZFBhcmFtczooKT0+cGFyYW1NYW5hZ2VyLmdldFBhcmFtcygpfTtcblxuXG4vKipcbiAqIEFkZCByZXF1aXJlZCBtZXRob2RzIHRvIHB1YmxpY0ZhY2V0XG4gKlxuICogQHRlbXBsYXRlIHt7fX0gUEYgcHVibGljIGZhY2V0XG4gKiBAcGFyYW0ge1BGfSBvcmlnaW5hbFB1YmxpY0ZhY2V0XG4gKiBAcmV0dXJucyB7R292ZXJuZWRQdWJsaWNGYWNldDxQRj59XG4gKi9cbmNvbnN0IGF1Z21lbnRQdWJsaWNGYWNldD0ob3JpZ2luYWxQdWJsaWNGYWNldCk9PntcbnJldHVybiBGYXIoJ3B1YmxpY0ZhY2V0Jyx7XG4uLi5vcmlnaW5hbFB1YmxpY0ZhY2V0LFxuLi4uY29tbW9uUHVibGljTWV0aG9kcyxcbi4uLnR5cGVkQWNjZXNzb3JzfSk7XG5cbiB9O1xuXG4vKipcbiAqIEFkZCByZXF1aXJlZCBtZXRob2RzIHRvIHB1YmxpY0ZhY2V0LCBmb3IgYSB2aXJ0dWFsL2R1cmFibGUgY29udHJhY3RcbiAqXG4gKiBAcGFyYW0ge09QRn0gb3JpZ2luYWxQdWJsaWNGYWNldFxuICogQHRlbXBsYXRlIHt7fX0gT1BGXG4gKi9cbmNvbnN0IGF1Z21lbnRWaXJ0dWFsUHVibGljRmFjZXQ9KG9yaWdpbmFsUHVibGljRmFjZXQpPT57XG5yZXR1cm4gRmFyKCdwdWJsaWNGYWNldCcse1xuLi4ub3JpZ2luYWxQdWJsaWNGYWNldCxcbi4uLmNvbW1vblB1YmxpY01ldGhvZHMsXG4uLi5vYmplY3RNYXAodHlwZWRBY2Nlc3NvcnMsaWdub3JlQ29udGV4dCl9KTtcblxuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIHt7fX0gQ0ZcbiAqIEBwYXJhbSB7Q0Z9IGxpbWl0ZWRDcmVhdG9yRmFjZXRcbiAqIEBwYXJhbSB7UmVjb3JkPHN0cmluZywgKC4uLmFueSkgPT4gdW5rbm93bj59IFtnb3Zlcm5lZEFwaXNdXG4gKiBAcmV0dXJucyB7R292ZXJuZWRDcmVhdG9yRmFjZXQ8Q0Y+fVxuICovXG5jb25zdCBtYWtlRmFyR292ZXJub3JGYWNldD0obGltaXRlZENyZWF0b3JGYWNldCxnb3Zlcm5lZEFwaXM9e30pPT57XG5jb25zdCBnb3Zlcm5vckZhY2V0PUZhcignZ292ZXJub3JGYWNldCcse1xuZ2V0UGFyYW1NZ3JSZXRyaWV2ZXI6KCk9PlxuRmFyKCdwYXJhbVJldHJpZXZlcicse2dldDooKT0+cGFyYW1NYW5hZ2VyfSksXG5nZXRJbnZpdGF0aW9uOihuYW1lKT0+cGFyYW1NYW5hZ2VyLmdldEludGVybmFsUGFyYW1WYWx1ZShuYW1lKSxcbmdldExpbWl0ZWRDcmVhdG9yRmFjZXQ6KCk9PmxpbWl0ZWRDcmVhdG9yRmFjZXQsXG4vKiBUaGUgY29udHJhY3QgcHJvdmlkZXMgYSBmYWNldCB3aXRoIHRoZSBBUElzIHRoYXQgY2FuIGJlIGludm9rZWQgYnkqL1xuLyogZ292ZXJuYW5jZSovXG4vKiogQHR5cGUgeygpID0+IEdvdmVybmVkQXBpc30gKi9cbmdldEdvdmVybmVkQXBpczooKT0+RmFyKCdnb3Zlcm5lZEFQSXMnLGdvdmVybmVkQXBpcyksXG4vKiBUaGUgZmFjZXQgcmV0dXJuZWQgYnkgZ2V0R292ZXJuZWRBcGlzIGlzIEZhciwgc28gd2UgY2FuJ3Qgc2VlIHdoYXQqL1xuLyogbWV0aG9kcyBpdCBoYXMuIFRoZXJlJ3Mgbm8gY2xlYW4gd2F5IHRvIGhhdmUgY29udHJhY3RzIHNwZWNpZnkgdGhlIEFQSXMqL1xuLyogd2l0aG91dCBhbHNvIHNlcGFyYXRlbHkgcHJvdmlkaW5nIHRoZWlyIG5hbWVzLiovXG5nZXRHb3Zlcm5lZEFwaU5hbWVzOigpPT5PYmplY3Qua2V5cyhnb3Zlcm5lZEFwaXMpLFxuc2V0T2ZmZXJGaWx0ZXI6KHN0cmluZ3MpPT56Y2Yuc2V0T2ZmZXJGaWx0ZXIoc3RyaW5ncyl9KTtcblxuXG4vKiBleGNsdXNpdmVseSBmb3IgY29udHJhY3RHb3Zlcm5vciwgd2hpY2ggb25seSByZXZlYWxzIGxpbWl0ZWRDcmVhdG9yRmFjZXQqL1xucmV0dXJuIGdvdmVybm9yRmFjZXQ7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge3t9fSBDRlxuICogQHBhcmFtIHtDRn0gb3JpZ2luYWxDcmVhdG9yRmFjZXRcbiAqIEBwYXJhbSB7e319IFtnb3Zlcm5lZEFwaXNdXG4gKiBAcmV0dXJucyB7R292ZXJuZWRDcmVhdG9yRmFjZXQ8Q0Y+fVxuICovXG5jb25zdCBtYWtlR292ZXJub3JGYWNldD0ob3JpZ2luYWxDcmVhdG9yRmFjZXQsZ292ZXJuZWRBcGlzPXt9KT0+e1xucmV0dXJuIG1ha2VGYXJHb3Zlcm5vckZhY2V0KG9yaWdpbmFsQ3JlYXRvckZhY2V0LGdvdmVybmVkQXBpcyk7XG4gfTtcblxuLyoqXG4gKiBBZGQgcmVxdWlyZWQgbWV0aG9kcyB0byBhIGNyZWF0b3JGYWNldCBmb3IgYSBkdXJhYmxlIGNvbnRyYWN0LlxuICpcbiAqIEBzZWUge21ha2VEdXJhYmxlR292ZXJub3JGYWNldH1cbiAqXG4gKiBAcGFyYW0ge3sgW21ldGhvZE5hbWU6IHN0cmluZ106IChjb250ZXh0PzogdW5rbm93biwgLi4ucmVzdDogdW5rbm93bltdKSA9PiB1bmtub3dufX0gbGltaXRlZENyZWF0b3JGYWNldFxuICovXG5jb25zdCBtYWtlVmlydHVhbEdvdmVybm9yRmFjZXQ9KGxpbWl0ZWRDcmVhdG9yRmFjZXQpPT57XG4vKiogQHR5cGUge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEvc3JjL3R5cGVzLmpzJykuRnVuY3Rpb25zUGx1c0NvbnRleHQ8dW5rbm93biwgR292ZXJuZWRDcmVhdG9yRmFjZXQ8bGltaXRlZENyZWF0b3JGYWNldD4+fSAqL1xuY29uc3QgZ292ZXJub3JGYWNldD1oYXJkZW4oe1xuZ2V0UGFyYW1NZ3JSZXRyaWV2ZXI6KCk9PlxuRmFyKCdwYXJhbVJldHJpZXZlcicse2dldDooKT0+cGFyYW1NYW5hZ2VyfSksXG5nZXRJbnZpdGF0aW9uOihfY29udGV4dCwvKiogQHR5cGUge3N0cmluZ30gKi9uYW1lKT0+XG5wYXJhbU1hbmFnZXIuZ2V0SW50ZXJuYWxQYXJhbVZhbHVlKG5hbWUpLFxuZ2V0TGltaXRlZENyZWF0b3JGYWNldDooe2ZhY2V0c30pPT5mYWNldHMubGltaXRlZENyZWF0b3JGYWNldCxcbi8qIFRoZSBjb250cmFjdCBwcm92aWRlcyBhIGZhY2V0IHdpdGggdGhlIEFQSXMgdGhhdCBjYW4gYmUgaW52b2tlZCBieSovXG4vKiBnb3Zlcm5hbmNlKi9cbmdldEdvdmVybmVkQXBpczooe2ZhY2V0c30pPT5mYWNldHMuZ292ZXJuZWRBcGlzLFxuLyogVGhlIGZhY2V0IHJldHVybmVkIGJ5IGdldEdvdmVybmVkQXBpcyBpcyBGYXIsIHNvIHdlIGNhbid0IHNlZSB3aGF0Ki9cbi8qIG1ldGhvZHMgaXQgaGFzLiBUaGVyZSdzIG5vIGNsZWFuIHdheSB0byBoYXZlIGNvbnRyYWN0cyBzcGVjaWZ5IHRoZSBBUElzKi9cbi8qIHdpdGhvdXQgYWxzbyBzZXBhcmF0ZWx5IHByb3ZpZGluZyB0aGVpciBuYW1lcy4qL1xuZ2V0R292ZXJuZWRBcGlOYW1lczooe2ZhY2V0c30pPT5cbmdldE1ldGhvZE5hbWVzKGZhY2V0cy5nb3Zlcm5lZEFwaXN8fHt9KSxcbnNldE9mZmVyRmlsdGVyOihfY29udGV4dCxzdHJpbmdzKT0+emNmLnNldE9mZmVyRmlsdGVyKHN0cmluZ3MpfSk7XG5cblxucmV0dXJue2dvdmVybm9yRmFjZXQsbGltaXRlZENyZWF0b3JGYWNldH07XG4gfTtcblxuLyoqXG4gKiBBZGQgcmVxdWlyZWQgbWV0aG9kcyB0byBhIGNyZWF0b3JGYWNldCBmb3IgYSBkdXJhYmxlIGNvbnRyYWN0LlxuICpcbiAqIEBzZWUge21ha2VWaXJ0dWFsR292ZXJub3JGYWNldH1cbiAqXG4gKiBAdGVtcGxhdGUgQ0ZcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YScpLkJhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7Q0Z9IGxpbWl0ZWRDcmVhdG9yRmFjZXRcbiAqIEBwYXJhbSB7UmVjb3JkPHN0cmluZywgKC4uLmFueSkgPT4gdW5rbm93bj59IFtnb3Zlcm5lZEFwaXNdXG4gKi9cbmNvbnN0IG1ha2VEdXJhYmxlR292ZXJub3JGYWNldD0oXG5iYWdnYWdlLFxubGltaXRlZENyZWF0b3JGYWNldCxcbmdvdmVybmVkQXBpcz17fSk9Plxue1xuY29uc3QgZ292ZXJub3JGYWNldD1wcmVwYXJlRXhvKFxuYmFnZ2FnZSxcbidnb3Zlcm5vckZhY2V0Jyxcbk0uaW50ZXJmYWNlKCdnb3Zlcm5vckZhY2V0JyxHb3Zlcm5vckZhY2V0U2hhcGUpLFxue1xuZ2V0UGFyYW1NZ3JSZXRyaWV2ZXI6KCk9PlxuRmFyKCdwYXJhbVJldHJpZXZlcicse2dldDooKT0+cGFyYW1NYW5hZ2VyfSksXG5nZXRJbnZpdGF0aW9uOihuYW1lKT0+cGFyYW1NYW5hZ2VyLmdldEludGVybmFsUGFyYW1WYWx1ZShuYW1lKSxcbmdldExpbWl0ZWRDcmVhdG9yRmFjZXQ6KCk9PmxpbWl0ZWRDcmVhdG9yRmFjZXQsXG4vKiBUaGUgY29udHJhY3QgcHJvdmlkZXMgYSBmYWNldCB3aXRoIHRoZSBBUElzIHRoYXQgY2FuIGJlIGludm9rZWQgYnkqL1xuLyogZ292ZXJuYW5jZSovXG4vKiogQHR5cGUgeygpID0+IEdvdmVybmVkQXBpc30gKi9cbmdldEdvdmVybmVkQXBpczooKT0+RmFyKCdnb3Zlcm5lZEFQSXMnLGdvdmVybmVkQXBpcyksXG4vKiBUaGUgZmFjZXQgcmV0dXJuZWQgYnkgZ2V0R292ZXJuZWRBcGlzIGlzIEZhciwgc28gd2UgY2FuJ3Qgc2VlIHdoYXQqL1xuLyogbWV0aG9kcyBpdCBoYXMuIFRoZXJlJ3Mgbm8gY2xlYW4gd2F5IHRvIGhhdmUgY29udHJhY3RzIHNwZWNpZnkgdGhlIEFQSXMqL1xuLyogd2l0aG91dCBhbHNvIHNlcGFyYXRlbHkgcHJvdmlkaW5nIHRoZWlyIG5hbWVzLiovXG5nZXRHb3Zlcm5lZEFwaU5hbWVzOigpPT5PYmplY3Qua2V5cyhnb3Zlcm5lZEFwaXN8fHt9KSxcbnNldE9mZmVyRmlsdGVyOihzdHJpbmdzKT0+emNmLnNldE9mZmVyRmlsdGVyKHN0cmluZ3MpfSk7XG5cblxuXG5yZXR1cm57Z292ZXJub3JGYWNldCxsaW1pdGVkQ3JlYXRvckZhY2V0fTtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKHtcbnB1YmxpY01peGluOntcbi4uLmNvbW1vblB1YmxpY01ldGhvZHMsXG4uLi50eXBlZEFjY2Vzc29yc30sXG5cbmF1Z21lbnRQdWJsaWNGYWNldCxcbmF1Z21lbnRWaXJ0dWFsUHVibGljRmFjZXQsXG5tYWtlR292ZXJub3JGYWNldCxcblxubWFrZUZhckdvdmVybm9yRmFjZXQsXG5tYWtlVmlydHVhbEdvdmVybm9yRmFjZXQsXG5tYWtlRHVyYWJsZUdvdmVybm9yRmFjZXQsXG5cbnBhcmFtczpwYXJhbU1hbmFnZXIucmVhZG9ubHkoKX0pO1xuXG4gfTtcblxuLyoqXG4gKiBIZWxwZXIgZm9yIHRoZSA5MCUgb2YgY29udHJhY3RzIHRoYXQgd2lsbCBoYXZlIG9ubHkgYSBzaW5nbGUgc2V0IG9mXG4gKiBwYXJhbWV0ZXJzLiBVc2luZyB0aGlzIGZvciBtYW5hZ2VkIHBhcmFtZXRlcnMsIGEgY29udHJhY3Qgb25seSBoYXMgdG9cbiAqXG4gKiAtIERlZmluZSB0aGUgcGFyYW1ldGVyIHRlbXBsYXRlLCB3aGljaCBpbmNsdWRlcyBuYW1lLCB0eXBlIGFuZCB2YWx1ZVxuICogLSBBZGQgYW55IG1ldGhvZHMgbmVlZGVkIGluIHRoZSBwdWJsaWMgYW5kIGNyZWF0b3IgZmFjZXRzLlxuICpcbiAqIEl0J3MgYWxzbyBjcnVjaWFsIHRoYXQgdGhlIGdvdmVybmVkIGNvbnRyYWN0IG5vdCBpbnRlcmFjdCB3aXRoIHRoZSBwcm9kdWN0IG9mXG4gKiBtYWtlR292ZXJub3JGYWNldCgpLiBUaGUgd3JhcHBlZCBjcmVhdG9yRmFjZXQgaGFzIHRoZSBwb3dlciB0byBjaGFuZ2VcbiAqIHBhcmFtZXRlciB2YWx1ZXMsIGFuZCB0aGUgZ292ZXJuYW5jZSBndWFyYW50ZWVzIG9ubHkgaG9sZCBpZiB0aGV5J3JlIG5vdCB1c2VkXG4gKiBkaXJlY3RseSBieSB0aGUgZ292ZXJuZWQgY29udHJhY3QuXG4gKlxuICogQHRlbXBsYXRlIHtYaW1wb3J0KCcuL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlcicpLlBhcmFtVHlwZXNNYXB9IE1cbiAqICAgTWFwIG9mIHR5cGVzIG9mIGN1c3RvbSBnb3Zlcm5lZCB0ZXJtc1xuICogQHBhcmFtIHtaQ0Y8R292ZXJuYW5jZVRlcm1zPE0+Pn0gemNmXG4gKiBAcGFyYW0ge0ludml0YXRpb259IGluaXRpYWxQb3Nlckludml0YXRpb25cbiAqIEBwYXJhbSB7TX0gcGFyYW1UeXBlc01hcFxuICogQHBhcmFtIHtFUmVmPFN0b3JhZ2VOb2RlPn0gW3N0b3JhZ2VOb2RlXVxuICogQHBhcmFtIHtFUmVmPE1hcnNoYWxsZXI+fSBbbWFyc2hhbGxlcl1cbiAqL1xuY29uc3QgaGFuZGxlUGFyYW1Hb3Zlcm5hbmNlPShcbnpjZixcbmluaXRpYWxQb3Nlckludml0YXRpb24sXG5wYXJhbVR5cGVzTWFwLFxuc3RvcmFnZU5vZGUsXG5tYXJzaGFsbGVyKT0+XG57XG4vKiogQHR5cGUge1hpbXBvcnQoJ0BhZ29yaWMvbm90aWZpZXInKS5TdG9yZWRQdWJsaXNoZXJLaXQ8R292ZXJuYW5jZVN1YnNjcmlwdGlvblN0YXRlPn0gKi9cbmNvbnN0IHB1Ymxpc2hlcktpdD1tYWtlU3RvcmVkUHVibGlzaGVyS2l0KFxuc3RvcmFnZU5vZGUsXG5tYXJzaGFsbGVyLFxuR09WRVJOQU5DRV9TVE9SQUdFX0tFWSk7XG5cbmNvbnN0IHBhcmFtTWFuYWdlcj1tYWtlUGFyYW1NYW5hZ2VyRnJvbVRlcm1zKFxucHVibGlzaGVyS2l0LFxuemNmLFxue0VsZWN0b3JhdGU6aW5pdGlhbFBvc2VySW52aXRhdGlvbn0sXG5wYXJhbVR5cGVzTWFwKTtcblxuXG5yZXR1cm4gZmFjZXRIZWxwZXJzKHpjZixwYXJhbU1hbmFnZXIpO1xuIH07JGjigI1fb25jZS5oYW5kbGVQYXJhbUdvdmVybmFuY2UoaGFuZGxlUGFyYW1Hb3Zlcm5hbmNlKTtcblxuaGFyZGVuKGhhbmRsZVBhcmFtR292ZXJuYW5jZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicHVibGljTWl4aW5BUEkiOlsicHVibGljTWl4aW5BUEkiXSwiaGFuZGxlUGFyYW1Hb3Zlcm5hbmNlIjpbImhhbmRsZVBhcmFtR292ZXJuYW5jZSJdLCJHT1ZFUk5BTkNFX1NUT1JBR0VfS0VZIjpbIkdPVkVSTkFOQ0VfU1RPUkFHRV9LRVkiXSwidmFsaWRhdGVFbGVjdG9yYXRlIjpbInZhbGlkYXRlRWxlY3RvcmF0ZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAD5/2VtLwoAAC8KAAAtAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vY29uc3RhbnRzLmpzIiwiLi9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanMiLCIuL2NvbnRyYWN0R292ZXJuYW5jZS9wYXJhbU1hbmFnZXIuanMiLCIuL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlci5qcyIsIi4vY29udHJhY3RHb3Zlcm5vci5qcyIsIi4vY29udHJhY3RIZWxwZXIuanMiLCIuL3F1ZXN0aW9uLmpzIiwiLi90eXBlcy1hbWJpZW50LmpzIiwiLi92YWxpZGF0b3JzLmpzIiwiQGFnb3JpYy9lcnRwL2V4cG9ydGVkLmpzIiwiQGFnb3JpYy9zd2luZ3NldC12YXQvc3JjL3ZhdHMvbmV0d29yay90eXBlcy5qcyIsIkBhZ29yaWMvem9lL2V4cG9ydGVkLmpzIl0sImV4cG9ydHMiOlsiRWxlY3Rpb25UeXBlIiwiRWxlY3Rpb25UeXBlIiwiYXNzZXJ0Q29udHJhY3RFbGVjdG9yYXRlIiwiYXNzZXJ0Q29udHJhY3RFbGVjdG9yYXRlIiwibWFrZVBhcmFtQ2hhbmdlUG9zaXRpb25zIiwibWFrZVBhcmFtQ2hhbmdlUG9zaXRpb25zIiwibWFrZVBhcmFtTWFuYWdlckJ1aWxkZXIiLCJtYWtlUGFyYW1NYW5hZ2VyQnVpbGRlciIsIm1ha2VQYXJhbU1hbmFnZXJTeW5jIiwibWFrZVBhcmFtTWFuYWdlclN5bmMiLCJwdWJsaWNNaXhpbkFQSSIsInB1YmxpY01peGluQVBJIiwidmFsaWRhdGVRdWVzdGlvbkZyb21Db3VudGVyIiwidmFsaWRhdGVRdWVzdGlvbkZyb21Db3VudGVyIixudWxsXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3N3aW5nc2V0LXZhdC9zcmMvdmF0cy9uZXR3b3JrL3R5cGVzLmpzXCIsIFtdXSxbXCJAYWdvcmljL2VydHAvZXhwb3J0ZWQuanNcIiwgW11dLFtcIkBhZ29yaWMvem9lL2V4cG9ydGVkLmpzXCIsIFtdXSxbXCIuL3R5cGVzLWFtYmllbnQuanNcIiwgW11dLFtcIi4vcXVlc3Rpb24uanNcIiwgW11dLFtcIi4vY29udHJhY3RHb3Zlcm5vci5qc1wiLCBbXV0sW1wiLi9jb250cmFjdEhlbHBlci5qc1wiLCBbXV0sW1wiLi9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanNcIiwgW11dLFtcIi4vY29udHJhY3RHb3Zlcm5hbmNlL3BhcmFtTWFuYWdlci5qc1wiLCBbXV0sW1wiLi9jb250cmFjdEdvdmVybmFuY2UvdHlwZWRQYXJhbU1hbmFnZXIuanNcIiwgW11dLFtcIi4vdmFsaWRhdG9ycy5qc1wiLCBbXV0sW1wiLi9jb25zdGFudHMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9xdWVzdGlvbi5qcyI6W1siQ2hvaWNlTWV0aG9kIiwiQ2hvaWNlTWV0aG9kIl0sWyJFbGVjdGlvblR5cGUiLCJFbGVjdGlvblR5cGUiXSxbIlF1b3J1bVJ1bGUiLCJRdW9ydW1SdWxlIl0sWyJjb2VyY2VRdWVzdGlvblNwZWMiLCJjb2VyY2VRdWVzdGlvblNwZWMiXSxbInBvc2l0aW9uSW5jbHVkZWQiLCJwb3NpdGlvbkluY2x1ZGVkIl0sWyJidWlsZFF1ZXN0aW9uIiwiYnVpbGRRdWVzdGlvbiJdXSwiLi9jb250cmFjdEdvdmVybm9yLmpzIjpbWyJ2YWxpZGF0ZVF1ZXN0aW9uRGV0YWlscyIsInZhbGlkYXRlUXVlc3Rpb25EZXRhaWxzIl0sWyJ2YWxpZGF0ZVF1ZXN0aW9uRnJvbUNvdW50ZXIiLCJ2YWxpZGF0ZVF1ZXN0aW9uRnJvbUNvdW50ZXIiXV0sIi4vY29udHJhY3RIZWxwZXIuanMiOltbImhhbmRsZVBhcmFtR292ZXJuYW5jZSIsImhhbmRsZVBhcmFtR292ZXJuYW5jZSJdLFsicHVibGljTWl4aW5BUEkiLCJwdWJsaWNNaXhpbkFQSSJdXSwiLi9jb250cmFjdEdvdmVybmFuY2UvZ292ZXJuUGFyYW0uanMiOltbImFzc2VydEJhbGxvdENvbmNlcm5zUGFyYW0iLCJhc3NlcnRCYWxsb3RDb25jZXJuc1BhcmFtIl0sWyJtYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMiLCJtYWtlUGFyYW1DaGFuZ2VQb3NpdGlvbnMiXSxbInNldHVwUGFyYW1Hb3Zlcm5hbmNlIiwic2V0dXBQYXJhbUdvdmVybmFuY2UiXSxbIkNPTlRSQUNUX0VMRUNUT1JBVEUiLCJDT05UUkFDVF9FTEVDVE9SQVRFIl1dLCIuL2NvbnRyYWN0R292ZXJuYW5jZS9wYXJhbU1hbmFnZXIuanMiOltbImFzc2VydEVsZWN0b3JhdGVNYXRjaGVzIiwiYXNzZXJ0RWxlY3RvcmF0ZU1hdGNoZXMiXSxbIm1ha2VQYXJhbU1hbmFnZXJCdWlsZGVyIiwibWFrZVBhcmFtTWFuYWdlckJ1aWxkZXIiXV0sIi4vY29udHJhY3RHb3Zlcm5hbmNlL3R5cGVkUGFyYW1NYW5hZ2VyLmpzIjpbWyJtYWtlUGFyYW1NYW5hZ2VyIiwibWFrZVBhcmFtTWFuYWdlciJdLFsibWFrZVBhcmFtTWFuYWdlclN5bmMiLCJtYWtlUGFyYW1NYW5hZ2VyU3luYyJdXSwiLi92YWxpZGF0b3JzLmpzIjpbWyJhc3NlcnRDb250cmFjdEdvdmVybmFuY2UiLCJhc3NlcnRDb250cmFjdEdvdmVybmFuY2UiXSxbImFzc2VydENvbnRyYWN0RWxlY3RvcmF0ZSIsImFzc2VydENvbnRyYWN0RWxlY3RvcmF0ZSJdXSwiLi9jb25zdGFudHMuanMiOltbIlBhcmFtVHlwZXMiLCJQYXJhbVR5cGVzIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABZt2/Ypw8AAKcPAAAwAAAAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL3F1ZXN0aW9uLmpzeyJpbXBvcnRzIjpbIi4vdHlwZUd1YXJkcy5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3pvZS9zcmMvbWFrZUhhbmRsZS5qcyJdLCJleHBvcnRzIjpbIkNob2ljZU1ldGhvZCIsIkVsZWN0aW9uVHlwZSIsIlF1b3J1bVJ1bGUiLCJidWlsZFF1ZXN0aW9uIiwiY29lcmNlUXVlc3Rpb25TcGVjIiwicG9zaXRpb25JbmNsdWRlZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlRXhvLG11c3RNYXRjaCxrZXlFUSxNLG1ha2VIYW5kbGUsUXVlc3Rpb25JLFF1ZXN0aW9uU3BlY1NoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm1ha2VFeG9cIiwgWyRo4oCNX2EgPT4gKG1ha2VFeG8gPSAkaOKAjV9hKV1dLFtcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJrZXlFUVwiLCBbJGjigI1fYSA9PiAoa2V5RVEgPSAkaOKAjV9hKV1dLFtcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy96b2Uvc3JjL21ha2VIYW5kbGUuanNcIiwgW1tcIm1ha2VIYW5kbGVcIiwgWyRo4oCNX2EgPT4gKG1ha2VIYW5kbGUgPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJRdWVzdGlvbklcIiwgWyRo4oCNX2EgPT4gKFF1ZXN0aW9uSSA9ICRo4oCNX2EpXV0sW1wiUXVlc3Rpb25TcGVjU2hhcGVcIiwgWyRo4oCNX2EgPT4gKFF1ZXN0aW9uU3BlY1NoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cbi8qIFRvcGljcyBiZWluZyB2b3RlZCBvbiBhcmUgJ1F1ZXN0aW9ucycuIEJlZm9yZSBhIFF1ZXN0aW9uIGlzIGtub3duIHRvIGEqL1xuLyogZWxlY3RvcmF0ZSwgdGhlIHBhcmFtZXRlcnMgY2FuIGJlIGRlc2NyaWJlZCB3aXRoIGEgUXVlc3Rpb25TcGVjLiBPbmNlIHRoZSovXG4vKiBxdWVzdGlvbiBoYXMgYmVlbiBwcmVzZW50ZWQgdG8gYW4gRWxlY3RvcmF0ZSwgdGhlcmUgaXMgYSBRdWVzdGlvbkRldGFpbHMqL1xuLyogcmVjb3JkIHRoYXQgYWxzbyBpbmNsdWRlcyB0aGUgVm90ZUNvdW50ZXIgd2hpY2ggd2lsbCBkZXRlcm1pbmUgdGhlIG91dGNvbWUqL1xuLyogYW5kIHRoZSBxdWVzdGlvbkhhbmRsZSB0aGF0IHVuaXF1ZWx5IGlkZW50aWZpZXMgaXQuKi9cblxuLyoqXG4gKiBcInVucmFua2VkXCIgaXMgbW9yZSBmb3JtYWxseSBrbm93biBhcyBcImFwcHJvdmFsXCIgdm90aW5nLCBidXQgdGhpcyBpcyBoYXJkIGZvclxuICogcGVvcGxlIHRvIGludHVpdCB3aGVuIHRoZXJlIGFyZSBvbmx5IHR3byBhbHRlcm5hdGl2ZXMuXG4gKi9cbmNvbnN0IENob2ljZU1ldGhvZD0vKiogQHR5cGUge2NvbnN0fSAqL3tcblVOUkFOS0VEOid1bnJhbmtlZCcsXG5PUkRFUjonb3JkZXInLFxuUExVUkFMSVRZOidwbHVyYWxpdHknfTskaOKAjV9vbmNlLkNob2ljZU1ldGhvZChDaG9pY2VNZXRob2QpO1xuXG5cbmNvbnN0IEVsZWN0aW9uVHlwZT0vKiogQHR5cGUge2NvbnN0fSAqL3tcbi8qIEEgcGFyYW1ldGVyIGlzIG5hbWVkLCBhbmQgYSBuZXcgdmFsdWUgcHJvcG9zZWQqL1xuUEFSQU1fQ0hBTkdFOidwYXJhbV9jaGFuZ2UnLFxuLyogY2hvb3NlIG9uZSBvciBtdWx0aXBsZSB3aW5uZXJzLCBkZXBlbmRpbmcgb24gQ2hvaWNlTWV0aG9kKi9cbkVMRUNUSU9OOidlbGVjdGlvbicsXG5TVVJWRVk6J3N1cnZleScsXG4vKiB3aGV0aGVyIG9yIG5vdCB0byBpbnZva2UgYW4gQVBJIG1ldGhvZCovXG5BUElfSU5WT0NBVElPTjonYXBpX2ludm9jYXRpb24nLFxuT0ZGRVJfRklMVEVSOidvZmZlcl9maWx0ZXInfTskaOKAjV9vbmNlLkVsZWN0aW9uVHlwZShFbGVjdGlvblR5cGUpO1xuXG5cbmNvbnN0IFF1b3J1bVJ1bGU9LyoqIEB0eXBlIHtjb25zdH0gKi97XG5NQUpPUklUWTonbWFqb3JpdHknLFxuTk9fUVVPUlVNOidub19xdW9ydW0nLFxuLyogVGhlIGVsZWN0aW9uIGlzbid0IHZhbGlkIHVubGVzcyBhbGwgdm90ZXJzIHZvdGUqL1xuQUxMOidhbGwnfTtcblxuXG4vKiogQHR5cGUge1Bvc2l0aW9uSW5jbHVkZWR9ICovJGjigI1fb25jZS5RdW9ydW1SdWxlKFF1b3J1bVJ1bGUpO1xuY29uc3QgcG9zaXRpb25JbmNsdWRlZD0ocG9zaXRpb25zLHApPT5wb3NpdGlvbnMuc29tZSgoZSk9PmtleUVRKGUscCkpO1xuXG4vKipcbiAqIEBwYXJhbSB7UXVlc3Rpb25TcGVjfSBhbGxlZ2VkUXVlc3Rpb25TcGVjXG4gKiBAcmV0dXJucyB7UXVlc3Rpb25TcGVjfVxuICovJGjigI1fb25jZS5wb3NpdGlvbkluY2x1ZGVkKHBvc2l0aW9uSW5jbHVkZWQpO1xuY29uc3QgY29lcmNlUXVlc3Rpb25TcGVjPSh7XG5tZXRob2QsXG5pc3N1ZSxcbnBvc2l0aW9ucyxcbmVsZWN0aW9uVHlwZSxcbm1heENob2ljZXMsXG5tYXhXaW5uZXJzLFxuY2xvc2luZ1J1bGUsXG5xdW9ydW1SdWxlLFxudGllT3V0Y29tZX0pPT5cbntcbmNvbnN0IHF1ZXN0aW9uPWhhcmRlbih7XG5tZXRob2QsXG5pc3N1ZSxcbnBvc2l0aW9ucyxcbm1heENob2ljZXM6TnVtYmVyKG1heENob2ljZXMpLFxubWF4V2lubmVyczpOdW1iZXIobWF4V2lubmVycyksXG5lbGVjdGlvblR5cGUsXG5jbG9zaW5nUnVsZSxcbnF1b3J1bVJ1bGUsXG50aWVPdXRjb21lfSk7XG5cblxubXVzdE1hdGNoKHF1ZXN0aW9uLFF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuLyogWFhYIEl0IHdvdWxkIGJlIG5pY2UgdG8gZW5mb3JjZSB0aGlzIHVzaW5nIHBhcmFtZXRlcml6ZWQgdHlwZXMsIGJ1dCB0aGF0Ki9cbi8qIHNlZW1zIHRvIG9ubHkgZW5mb3JjZSB0eXBlIGNvbnN0cmFpbnRzLCAoaS5lLiB0aGUgdGllT3V0Y29tZSB3aWxsIGJlIHRoZSovXG4vKiBzYW1lIHR5cGUgYXMgYW55IG9mIHRoZSBwb3NpdGlvbnMpIHVubGVzcyB5b3UgY2FuIHByb3ZpZGUgdGhlIGNvbmNyZXRlKi9cbi8qIHZhbHVlIGF0IHBhdHRlcm4gY3JlYXRpb24gdGltZS4qL1xubXVzdE1hdGNoKHF1ZXN0aW9uLnRpZU91dGNvbWUsTS5vciguLi5xdWVzdGlvbi5wb3NpdGlvbnMpKTtcblxucmV0dXJuIHF1ZXN0aW9uO1xuIH07XG5cbi8qKiBAdHlwZSB7QnVpbGRRdWVzdGlvbn0gKi8kaOKAjV9vbmNlLmNvZXJjZVF1ZXN0aW9uU3BlYyhjb2VyY2VRdWVzdGlvblNwZWMpO1xuY29uc3QgYnVpbGRRdWVzdGlvbj0ocXVlc3Rpb25TcGVjLGNvdW50ZXJJbnN0YW5jZSk9PntcbmNvbnN0IHF1ZXN0aW9uSGFuZGxlPW1ha2VIYW5kbGUoJ1F1ZXN0aW9uJyk7XG5cbi8qKiBAdHlwZSB7UXVlc3Rpb259ICovXG5yZXR1cm4gbWFrZUV4bygncXVlc3Rpb24gZGV0YWlscycsUXVlc3Rpb25JLHtcbmdldFZvdGVDb3VudGVyKCl7XG5yZXR1cm4gY291bnRlckluc3RhbmNlO1xuIH0sXG5nZXREZXRhaWxzKCl7XG5yZXR1cm4gaGFyZGVuKHtcbi4uLnF1ZXN0aW9uU3BlYyxcbnF1ZXN0aW9uSGFuZGxlLFxuY291bnRlckluc3RhbmNlfSk7XG5cbiB9fSk7XG5cbiB9OyRo4oCNX29uY2UuYnVpbGRRdWVzdGlvbihidWlsZFF1ZXN0aW9uKTtcblxuaGFyZGVuKGJ1aWxkUXVlc3Rpb24pO1xuaGFyZGVuKENob2ljZU1ldGhvZCk7XG5oYXJkZW4oRWxlY3Rpb25UeXBlKTtcbmhhcmRlbihjb2VyY2VRdWVzdGlvblNwZWMpO1xuaGFyZGVuKHBvc2l0aW9uSW5jbHVkZWQpO1xuaGFyZGVuKFF1b3J1bVJ1bGUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNob2ljZU1ldGhvZCI6WyJDaG9pY2VNZXRob2QiXSwiRWxlY3Rpb25UeXBlIjpbIkVsZWN0aW9uVHlwZSJdLCJRdW9ydW1SdWxlIjpbIlF1b3J1bVJ1bGUiXSwicG9zaXRpb25JbmNsdWRlZCI6WyJwb3NpdGlvbkluY2x1ZGVkIl0sImNvZXJjZVF1ZXN0aW9uU3BlYyI6WyJjb2VyY2VRdWVzdGlvblNwZWMiXSwiYnVpbGRRdWVzdGlvbiI6WyJidWlsZFF1ZXN0aW9uIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJ7Q0hMoOwAAKDsAADIAAABAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvdHlwZUd1YXJkcy5qc3siaW1wb3J0cyI6WyJAYWdvcmljL25vdGlmaWVyIiwiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvdGltZSIsIkBhZ29yaWMvem9lL3NyYy90eXBlR3VhcmRzLmpzIl0sImV4cG9ydHMiOlsiQXBpSW52b2NhdGlvblBvc2l0aW9uc1NoYXBlIiwiQXBpSW52b2NhdGlvblF1ZXN0aW9uRGV0YWlsc1NoYXBlIiwiQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlIiwiQmluYXJ5Vm90ZUNvdW50ZXJBZG1pbkkiLCJCaW5hcnlWb3RlQ291bnRlckNsb3NlSSIsIkJpbmFyeVZvdGVDb3VudGVyUHVibGljSSIsIkNob2ljZU1ldGhvZFNoYXBlIiwiQ2xvc2luZ1J1bGVTaGFwZSIsIkVsZWN0aW9uVHlwZVNoYXBlIiwiRWxlY3RvcmF0ZUNyZWF0b3JJIiwiRWxlY3RvcmF0ZVB1YmxpY0kiLCJHb3Zlcm5vckZhY2V0U2hhcGUiLCJJbnZpdGF0aW9uU2hhcGUiLCJOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlIiwiTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGUiLCJOb1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUiLCJOb1NpbXBsZVBvc2l0aW9uU2hhcGUiLCJPZmZlckZpbHRlcklzc3VlU2hhcGUiLCJPZmZlckZpbHRlclBvc2l0aW9uc1NoYXBlIiwiT2ZmZXJGaWx0ZXJRdWVzdGlvbkRldGFpbHNTaGFwZSIsIk9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGUiLCJQYXJhbUNoYW5nZXNJc3N1ZVNoYXBlIiwiUGFyYW1DaGFuZ2VzUG9zaXRpb25zU2hhcGUiLCJQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZSIsIlBhcmFtQ2hhbmdlc1F1ZXN0aW9uU3BlY1NoYXBlIiwiUGFyYW1DaGFuZ2VzU3BlY1NoYXBlIiwiUGFyYW1QYXRoU2hhcGUiLCJQb3NpdGlvblNoYXBlIiwiUXVlc3Rpb25EZXRhaWxzU2hhcGUiLCJRdWVzdGlvbkhhbmRsZVNoYXBlIiwiUXVlc3Rpb25JIiwiUXVlc3Rpb25TcGVjU2hhcGUiLCJRdWVzdGlvblN0YXRzU2hhcGUiLCJRdW9ydW1SdWxlU2hhcGUiLCJTaW1wbGVJc3N1ZVNoYXBlIiwiU2ltcGxlUG9zaXRpb25zU2hhcGUiLCJTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSIsIlNpbXBsZVF1ZXN0aW9uU3BlY1NoYXBlIiwiVm90ZUNvdW50ZXJBZG1pbkkiLCJWb3RlQ291bnRlckNsb3NlSSIsIlZvdGVDb3VudGVyUHVibGljSSIsIlZvdGVySGFuZGxlIiwiWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUiLCJZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGUiLCJZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlIiwiWWVzU2ltcGxlUG9zaXRpb25TaGFwZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLFRpbWVzdGFtcFNoYXBlLEluc3RhbmNlSGFuZGxlU2hhcGUsVGltZXJTaGFwZSxtYWtlSGFuZGxlU2hhcGUsU3Vic2NyaWJlclNoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy90aW1lXCIsIFtbXCJUaW1lc3RhbXBTaGFwZVwiLCBbJGjigI1fYSA9PiAoVGltZXN0YW1wU2hhcGUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy96b2Uvc3JjL3R5cGVHdWFyZHMuanNcIiwgW1tcIkluc3RhbmNlSGFuZGxlU2hhcGVcIiwgWyRo4oCNX2EgPT4gKEluc3RhbmNlSGFuZGxlU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlRpbWVyU2hhcGVcIiwgWyRo4oCNX2EgPT4gKFRpbWVyU2hhcGUgPSAkaOKAjV9hKV1dLFtcIm1ha2VIYW5kbGVTaGFwZVwiLCBbJGjigI1fYSA9PiAobWFrZUhhbmRsZVNoYXBlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvbm90aWZpZXJcIiwgW1tcIlN1YnNjcmliZXJTaGFwZVwiLCBbJGjigI1fYSA9PiAoU3Vic2NyaWJlclNoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuY29uc3QgICAgICAgIENob2ljZU1ldGhvZFNoYXBlPU0ub3IoJ3VucmFua2VkJywnb3JkZXInLCdwbHVyYWxpdHknKTskaOKAjV9vbmNlLkNob2ljZU1ldGhvZFNoYXBlKENob2ljZU1ldGhvZFNoYXBlKTtcbmNvbnN0ICAgICAgICBRdW9ydW1SdWxlU2hhcGU9TS5vcignbWFqb3JpdHknLCdub19xdW9ydW0nLCdhbGwnKTskaOKAjV9vbmNlLlF1b3J1bVJ1bGVTaGFwZShRdW9ydW1SdWxlU2hhcGUpO1xuY29uc3QgICAgICAgIEVsZWN0aW9uVHlwZVNoYXBlPU0ub3IoXG4ncGFyYW1fY2hhbmdlJyxcbidlbGVjdGlvbicsXG4nc3VydmV5JyxcbidhcGlfaW52b2NhdGlvbicsXG4nb2ZmZXJfZmlsdGVyJyk7JGjigI1fb25jZS5FbGVjdGlvblR5cGVTaGFwZShFbGVjdGlvblR5cGVTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIENsb3NpbmdSdWxlU2hhcGU9aGFyZGVuKHtcbnRpbWVyOk0uZXJlZihUaW1lclNoYXBlKSxcbmRlYWRsaW5lOlRpbWVzdGFtcFNoYXBlfSk7XG5cblxuLyogYWxsIHRoZSBzdHJpbmdzIHRoYXQgd2lsbCBiZSBpbiB0aGUgZmlsdGVyIGFmdGVyIHBhc3NpbmcqLyRo4oCNX29uY2UuQ2xvc2luZ1J1bGVTaGFwZShDbG9zaW5nUnVsZVNoYXBlKTtcbmNvbnN0ICAgICAgICBZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGU9aGFyZGVuKHtcbnN0cmluZ3M6TS5hcnJheU9mKE0uc3RyaW5nKCkpfSk7JGjigI1fb25jZS5ZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGUoWWVzT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlKTtcblxuY29uc3QgICAgICAgIE5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlPWhhcmRlbih7XG5kb250VXBkYXRlOk0uYXJyYXlPZihNLnN0cmluZygpKX0pOyRo4oCNX29uY2UuTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGUoTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGUpO1xuXG5jb25zdCAgICAgICAgT2ZmZXJGaWx0ZXJQb3NpdGlvbnNTaGFwZT1oYXJkZW4oW1xuWWVzT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlLFxuTm9PZmZlckZpbHRlclBvc2l0aW9uU2hhcGVdKTskaOKAjV9vbmNlLk9mZmVyRmlsdGVyUG9zaXRpb25zU2hhcGUoT2ZmZXJGaWx0ZXJQb3NpdGlvbnNTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBPZmZlckZpbHRlcklzc3VlU2hhcGU9aGFyZGVuKHtcbnN0cmluZ3M6TS5hcnJheU9mKE0uc3RyaW5nKCkpfSk7JGjigI1fb25jZS5PZmZlckZpbHRlcklzc3VlU2hhcGUoT2ZmZXJGaWx0ZXJJc3N1ZVNoYXBlKTtcblxuY29uc3QgICAgICAgIE9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGU9aGFyZGVuKHtcbm1ldGhvZDpDaG9pY2VNZXRob2RTaGFwZSxcbmlzc3VlOk9mZmVyRmlsdGVySXNzdWVTaGFwZSxcbnBvc2l0aW9uczpPZmZlckZpbHRlclBvc2l0aW9uc1NoYXBlLFxuZWxlY3Rpb25UeXBlOidvZmZlcl9maWx0ZXInLFxubWF4Q2hvaWNlczoxLFxubWF4V2lubmVyczoxLFxuY2xvc2luZ1J1bGU6Q2xvc2luZ1J1bGVTaGFwZSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZVNoYXBlLFxudGllT3V0Y29tZTpOb09mZmVyRmlsdGVyUG9zaXRpb25TaGFwZX0pOyRo4oCNX29uY2UuT2ZmZXJGaWx0ZXJRdWVzdGlvblNwZWNTaGFwZShPZmZlckZpbHRlclF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuY29uc3QgICAgICAgIE9mZmVyRmlsdGVyUXVlc3Rpb25EZXRhaWxzU2hhcGU9aGFyZGVuKHtcbi4uLk9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGUsXG5xdWVzdGlvbkhhbmRsZTptYWtlSGFuZGxlU2hhcGUoJ1F1ZXN0aW9uJyksXG5jb3VudGVySW5zdGFuY2U6SW5zdGFuY2VIYW5kbGVTaGFwZX0pO1xuXG5cbi8qIGtleXMgYXJlIHBhcmFtZXRlciBuYW1lcywgdmFsdWVzIGFyZSBwcm9wb3NlZCB2YWx1ZXMqLyRo4oCNX29uY2UuT2ZmZXJGaWx0ZXJRdWVzdGlvbkRldGFpbHNTaGFwZShPZmZlckZpbHRlclF1ZXN0aW9uRGV0YWlsc1NoYXBlKTtcbmNvbnN0ICAgICAgICBQYXJhbUNoYW5nZXNTcGVjU2hhcGU9TS5yZWNvcmRPZihNLnN0cmluZygpLE0uYW55KCkpOyRo4oCNX29uY2UuUGFyYW1DaGFuZ2VzU3BlY1NoYXBlKFBhcmFtQ2hhbmdlc1NwZWNTaGFwZSk7XG5jb25zdCAgICAgICAgWWVzUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZT1QYXJhbUNoYW5nZXNTcGVjU2hhcGU7JGjigI1fb25jZS5ZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlKFllc1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUpO1xuY29uc3QgICAgICAgIE5vUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZT1oYXJkZW4oe1xubm9DaGFuZ2U6TS5hcnJheU9mKE0uc3RyaW5nKCkpfSk7JGjigI1fb25jZS5Ob1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUoTm9QYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlKTtcblxuY29uc3QgICAgICAgIFBhcmFtQ2hhbmdlc1Bvc2l0aW9uc1NoYXBlPWhhcmRlbihbXG5ZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlLFxuTm9QYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlXSk7JGjigI1fb25jZS5QYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZShQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBQYXJhbVBhdGhTaGFwZT1oYXJkZW4oe1xua2V5Ok0uYW55KCl9KTskaOKAjV9vbmNlLlBhcmFtUGF0aFNoYXBlKFBhcmFtUGF0aFNoYXBlKTtcblxuY29uc3QgICAgICAgIFBhcmFtQ2hhbmdlc0lzc3VlU2hhcGU9aGFyZGVuKHtcbnNwZWM6e1xucGFyYW1QYXRoOlBhcmFtUGF0aFNoYXBlLFxuY2hhbmdlczpQYXJhbUNoYW5nZXNTcGVjU2hhcGV9LFxuXG5jb250cmFjdDpJbnN0YW5jZUhhbmRsZVNoYXBlfSk7JGjigI1fb25jZS5QYXJhbUNoYW5nZXNJc3N1ZVNoYXBlKFBhcmFtQ2hhbmdlc0lzc3VlU2hhcGUpO1xuXG5jb25zdCAgICAgICAgUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGU9aGFyZGVuKHtcbm1ldGhvZDondW5yYW5rZWQnLFxuaXNzdWU6UGFyYW1DaGFuZ2VzSXNzdWVTaGFwZSxcbnBvc2l0aW9uczpQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSxcbmVsZWN0aW9uVHlwZToncGFyYW1fY2hhbmdlJyxcbm1heENob2ljZXM6MSxcbm1heFdpbm5lcnM6MSxcbmNsb3NpbmdSdWxlOkNsb3NpbmdSdWxlU2hhcGUsXG5xdW9ydW1SdWxlOidtYWpvcml0eScsXG50aWVPdXRjb21lOk5vUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZX0pOyRo4oCNX29uY2UuUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUoUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBQYXJhbUNoYW5nZXNRdWVzdGlvbkRldGFpbHNTaGFwZT1oYXJkZW4oe1xuLi4uUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUsXG5xdWVzdGlvbkhhbmRsZTptYWtlSGFuZGxlU2hhcGUoJ1F1ZXN0aW9uJyksXG5jb3VudGVySW5zdGFuY2U6SW5zdGFuY2VIYW5kbGVTaGFwZX0pOyRo4oCNX29uY2UuUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUoUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUpO1xuXG5cbmNvbnN0IEFwaUludm9jYXRpb25TcGVjU2hhcGU9aGFyZGVuKHtcbmFwaU1ldGhvZE5hbWU6TS5zdHJpbmcoKSxcbm1ldGhvZEFyZ3M6TS5hcnJheU9mKE0uYW55KCkpfSk7XG5cbmNvbnN0ICAgICAgICBZZXNBcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZT1BcGlJbnZvY2F0aW9uU3BlY1NoYXBlOyRo4oCNX29uY2UuWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUoWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUpO1xuY29uc3QgICAgICAgIE5vQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGU9aGFyZGVuKHtcbmRvbnRJbnZva2U6TS5zdHJpbmcoKX0pOyRo4oCNX29uY2UuTm9BcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZShOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlKTtcblxuY29uc3QgICAgICAgIEFwaUludm9jYXRpb25Qb3NpdGlvbnNTaGFwZT1oYXJkZW4oW1xuWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUsXG5Ob0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlXSk7JGjigI1fb25jZS5BcGlJbnZvY2F0aW9uUG9zaXRpb25zU2hhcGUoQXBpSW52b2NhdGlvblBvc2l0aW9uc1NoYXBlKTtcblxuY29uc3QgICAgICAgIEFwaUludm9jYXRpb25RdWVzdGlvblNwZWNTaGFwZT1oYXJkZW4oe1xubWV0aG9kOid1bnJhbmtlZCcsXG5pc3N1ZTpBcGlJbnZvY2F0aW9uU3BlY1NoYXBlLFxucG9zaXRpb25zOkFwaUludm9jYXRpb25Qb3NpdGlvbnNTaGFwZSxcbmVsZWN0aW9uVHlwZTonYXBpX2ludm9jYXRpb24nLFxubWF4Q2hvaWNlczoxLFxubWF4V2lubmVyczoxLFxuY2xvc2luZ1J1bGU6Q2xvc2luZ1J1bGVTaGFwZSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZVNoYXBlLFxudGllT3V0Y29tZTpOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlfSk7JGjigI1fb25jZS5BcGlJbnZvY2F0aW9uUXVlc3Rpb25TcGVjU2hhcGUoQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuY29uc3QgICAgICAgIEFwaUludm9jYXRpb25RdWVzdGlvbkRldGFpbHNTaGFwZT1oYXJkZW4oe1xuLi4uQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlLFxucXVlc3Rpb25IYW5kbGU6bWFrZUhhbmRsZVNoYXBlKCdRdWVzdGlvbicpLFxuY291bnRlckluc3RhbmNlOkluc3RhbmNlSGFuZGxlU2hhcGV9KTskaOKAjV9vbmNlLkFwaUludm9jYXRpb25RdWVzdGlvbkRldGFpbHNTaGFwZShBcGlJbnZvY2F0aW9uUXVlc3Rpb25EZXRhaWxzU2hhcGUpO1xuXG5cbmNvbnN0IFNpbXBsZVNwZWNTaGFwZT1oYXJkZW4oe1xudGV4dDpNLnN0cmluZygpfSk7XG5cbmNvbnN0ICAgICAgICBZZXNTaW1wbGVQb3NpdGlvblNoYXBlPWhhcmRlbih7dGV4dDpNLnN0cmluZygpfSk7JGjigI1fb25jZS5ZZXNTaW1wbGVQb3NpdGlvblNoYXBlKFllc1NpbXBsZVBvc2l0aW9uU2hhcGUpO1xuY29uc3QgICAgICAgIE5vU2ltcGxlUG9zaXRpb25TaGFwZT1oYXJkZW4oe3RleHQ6TS5zdHJpbmcoKX0pOyRo4oCNX29uY2UuTm9TaW1wbGVQb3NpdGlvblNoYXBlKE5vU2ltcGxlUG9zaXRpb25TaGFwZSk7XG5jb25zdCAgICAgICAgU2ltcGxlUG9zaXRpb25zU2hhcGU9aGFyZGVuKFtcblllc1NpbXBsZVBvc2l0aW9uU2hhcGUsXG5Ob1NpbXBsZVBvc2l0aW9uU2hhcGVdKTskaOKAjV9vbmNlLlNpbXBsZVBvc2l0aW9uc1NoYXBlKFNpbXBsZVBvc2l0aW9uc1NoYXBlKTtcblxuY29uc3QgICAgICAgIFNpbXBsZUlzc3VlU2hhcGU9U2ltcGxlU3BlY1NoYXBlOyRo4oCNX29uY2UuU2ltcGxlSXNzdWVTaGFwZShTaW1wbGVJc3N1ZVNoYXBlKTtcbmNvbnN0ICAgICAgICBTaW1wbGVRdWVzdGlvblNwZWNTaGFwZT1oYXJkZW4oe1xubWV0aG9kOkNob2ljZU1ldGhvZFNoYXBlLFxuaXNzdWU6U2ltcGxlSXNzdWVTaGFwZSxcbnBvc2l0aW9uczpNLmFycmF5T2YoaGFyZGVuKHt0ZXh0Ok0uc3RyaW5nKCl9KSksXG5lbGVjdGlvblR5cGU6TS5vcignZWxlY3Rpb24nLCdzdXJ2ZXknKSxcbm1heENob2ljZXM6TS5ndGUoMSksXG5tYXhXaW5uZXJzOk0uZ3RlKDEpLFxuY2xvc2luZ1J1bGU6Q2xvc2luZ1J1bGVTaGFwZSxcbnF1b3J1bVJ1bGU6UXVvcnVtUnVsZVNoYXBlLFxudGllT3V0Y29tZTpOb1NpbXBsZVBvc2l0aW9uU2hhcGV9KTskaOKAjV9vbmNlLlNpbXBsZVF1ZXN0aW9uU3BlY1NoYXBlKFNpbXBsZVF1ZXN0aW9uU3BlY1NoYXBlKTtcblxuY29uc3QgICAgICAgIFNpbXBsZVF1ZXN0aW9uRGV0YWlsc1NoYXBlPWhhcmRlbih7XG4uLi5TaW1wbGVRdWVzdGlvblNwZWNTaGFwZSxcbnF1ZXN0aW9uSGFuZGxlOm1ha2VIYW5kbGVTaGFwZSgnUXVlc3Rpb24nKSxcbmNvdW50ZXJJbnN0YW5jZTpJbnN0YW5jZUhhbmRsZVNoYXBlfSk7JGjigI1fb25jZS5TaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZShTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIFF1ZXN0aW9uU3BlY1NoYXBlPU0ub3IoXG5BcGlJbnZvY2F0aW9uUXVlc3Rpb25TcGVjU2hhcGUsXG5PZmZlckZpbHRlclF1ZXN0aW9uU3BlY1NoYXBlLFxuUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUsXG5TaW1wbGVRdWVzdGlvblNwZWNTaGFwZSk7JGjigI1fb25jZS5RdWVzdGlvblNwZWNTaGFwZShRdWVzdGlvblNwZWNTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIFBvc2l0aW9uU2hhcGU9TS5vcihcblllc0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlLFxuTm9BcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZSxcblllc09mZmVyRmlsdGVyUG9zaXRpb25TaGFwZSxcbk5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlLFxuWWVzU2ltcGxlUG9zaXRpb25TaGFwZSxcbk5vU2ltcGxlUG9zaXRpb25TaGFwZSxcblllc1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUsXG5Ob1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUpOyRo4oCNX29uY2UuUG9zaXRpb25TaGFwZShQb3NpdGlvblNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgUXVlc3Rpb25IYW5kbGVTaGFwZT1tYWtlSGFuZGxlU2hhcGUoJ3F1ZXN0aW9uJyk7XG5cbi8qIFRPRE8oaGliYmVydCk6IGFkZCBkZXRhaWxzOyBtb3ZlIHRvIGEgbW9yZSBhcHByb3ByaWF0ZSBsb2NhdGlvbiovJGjigI1fb25jZS5RdWVzdGlvbkhhbmRsZVNoYXBlKFF1ZXN0aW9uSGFuZGxlU2hhcGUpO1xuY29uc3QgICAgICAgIEludml0YXRpb25TaGFwZT1NLnJlbW90YWJsZSgnSW52aXRhdGlvbicpO1xuXG4vKiBYWFggSSB3YW50IHRvIGFkZCBxdWVzdGlvbkhhbmRsZSBhbmQgY291bnRlckluc3RhbmNlIHRvKi9cbi8qIFBhcmFtQ2hhbmdlc1F1ZXN0aW9uU3BlY1NoYXBlLiBJIGRvbid0IHNlZSBhbnkgYWx0ZXJuYXRpdmUgdG8gYWRkaW5nIHRoZSovXG4vKiBtZXRob2RzIHRvIGVhY2ggbWVtYmVyIHNlcGFyYXRlbHkqLyRo4oCNX29uY2UuSW52aXRhdGlvblNoYXBlKEludml0YXRpb25TaGFwZSk7XG5jb25zdCAgICAgICAgUXVlc3Rpb25EZXRhaWxzU2hhcGU9TS5vcihcblBhcmFtQ2hhbmdlc1F1ZXN0aW9uRGV0YWlsc1NoYXBlLFxuQXBpSW52b2NhdGlvblF1ZXN0aW9uRGV0YWlsc1NoYXBlLFxuT2ZmZXJGaWx0ZXJRdWVzdGlvbkRldGFpbHNTaGFwZSxcblNpbXBsZVF1ZXN0aW9uRGV0YWlsc1NoYXBlKTskaOKAjV9vbmNlLlF1ZXN0aW9uRGV0YWlsc1NoYXBlKFF1ZXN0aW9uRGV0YWlsc1NoYXBlKTtcblxuXG5jb25zdCAgICAgICAgRWxlY3RvcmF0ZVB1YmxpY0k9TS5pbnRlcmZhY2UoJ0NvbW1pdHRlZSBQdWJsaWNGYWNldCcse1xuZ2V0UXVlc3Rpb25TdWJzY3JpYmVyOk0uY2FsbCgpLnJldHVybnMoU3Vic2NyaWJlclNoYXBlKSxcbmdldE9wZW5RdWVzdGlvbnM6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXROYW1lOk0uY2FsbCgpLnJldHVybnMoTS5zdHJpbmcoKSksXG5nZXRJbnN0YW5jZTpNLmNhbGwoKS5yZXR1cm5zKEluc3RhbmNlSGFuZGxlU2hhcGUpLFxuZ2V0UXVlc3Rpb246TS5jYWxsKFF1ZXN0aW9uSGFuZGxlU2hhcGUpLnJldHVybnMoTS5wcm9taXNlKCkpfSk7JGjigI1fb25jZS5FbGVjdG9yYXRlUHVibGljSShFbGVjdG9yYXRlUHVibGljSSk7XG5cbmNvbnN0IEVsZWN0b3JhdGVQdWJsaWNTaGFwZT1NLnJlbW90YWJsZSgnRWxlY3RvcmF0ZVB1YmxpYycpO1xuXG5jb25zdCAgICAgICAgRWxlY3RvcmF0ZUNyZWF0b3JJPU0uaW50ZXJmYWNlKCdDb21taXR0ZWUgQWRtaW5GYWNldCcse1xuZ2V0UG9zZXJJbnZpdGF0aW9uOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuYWRkUXVlc3Rpb246TS5jYWxsKEluc3RhbmNlSGFuZGxlU2hhcGUsUXVlc3Rpb25TcGVjU2hhcGUpLnJldHVybnMoXG5NLnByb21pc2UoKSksXG5cbmdldFZvdGVySW52aXRhdGlvbnM6TS5jYWxsKCkucmV0dXJucyhNLmFycmF5T2YoTS5wcm9taXNlKCkpKSxcbmdldFF1ZXN0aW9uU3Vic2NyaWJlcjpNLmNhbGwoKS5yZXR1cm5zKFN1YnNjcmliZXJTaGFwZSksXG5nZXRQdWJsaWNGYWNldDpNLmNhbGwoKS5yZXR1cm5zKEVsZWN0b3JhdGVQdWJsaWNTaGFwZSl9KTskaOKAjV9vbmNlLkVsZWN0b3JhdGVDcmVhdG9ySShFbGVjdG9yYXRlQ3JlYXRvckkpO1xuXG5cbmNvbnN0ICAgICAgICBRdWVzdGlvblN0YXRzU2hhcGU9aGFyZGVuKHtcbnNwb2lsZWQ6TS5uYXQoKSxcbnZvdGVzOk0ubmF0KCksXG5yZXN1bHRzOk0uYXJyYXlPZih7cG9zaXRpb246UG9zaXRpb25TaGFwZSx0b3RhbDpNLm5hdCgpfSl9KTskaOKAjV9vbmNlLlF1ZXN0aW9uU3RhdHNTaGFwZShRdWVzdGlvblN0YXRzU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBRdWVzdGlvbkk9TS5pbnRlcmZhY2UoJ1F1ZXN0aW9uJyx7XG5nZXRWb3RlQ291bnRlcjpNLmNhbGwoKS5yZXR1cm5zKEluc3RhbmNlSGFuZGxlU2hhcGUpLFxuZ2V0RGV0YWlsczpNLmNhbGwoKS5yZXR1cm5zKFF1ZXN0aW9uRGV0YWlsc1NoYXBlKX0pOyRo4oCNX29uY2UuUXVlc3Rpb25JKFF1ZXN0aW9uSSk7XG5cbmNvbnN0IFF1ZXN0aW9uU2hhcGU9TS5yZW1vdGFibGUoJ1F1ZXN0aW9uJyk7XG5cbmNvbnN0ICAgICAgICBCaW5hcnlWb3RlQ291bnRlclB1YmxpY0k9TS5pbnRlcmZhY2UoXG4nQmluYXJ5Vm90ZUNvdW50ZXIgUHVibGljRmFjZXQnLFxue1xuZ2V0UXVlc3Rpb246TS5jYWxsKCkucmV0dXJucyhRdWVzdGlvblNoYXBlKSxcbmlzT3BlbjpNLmNhbGwoKS5yZXR1cm5zKE0uYm9vbGVhbigpKSxcbmdldE91dGNvbWU6TS5jYWxsKCkucmV0dXJucyhNLmVyZWYoTS5wcm9taXNlKCkpKSxcbmdldFN0YXRzOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0RGV0YWlsczpNLmNhbGwoKS5yZXR1cm5zKFF1ZXN0aW9uRGV0YWlsc1NoYXBlKSxcbmdldEluc3RhbmNlOk0uY2FsbCgpLnJldHVybnMoSW5zdGFuY2VIYW5kbGVTaGFwZSl9KTskaOKAjV9vbmNlLkJpbmFyeVZvdGVDb3VudGVyUHVibGljSShCaW5hcnlWb3RlQ291bnRlclB1YmxpY0kpO1xuXG5cblxuY29uc3QgICAgICAgIFZvdGVySGFuZGxlPU0ucmVtb3RhYmxlKCk7JGjigI1fb25jZS5Wb3RlckhhbmRsZShWb3RlckhhbmRsZSk7XG5jb25zdCAgICAgICAgQmluYXJ5Vm90ZUNvdW50ZXJBZG1pbkk9TS5pbnRlcmZhY2UoXG4nQmluYXJ5Vm90ZUNvdW50ZXIgQWRtaW5GYWNldCcsXG57XG5zdWJtaXRWb3RlOk0uY2FsbChWb3RlckhhbmRsZSxNLmFycmF5T2YoUG9zaXRpb25TaGFwZSkpLlxub3B0aW9uYWwoTS5uYXQoKSkuXG5yZXR1cm5zKHtjaG9zZW46UG9zaXRpb25TaGFwZSxzaGFyZXM6TS5uYXQoKX0pfSk7JGjigI1fb25jZS5CaW5hcnlWb3RlQ291bnRlckFkbWluSShCaW5hcnlWb3RlQ291bnRlckFkbWluSSk7XG5cblxuXG5jb25zdCAgICAgICAgQmluYXJ5Vm90ZUNvdW50ZXJDbG9zZUk9TS5pbnRlcmZhY2UoXG4nQmluYXJ5Vm90ZUNvdW50ZXIgQ2xvc2VGYWNldCcsXG57XG5jbG9zZVZvdGluZzpNLmNhbGwoKS5yZXR1cm5zKCl9KTskaOKAjV9vbmNlLkJpbmFyeVZvdGVDb3VudGVyQ2xvc2VJKEJpbmFyeVZvdGVDb3VudGVyQ2xvc2VJKTtcblxuXG5cbmNvbnN0ICAgICAgICBWb3RlQ291bnRlclB1YmxpY0k9TS5pbnRlcmZhY2UoJ1ZvdGVDb3VudGVyIFB1YmxpY0ZhY2V0Jyx7XG5nZXRRdWVzdGlvbjpNLmNhbGwoKS5yZXR1cm5zKFF1ZXN0aW9uU2hhcGUpLFxuaXNPcGVuOk0uY2FsbCgpLnJldHVybnMoTS5ib29sZWFuKCkpLFxuZ2V0T3V0Y29tZTpNLmNhbGwoKS5yZXR1cm5zKE0uZXJlZihNLnByb21pc2UoKSkpLFxuZ2V0U3RhdHM6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXREZXRhaWxzOk0uY2FsbCgpLnJldHVybnMoUXVlc3Rpb25EZXRhaWxzU2hhcGUpLFxuZ2V0SW5zdGFuY2U6TS5jYWxsKCkucmV0dXJucyhJbnN0YW5jZUhhbmRsZVNoYXBlKX0pOyRo4oCNX29uY2UuVm90ZUNvdW50ZXJQdWJsaWNJKFZvdGVDb3VudGVyUHVibGljSSk7XG5cblxuY29uc3QgICAgICAgIFZvdGVDb3VudGVyQWRtaW5JPU0uaW50ZXJmYWNlKCdWb3RlQ291bnRlciBBZG1pbkZhY2V0Jyx7XG5zdWJtaXRWb3RlOk0uY2FsbChWb3RlckhhbmRsZSxNLmFycmF5T2YoUG9zaXRpb25TaGFwZSkpLlxub3B0aW9uYWwoTS5uYXQoKSkuXG5yZXR1cm5zKHtjaG9zZW46TS5hcnJheU9mKFBvc2l0aW9uU2hhcGUpLHNoYXJlczpNLm5hdCgpfSl9KTskaOKAjV9vbmNlLlZvdGVDb3VudGVyQWRtaW5JKFZvdGVDb3VudGVyQWRtaW5JKTtcblxuXG5jb25zdCAgICAgICAgVm90ZUNvdW50ZXJDbG9zZUk9TS5pbnRlcmZhY2UoJ1ZvdGVDb3VudGVyIENsb3NlRmFjZXQnLHtcbmNsb3NlVm90aW5nOk0uY2FsbCgpLnJldHVybnMoKX0pOyRo4oCNX29uY2UuVm90ZUNvdW50ZXJDbG9zZUkoVm90ZUNvdW50ZXJDbG9zZUkpO1xuXG5cbmNvbnN0ICAgICAgICBHb3Zlcm5vckZhY2V0U2hhcGU9e1xuZ2V0UGFyYW1NZ3JSZXRyaWV2ZXI6TS5jYWxsKCkucmV0dXJucyhNLnJlbW90YWJsZSgncGFyYW1SZXRyaWV2ZXInKSksXG5nZXRJbnZpdGF0aW9uOk0uY2FsbCgpLnJldHVybnMoSW52aXRhdGlvblNoYXBlKSxcbmdldExpbWl0ZWRDcmVhdG9yRmFjZXQ6TS5jYWxsKCkucmV0dXJucyhNLnJlbW90YWJsZSgpKSxcbmdldEdvdmVybmVkQXBpczpNLmNhbGwoKS5yZXR1cm5zKE0ucmVtb3RhYmxlKCdnb3Zlcm5lZEFQSXMnKSksXG5nZXRHb3Zlcm5lZEFwaU5hbWVzOk0uY2FsbCgpLnJldHVybnMoTS5hcnJheU9mKE0uc3RyaW5nKCkpKSxcbnNldE9mZmVyRmlsdGVyOk0uY2FsbChNLmFycmF5T2YoTS5zdHJpbmcoKSkpLnJldHVybnMoTS5wcm9taXNlKCkpfTskaOKAjV9vbmNlLkdvdmVybm9yRmFjZXRTaGFwZShHb3Zlcm5vckZhY2V0U2hhcGUpO1xuXG5oYXJkZW4oR292ZXJub3JGYWNldFNoYXBlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJDaG9pY2VNZXRob2RTaGFwZSI6WyJDaG9pY2VNZXRob2RTaGFwZSJdLCJRdW9ydW1SdWxlU2hhcGUiOlsiUXVvcnVtUnVsZVNoYXBlIl0sIkVsZWN0aW9uVHlwZVNoYXBlIjpbIkVsZWN0aW9uVHlwZVNoYXBlIl0sIkNsb3NpbmdSdWxlU2hhcGUiOlsiQ2xvc2luZ1J1bGVTaGFwZSJdLCJZZXNPZmZlckZpbHRlclBvc2l0aW9uU2hhcGUiOlsiWWVzT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlIl0sIk5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlIjpbIk5vT2ZmZXJGaWx0ZXJQb3NpdGlvblNoYXBlIl0sIk9mZmVyRmlsdGVyUG9zaXRpb25zU2hhcGUiOlsiT2ZmZXJGaWx0ZXJQb3NpdGlvbnNTaGFwZSJdLCJPZmZlckZpbHRlcklzc3VlU2hhcGUiOlsiT2ZmZXJGaWx0ZXJJc3N1ZVNoYXBlIl0sIk9mZmVyRmlsdGVyUXVlc3Rpb25TcGVjU2hhcGUiOlsiT2ZmZXJGaWx0ZXJRdWVzdGlvblNwZWNTaGFwZSJdLCJPZmZlckZpbHRlclF1ZXN0aW9uRGV0YWlsc1NoYXBlIjpbIk9mZmVyRmlsdGVyUXVlc3Rpb25EZXRhaWxzU2hhcGUiXSwiUGFyYW1DaGFuZ2VzU3BlY1NoYXBlIjpbIlBhcmFtQ2hhbmdlc1NwZWNTaGFwZSJdLCJZZXNQYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlIjpbIlllc1BhcmFtQ2hhbmdlc1Bvc2l0aW9uU2hhcGUiXSwiTm9QYXJhbUNoYW5nZXNQb3NpdGlvblNoYXBlIjpbIk5vUGFyYW1DaGFuZ2VzUG9zaXRpb25TaGFwZSJdLCJQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSI6WyJQYXJhbUNoYW5nZXNQb3NpdGlvbnNTaGFwZSJdLCJQYXJhbVBhdGhTaGFwZSI6WyJQYXJhbVBhdGhTaGFwZSJdLCJQYXJhbUNoYW5nZXNJc3N1ZVNoYXBlIjpbIlBhcmFtQ2hhbmdlc0lzc3VlU2hhcGUiXSwiUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUiOlsiUGFyYW1DaGFuZ2VzUXVlc3Rpb25TcGVjU2hhcGUiXSwiUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUiOlsiUGFyYW1DaGFuZ2VzUXVlc3Rpb25EZXRhaWxzU2hhcGUiXSwiWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUiOlsiWWVzQXBpSW52b2NhdGlvblBvc2l0aW9uU2hhcGUiXSwiTm9BcGlJbnZvY2F0aW9uUG9zaXRpb25TaGFwZSI6WyJOb0FwaUludm9jYXRpb25Qb3NpdGlvblNoYXBlIl0sIkFwaUludm9jYXRpb25Qb3NpdGlvbnNTaGFwZSI6WyJBcGlJbnZvY2F0aW9uUG9zaXRpb25zU2hhcGUiXSwiQXBpSW52b2NhdGlvblF1ZXN0aW9uU3BlY1NoYXBlIjpbIkFwaUludm9jYXRpb25RdWVzdGlvblNwZWNTaGFwZSJdLCJBcGlJbnZvY2F0aW9uUXVlc3Rpb25EZXRhaWxzU2hhcGUiOlsiQXBpSW52b2NhdGlvblF1ZXN0aW9uRGV0YWlsc1NoYXBlIl0sIlllc1NpbXBsZVBvc2l0aW9uU2hhcGUiOlsiWWVzU2ltcGxlUG9zaXRpb25TaGFwZSJdLCJOb1NpbXBsZVBvc2l0aW9uU2hhcGUiOlsiTm9TaW1wbGVQb3NpdGlvblNoYXBlIl0sIlNpbXBsZVBvc2l0aW9uc1NoYXBlIjpbIlNpbXBsZVBvc2l0aW9uc1NoYXBlIl0sIlNpbXBsZUlzc3VlU2hhcGUiOlsiU2ltcGxlSXNzdWVTaGFwZSJdLCJTaW1wbGVRdWVzdGlvblNwZWNTaGFwZSI6WyJTaW1wbGVRdWVzdGlvblNwZWNTaGFwZSJdLCJTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSI6WyJTaW1wbGVRdWVzdGlvbkRldGFpbHNTaGFwZSJdLCJRdWVzdGlvblNwZWNTaGFwZSI6WyJRdWVzdGlvblNwZWNTaGFwZSJdLCJQb3NpdGlvblNoYXBlIjpbIlBvc2l0aW9uU2hhcGUiXSwiUXVlc3Rpb25IYW5kbGVTaGFwZSI6WyJRdWVzdGlvbkhhbmRsZVNoYXBlIl0sIkludml0YXRpb25TaGFwZSI6WyJJbnZpdGF0aW9uU2hhcGUiXSwiUXVlc3Rpb25EZXRhaWxzU2hhcGUiOlsiUXVlc3Rpb25EZXRhaWxzU2hhcGUiXSwiRWxlY3RvcmF0ZVB1YmxpY0kiOlsiRWxlY3RvcmF0ZVB1YmxpY0kiXSwiRWxlY3RvcmF0ZUNyZWF0b3JJIjpbIkVsZWN0b3JhdGVDcmVhdG9ySSJdLCJRdWVzdGlvblN0YXRzU2hhcGUiOlsiUXVlc3Rpb25TdGF0c1NoYXBlIl0sIlF1ZXN0aW9uSSI6WyJRdWVzdGlvbkkiXSwiQmluYXJ5Vm90ZUNvdW50ZXJQdWJsaWNJIjpbIkJpbmFyeVZvdGVDb3VudGVyUHVibGljSSJdLCJWb3RlckhhbmRsZSI6WyJWb3RlckhhbmRsZSJdLCJCaW5hcnlWb3RlQ291bnRlckFkbWluSSI6WyJCaW5hcnlWb3RlQ291bnRlckFkbWluSSJdLCJCaW5hcnlWb3RlQ291bnRlckNsb3NlSSI6WyJCaW5hcnlWb3RlQ291bnRlckNsb3NlSSJdLCJWb3RlQ291bnRlclB1YmxpY0kiOlsiVm90ZUNvdW50ZXJQdWJsaWNJIl0sIlZvdGVDb3VudGVyQWRtaW5JIjpbIlZvdGVDb3VudGVyQWRtaW5JIl0sIlZvdGVDb3VudGVyQ2xvc2VJIjpbIlZvdGVDb3VudGVyQ2xvc2VJIl0sIkdvdmVybm9yRmFjZXRTaGFwZSI6WyJHb3Zlcm5vckZhY2V0U2hhcGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAPWNrkWNhAABjYQAANQAAAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy90eXBlcy1hbWJpZW50LmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyoqXG4gKiBAdHlwZWRlZiB7ICd1bnJhbmtlZCcgfCAnb3JkZXInIHwgJ3BsdXJhbGl0eScgfSBDaG9pY2VNZXRob2RcbiAqICogVU5SQU5LRUQ6IFwidW5yYW5rZWQgdm90aW5nXCIgbWVhbnMgdGhhdCB0aGUgdm90ZXIgc3BlY2lmaWVzIHNvbWUgbnVtYmVyIG9mXG4gKiAgICBwb3NpdGlvbnMsIGFuZCBpcyBlbmRvcnNpbmcgdGhlbSBlcXVhbGx5LlxuICogKiBPUkRFUjogVGhlIHZvdGVyIGFzc2lnbnMgb3JkaW5hbCBudW1iZXJzIHRvIHNvbWUgb2YgdGhlIHBvc2l0aW9ucy4gVGhlXG4gKiAgICBwb3NpdGlvbnMgd2lsbCBiZSB0cmVhdGVkIGFzIGFuIG9yZGVyZWQgbGlzdCB3aXRoIG5vIGdhcHMuXG4gKlxuICogV2hlbiB2b3RlcnMgYXJlIGxpbWl0ZWQgdG8gY2hvb3NpbmcgYSBzaW5nbGUgY2FuZGlkYXRlLCBlaXRoZXIgVU5SQU5LRUQgb3JcbiAqIE9SREVSIHdvdWxkIHdvcmsuIFVOUkFOS0VEIGhhcyBhIHNpbXBsZXIgcmVwcmVzZW50YXRpb24gc28gd2UgdXNlIHRoYXQuXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7ICdwYXJhbV9jaGFuZ2UnIHwgJ2VsZWN0aW9uJyB8ICdzdXJ2ZXknIHwgJ2FwaV9pbnZvY2F0aW9uJyB8XG4gKiAgICdvZmZlcl9maWx0ZXInIH0gRWxlY3Rpb25UeXBlXG4gKiBwYXJhbV9jaGFuZ2UgaXMgdmVyeSBzcGVjaWZpYy4gU3VydmV5IG1lYW5zIG11bHRpcGxlIGFuc3dlcnMgYXJlIHBvc3NpYmxlLFxuICogRWxlY3Rpb24gbWVhbnMgc29tZSBjYW5kaWRhdGVzIGFyZSBnb2luZyB0byBcIndpblwiLiBJdCdzIG5vdCBjbGVhciB0aGVzZSBhcmVcbiAqIG9ydGhvZ29uYWwuIFRoZSBpbXBvcnRhbnQgZGlzdGluY3Rpb24gaXMgdGhhdCBwYXJhbV9jaGFuZ2UgaGFzIGEgc3RydWN0dXJlZFxuICogaXNzdWUsIHdoaWxlIHRoZSBvdGhlcnMgaGF2ZSBhIGlzc3VlIHByZXNlbnRlZCBhcyBhIHN0cmluZy5cbiAqL1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vY29uc3RhbnRzLmpzJykuUGFyYW1UeXBlfSBQYXJhbVR5cGUgKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7ICdtYWpvcml0eScgfCAnYWxsJyB8ICdub19xdW9ydW0nIH0gUXVvcnVtUnVsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gU2ltcGxlSXNzdWVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSB0ZXh0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IEFtb3VudCB8IEJyYW5kIHwgSW5zdGFsbGF0aW9uIHwgSW5zdGFuY2UgfCBiaWdpbnQgfFxuICogICBSYXRpbyB8IHN0cmluZyB8IFhpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lc3RhbXBSZWNvcmQgfFxuICogICBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuUmVsYXRpdmVUaW1lUmVjb3JkIHwgdW5rbm93biB9IFBhcmFtVmFsdWVcbiAqL1xuXG4vKiBYWFggYmV0dGVyIHRvIHVzZSB0aGUgbWFuaWZlc3QgY29uc3RhbnQgUGFyYW1UeXBlcyovXG4vKiBidXQgaW1wb3J0aW5nIHRoYXQgaGVyZSB0dXJucyB0aGlzIGZpbGUgaW50byBhIG1vZHVsZSwqL1xuLyogYnJlYWtpbmcgdGhlIGFtYmllbnQgdHlwaW5nKi9cbi8qKlxuICogQHRlbXBsYXRlIHtQYXJhbVR5cGV9IFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgJ2Ftb3VudCcgPyBBbW91bnQ8YW55PiA6XG4gKiBUIGV4dGVuZHMgJ2JyYW5kJyA/IEJyYW5kIDpcbiAqIFQgZXh0ZW5kcyAnaW5zdGFsbGF0aW9uJyA/IEluc3RhbGxhdGlvbjpcbiAqIFQgZXh0ZW5kcyAnaW5zdGFuY2UnID8gSW5zdGFuY2UgOlxuICogVCBleHRlbmRzICdpbnZpdGF0aW9uJyA/IEFtb3VudDwnc2V0Jz4gOiAvLyBYWFggdGhpcyBpcyB0aGUgZ2V0dGVyIHZhbHVlIGJ1dCBub3QgdGhlIHNldHRlclxuICogVCBleHRlbmRzICduYXQnID8gYmlnaW50IDpcbiAqIFQgZXh0ZW5kcyAncmF0aW8nID8gUmF0aW8gOlxuICogVCBleHRlbmRzICdzdHJpbmcnID8gc3RyaW5nIDpcbiAqIFQgZXh0ZW5kcyAndGltZXN0YW1wJyA/IFhpbXBvcnQoJ0BhZ29yaWMvdGltZScpLlRpbWVzdGFtcCA6XG4gKiBUIGV4dGVuZHMgJ3JlbGF0aXZlVGltZScgPyBYaW1wb3J0KCdAYWdvcmljL3RpbWUnKS5SZWxhdGl2ZVRpbWUgOlxuICogVCBleHRlbmRzICd1bmtub3duJyA/IHVua25vd24gOlxuICogbmV2ZXJcbiAqIH0gUGFyYW1WYWx1ZUZvclR5cGVcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UGFyYW1UeXBlfSBbVD1QYXJhbVR5cGVdXG4gKiBAdHlwZWRlZiB7eyB0eXBlOiBULCB2YWx1ZTogUGFyYW1WYWx1ZUZvclR5cGU8VD4gfX0gUGFyYW1WYWx1ZVR5cGVkPFQ+XG4gKi9cblxuLyoqXG4gKiBUZXJtcyBhIGNvbnRyYWN0IG11c3QgcHJvdmlkZSBpbiBvcmRlciB0byBiZSBnb3Zlcm5lZC5cbiAqXG4gKiBAdGVtcGxhdGUge1hpbXBvcnQoJy4vY29udHJhY3RHb3Zlcm5hbmNlL3R5cGVkUGFyYW1NYW5hZ2VyLmpzJykuUGFyYW1UeXBlc01hcH0gVCBHb3Zlcm5lZCBwYXJhbWV0ZXJzIG9mIGNvbnRyYWN0XG4gKiBAdHlwZWRlZiB7e1xuICogICBlbGVjdGlvbk1hbmFnZXI6IFhpbXBvcnQoJ0BhZ29yaWMvem9lL3NyYy96b2VTZXJ2aWNlL3V0aWxzLmpzJykuSW5zdGFuY2U8WGltcG9ydCgnLi9jb250cmFjdEdvdmVybm9yLmpzJylbJ3ByZXBhcmUnXT4sXG4gKiAgIGdvdmVybmVkUGFyYW1zOiBYaW1wb3J0KCcuL2NvbnRyYWN0R292ZXJuYW5jZS90eXBlZFBhcmFtTWFuYWdlci5qcycpLlBhcmFtUmVjb3Jkc0Zyb21UeXBlczxUICYge1xuICogICAgIEVsZWN0b3JhdGU6ICdpbnZpdGF0aW9uJ1xuICogICB9PlxuICogfX0gR292ZXJuYW5jZVRlcm1zPFQ+XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IFNpbXBsZUlzc3VlIHwgUGFyYW1DaGFuZ2VJc3N1ZTx1bmtub3duPiB8IEFwaUludm9jYXRpb25Jc3N1ZSB8XG4gKiAgIE9mZmVyRmlsdGVySXNzdWUgfSBJc3N1ZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUXVlc3Rpb25UZXJtcyAtIFF1ZXN0aW9uU3BlYyBwbHVzIHRoZSBFbGVjdG9yYXRlIEluc3RhbmNlIGFuZFxuICogICBhIG51bWVyaWNhbCB0aHJlc2hvbGQgZm9yIHRoZSBxdW9ydW0uIChUaGUgdm90ZUNvdW50ZXIgZG9lc24ndCBrbm93IHRoZVxuICogICBzaXplIG9mIHRoZSBlbGVjdG9yYXRlLCBzbyB0aGUgRWxlY3RvcmF0ZSBoYXMgdG8gc2F5IHdoYXQgbGltaXQgdG8gZW5mb3JjZS4pXG4gKiBAcHJvcGVydHkge1F1ZXN0aW9uU3BlY30gcXVlc3Rpb25TcGVjXG4gKiBAcHJvcGVydHkge251bWJlcn0gcXVvcnVtVGhyZXNob2xkXG4gKiBAcHJvcGVydHkge0luc3RhbmNlfSBlbGVjdG9yYXRlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBUZXh0UG9zaXRpb25cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSB0ZXh0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7IFRleHRQb3NpdGlvbiB8IENoYW5nZVBhcmFtc1Bvc2l0aW9uIHwgTm9DaGFuZ2VQYXJhbXNQb3NpdGlvbiB8IEludm9rZUFwaVBvc2l0aW9uIHwgRG9udEludm9rZUFwaVBvc2l0aW9uIHxcbiAqICAgIE9mZmVyRmlsdGVyUG9zaXRpb24gfCBOb0NoYW5nZU9mZmVyRmlsdGVyUG9zaXRpb24gfCBJbnZva2VBcGlQb3NpdGlvbiB9IFBvc2l0aW9uXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7eyBxdWVzdGlvbjogSGFuZGxlPCdRdWVzdGlvbic+IH0gJiAoXG4gKiAgIHsgb3V0Y29tZTogJ3dpbicsIHBvc2l0aW9uOiBQb3NpdGlvbiB9IHxcbiAqICAgeyBvdXRjb21lOiAnZmFpbCcsIHJlYXNvbjogJ05vIHF1b3J1bScgfVxuICogKX0gT3V0Y29tZVJlY29yZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge3sgcXVlc3Rpb246IEhhbmRsZTwnUXVlc3Rpb24nPiB9ICYgKFxuICogIHsgb3V0Y29tZTogJ3dpbicsIHBvc2l0aW9uczogUG9zaXRpb25bXSB9IHxcbiAqICB7IG91dGNvbWU6ICdmYWlsJywgcmVhc29uOiAnTm8gcXVvcnVtJyB9XG4gKiApfSBNdWx0aU91dGNvbWVSZWNvcmRcbiAqL1xuXG4vKipcbiAqIFNwZWNpZmljYXRpb24gd2hlbiByZXF1ZXN0aW5nIGNyZWF0aW9uIG9mIGEgUXVlc3Rpb25cbiAqXG4gKiBAdGVtcGxhdGUge0lzc3VlfSBbST1Jc3N1ZV1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IFF1ZXN0aW9uU3BlY1xuICogQHByb3BlcnR5IHtDaG9pY2VNZXRob2R9IG1ldGhvZFxuICogQHByb3BlcnR5IHtJfSBpc3N1ZVxuICogQHByb3BlcnR5IHtQb3NpdGlvbltdfSBwb3NpdGlvbnNcbiAqIEBwcm9wZXJ0eSB7RWxlY3Rpb25UeXBlfSBlbGVjdGlvblR5cGVcbiAqIEBwcm9wZXJ0eSB7bnVtYmVyfSBtYXhDaG9pY2VzXG4gKiBAcHJvcGVydHkge251bWJlcn0gbWF4V2lubmVyc1xuICogQHByb3BlcnR5IHtDbG9zaW5nUnVsZX0gY2xvc2luZ1J1bGVcbiAqIEBwcm9wZXJ0eSB7UXVvcnVtUnVsZX0gcXVvcnVtUnVsZVxuICogQHByb3BlcnR5IHtQb3NpdGlvbn0gdGllT3V0Y29tZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUXVlc3Rpb25EZXRhaWxzRXh0cmFQcm9wZXJ0aWVzXG4gKiBAcHJvcGVydHkge0luc3RhbmNlfSBjb3VudGVySW5zdGFuY2UgLSBpbnN0YW5jZSBvZiB0aGUgVm90ZUNvdW50ZXJcbiAqIEBwcm9wZXJ0eSB7SGFuZGxlPCdRdWVzdGlvbic+fSBxdWVzdGlvbkhhbmRsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge1F1ZXN0aW9uU3BlYyAmIFF1ZXN0aW9uRGV0YWlsc0V4dHJhUHJvcGVydGllc30gUXVlc3Rpb25EZXRhaWxzXG4gKiAgICBjb21wbGV0ZSBxdWVzdGlvbiBkZXRhaWxzOiBxdWVzdGlvblNwZWMgcGx1cyBjb3VudGVyIGFuZCBxdWVzdGlvbkhhbmRsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gR292ZXJuYW5jZVBhaXJcbiAqIEBwcm9wZXJ0eSB7SW5zdGFuY2V9IGdvdmVybm9yXG4gKiBAcHJvcGVydHkge0luc3RhbmNlfSBnb3Zlcm5lZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUXVlc3Rpb25cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gSW5zdGFuY2V9IGdldFZvdGVDb3VudGVyXG4gKiBAcHJvcGVydHkgeygpID0+IFF1ZXN0aW9uRGV0YWlsc30gZ2V0RGV0YWlsc1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQ29tcGxldGVVbnJhbmtlZFF1ZXN0aW9uXG4gKiBAcHJvcGVydHkge0hhbmRsZTwnUXVlc3Rpb24nPn0gcXVlc3Rpb25IYW5kbGVcbiAqIEBwcm9wZXJ0eSB7UG9zaXRpb25bXX0gY2hvc2VuIC0gYSBsaXN0IG9mIGVxdWFsLXdlaWdodCBwcmVmZXJyZWQgcG9zaXRpb25zXG4gKi9cblxuLyogbm90IHlldCBpbiB1c2UqL1xuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb21wbGV0ZVdlaWdodGVkQmFsbG90XG4gKiBAcHJvcGVydHkge0hhbmRsZTwnUXVlc3Rpb24nPn0gcXVlc3Rpb25IYW5kbGVcbiAqIEBwcm9wZXJ0eSB7W1Bvc2l0aW9uLGJpZ2ludF1bXX0gd2VpZ2h0ZWQgLSBsaXN0IG9mIHBvc2l0aW9ucyB3aXRoXG4gKiAgIHdlaWdodHMuIFZvdGVDb3VudGVyIG1heSBsaW1pdCB3ZWlnaHRzIHRvIGEgcmFuZ2Ugb3IgcmVxdWlyZSB1bmlxdWVuZXNzLlxuICovXG5cbi8qIG5vdCB5ZXQgaW4gdXNlKi9cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQ29tcGxldGVPcmRlcmVkQmFsbG90XG4gKiBAcHJvcGVydHkge0hhbmRsZTwnUXVlc3Rpb24nPn0gcXVlc3Rpb25IYW5kbGVcbiAqIEBwcm9wZXJ0eSB7UG9zaXRpb25bXX0gb3JkZXJlZCAtIG9yZGVyZWQgbGlzdCBvZiBwb3NpdGlvbiBmcm9tIG1vc3QgcHJlZmVycmVkXG4gKiAgIHRvIGxlYXN0IHByZWZlcnJlZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUG9zaXRpb25Db3VudFxuICogQHByb3BlcnR5IHtQb3NpdGlvbn0gcG9zaXRpb25cbiAqIEBwcm9wZXJ0eSB7YmlnaW50fSB0b3RhbFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gVm90ZVN0YXRpc3RpY3NcbiAqIEBwcm9wZXJ0eSB7YmlnaW50fSBzcG9pbGVkXG4gKiBAcHJvcGVydHkge251bWJlcn0gdm90ZXNcbiAqIEBwcm9wZXJ0eSB7UG9zaXRpb25Db3VudFtdfSByZXN1bHRzXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBRdW9ydW1Db3VudGVyXG4gKiBAcHJvcGVydHkgeyhzdGF0czogVm90ZVN0YXRpc3RpY3MpID0+IGJvb2xlYW59IGNoZWNrXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQnVpbGRRdWVzdGlvblxuICogQHBhcmFtIHtRdWVzdGlvblNwZWN9IHF1ZXN0aW9uU3BlY1xuICogQHBhcmFtIHtJbnN0YW5jZX0gaW5zdGFuY2UgLSB2b3RlQ291bnRlciBpbnN0YW5jZVxuICogQHJldHVybnMge1F1ZXN0aW9ufVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gVm90ZUNvdW50ZXJDcmVhdG9yRmFjZXQgLSBhIGZhY2V0IHRoYXQgdGhlIEVsZWN0b3JhdGUgc2hvdWxkXG4gKiAgIGhvbGQgdGlnaHRseS4gc3VibWl0Vm90ZSgpIGlzIHRoZSBjb3JlIGNhcGFiaWxpdHkgdGhhdCBhbGxvd3MgdGhlIGhvbGRlciB0b1xuICogICBzcGVjaWZ5IHRoZSBpZGVudGl0eSBhbmQgY2hvaWNlIG9mIGEgdm90ZXIuIFRoZSB2b3RlQ291bnRlciBpcyBtYWtpbmcgdGhhdFxuICogICBhdmFpbGFibGUgdG8gdGhlIEVsZWN0b3JhdGUsIHdoaWNoIHNob3VsZCB3cmFwIGFuZCBhdHRlbnVhdGUgaXQgc28gZWFjaFxuICogICB2b3RlciBnZXRzIG9ubHkgdGhlIGFiaWxpdHkgdG8gY2FzdCB0aGVpciBvd24gdm90ZSBhdCBhIHdlaWdodCBzcGVjaWZpZWQgYnlcbiAqICAgdGhlIGVsZWN0b3JhdGUuXG4gKiBAcHJvcGVydHkge1N1Ym1pdFZvdGV9IHN1Ym1pdFZvdGVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFZvdGVDb3VudGVyUHVibGljRmFjZXRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gYm9vbGVhbn0gaXNPcGVuXG4gKiBAcHJvcGVydHkgeygpID0+IFF1ZXN0aW9ufSBnZXRRdWVzdGlvblxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPFBvc2l0aW9uPn0gZ2V0T3V0Y29tZVxuICogQHByb3BlcnR5IHsoKSA9PiBRdWVzdGlvbkRldGFpbHN9IGdldERldGFpbHNcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxWb3RlU3RhdGlzdGljcz59IGdldFN0YXRzXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBNdWx0aVZvdGVDb3VudGVyUHVibGljRmFjZXRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gYm9vbGVhbn0gaXNPcGVuXG4gKiBAcHJvcGVydHkgeygpID0+IFF1ZXN0aW9ufSBnZXRRdWVzdGlvblxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPFBvc2l0aW9uW10+fSBnZXRPdXRjb21lXG4gKiBAcHJvcGVydHkgeygpID0+IFF1ZXN0aW9uRGV0YWlsc30gZ2V0RGV0YWlsc1xuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPFZvdGVTdGF0aXN0aWNzPn0gZ2V0U3RhdHNcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFZvdGVDb3VudGVyQ2xvc2VGYWNldFxuICogICBURVNUIE9OTFk6IFNob3VsZCBub3QgYmUgYWxsb3dlZCB0byBlc2NhcGUgZnJvbSBjb250cmFjdHNcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gdm9pZH0gY2xvc2VWb3RpbmdcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFZvdGVDb3VudGVyRmFjZXRzXG4gKiBAcHJvcGVydHkge1ZvdGVDb3VudGVyUHVibGljRmFjZXR9IHB1YmxpY0ZhY2V0XG4gKiBAcHJvcGVydHkge1ZvdGVDb3VudGVyQ3JlYXRvckZhY2V0fSBjcmVhdG9yRmFjZXRcbiAqIEBwcm9wZXJ0eSB7Vm90ZUNvdW50ZXJDbG9zZUZhY2V0fSBjbG9zZUZhY2V0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBNdWx0aVZvdGVDb3VudGVyRmFjZXRzXG4gKiBAcHJvcGVydHkge011bHRpVm90ZUNvdW50ZXJQdWJsaWNGYWNldH0gcHVibGljRmFjZXRcbiAqIEBwcm9wZXJ0eSB7Vm90ZUNvdW50ZXJDcmVhdG9yRmFjZXR9IGNyZWF0b3JGYWNldFxuICogQHByb3BlcnR5IHtWb3RlQ291bnRlckNsb3NlRmFjZXR9IGNsb3NlRmFjZXRcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBCdWlsZFZvdGVDb3VudGVyXG4gKiBAcGFyYW0ge1F1ZXN0aW9uU3BlY30gcXVlc3Rpb25TcGVjXG4gKiBAcGFyYW0ge2JpZ2ludH0gdGhyZXNob2xkIC0gcXVlc3Rpb25TcGVjIGluY2x1ZGVzIHF1b3J1bVJ1bGU7IHRoZSBlbGVjdG9yYXRlXG4gKiAgICBjb252ZXJ0cyB0aGF0IHRvIGEgbnVtYmVyIHRoYXQgdGhlIGNvdW50ZXIgY2FuIGVuZm9yY2UuXG4gKiBAcGFyYW0ge0luc3RhbmNlfSBpbnN0YW5jZVxuICogQHBhcmFtIHtFUmVmPFB1Ymxpc2hlcjxPdXRjb21lUmVjb3JkPj59IHB1Ymxpc2hlclxuICogQHJldHVybnMge1ZvdGVDb3VudGVyRmFjZXRzfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEJ1aWxkTXVsdGlWb3RlQ291bnRlclxuICogQHBhcmFtIHtRdWVzdGlvblNwZWN9IHF1ZXN0aW9uU3BlY1xuICogQHBhcmFtIHtiaWdpbnR9IHRocmVzaG9sZCAtIHF1ZXN0aW9uU3BlYyBpbmNsdWRlcyBxdW9ydW1SdWxlOyB0aGUgZWxlY3RvcmF0ZVxuICogICAgY29udmVydHMgdGhhdCB0byBhIG51bWJlciB0aGF0IHRoZSBjb3VudGVyIGNhbiBlbmZvcmNlLlxuICogQHBhcmFtIHtJbnN0YW5jZX0gaW5zdGFuY2VcbiAqIEBwYXJhbSB7RVJlZjxQdWJsaXNoZXI8TXVsdGlPdXRjb21lUmVjb3JkPj59IHB1Ymxpc2hlclxuICogQHJldHVybnMge011bHRpVm90ZUNvdW50ZXJGYWNldHN9XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb21wbGV0ZWRCYWxsZXRcbiAqIEBwcm9wZXJ0eSB7UG9zaXRpb259IGNob3NlblxuICogQHByb3BlcnR5IHtiaWdpbnR9IHNoYXJlc1xuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFN1Ym1pdFZvdGVcbiAqIEBwYXJhbSB7SGFuZGxlPCdWb3Rlcic+fSB2b3RlckhhbmRsZVxuICogQHBhcmFtIHtQb3NpdGlvbltdfSBjaG9zZW5Qb3NpdGlvbnNcbiAqIEBwYXJhbSB7YmlnaW50fSBbd2VpZ2h0XVxuICogQHJldHVybnMge0NvbXBsZXRlZEJhbGxldH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBHZXRPcGVuUXVlc3Rpb25zXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxIYW5kbGU8J1F1ZXN0aW9uJz5bXT59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgR2V0UXVlc3Rpb25cbiAqIEBwYXJhbSB7SGFuZGxlPCdRdWVzdGlvbic+fSBoXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxRdWVzdGlvbj59XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFbGVjdG9yYXRlUHVibGljXG4gKiBAcHJvcGVydHkgeygpID0+IFN1YnNjcmliZXI8UXVlc3Rpb25EZXRhaWxzPn0gZ2V0UXVlc3Rpb25TdWJzY3JpYmVyXG4gKiBAcHJvcGVydHkge0dldE9wZW5RdWVzdGlvbnN9IGdldE9wZW5RdWVzdGlvbnMsXG4gKiBAcHJvcGVydHkgeygpID0+IEluc3RhbmNlfSBnZXRJbnN0YW5jZVxuICogQHByb3BlcnR5IHtHZXRRdWVzdGlvbn0gZ2V0UXVlc3Rpb25cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsgRWxlY3RvcmF0ZVB1YmxpYyAmIHttYWtlVm90ZXJJbnZpdGF0aW9uOiAoKSA9PiBFUmVmPEludml0YXRpb24+fSB9IENsYWltc0VsZWN0b3JhdGVQdWJsaWNcbiAqIEB0eXBlZGVmIHsgRWxlY3RvcmF0ZVB1YmxpYyAmIHtnZXROYW1lOiAoKSA9PiBzdHJpbmd9IH0gQ29tbWl0dGVlRWxlY3RvcmF0ZVB1YmxpY1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUG9zZXJGYWNldFxuICogQHByb3BlcnR5IHtBZGRRdWVzdGlvbn0gYWRkUXVlc3Rpb25cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVsZWN0b3JhdGVDcmVhdG9yRmFjZXRcbiAqIEBwcm9wZXJ0eSB7QWRkUXVlc3Rpb259IGFkZFF1ZXN0aW9uIGNhbiBiZSB1c2VkIGRpcmVjdGx5IHdoZW4gdGhlIGNyZWF0b3IgZG9lc24ndCBuZWVkIGFueVxuICogIHJlYXNzdXJhbmNlLiBXaGVuIHNvbWVvbmUgbmVlZHMgdG8gY29ubmVjdCBhZGRRdWVzdGlvbiB0byB0aGUgRWxlY3RvcmF0ZVxuICogIGluc3RhbmNlLCBnZXRQb3Nlckludml0YXRpb24oKSBsZXRzIHRoZW0gZ2V0IGFkZFF1ZXN0aW9uIHdpdGggYXNzdXJhbmNlLlxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEludml0YXRpb24+fSBnZXRQb3Nlckludml0YXRpb25cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gU3Vic2NyaWJlcjxRdWVzdGlvbkRldGFpbHM+fSBnZXRRdWVzdGlvblN1YnNjcmliZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gRWxlY3RvcmF0ZVB1YmxpY30gZ2V0UHVibGljRmFjZXRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEdldFZvdGVySW52aXRhdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gSW52aXRhdGlvbltdfSBnZXRWb3Rlckludml0YXRpb25zXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBWb3RlckZhY2V0IC0gYSBmYWNldCB0aGF0IHRoZSBFbGVjdG9yYXRlIHNob3VsZCBob2xkXG4gKiAgIHRpZ2h0bHkuIEl0IGFsbG93cyBzcGVjaWZpY2F0aW9uIG9mIHRoZSB2b3RlJ3Mgd2VpZ2h0LCBzbyB0aGUgRWxlY3RvcmF0ZVxuICogICBzaG91bGQgZGlzdHJpYnV0ZSBhbiBhdHRlbnVhdGVkIHdyYXBwZXIgdGhhdCBkb2Vzbid0IG1ha2UgdGhhdCBhdmFpbGFibGUhXG4gKiBAcHJvcGVydHkge1N1Ym1pdFZvdGV9IHN1Ym1pdFZvdGVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IENsb3NpbmdSdWxlXG4gKiBAcHJvcGVydHkge0VSZWY8VGltZXI+fSB0aW1lclxuICogQHByb3BlcnR5IHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wfSBkZWFkbGluZVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIENsb3NlVm90aW5nXG4gKiBAcGFyYW0ge0Nsb3NpbmdSdWxlfSBjbG9zaW5nUnVsZVxuICogQHBhcmFtIHsoKSA9PiB2b2lkfSBjbG9zZVZvdGluZ1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQWRkUXVlc3Rpb25SZXR1cm5cbiAqIEBwcm9wZXJ0eSB7Vm90ZUNvdW50ZXJQdWJsaWNGYWNldH0gcHVibGljRmFjZXRcbiAqIEBwcm9wZXJ0eSB7Vm90ZUNvdW50ZXJDcmVhdG9yRmFjZXR9IGNyZWF0b3JGYWNldFxuICogQHByb3BlcnR5IHtYaW1wb3J0KCdAYWdvcmljL3pvZS9zcmMvem9lU2VydmljZS91dGlscy5qcycpLkluc3RhbmNlPHR5cGVvZiBYaW1wb3J0KCcuL2JpbmFyeVZvdGVDb3VudGVyLmpzJykuc3RhcnQ+fSBpbnN0YW5jZVxuICogQHByb3BlcnR5IHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wfSBkZWFkbGluZVxuICogQHByb3BlcnR5IHtIYW5kbGU8J1F1ZXN0aW9uJz59IHF1ZXN0aW9uSGFuZGxlXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgQWRkUXVlc3Rpb25cbiAqIEBwYXJhbSB7RVJlZjxJbnN0YWxsYXRpb24+fSB2b3RlQ291bnRlclxuICogQHBhcmFtIHtRdWVzdGlvblNwZWN9IHF1ZXN0aW9uU3BlY1xuICogQHJldHVybnMge1Byb21pc2U8QWRkUXVlc3Rpb25SZXR1cm4+fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIENyZWF0ZVF1ZXN0aW9uXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IG5hbWUgLSBUaGUgbmFtZSBvZiB0aGUgcGFyYW1ldGVyIHRvIGNoYW5nZVxuICogQHBhcmFtIHtQYXJhbVZhbHVlfSBwcm9wb3NlZFZhbHVlIC0gdGhlIHByb3Bvc2VkIHZhbHVlIGZvciB0aGUgbmFtZWRcbiAqICAgcGFyYW1ldGVyXG4gKiBAcGFyYW0ge0luc3RhbGxhdGlvbn0gdm90ZUNvdW50ZXJJbnN0YWxsYXRpb24gLSB0aGUgdm90ZUNvdW50ZXIgdG9cbiAqICAgaW5zdGFudGlhdGUgdG8gY291bnQgdm90ZXMuIEV4cGVjdGVkIHRvIGJlIGEgYmluYXJ5Vm90ZUNvdW50ZXIuIE90aGVyXG4gKiAgIHZvdGVDb3VudGVycyBtaWdodCBiZSBhZGRlZCBoZXJlLCBvciBtaWdodCByZXF1aXJlIHNlcGFyYXRlIGdvdmVybm9ycy5cbiAqICAgdW5kZXIgbWFuYWdlbWVudCBzbyB1c2VycyBjYW4gdHJhY2UgaXQgYmFjayBhbmQgc2VlIHRoYXQgaXQgd291bGQgdXNlXG4gKiAgIHRoaXMgZWxlY3Rpb25NYW5hZ2VyIHRvIG1hbmFnZSBwYXJhbWV0ZXJzXG4gKiBAcGFyYW0ge0luc3RhbmNlfSBjb250cmFjdEluc3RhbmNlIC0gaW5jbHVkZSB0aGUgaW5zdGFuY2Ugb2YgdGhlIGNvbnRyYWN0XG4gKiBAcGFyYW0ge0Nsb3NpbmdSdWxlfSBjbG9zaW5nUnVsZSAtIGRlYWRsaW5lIGFuZCB0aW1lciBmb3IgY2xvc2luZyB2b3RpbmdcbiAqIEByZXR1cm5zIHtQcm9taXNlPFF1ZXN0aW9uRGV0YWlscz59XG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1A9U3RhbmRhcmRQYXJhbVBhdGhdIHBhdGggZm9yIGEgcGFyYW1NYW5hZ2VyUmV0cmlldmVyXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXJhbUNoYW5nZUlzc3VlXG4gKiBAcHJvcGVydHkge1BhcmFtQ2hhbmdlc1NwZWM8UD59IHNwZWNcbiAqIEBwcm9wZXJ0eSB7WGltcG9ydCgnQGFnb3JpYy96b2Uvc3JjL3pvZVNlcnZpY2UvdXRpbHMuanMnKS5JbnN0YW5jZTwoemNmOiBaQ0Y8R292ZXJuYW5jZVRlcm1zPHt9Pj4pID0+IHt9Pn0gY29udHJhY3RcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEFwaUludm9jYXRpb25Jc3N1ZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IGFwaU1ldGhvZE5hbWVcbiAqIEBwcm9wZXJ0eSB7dW5rbm93bltdfSBtZXRob2RBcmdzXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBPZmZlckZpbHRlcklzc3VlXG4gKiBAcHJvcGVydHkge3N0cmluZ1tdfSBzdHJpbmdzXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQYXJhbUNoYW5nZVBvc2l0aW9uc1xuICogQHByb3BlcnR5IHtDaGFuZ2VQYXJhbXNQb3NpdGlvbn0gcG9zaXRpdmVcbiAqIEBwcm9wZXJ0eSB7Tm9DaGFuZ2VQYXJhbXNQb3NpdGlvbn0gbmVnYXRpdmVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFBhcmFtQ2hhbmdlSXNzdWVEZXRhaWxzXG4gKiAgICBkZXRhaWxzIGZvciBhIHF1ZXN0aW9uIHRoYXQgY2FuIGNoYW5nZSBhIGNvbnRyYWN0IHBhcmFtZXRlclxuICogQHByb3BlcnR5IHtDaG9pY2VNZXRob2R9IG1ldGhvZFxuICogQHByb3BlcnR5IHtQYXJhbUNoYW5nZUlzc3VlPHVua25vd24+fSBpc3N1ZVxuICogQHByb3BlcnR5IHtQYXJhbUNoYW5nZVBvc2l0aW9uc30gcG9zaXRpb25zXG4gKiBAcHJvcGVydHkge0VsZWN0aW9uVHlwZX0gZWxlY3Rpb25UeXBlXG4gKiBAcHJvcGVydHkge251bWJlcn0gbWF4Q2hvaWNlc1xuICogQHByb3BlcnR5IHtDbG9zaW5nUnVsZX0gY2xvc2luZ1J1bGVcbiAqIEBwcm9wZXJ0eSB7UXVvcnVtUnVsZX0gcXVvcnVtUnVsZVxuICogQHByb3BlcnR5IHtOb0NoYW5nZVBhcmFtc1Bvc2l0aW9ufSB0aWVPdXRjb21lXG4gKiBAcHJvcGVydHkge0luc3RhbmNlfSBjb3VudGVySW5zdGFuY2UgLSBpbnN0YW5jZSBvZiB0aGUgVm90ZUNvdW50ZXJcbiAqIEBwcm9wZXJ0eSB7SGFuZGxlPCdRdWVzdGlvbic+fSBxdWVzdGlvbkhhbmRsZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge1JlY29yZDxLZXl3b3JkLCBQYXJhbVZhbHVlVHlwZWQ+fSBQYXJhbVN0YXRlUmVjb3JkIGEgUmVjb3JkIGNvbnRhaW5pbmdcbiAqICAga2V5d29yZCBwYWlycyB3aXRoIGRlc2NyaXB0aW9ucyBvZiBwYXJhbWV0ZXJzIHVuZGVyIGdvdmVybmFuY2UuXG4gKi9cblxuLyoqIEB0eXBlZGVmIHt7Y3VycmVudDogUGFyYW1TdGF0ZVJlY29yZH19IEdvdmVybmFuY2VTdWJzY3JpcHRpb25TdGF0ZSAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFBhcmFtTWFuYWdlckJhc2UgVGhlIGJhc2UgcGFyYW1NYW5hZ2VyIHdpdGggdHlwZWQgZ2V0dGVyc1xuICogQHByb3BlcnR5IHsoKSA9PiBFUmVmPFBhcmFtU3RhdGVSZWNvcmQ+fSBnZXRQYXJhbXNcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZykgPT4gQW1vdW50fSBnZXRBbW91bnRcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZykgPT4gQnJhbmR9IGdldEJyYW5kXG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcpID0+IEluc3RhbmNlfSBnZXRJbnN0YW5jZVxuICogQHByb3BlcnR5IHsobmFtZTogc3RyaW5nKSA9PiBJbnN0YWxsYXRpb259IGdldEluc3RhbGxhdGlvblxuICogQHByb3BlcnR5IHsobmFtZTogc3RyaW5nKSA9PiBBbW91bnQ8J3NldCc+fSBnZXRJbnZpdGF0aW9uQW1vdW50XG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcpID0+IGJpZ2ludH0gZ2V0TmF0XG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcpID0+IFJhdGlvfSBnZXRSYXRpb1xuICogQHByb3BlcnR5IHsobmFtZTogc3RyaW5nKSA9PiBzdHJpbmd9IGdldFN0cmluZ1xuICogQHByb3BlcnR5IHsobmFtZTogc3RyaW5nKSA9PiBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wUmVjb3JkfSBnZXRUaW1lc3RhbXBcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZykgPT4gWGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlJlbGF0aXZlVGltZVJlY29yZH0gZ2V0UmVsYXRpdmVUaW1lXG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcpID0+IGFueX0gZ2V0VW5rbm93blxuICogQHByb3BlcnR5IHsobmFtZTogc3RyaW5nLCBwcm9wb3NlZFZhbHVlOiBQYXJhbVZhbHVlKSA9PiBQYXJhbVZhbHVlfSBnZXRWaXNpYmxlVmFsdWUgLSBmb3JcbiAqICAgbW9zdCB0eXBlcywgdGhlIHZpc2libGUgdmFsdWUgaXMgdGhlIHNhbWUgYXMgcHJvcG9zZWRWYWx1ZS4gRm9yIEludml0YXRpb25zXG4gKiAgIHRoZSB2aXNpYmxlIHZhbHVlIGlzIHRoZSBhbW91bnQgb2YgdGhlIGludml0YXRpb24uXG4gKiBAcHJvcGVydHkgeyhuYW1lOiBzdHJpbmcpID0+IFByb21pc2U8SW52aXRhdGlvbj59IGdldEludGVybmFsUGFyYW1WYWx1ZVxuICogQHByb3BlcnR5IHsoKSA9PiBTdG9yZWRTdWJzY3JpcHRpb248R292ZXJuYW5jZVN1YnNjcmlwdGlvblN0YXRlPn0gZ2V0U3Vic2NyaXB0aW9uXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgVXBkYXRlUGFyYW1zXG4gKiBAcGFyYW0ge1JlY29yZDxzdHJpbmcsUGFyYW1WYWx1ZT59IHBhcmFtQ2hhbmdlc1xuICogQHJldHVybnMge1Byb21pc2U8dm9pZD59XG4gKi9cblxuLyoqXG4gKiBUaGVzZSBhcmUgdHlwZWQgYGFueWAgYmVjYXVzZSB0aGUgYnVpbGRlciBwYXR0ZXJuIG9mIHBhcmFtTWFuYWdlciBtYWtlcyBpdCB2ZXJ5XG4gKiBjb21wbGljYXRlZCBmb3IgdGhlIHR5cGUgc3lzdGVtIHRvIGtub3cgdGhlIHNldCBvZiBwYXJhbS1zcGVjaWZpYyBmdW5jdGlvbnNcbiAqIHJldHVybmVkIGJ5IGAuYnVpbGQoKWAuIEluc3RlYWQgd2UgbGV0IHBhcmFtTWFuYWdlciBjcmVhdGUgdGhlIGRlc2lyZWQgbWV0aG9kc1xuICogYW5kIHVzZSB0eXBlZFBhcmFtTWFuYWdlciB0byBjcmVhdGUgYSB2ZXJzaW9uIHRoYXQgaW5jbHVkZXMgdGhlIHN0YXRpYyB0eXBlcy5cbiAqXG4gKiBAdHlwZWRlZiB7UmVjb3JkPHN0cmluZywgYW55Pn0gUGFyYW1NYW5hZ2VyR2V0dGVyc0FuZFVwZGF0ZXJzXG4gKiBAdHlwZWRlZiB7UGFyYW1NYW5hZ2VyQmFzZSAmIFBhcmFtTWFuYWdlckdldHRlcnNBbmRVcGRhdGVycyAmIHt1cGRhdGVQYXJhbXM6IFVwZGF0ZVBhcmFtc319IEFueVBhcmFtTWFuYWdlclxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge1JlY29yZDxzdHJpbmcsIHN0cmluZ1tdPn0gUGFyYW1ldGVyTmFtZUxpc3RcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRQYXJhbU1hbmFnZXJUeXBlXG4gKiBAcGFyYW0ge1BhcmFtVHlwZX0gdHlwZVxuICogQHBhcmFtIHtQYXJhbVZhbHVlfSB2YWx1ZVxuICogQHBhcmFtIHtzdHJpbmd9IG5hbWVcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBCdWlsZFBhcmFtTWFuYWdlciAtIFBhcmFtTWFuYWdlciBpcyBhIGZhY2lsaXR5IHRoYXQgZ292ZXJuZWRcbiAqICAgY29udHJhY3RzIGNhbiB1c2UgdG8gbWFuYWdlIHRoZWlyIHZpc2libGUgc3RhdGUgaW4gYSB3YXkgdGhhdCBhbGxvd3MgdGhlXG4gKiAgIENvbnRyYWN0R292ZXJub3IgdG8gdXBkYXRlIHZhbHVlcyB1c2luZyBnb3Zlcm5hbmNlLiBXaGVuIHBhcmFtTWFuYWdlciBpc1xuICogICBpbnN0YW50aWF0ZWQgaW5zaWRlIHRoZSBjb250cmFjdCwgdGhlIGNvbnRyYWN0IGhhcyBzeW5jaHJvbm91cyBhY2Nlc3MgdG9cbiAqICAgdGhlIHZhbHVlcywgYW5kIGNsaWVudHMgb2YgdGhlIGNvbnRyYWN0IGNhbiB2ZXJpZnkgdGhhdCBhIENvbnRyYWN0R292ZXJub3JcbiAqICAgY2FuIGNoYW5nZSB0aGUgdmFsdWVzIGluIGEgbGVnaWJsZSB3YXkuXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFBhcmFtVmFsdWVUeXBlZD59IHBhcmFtRGVzY3JpcHRpb25zXG4gKiBAcmV0dXJucyB7QW55UGFyYW1NYW5hZ2VyfVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQ2hhbmdlUGFyYW1zUG9zaXRpb25cbiAqIEBwcm9wZXJ0eSB7UmVjb3JkPHN0cmluZyxQYXJhbVZhbHVlPn0gY2hhbmdlcyBvbmUgb3IgbW9yZSBjaGFuZ2VzIHRvIHBhcmFtZXRlcnNcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IE9mZmVyRmlsdGVyUG9zaXRpb25cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nW119IHN0cmluZ3NcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IE5vQ2hhbmdlT2ZmZXJGaWx0ZXJQb3NpdGlvblxuICogQHByb3BlcnR5IHtzdHJpbmdbXX0gZG9udFVwZGF0ZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gSW52b2tlQXBpUG9zaXRpb25cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBhcGlNZXRob2ROYW1lXG4gKiBAcHJvcGVydHkge3Vua25vd25bXX0gbWV0aG9kQXJnc1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRG9udEludm9rZUFwaVBvc2l0aW9uXG4gKiBAcHJvcGVydHkge3N0cmluZ30gZG9udEludm9rZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gTm9DaGFuZ2VQYXJhbXNQb3NpdGlvblxuICogQHByb3BlcnR5IHtzdHJpbmdbXX0gbm9DaGFuZ2UgUGFyYW1ldGVycyBpbiB0aGUgcHJvcG9zYWwgdGhhdCB0aGlzIHBvc2l0aW9uXG4gKiAgIGlzIG9wcG9zZWQgdG9cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEdvdmVybm9yXG4gKiBAcHJvcGVydHkge0NyZWF0ZVF1ZXN0aW9ufSBjcmVhdGVRdWVzdGlvblxuICovXG5cbi8qKiBAdHlwZWRlZiB7eyBbbWV0aG9kTmFtZTogc3RyaW5nXTogKC4uLmFyZ3M6IGFueSkgPT4gdW5rbm93biB9fSBHb3Zlcm5lZEFwaXMgKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBHb3Zlcm5vclB1YmxpY1xuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEluc3RhbmNlPn0gZ2V0RWxlY3RvcmF0ZVxuICogQHByb3BlcnR5IHsoKSA9PiBJbnN0YW5jZX0gZ2V0R292ZXJuZWRDb250cmFjdFxuICogQHByb3BlcnR5IHsodm90ZUNvdW50ZXI6IEluc3RhbmNlKSA9PiBQcm9taXNlPHZvaWQ+fSB2YWxpZGF0ZVZvdGVDb3VudGVyXG4gKiBAcHJvcGVydHkgeyhyZWdQOiBFUmVmPEluc3RhbmNlPikgPT4gUHJvbWlzZTx2b2lkPn0gdmFsaWRhdGVFbGVjdG9yYXRlXG4gKiBAcHJvcGVydHkgeyhjbG9zaW5nUnVsZTogQ2xvc2luZ1J1bGUpID0+IHZvaWR9IHZhbGlkYXRlVGltZXJcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFBhcmFtS2V5IGlkZW50aWZpZXIgZm9yIGEgcGFyYW1NYW5hZ2VyIHdpdGhpbiBhIGNvbnRyYWN0XG4gKiBAcHJvcGVydHkge3Vua25vd259IGtleVxuICovXG5cbi8qKlxuICogRGVzY3JpcHRpb24gb2YgYSBzZXQgb2YgY29vcmRpbmF0ZWQgY2hhbmdlcyBmb3IgYSBQYXJhbU1hbmFnZXJcbiAqXG4gKiBAdGVtcGxhdGUgUCBwYXRoIGZvciBhIHBhcmFtTWFuYWdlclJldHJpZXZlclxuICogQHR5cGVkZWYge29iamVjdH0gUGFyYW1DaGFuZ2VzU3BlYzxQPlxuICogQHByb3BlcnR5IHtQfSBwYXJhbVBhdGhcbiAqIEBwcm9wZXJ0eSB7UmVjb3JkPHN0cmluZywgUGFyYW1WYWx1ZT59IGNoYW5nZXMgb25lIG9yIG1vcmUgY2hhbmdlcyB0byBwYXJhbWV0ZXJzXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb250cmFjdEdvdmVybmFuY2VWb3RlUmVzdWx0XG4gKiBAcHJvcGVydHkge0luc3RhbmNlfSBpbnN0YW5jZSAtIGluc3RhbmNlIG9mIHRoZSBWb3RlQ291bnRlclxuICogQHByb3BlcnR5IHtFUmVmPFF1ZXN0aW9uRGV0YWlscz59IGRldGFpbHNcbiAqIEBwcm9wZXJ0eSB7UHJvbWlzZTxQYXJhbVZhbHVlPn0gb3V0Y29tZU9mVXBkYXRlIC0gQSBwcm9taXNlIGZvciB0aGUgcmVzdWx0XG4gKiAgICBvZiB1cGRhdGluZyB0aGUgcGFyYW1ldGVyIHZhbHVlLiBQcmltYXJpbHkgdXNlZnVsIGZvciBpdHMgYmVoYXZpb3Igb25cbiAqICAgIHJlamVjdGlvbi5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7R292ZXJuYWJsZVN0YXJ0Rm59IFNGIFN0YXJ0IGZ1bmN0aW9uIG9mIGdvdmVybmVkIGNvbnRyYWN0XG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBHb3Zlcm5vckNyZWF0b3JGYWNldFxuICogQHByb3BlcnR5IHtWb3RlT25QYXJhbUNoYW5nZXN9IHZvdGVPblBhcmFtQ2hhbmdlc1xuICogQHByb3BlcnR5IHtWb3RlT25BcGlJbnZvY2F0aW9ufSB2b3RlT25BcGlJbnZvY2F0aW9uXG4gKiBAcHJvcGVydHkge1ZvdGVPbk9mZmVyRmlsdGVyfSB2b3RlT25PZmZlckZpbHRlclxuICogQHByb3BlcnR5IHsoKSA9PiBMaW1pdGVkQ0Y8U0Y+fSBnZXRDcmVhdG9yRmFjZXQgZmFjZXQgb2YgdGhlIGdvdmVybmVkIGNvbnRyYWN0LFxuICogICB3aXRoIGNyZWF0b3ItbGlrZSBwb3dlcnMgYnV0IHdpdGhvdXQgdGhlIHRpZ2h0bHkgaGVsZCBhYmlsaXR5IHRvIGNoYW5nZVxuICogICBwYXJhbSB2YWx1ZXMuXG4gKiBAcHJvcGVydHkgeyhwb3Nlckludml0YXRpb246IEludml0YXRpb24pID0+IFByb21pc2U8dm9pZD59IHJlcGxhY2VFbGVjdG9yYXRlXG4gKiBAcHJvcGVydHkgeygpID0+IEFkbWluRmFjZXR9IGdldEFkbWluRmFjZXRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gR292ZXJuZWRQdWJsaWNGYWNldDxBd2FpdGVkPFJldHVyblR5cGU8U0Y+PlsncHVibGljRmFjZXQnXT59IGdldFB1YmxpY0ZhY2V0IC0gcHVibGljIGZhY2V0IG9mIHRoZSBnb3Zlcm5lZCBjb250cmFjdFxuICogQHByb3BlcnR5IHsoKSA9PiBJbnN0YW5jZX0gZ2V0SW5zdGFuY2UgLSBpbnN0YW5jZSBvZiB0aGUgZ292ZXJuZWRcbiAqICAgY29udHJhY3RcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIEdvdmVybmVkUHVibGljRmFjZXRNZXRob2RzXG4gKiBAcHJvcGVydHkgeyhrZXk/OiBhbnkpID0+IFN0b3JlZFN1YnNjcmlwdGlvbjxHb3Zlcm5hbmNlU3Vic2NyaXB0aW9uU3RhdGU+fSBnZXRTdWJzY3JpcHRpb25cbiAqIEBwcm9wZXJ0eSB7KGtleT86IGFueSkgPT4gRVJlZjxQYXJhbVN0YXRlUmVjb3JkPn0gZ2V0R292ZXJuZWRQYXJhbXMgLSBnZXQgZGVzY3JpcHRpb25zIG9mXG4gKiAgIGFsbCB0aGUgZ292ZXJuZWQgcGFyYW1ldGVyc1xuICogQHByb3BlcnR5IHsobmFtZTogc3RyaW5nKSA9PiBBbW91bnR9IGdldEludml0YXRpb25BbW91bnRcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7e319IFBGIFB1YmxpYyBmYWNldFxuICogQHR5cGVkZWYge1BGICYgR292ZXJuZWRQdWJsaWNGYWNldE1ldGhvZHN9IEdvdmVybmVkUHVibGljRmFjZXRcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7R292ZXJuYWJsZVN0YXJ0Rm59IFNGXG4gKiBAdHlwZWRlZiB7UmV0dXJuVHlwZTxBd2FpdGVkPFJldHVyblR5cGU8U0Y+PlsnY3JlYXRvckZhY2V0J11bJ2dldExpbWl0ZWRDcmVhdG9yRmFjZXQnXT59IExpbWl0ZWRDRlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHt7fX0gQ0YgY3JlYXRvciBmYWNldFxuICogQHR5cGVkZWYgR292ZXJuZWRDcmVhdG9yRmFjZXRcbiAqIFdoYXQgYSBnb3Zlcm5lZCBjb250cmFjdCBtdXN0IHJldHVybiBhcyBpdHMgY3JlYXRvckZhY2V0IGluIG9yZGVyIHRvIGJlIGdvdmVybmVkXG4gKiBAcHJvcGVydHkgeygpID0+IFBhcmFtTWFuYWdlclJldHJpZXZlcn0gZ2V0UGFyYW1NZ3JSZXRyaWV2ZXIgLSBhbGxvd3MgYWNjZXNzaW5nXG4gKiAgIGFuZCB1cGRhdGluZyBnb3Zlcm5lZCBwYXJhbWV0ZXJzLiBTaG91bGQgb25seSBiZSBkaXJlY3RseSBhY2Nlc3NpYmxlIHRvIHRoZVxuICogICBjb250cmFjdEdvdmVybm9yXG4gKiBAcHJvcGVydHkgeygpID0+IEVSZWY8Q0Y+fSBnZXRMaW1pdGVkQ3JlYXRvckZhY2V0IC0gdGhlIGNyZWF0b3JcbiAqICAgZmFjZXQgb2YgdGhlIGdvdmVybmVkIGNvbnRyYWN0LiBEb2Vzbid0IHByb3ZpZGUgYWNjZXNzIHRvIGFueSBnb3Zlcm5hbmNlXG4gKiAgIGZ1bmN0aW9uYWxpdHlcbiAqIEBwcm9wZXJ0eSB7KG5hbWU6IHN0cmluZykgPT4gUHJvbWlzZTxJbnZpdGF0aW9uPn0gZ2V0SW52aXRhdGlvblxuICogQHByb3BlcnR5IHsoKSA9PiBFUmVmPEdvdmVybmVkQXBpcz59IGdldEdvdmVybmVkQXBpc1xuICogQHByb3BlcnR5IHsoKSA9PiAoc3RyaW5nIHwgc3ltYm9sKVtdfSBnZXRHb3Zlcm5lZEFwaU5hbWVzXG4gKiBAcHJvcGVydHkgeyhzdHJpbmdzOiBzdHJpbmdbXSkgPT4gdm9pZH0gc2V0T2ZmZXJGaWx0ZXJcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHt7a2V5OiBzdHJpbmd9fSBTdGFuZGFyZFBhcmFtUGF0aFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUGFyYW1NYW5hZ2VyUmV0cmlldmVyXG4gKiBAcHJvcGVydHkgeyhwYXJhbUtleT86IFBhcmFtS2V5KSA9PiBBbnlQYXJhbU1hbmFnZXJ9IGdldFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFtQPVN0YW5kYXJkUGFyYW1QYXRoXVxuICpcbiAqIEBjYWxsYmFjayBWb3RlT25QYXJhbUNoYW5nZXNcbiAqIEBwYXJhbSB7SW5zdGFsbGF0aW9ufSB2b3RlQ291bnRlckluc3RhbGxhdGlvblxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wfSBkZWFkbGluZVxuICogQHBhcmFtIHtQYXJhbUNoYW5nZXNTcGVjPFA+fSBwYXJhbVNwZWNcbiAqIEByZXR1cm5zIHtDb250cmFjdEdvdmVybmFuY2VWb3RlUmVzdWx0fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFZvdGVPbkFwaUludm9jYXRpb25cbiAqIEBwYXJhbSB7c3RyaW5nfSBhcGlNZXRob2ROYW1lXG4gKiBAcGFyYW0ge3Vua25vd25bXX0gbWV0aG9kQXJnc1xuICogQHBhcmFtIHtJbnN0YWxsYXRpb259IHZvdGVDb3VudGVySW5zdGFsbGF0aW9uXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lc3RhbXB9IGRlYWRsaW5lXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxDb250cmFjdEdvdmVybmFuY2VWb3RlUmVzdWx0Pn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBWb3RlT25PZmZlckZpbHRlclxuICogQHBhcmFtIHtJbnN0YWxsYXRpb259IHZvdGVDb3VudGVySW5zdGFsbGF0aW9uXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lc3RhbXB9IGRlYWRsaW5lXG4gKiBAcGFyYW0ge3N0cmluZ1tdfSBzdHJpbmdzXG4gKiBAcmV0dXJucyB7Q29udHJhY3RHb3Zlcm5hbmNlVm90ZVJlc3VsdH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFBhcmFtR292ZXJub3JcbiAqIEBwcm9wZXJ0eSB7Vm90ZU9uUGFyYW1DaGFuZ2VzfSB2b3RlT25QYXJhbUNoYW5nZXNcbiAqIEBwcm9wZXJ0eSB7Q3JlYXRlZFF1ZXN0aW9ufSBjcmVhdGVkUXVlc3Rpb25cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEFwaUdvdmVybm9yXG4gKiBAcHJvcGVydHkge1ZvdGVPbkFwaUludm9jYXRpb259IHZvdGVPbkFwaUludm9jYXRpb25cbiAqIEBwcm9wZXJ0eSB7Q3JlYXRlZFF1ZXN0aW9ufSBjcmVhdGVkUXVlc3Rpb25cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEZpbHRlckdvdmVybm9yXG4gKiBAcHJvcGVydHkge1ZvdGVPbk9mZmVyRmlsdGVyfSB2b3RlT25GaWx0ZXJcbiAqIEBwcm9wZXJ0eSB7Q3JlYXRlZFF1ZXN0aW9ufSBjcmVhdGVkUXVlc3Rpb25cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBDcmVhdGVkUXVlc3Rpb25cbiAqICAgV2FzIHRoaXMgcXVlc3Rpb24gY3JlYXRlZCBieSB0aGlzIENvbnRyYWN0R292ZXJub3I/XG4gKiBAcGFyYW0ge0luc3RhbmNlfSBxdWVzdGlvbkluc3RhbmNlXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBQb3NpdGlvbkluY2x1ZGVkXG4gKiBAcGFyYW0ge1Bvc2l0aW9uW119IHBvc2l0aW9uc1xuICogQHBhcmFtIHtQb3NpdGlvbn0gcG9zaXRpb25cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gR292ZXJuZWRDb250cmFjdFRlcm1zXG4gKiBAcHJvcGVydHkge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lclNlcnZpY2V9IHRpbWVyXG4gKiBAcHJvcGVydHkge0lzc3VlcktleXdvcmRSZWNvcmR9IGlzc3VlcktleXdvcmRSZWNvcmRcbiAqIEBwcm9wZXJ0eSB7b2JqZWN0fSBwcml2YXRlQXJnc1xuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydENvbnRyYWN0R292ZXJuYW5jZVxuICpcbiAqIEBwYXJhbSB7RVJlZjxab2VTZXJ2aWNlPn0gem9lXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9lL3NyYy96b2VTZXJ2aWNlL3V0aWxzLmpzJykuSW5zdGFuY2U8KHpjZjogWkNGPEdvdmVybmFuY2VUZXJtczx7fT4+KSA9PiB7fT59IGFsbGVnZWRHb3Zlcm5lZFxuICogQHBhcmFtIHtJbnN0YW5jZX0gYWxsZWdlZEdvdmVybm9yXG4gKiBAcGFyYW0ge0luc3RhbGxhdGlvbjxYaW1wb3J0KCdAYWdvcmljL2dvdmVybmFuY2Uvc3JjL2NvbnRyYWN0R292ZXJub3IuanMnKS5wcmVwYXJlPn0gY29udHJhY3RHb3Zlcm5vckluc3RhbGxhdGlvblxuICogQHJldHVybnMge1Byb21pc2U8R292ZXJuYW5jZVBhaXI+fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydENvbnRyYWN0RWxlY3RvcmF0ZSAtIGFzc2VydCB0aGF0IHRoZSBjb250cmFjdCB1c2VzIHRoZVxuICogICBlbGVjdG9yYXRlXG4gKlxuICogQHBhcmFtIHtFUmVmPFpvZVNlcnZpY2U+fSB6b2VcbiAqIEBwYXJhbSB7SW5zdGFuY2V9IGFsbGVnZWRHb3Zlcm5vclxuICogQHBhcmFtIHtJbnN0YW5jZX0gYWxsZWdlZEVsZWN0b3JhdGVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3pvZS9zcmMvem9lU2VydmljZS91dGlscy5qcycpLkNvbnRyYWN0U3RhcnRGdW5jdGlvblxuICogJiAoKHpjZj86IGFueSwgcGE/OiBhbnksIGJhZ2dhZ2U/OiBhbnkpID0+IEVSZWY8e2NyZWF0b3JGYWNldDogR292ZXJuZWRDcmVhdG9yRmFjZXQ8e30+LCBwdWJsaWNGYWNldDogR292ZXJuZWRQdWJsaWNGYWNldDx7fT59Pil9IEdvdmVybmFibGVTdGFydEZuXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9jb250cmFjdEdvdmVybm9yLmpzJylbJ3ByZXBhcmUnXX0gR292ZXJub3JTRlxuICovXG5cbi8qIFRPRE8gZmluZCBhIHdheSB0byBwYXJhbWV0ZXJpemUgdGhlIHN0YXJ0SW5zdGFuY2Ugc28gdGhlIGdvdmVybmVkIGNvbnRyYWN0IHR5cGVzIGZsb3cqL1xuLyoqXG4gKiBAc2VlIHtTdGFydGVkSW5zdGFuY2VLaXR9XG4gKiBAdGVtcGxhdGUge0VSZWY8SW5zdGFsbGF0aW9uPEdvdmVybmFibGVTdGFydEZuPj59IElcbiAqIEB0eXBlZGVmIEdvdmVybm9yU3RhcnRlZEluc3RhbGxhdGlvbktpdFxuICogU2FtZSByZXN1bHQgYXMgU3RhcnRlZEluc3RhbmNlS2l0IGJ1dDpcbiAqIC0gdHlwZWQgZm9yIGNvbnRyYWN0R292ZXJub3IgaW5zdGFsbGF0aW9uIGJlaW5nIHN0YXJ0ZWQgYnkgWm9lLiAoSXQgaW4gdHVybiBzdGFydHMgdGhlIGdvdmVybmVkIGNvbnRyYWN0LilcbiAqIC0gcGFyYW1ldGVyaXplZCBieSBJbnN0YWxsYXRpb24gaW5zdGVhZCBvZiBTdGFydEZ1bmN0aW9uXG4gKiBAcHJvcGVydHkge1hpbXBvcnQoJ0BhZ29yaWMvem9lL3NyYy96b2VTZXJ2aWNlL3V0aWxzLmpzJykuSW5zdGFuY2U8R292ZXJub3JTRj59IGluc3RhbmNlXG4gKiBAcHJvcGVydHkge0FkbWluRmFjZXR9IGFkbWluRmFjZXRcbiAqIEBwcm9wZXJ0eSB7R292ZXJub3JDcmVhdG9yRmFjZXQ8SW5zdGFsbGF0aW9uU3RhcnQ8QXdhaXRlZDxJPj4+fSBjcmVhdG9yRmFjZXRcbiAqIEBwcm9wZXJ0eSB7R292ZXJub3JQdWJsaWN9IHB1YmxpY0ZhY2V0XG4gKi9cblxuLyoqXG4gKiBAc2VlIHtTdGFydGVkSW5zdGFuY2VLaXR9XG4gKiBAdGVtcGxhdGUge0dvdmVybmFibGVTdGFydEZufSBTRlxuICogQHR5cGVkZWYgR292ZXJuYW5jZUZhY2V0S2l0XG4gKiBBa2luIHRvIFN0YXJ0ZWRJbnN0YW5jZUtpdCBidXQgZGVzaWduZWQgZm9yIHRoZSByZXN1bHRzIG9mIHN0YXJ0aW5nIGdvdmVybmVkIGNvbnRyYWN0cy4gVXNlZCBpbiBib290c3RyYXAgc3BhY2UuXG4gKiBAcHJvcGVydHkge0FkbWluRmFjZXR9IGFkbWluRmFjZXQgb2YgdGhlIGdvdmVybmVkIGNvbnRyYWN0XG4gKiBAcHJvcGVydHkge0xpbWl0ZWRDRjxTRj59IGNyZWF0b3JGYWNldCBjcmVhdG9yLWxpa2UgZmFjZXQgd2l0aGluIHRoZSBnb3Zlcm5lZCBjb250cmFjdCAod2l0aG91dCB0aGUgcG93ZXJzIHRoZSBnb3Zlcm5vciBuZWVkcylcbiAqIEBwcm9wZXJ0eSB7R292ZXJub3JDcmVhdG9yRmFjZXQ8U0Y+fSBnb3Zlcm5vckNyZWF0b3JGYWNldCBvZiB0aGUgZ292ZXJuaW5nIGNvbnRyYWN0XG4gKiBAcHJvcGVydHkge0FkbWluRmFjZXR9IGdvdmVybm9yQWRtaW5GYWNldCBvZiB0aGUgZ292ZXJuaW5nIGNvbnRyYWN0XG4gKiBAcHJvcGVydHkge0F3YWl0ZWQ8UmV0dXJuVHlwZTxTRj4+WydwdWJsaWNGYWNldCddfSBwdWJsaWNGYWNldFxuICogQHByb3BlcnR5IHtJbnN0YW5jZX0gaW5zdGFuY2VcbiAqIEBwcm9wZXJ0eSB7SW5zdGFuY2V9IGdvdmVybm9yXG4gKi9cbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA6FEl/WMKAABjCgAAMgAAAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy92YWxpZGF0b3JzLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2V2ZW50dWFsLXNlbmQiXSwiZXhwb3J0cyI6WyJhc3NlcnRDb250cmFjdEVsZWN0b3JhdGUiLCJhc3NlcnRDb250cmFjdEdvdmVybmFuY2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dXSk7ICAgXG5cbmNvbnN0e0ZhaWwscXVvdGU6cX09YXNzZXJ0O1xuXG4vKipcbiAqIEFzc2VydCB0aGF0IHRoZSBnb3Zlcm5lZCBjb250cmFjdCB3YXMgc3RhcnRlZCBieSB0aGUgZ292ZXJub3IuIFRocm93cyBpZlxuICogZWl0aGVyIGRpcmVjdGlvbiBjYW4ndCBiZSBlc3RhYmxpc2hlZC4gSWYgdGhlIGNhbGwgc3VjY2VlZHMsIHRoZW4gdGhlXG4gKiBnb3Zlcm5vciBnb3QgZXhjbHVzaXZlIGFjY2VzcyB0byB0aGUgZ292ZXJuZWQgY29udHJhY3QncyBjcmVhdG9yRmFjZXQsIGFuZFxuICogY2FuIGJlIHRydXN0ZWQgdG8gbWFuYWdlIGl0cyBwYXJhbWV0ZXJzLlxuICpcbiAqIEB0eXBlIHtBc3NlcnRDb250cmFjdEdvdmVybmFuY2V9XG4gKi9cbmNvbnN0IGFzc2VydENvbnRyYWN0R292ZXJuYW5jZT1hc3luYyhcbnpvZSxcbmFsbGVnZWRHb3Zlcm5lZCxcbmFsbGVnZWRHb3Zlcm5vcixcbmNvbnRyYWN0R292ZXJub3JJbnN0YWxsYXRpb24pPT5cbntcbmNvbnN0IGFsbGVnZWRHb3Zlcm5vclBGPUUoem9lKS5nZXRQdWJsaWNGYWNldChhbGxlZ2VkR292ZXJub3IpO1xuY29uc3QgcmVhbEdvdmVybmVkUD1FKGFsbGVnZWRHb3Zlcm5vclBGKS5nZXRHb3Zlcm5lZENvbnRyYWN0KCk7XG5jb25zdCBhbGxlZ2VkR292ZXJuZWRUZXJtc1A9RSh6b2UpLmdldFRlcm1zKGFsbGVnZWRHb3Zlcm5lZCk7XG5cbmNvbnN0W3tlbGVjdGlvbk1hbmFnZXI6cmVhbEdvdmVybm9ySW5zdGFuY2V9LHJlYWxHb3Zlcm5lZEluc3RhbmNlXT1cbmF3YWl0IFByb21pc2UuYWxsKFthbGxlZ2VkR292ZXJuZWRUZXJtc1AscmVhbEdvdmVybmVkUF0pO1xuXG5hc3NlcnQoXG5hbGxlZ2VkR292ZXJub3I9PT1yZWFsR292ZXJub3JJbnN0YW5jZSxcbidUaGUgYWxsZWdlZCBnb3Zlcm5vciBkaWQgbm90IG1hdGNoIHRoZSBnb3Zlcm5vciByZXRyaWV2ZWQgZnJvbSB0aGUgZ292ZXJuZWQgY29udHJhY3QnKTtcblxuXG5hc3NlcnQoXG5hbGxlZ2VkR292ZXJuZWQ9PT1yZWFsR292ZXJuZWRJbnN0YW5jZSxcbidUaGUgYWxsZWdlZCBnb3Zlcm5lZCBkaWQgbm90IG1hdGNoIHRoZSBnb3Zlcm5lZCBjb250cmFjdCByZXRyaWV2ZWQgZnJvbSB0aGUgZ292ZXJub3InKTtcblxuXG5jb25zdCBnb3Zlcm5vckluc3RhbGxhdGlvbkZyb21Hb3Zlcm5lZD1hd2FpdCBFKFxuem9lKS5cbmdldEluc3RhbGxhdGlvbkZvckluc3RhbmNlKHJlYWxHb3Zlcm5vckluc3RhbmNlKTtcblxuYXNzZXJ0KFxuZ292ZXJub3JJbnN0YWxsYXRpb25Gcm9tR292ZXJuZWQ9PT1jb250cmFjdEdvdmVybm9ySW5zdGFsbGF0aW9uLFxuJ1RoZSBnb3Zlcm5lZCBjb250cmFjdCBpcyBub3QgZ292ZXJuZWQgYnkgYW4gaW5zdGFuY2Ugb2YgdGhlIHByb3ZpZGVkIGluc3RhbGxhdGlvbi4nKTtcblxuXG5yZXR1cm57Z292ZXJub3I6cmVhbEdvdmVybm9ySW5zdGFuY2UsZ292ZXJuZWQ6cmVhbEdvdmVybmVkSW5zdGFuY2V9O1xuIH07XG5cbi8qKlxuICogQXNzZXJ0IHRoYXQgdGhlIGdvdmVybm9yIHJlZmVycyB0byB0aGUgaW5kaWNhdGVkIGVsZWN0b3JhdGUuXG4gKlxuICogQHR5cGUge0Fzc2VydENvbnRyYWN0RWxlY3RvcmF0ZX1cbiAqLyRo4oCNX29uY2UuYXNzZXJ0Q29udHJhY3RHb3Zlcm5hbmNlKGFzc2VydENvbnRyYWN0R292ZXJuYW5jZSk7XG5jb25zdCBhc3NlcnRDb250cmFjdEVsZWN0b3JhdGU9YXN5bmMoXG56b2UsXG5hbGxlZ2VkR292ZXJub3IsXG5hbGxlZ2VkRWxlY3RvcmF0ZSk9Plxue1xuY29uc3QgYWxsZWdlZEdvdmVybm9yUEY9RSh6b2UpLmdldFB1YmxpY0ZhY2V0KGFsbGVnZWRHb3Zlcm5vcik7XG5jb25zdCBlbGVjdG9yYXRlPWF3YWl0IEUoYWxsZWdlZEdvdmVybm9yUEYpLmdldEVsZWN0b3JhdGUoKTtcbmVsZWN0b3JhdGU9PT1hbGxlZ2VkRWxlY3RvcmF0ZXx8XG5GYWlsIGBUaGUgYWxsZWdlZEVsZWN0b3JhdGUgZGlkbid0IG1hdGNoIHRoZSBhY3R1YWwgJHtxKGVsZWN0b3JhdGUpfWA7XG5cbnJldHVybiB0cnVlO1xuIH07JGjigI1fb25jZS5hc3NlcnRDb250cmFjdEVsZWN0b3JhdGUoYXNzZXJ0Q29udHJhY3RFbGVjdG9yYXRlKTtcblxuaGFyZGVuKGFzc2VydENvbnRyYWN0R292ZXJuYW5jZSk7XG5oYXJkZW4oYXNzZXJ0Q29udHJhY3RFbGVjdG9yYXRlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRDb250cmFjdEdvdmVybmFuY2UiOlsiYXNzZXJ0Q29udHJhY3RHb3Zlcm5hbmNlIl0sImFzc2VydENvbnRyYWN0RWxlY3RvcmF0ZSI6WyJhc3NlcnRDb250cmFjdEVsZWN0b3JhdGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAbdthCl4oAABeKAAALQAAAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy9jYWxsYmFjay5qc3siaW1wb3J0cyI6WyJAZW5kby9mYXIiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiY2FsbEUiLCJjYWxsU3luYyIsImlzQ2FsbGJhY2siLCJtYWtlRnVuY3Rpb25DYWxsYmFjayIsIm1ha2VNZXRob2RDYWxsYmFjayIsIm1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayIsIm1ha2VTeW5jTWV0aG9kQ2FsbGJhY2siLCJwcmVwYXJlQXR0ZW51YXRvciIsInByZXBhcmVHdWFyZGVkQXR0ZW51YXRvciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLGlzT2JqZWN0LGlzUGFzc2FibGVTeW1ib2w7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL21hcnNoYWxcIiwgW1tcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wiaXNQYXNzYWJsZVN5bWJvbFwiLCBbJGjigI1fYSA9PiAoaXNQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5cbmNvbnN0e2Zyb21FbnRyaWVzfT1PYmplY3Q7XG5cbmNvbnN0e293bktleXM6cmF3T3duS2V5c309UmVmbGVjdDtcbmNvbnN0IG93bktleXM9XG4vKiogQHR5cGUgezxUIGV4dGVuZHMgUHJvcGVydHlLZXk+KG9iajoge1tLIGluIFRdPzogdW5rbm93bn0pID0+IFRbXX0gKi9cbnJhd093bktleXM7XG5cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPFJldHVyblR5cGU8cHJlcGFyZUF0dGVudWF0b3I+PikgPT4gRmFyYWJsZTxUPn0gTWFrZUF0dGVudWF0b3JcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IHVua25vd25bXSkgPT4gYW55fSBJXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcycpLkNhbGxiYWNrPEk+fSBDYWxsYmFja1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzJykuU3luY0NhbGxiYWNrPEk+fSBTeW5jQ2FsbGJhY2tcbiAqL1xuXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDx7fSwgVD4gJiBUfSBGYXJhYmxlICovXG5cbi8qKlxuICogQHBhcmFtIHt1bmtub3dufSBrZXlcbiAqIEByZXR1cm5zIHtrZXkgaXMgUHJvcGVydHlLZXl9IEZJWE1FOiBzaG91bGQgYmUganVzdCBgUHJvcGVydHlLZXlgIGJ1dCBUU1xuICogY29tcGxhaW5zIGl0IGNhbid0IGJlIHVzZWQgYXMgYW4gaW5kZXggdHlwZS5cbiAqL1xuY29uc3QgaXNQcm9wZXJ0eUtleT0oa2V5KT0+e1xuc3dpdGNoKHR5cGVvZiBrZXkpe1xuY2FzZSdzdHJpbmcnOlxuY2FzZSdudW1iZXInOlxuY2FzZSdzeW1ib2wnOlxucmV0dXJuIHRydWU7XG5kZWZhdWx0OlxucmV0dXJuIGZhbHNlO31cblxuIH07XG5cbi8qKlxuICogU3luY2hyb25vdXNseSBjYWxsIGEgY2FsbGJhY2suXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEBwYXJhbSB7U3luY0NhbGxiYWNrPEk+fSBjYWxsYmFja1xuICogQHBhcmFtIHtQYXJhbWV0ZXJzPEk+fSBhcmdzXG4gKiBAcmV0dXJucyB7UmV0dXJuVHlwZTxJPn1cbiAqL1xuY29uc3QgICAgICAgIGNhbGxTeW5jPShjYWxsYmFjaywuLi5hcmdzKT0+e1xuY29uc3R7dGFyZ2V0LG1ldGhvZE5hbWUsYm91bmR9PWNhbGxiYWNrO1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gdGFyZ2V0KC4uLmJvdW5kLC4uLmFyZ3MpO1xuIH1cbnJldHVybiB0YXJnZXRbbWV0aG9kTmFtZV0oLi4uYm91bmQsLi4uYXJncyk7XG4gfTskaOKAjV9vbmNlLmNhbGxTeW5jKGNhbGxTeW5jKTtcbmhhcmRlbihjYWxsU3luYyk7XG5cbi8qKlxuICogRXZlbnR1YWwgc2VuZCB0byBhIGNhbGxiYWNrLlxuICpcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IHVua25vd25bXSkgPT4gYW55fSBJXG4gKiBAcGFyYW0ge0NhbGxiYWNrPEk+fSBjYWxsYmFja1xuICogQHBhcmFtIHtQYXJhbWV0ZXJzPEk+fSBhcmdzXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFJldHVyblR5cGU8ST4+Pn1cbiAqL1xuY29uc3QgICAgICAgIGNhbGxFPShjYWxsYmFjaywuLi5hcmdzKT0+e1xuY29uc3R7dGFyZ2V0LG1ldGhvZE5hbWUsYm91bmR9PWNhbGxiYWNrO1xuaWYobWV0aG9kTmFtZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gRSh0YXJnZXQpKC4uLmJvdW5kLC4uLmFyZ3MpO1xuIH1cbnJldHVybiBFKHRhcmdldClbbWV0aG9kTmFtZV0oLi4uYm91bmQsLi4uYXJncyk7XG4gfTskaOKAjV9vbmNlLmNhbGxFKGNhbGxFKTtcbmhhcmRlbihjYWxsRSk7XG5cbi8qKlxuICogQ3JlYXRlIGEgY2FsbGJhY2sgZnJvbSBhIG5lYXIgZnVuY3Rpb24uXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IFsuLi5CLCAuLi5QYXJhbWV0ZXJzPEk+XSkgPT4gUmV0dXJuVHlwZTxJPn0gW1Q9SV1cbiAqIEB0ZW1wbGF0ZSB7dW5rbm93bltdfSBbQj1bXV1cbiAqIEBwYXJhbSB7VH0gdGFyZ2V0XG4gKiBAcGFyYW0ge0J9IGJvdW5kXG4gKiBAcmV0dXJucyB7U3luY0NhbGxiYWNrPEk+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVN5bmNGdW5jdGlvbkNhbGxiYWNrPSh0YXJnZXQsLi4uYm91bmQpPT57XG50eXBlb2YgdGFyZ2V0PT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBzeW5jIGZ1bmN0aW9uIGNhbGxiYWNrIHRhcmdldCBtdXN0IGJlIGEgZnVuY3Rpb246ICR7dGFyZ2V0fWA7XG4vKiogQHR5cGUge3Vua25vd259ICovXG5jb25zdCBjYj1oYXJkZW4oe3RhcmdldCxib3VuZCxpc1N5bmM6dHJ1ZX0pO1xucmV0dXJuICgvKiogQHR5cGUge1N5bmNDYWxsYmFjazxJPn0gKi9jYik7XG4gfTskaOKAjV9vbmNlLm1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayhtYWtlU3luY0Z1bmN0aW9uQ2FsbGJhY2spO1xuaGFyZGVuKG1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayk7XG5cbi8qKlxuICogQ3JlYXRlIGEgY2FsbGJhY2sgZnJvbSBhIHBvdGVudGlhbGx5IGZhciBmdW5jdGlvbi5cbiAqXG4gKiBAdGVtcGxhdGUgeyguLi5hcmdzOiB1bmtub3duW10pID0+IGFueX0gSVxuICogQHRlbXBsYXRlIHtYaW1wb3J0KCdAZW5kby9mYXInKS5FUmVmPFxuICogICAoLi4uYXJnczogWy4uLkIsIC4uLlBhcmFtZXRlcnM8ST5dKSA9PiBSZXR1cm5UeXBlPEk+XG4gKiA+fSBbVD1YaW1wb3J0KCdAZW5kby9mYXInKS5FUmVmPEk+XVxuICogQHRlbXBsYXRlIHt1bmtub3duW119IFtCPVtdXVxuICogQHBhcmFtIHtUfSB0YXJnZXRcbiAqIEBwYXJhbSB7Qn0gYm91bmRcbiAqIEByZXR1cm5zIHtDYWxsYmFjazxJPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VGdW5jdGlvbkNhbGxiYWNrPSh0YXJnZXQsLi4uYm91bmQpPT57XG5pc09iamVjdCh0YXJnZXQpfHxcbkZhaWwgYGZ1bmN0aW9uIGNhbGxiYWNrIHRhcmdldCBtdXN0IGJlIGEgZnVuY3Rpb24gcHJlc2VuY2U6ICR7dGFyZ2V0fWA7XG4vKiogQHR5cGUge3Vua25vd259ICovXG5jb25zdCBjYj1oYXJkZW4oe3RhcmdldCxib3VuZH0pO1xucmV0dXJuICgvKiogQHR5cGUge0NhbGxiYWNrPEk+fSAqL2NiKTtcbiB9OyRo4oCNX29uY2UubWFrZUZ1bmN0aW9uQ2FsbGJhY2sobWFrZUZ1bmN0aW9uQ2FsbGJhY2spO1xuaGFyZGVuKG1ha2VGdW5jdGlvbkNhbGxiYWNrKTtcblxuLyoqXG4gKiBDcmVhdGUgYSBjYWxsYmFjayBmcm9tIGEgbmVhciBtZXRob2QuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0ZW1wbGF0ZSB7UHJvcGVydHlLZXl9IFBcbiAqIEB0ZW1wbGF0ZSB7e1xuICogICBbeCBpbiBQXTogKC4uLmFyZ3M6IFsuLi5CLCAuLi5QYXJhbWV0ZXJzPEk+XSkgPT4gUmV0dXJuVHlwZTxJPlxuICogfX0gW1Q9eyBbeCBpbiBQXTogSSB9XVxuICogQHRlbXBsYXRlIHt1bmtub3duW119IFtCPVtdXVxuICogQHBhcmFtIHtUfSB0YXJnZXRcbiAqIEBwYXJhbSB7UH0gbWV0aG9kTmFtZVxuICogQHBhcmFtIHtCfSBib3VuZFxuICogQHJldHVybnMge1N5bmNDYWxsYmFjazxJPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VTeW5jTWV0aG9kQ2FsbGJhY2s9KHRhcmdldCxtZXRob2ROYW1lLC4uLmJvdW5kKT0+e1xuaXNPYmplY3QodGFyZ2V0KXx8XG5GYWlsIGBzeW5jIG1ldGhvZCBjYWxsYmFjayB0YXJnZXQgbXVzdCBiZSBhbiBvYmplY3Q6ICR7dGFyZ2V0fWA7XG50eXBlb2YgbWV0aG9kTmFtZT09PSdzdHJpbmcnfHxcbmlzUGFzc2FibGVTeW1ib2wobWV0aG9kTmFtZSl8fFxuRmFpbCBgbWV0aG9kIG5hbWUgbXVzdCBiZSBhIHN0cmluZyBvciBwYXNzYWJsZSBzeW1ib2w6ICR7bWV0aG9kTmFtZX1gO1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL1xuY29uc3QgY2I9aGFyZGVuKHt0YXJnZXQsbWV0aG9kTmFtZSxib3VuZCxpc1N5bmM6dHJ1ZX0pO1xucmV0dXJuICgvKiogQHR5cGUge1N5bmNDYWxsYmFjazxJPn0gKi9jYik7XG4gfTskaOKAjV9vbmNlLm1ha2VTeW5jTWV0aG9kQ2FsbGJhY2sobWFrZVN5bmNNZXRob2RDYWxsYmFjayk7XG5oYXJkZW4obWFrZVN5bmNNZXRob2RDYWxsYmFjayk7XG5cbi8qKlxuICogQ3JlYXRlIGEgY2FsbGJhY2sgZnJvbSBhIHBvdGVudGlhbGx5IGZhciBtZXRob2QuXG4gKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnl9IElcbiAqIEB0ZW1wbGF0ZSB7UHJvcGVydHlLZXl9IFBcbiAqIEB0ZW1wbGF0ZSB7WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjx7XG4gKiAgIFt4IGluIFBdOiAoLi4uYXJnczogWy4uLkIsIC4uLlBhcmFtZXRlcnM8ST5dKSA9PiBSZXR1cm5UeXBlPEk+XG4gKiB9Pn0gW1Q9WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjx7IFt4IGluIFBdOiBJIH0+XVxuICogQHRlbXBsYXRlIHt1bmtub3duW119IFtCPVtdXVxuICogQHBhcmFtIHtUfSB0YXJnZXRcbiAqIEBwYXJhbSB7UH0gbWV0aG9kTmFtZVxuICogQHBhcmFtIHtCfSBib3VuZFxuICogQHJldHVybnMge0NhbGxiYWNrPEk+fVxuICovXG5jb25zdCAgICAgICAgbWFrZU1ldGhvZENhbGxiYWNrPSh0YXJnZXQsbWV0aG9kTmFtZSwuLi5ib3VuZCk9PntcbmlzT2JqZWN0KHRhcmdldCl8fEZhaWwgYG1ldGhvZCBjYWxsYmFjayB0YXJnZXQgbXVzdCBiZSBhbiBvYmplY3Q6ICR7dGFyZ2V0fWA7XG50eXBlb2YgbWV0aG9kTmFtZT09PSdzdHJpbmcnfHxcbmlzUGFzc2FibGVTeW1ib2wobWV0aG9kTmFtZSl8fFxuRmFpbCBgbWV0aG9kIG5hbWUgbXVzdCBiZSBhIHN0cmluZyBvciBwYXNzYWJsZSBzeW1ib2w6ICR7bWV0aG9kTmFtZX1gO1xuLyoqIEB0eXBlIHt1bmtub3dufSAqL1xuY29uc3QgY2I9aGFyZGVuKHt0YXJnZXQsbWV0aG9kTmFtZSxib3VuZH0pO1xucmV0dXJuICgvKiogQHR5cGUge0NhbGxiYWNrPEk+fSAqL2NiKTtcbiB9OyRo4oCNX29uY2UubWFrZU1ldGhvZENhbGxiYWNrKG1ha2VNZXRob2RDYWxsYmFjayk7XG5oYXJkZW4obWFrZU1ldGhvZENhbGxiYWNrKTtcblxuLyoqXG4gKiBAcGFyYW0ge2FueX0gY2FsbGJhY2tcbiAqIEByZXR1cm5zIHtjYWxsYmFjayBpcyBDYWxsYmFjazxhbnk+fVxuICovXG5jb25zdCAgICAgICAgaXNDYWxsYmFjaz0oY2FsbGJhY2spPT57XG5pZighaXNPYmplY3QoY2FsbGJhY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdHt0YXJnZXQsbWV0aG9kTmFtZSxib3VuZH09Y2FsbGJhY2s7XG5yZXR1cm4oXG5pc09iamVjdCh0YXJnZXQpJiYoXG5tZXRob2ROYW1lPT09dW5kZWZpbmVkfHxcbnR5cGVvZiBtZXRob2ROYW1lPT09J3N0cmluZyd8fFxuaXNQYXNzYWJsZVN5bWJvbChtZXRob2ROYW1lKSkmJlxuQXJyYXkuaXNBcnJheShib3VuZCkpO1xuXG4gfTskaOKAjV9vbmNlLmlzQ2FsbGJhY2soaXNDYWxsYmFjayk7XG5oYXJkZW4oaXNDYWxsYmFjayk7XG5cbi8qKlxuICogUHJlcGFyZSBhbiBhdHRlbnVhdG9yIGNsYXNzIHdob3NlIG1ldGhvZHMgY2FuIGJlIHJlZGlyZWN0ZWQgdmlhIGNhbGxiYWNrcy5cbiAqXG4gKiBAdGVtcGxhdGUge1Byb3BlcnR5S2V5fSBNXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9uZScpLlpvbmV9IHpvbmUgVGhlIHpvbmUgaW4gd2hpY2ggdG8gYWxsb2NhdGUgYXR0ZW51YXRvcnMuXG4gKiBAcGFyYW0ge01bXX0gbWV0aG9kTmFtZXMgTWV0aG9kcyB0byBmb3J3YXJkLlxuICogQHBhcmFtIHtvYmplY3R9IG9wdHNcbiAqIEBwYXJhbSB7SW50ZXJmYWNlR3VhcmR9IFtvcHRzLmludGVyZmFjZUd1YXJkXSBBbiBpbnRlcmZhY2UgZ3VhcmQgZm9yIHRoZVxuICogbmV3IGF0dGVudWF0b3IuXG4gKiBAcGFyYW0ge3N0cmluZ30gW29wdHMudGFnXSBBIHRhZyBmb3IgdGhlIG5ldyBhdHRlbnVhdG9yIGV4b0NsYXNzLlxuICovXG5jb25zdCAgICAgICAgcHJlcGFyZUF0dGVudWF0b3I9KFxuem9uZSxcbm1ldGhvZE5hbWVzLFxue2ludGVyZmFjZUd1YXJkLHRhZz0nQXR0ZW51YXRvcid9PXt9KT0+XG57XG4vKipcbiAqIEB0eXBlZGVmIHsodGhpczogYW55LCAuLi5hcmdzOiB1bmtub3duW10pID0+IGFueX0gTWV0aG9kXG4gKiBAdHlwZWRlZiB7eyBbSyBpbiBNXT86IENhbGxiYWNrPGFueT4gfCBudWxsfX0gT3ZlcnJpZGVzXG4gKiBAdHlwZWRlZiB7eyBbSyBpbiBNXTogKHRoaXM6IGFueSwgLi4uYXJnczogdW5rbm93bltdKSA9PiBhbnkgfX0gTWV0aG9kc1xuICovXG5jb25zdCBtZXRob2RzPS8qKiBAdHlwZSB7TWV0aG9kc30gKi9cbmZyb21FbnRyaWVzKFxubWV0aG9kTmFtZXMubWFwKChrZXkpPT57XG4vKiBPbmx5IGFsbG93IHRoZSBgUHJvcGVydHlLZXlgIHR5cGUgZm9yIHRoZSB0YXJnZXQgbWV0aG9kIGtleS4qL1xuaWYoIWlzUHJvcGVydHlLZXkoa2V5KSl7XG50aHJvdyBGYWlsIGBrZXkgJHtxKGtleSl9IGlzIG5vdCBhIFByb3BlcnR5S2V5YDtcbiB9XG5cbmNvbnN0IG09LyoqIEB0eXBlIHtNZXRob2RzfSAqL3tcbi8qIEV4cGxpY2l0bHkgdXNlIGNvbmNpc2UgbWV0aG9kIHN5bnRheCB0byBwcmVzZXJ2ZSBgdGhpc2AgYnV0IHByZXZlbnQqL1xuLyogY29uc3RydWN0b3IgYmVoYXZpb3IuKi9cbi8qKiBAdHlwZSB7TWV0aG9kfSAqL1xuW2tleV0oLi4uYXJncyl7XG4vKiBTdXBwb3J0IGJvdGggc3luY2hyb25vdXMgYW5kIGFzeW5jIGNhbGxiYWNrcy4qL1xuY29uc3QgY2I9dGhpcy5zdGF0ZS5jYnNba2V5XTtcbmlmKCFjYil7XG5jb25zdCBlcnI9YXNzZXJ0LmVycm9yKFxuIGB1bmltcGxlbWVudGVkICR7cSh0YWcpfSBtZXRob2QgJHtxKGtleSl9YCk7XG5cbmlmKHRoaXMuc3RhdGUuaXNTeW5jKXtcbnRocm93IGVycjtcbiB9XG5yZXR1cm4gUHJvbWlzZS5yZWplY3QoZXJyKTtcbiB9XG5pZihjYi5pc1N5bmMpe1xucmV0dXJuIGNhbGxTeW5jKGNiLC4uLmFyZ3MpO1xuIH1cbnJldHVybiBjYWxsRShjYiwuLi5hcmdzKTtcbiB9fVtcbmtleV07XG5yZXR1cm4gKC8qKiBAdHlwZSB7Y29uc3R9ICovW2tleSxtXSk7XG4gfSkpO1xuXG5cblxuLyoqXG4gKiBDcmVhdGUgYW4gZXhvIG9iamVjdCB3aG9zZSBiZWhhdmlvciBpcyBjb21wb3NlZCBmcm9tIGEgZGVmYXVsdCB0YXJnZXRcbiAqIGFuZC9vciBpbmRpdmlkdWFsIG1ldGhvZCBvdmVycmlkZSBjYWxsYmFja3MuXG4gKlxuICogQHBhcmFtIHtvYmplY3R9IG9wdHNcbiAqIEBwYXJhbSB7dW5rbm93bn0gW29wdHMudGFyZ2V0XSBUaGUgdGFyZ2V0IGZvciBhbnkgbWV0aG9kcyB0aGF0XG4gKiB3ZXJlbid0IHNwZWNpZmllZCBpbiBgb3B0cy5vdmVycmlkZXNgLlxuICogQHBhcmFtIHtib29sZWFufSBbb3B0cy5pc1N5bmM9ZmFsc2VdIFdoZXRoZXIgdGhlIHRhcmdldCBzaG91bGQgYmUgdHJlYXRlZFxuICogYXMgc3luY2hyb25vdXNseSBhdmFpbGFibGUuXG4gKiBAcGFyYW0ge092ZXJyaWRlc30gW29wdHMub3ZlcnJpZGVzXSBTZXQgaW5kaXZpZHVhbFxuICogY2FsbGJhY2tzIGZvciBtZXRob2RzICh3aG9zZSBuYW1lcyBtdXN0IGJlIGRlZmluZWQgaW4gdGhlXG4gKiBgcHJlcGFyZUF0dGVudWF0b3JgIG9yIGBwcmVwYXJlR3VhcmRlZEF0dGVudWF0b3JgIGNhbGwpLiAgTnVsbGlzaCBvdmVycmlkZXNcbiAqIG1lYW4gdG8gdGhyb3cuXG4gKi9cbmNvbnN0IG1ha2VBdHRlbnVhdG9yPXpvbmUuZXhvQ2xhc3MoXG50YWcsXG5pbnRlcmZhY2VHdWFyZCxcbi8qKlxuICogQHBhcmFtIHtvYmplY3R9IG9wdHNcbiAqIEBwYXJhbSB7YW55fSBbb3B0cy50YXJnZXRdXG4gKiBAcGFyYW0ge2Jvb2xlYW59IFtvcHRzLmlzU3luYz1mYWxzZV1cbiAqIEBwYXJhbSB7T3ZlcnJpZGVzfSBbb3B0cy5vdmVycmlkZXNdXG4gKi9cbih7XG50YXJnZXQ9bnVsbCxcbmlzU3luYz1mYWxzZSxcbm92ZXJyaWRlcz0vKiogQHR5cGUge092ZXJyaWRlc30gKi97fX0pPT5cbntcbmNvbnN0IGNicz0vKiogQHR5cGUge092ZXJyaWRlc30gKi97fTtcblxuY29uc3QgcmVtYWluaW5nPW5ldyBTZXQobWV0aG9kTmFtZXMpO1xuZm9yKGNvbnN0IGtleSBvZiBvd25LZXlzKG92ZXJyaWRlcykpe1xucmVtYWluaW5nLmhhcyhrZXkpfHxcbkZhaWwgYCR7cSh0YWcpfSBvdmVycmlkZXNbJHtxKGtleSl9XSBub3QgYWxsb3dlZCBieSBtZXRob2ROYW1lc2A7XG5cbnJlbWFpbmluZy5kZWxldGUoa2V5KTtcbmNvbnN0IGNiPW92ZXJyaWRlc1trZXldO1xuY2I9PW51bGx8fFxuaXNDYWxsYmFjayhjYil8fFxuRmFpbCBgJHtxKHRhZyl9IG92ZXJyaWRlc1ske3Eoa2V5KX1dIGlzIG5vdCBhIGNhbGxiYWNrOyBnb3QgJHtjYn1gO1xuY2JzW2tleV09Y2I7XG4gfVxuZm9yKGNvbnN0IGtleSBvZiByZW1haW5pbmcpe1xuaWYoaXNTeW5jKXtcbmNic1trZXldPW1ha2VTeW5jTWV0aG9kQ2FsbGJhY2sodGFyZ2V0LGtleSk7XG4gfWVsc2V7XG5jYnNba2V5XT1tYWtlTWV0aG9kQ2FsbGJhY2sodGFyZ2V0LGtleSk7XG4gfVxuIH1cbnJldHVybiBoYXJkZW4oe2Nicyxpc1N5bmN9KTtcbiB9LFxuLyoqIEB0eXBlIHtNZXRob2RzfSAqL21ldGhvZHMpO1xuXG5yZXR1cm4gbWFrZUF0dGVudWF0b3I7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVBdHRlbnVhdG9yKHByZXBhcmVBdHRlbnVhdG9yKTtcbmhhcmRlbihwcmVwYXJlQXR0ZW51YXRvcik7XG5cbi8qKlxuICogUHJlcGFyZSBhbiBhdHRlbnVhdG9yIHdob3NlIG1ldGhvZE5hbWVzIGFyZSBkZXJpdmVkIGZyb20gdGhlIGludGVyZmFjZUd1YXJkLlxuICpcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy96b25lJykuWm9uZX0gem9uZVxuICogQHBhcmFtIHtJbnRlcmZhY2VHdWFyZH0gaW50ZXJmYWNlR3VhcmRcbiAqIEBwYXJhbSB7b2JqZWN0fSBbb3B0c11cbiAqIEBwYXJhbSB7c3RyaW5nfSBbb3B0cy50YWddXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlR3VhcmRlZEF0dGVudWF0b3I9KHpvbmUsaW50ZXJmYWNlR3VhcmQsb3B0cz17fSk9PntcbmNvbnN0e21ldGhvZEd1YXJkc309aW50ZXJmYWNlR3VhcmQ7XG5jb25zdCBtZXRob2ROYW1lcz1vd25LZXlzKG1ldGhvZEd1YXJkcyk7XG5jb25zdCBtYWtlQXR0ZW51YXRvcj1wcmVwYXJlQXR0ZW51YXRvcih6b25lLG1ldGhvZE5hbWVzLHtcbi4uLm9wdHMsXG5pbnRlcmZhY2VHdWFyZH0pO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7TWFrZUF0dGVudWF0b3I8YW55Pn0gKi9tYWtlQXR0ZW51YXRvcik7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVHdWFyZGVkQXR0ZW51YXRvcihwcmVwYXJlR3VhcmRlZEF0dGVudWF0b3IpO1xuaGFyZGVuKHByZXBhcmVHdWFyZGVkQXR0ZW51YXRvcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiY2FsbFN5bmMiOlsiY2FsbFN5bmMiXSwiY2FsbEUiOlsiY2FsbEUiXSwibWFrZVN5bmNGdW5jdGlvbkNhbGxiYWNrIjpbIm1ha2VTeW5jRnVuY3Rpb25DYWxsYmFjayJdLCJtYWtlRnVuY3Rpb25DYWxsYmFjayI6WyJtYWtlRnVuY3Rpb25DYWxsYmFjayJdLCJtYWtlU3luY01ldGhvZENhbGxiYWNrIjpbIm1ha2VTeW5jTWV0aG9kQ2FsbGJhY2siXSwibWFrZU1ldGhvZENhbGxiYWNrIjpbIm1ha2VNZXRob2RDYWxsYmFjayJdLCJpc0NhbGxiYWNrIjpbImlzQ2FsbGJhY2siXSwicHJlcGFyZUF0dGVudWF0b3IiOlsicHJlcGFyZUF0dGVudWF0b3IiXSwicHJlcGFyZUd1YXJkZWRBdHRlbnVhdG9yIjpbInByZXBhcmVHdWFyZGVkQXR0ZW51YXRvciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACqj91GIgYAACIGAAArAAAAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL2NvbmZpZy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiQnJpZGdlSWQiLCJWQmFua0FjY291bnQiLCJXYWxsZXROYW1lIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQHRzLWNoZWNrKi9cbi8qIEBqZXNzaWUtY2hlY2sqL1xuXG4vKipcbiAqIEBmaWxlXG4gKlxuICogU29tZSBvZiB0aGlzIGNvbmZpZyBpbmZvIG1heSBtYWtlIG1vcmUgc2Vuc2UgaW4gYSBwYXJ0aWN1bGFyIHBhY2thZ2UuIEhvd2V2ZXJcbiAqIGR1ZSB0byBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQ2MjAgYW5kIG91ciBsYXggcGFja2FnZVxuICogZGVwZW5kZW5jeSBncmFwaCwgc29tZXRpbWVzIHJhdGlvbmFsIHBsYWNlbWVudHMgY2F1c2UgdHlwZSByZXNvbHV0aW9uIGVycm9ycy5cbiAqXG4gKiBTbyBhcyBhIHdvcmstYXJvdW5kIHNvbWUgY29uc3RhbnRzIHRoYXQgbmVlZCBhY2Nlc3MgZnJvbSBtb3JlIHRoYW4gb25lIHBhY2thZ2UgYXJlIHBsYWNlZCBoZXJlLlxuICovXG5cbi8qKlxuICogRXZlbnQgc291cmNlIGlkcyB1c2VkIGJ5IHRoZSBicmlkZ2UgZGV2aWNlLlxuICovXG5jb25zdCAgICAgICAgQnJpZGdlSWQ9e1xuQkFOSzonYmFuaycsXG5DT1JFOidjb3JlJyxcbkRJQkM6J2RpYmMnLFxuU1RPUkFHRTonc3RvcmFnZScsXG5QUk9WSVNJT046J3Byb3Zpc2lvbicsXG5QUk9WSVNJT05fU01BUlRfV0FMTEVUOidwcm92aXNpb25XYWxsZXQnLFxuV0FMTEVUOid3YWxsZXQnfTskaOKAjV9vbmNlLkJyaWRnZUlkKEJyaWRnZUlkKTtcblxuaGFyZGVuKEJyaWRnZUlkKTtcblxuY29uc3QgICAgICAgIFdhbGxldE5hbWU9e1xuZGVwb3NpdEZhY2V0OidkZXBvc2l0RmFjZXQnfTskaOKAjV9vbmNlLldhbGxldE5hbWUoV2FsbGV0TmFtZSk7XG5cbmhhcmRlbihXYWxsZXROYW1lKTtcblxuLyogZGVmaW5lZCBpbiBnb2xhbmcvY29zbW9zL3gvdmJhbmsqL1xuY29uc3QgICAgICAgIFZCYW5rQWNjb3VudD17XG5yZXNlcnZlOntcbm1vZHVsZTondmJhbmsvcmVzZXJ2ZScsXG5hZGRyZXNzOidhZ29yaWMxYWUwbG10emxncmNubGE5eGprcGFhcnE1ZDVkZmV6NjNoM251Y2wnfSxcblxucHJvdmlzaW9uOntcbm1vZHVsZTondmJhbmsvcHJvdmlzaW9uJyxcbmFkZHJlc3M6J2Fnb3JpYzFtZWd6eXRnNjVjeXJnenM2ZnZ6eGdyY3F2d3dsN3VncHQ2MjM0Nid9fTskaOKAjV9vbmNlLlZCYW5rQWNjb3VudChWQmFua0FjY291bnQpO1xuXG5cbmhhcmRlbihWQmFua0FjY291bnQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkJyaWRnZUlkIjpbIkJyaWRnZUlkIl0sIldhbGxldE5hbWUiOlsiV2FsbGV0TmFtZSJdLCJWQmFua0FjY291bnQiOlsiVkJhbmtBY2NvdW50Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABfJM4DIBAAAyAQAACoAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvZGVidWcuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbIm1ha2VUcmFjZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAamVzc2llLWNoZWNrKi9cblxubGV0IGRlYnVnSW5zdGFuY2U9MTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtib29sZWFuIHwgJ3ZlcmJvc2UnfSBlbmFibGVcbiAqL1xuY29uc3QgICAgICAgIG1ha2VUcmFjZXI9KG5hbWUsZW5hYmxlPXRydWUpPT57XG5kZWJ1Z0luc3RhbmNlKz0xO1xubGV0IGRlYnVnQ291bnQ9MTtcbmNvbnN0IGtleT0gYC0tLS0tICR7bmFtZX0uJHtkZWJ1Z0luc3RhbmNlfSBgO1xuLyogdGhlIGNhc2VzIGJlbG93IGRlZmluZSBhIG5hbWVkIHZhcmlhYmxlIHRvIHByb3ZpZGUgYmV0dGVyIGRlYnVnIGluZm8qL1xuc3dpdGNoKGVuYWJsZSl7XG5jYXNlIGZhbHNlOntcbmNvbnN0IGxvZ0Rpc2FibGVkPSguLi5fYXJncyk9PnsgfTtcbnJldHVybiBsb2dEaXNhYmxlZDtcbiB9XG5jYXNlJ3ZlcmJvc2UnOntcbmNvbnN0IGluZm9UaWNrPShvcHRMb2csLi4uYXJncyk9PntcbmlmKG9wdExvZy5sb2cpe1xuY29uc29sZS5pbmZvKGtleSxkZWJ1Z0NvdW50Kz0xLC4uLmFyZ3MpO1xuIH1lbHNle1xuY29uc29sZS5pbmZvKGtleSxkZWJ1Z0NvdW50Kz0xLG9wdExvZywuLi5hcmdzKTtcbiB9XG4gfTtcbnJldHVybiBpbmZvVGljaztcbiB9XG5kZWZhdWx0OntcbmNvbnN0IGRlYnVnVGljaz0ob3B0TG9nLC4uLmFyZ3MpPT57XG5pZihvcHRMb2cubG9nKXtcbm9wdExvZy5sb2coa2V5LGRlYnVnQ291bnQrPTEsLi4uYXJncyk7XG4gfWVsc2V7XG5jb25zb2xlLmluZm8oa2V5LGRlYnVnQ291bnQrPTEsb3B0TG9nLC4uLmFyZ3MpO1xuIH1cbiB9O1xucmV0dXJuIGRlYnVnVGljaztcbiB9fVxuXG4gfTskaOKAjV9vbmNlLm1ha2VUcmFjZXIobWFrZVRyYWNlcik7XG5oYXJkZW4obWFrZVRyYWNlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVRyYWNlciI6WyJtYWtlVHJhY2VyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG4VmJ9DAgAAQwIAACoAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvaW5kZXguanN7ImltcG9ydHMiOlsiLi9jb25maWcuanMiLCIuL2RlYnVnLmpzIiwiLi9tZXRob2QtdG9vbHMuanMiLCIuL3R5cGVHdWFyZHMuanMiLCIuL3V0aWxzLmpzIl0sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOlsiLi9jb25maWcuanMiLCIuL2RlYnVnLmpzIiwiLi9tZXRob2QtdG9vbHMuanMiLCIuL3R5cGVHdWFyZHMuanMiLCIuL3V0aWxzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9jb25maWcuanNcIiwgW11dLFtcIi4vZGVidWcuanNcIiwgW11dLFtcIi4vdXRpbHMuanNcIiwgW11dLFtcIi4vbWV0aG9kLXRvb2xzLmpzXCIsIFtdXSxbXCIuL3R5cGVHdWFyZHMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG3KOOsJLgAACS4AADUAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvbGliLWNoYWluU3RvcmFnZS5qc3siaW1wb3J0cyI6WyIuL2NhbGxiYWNrLmpzIiwiQGFnb3JpYy96b25lIiwiQGVuZG8vZmFyIl0sImV4cG9ydHMiOlsiYXNzZXJ0Q2FwRGF0YSIsImFzc2VydFBhdGhTZWdtZW50IiwiaXNTdHJlYW1DZWxsIiwibWFrZUNoYWluU3RvcmFnZVJvb3QiLCJtYWtlU2VyaWFsaXplVG9TdG9yYWdlIiwibWFrZVN0b3JhZ2VOb2RlQ2hpbGQiLCJwcmVwYXJlQ2hhaW5TdG9yYWdlTm9kZSIsInVubWFyc2hhbEZyb21Wc3RvcmFnZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLE0saGVhcFpvbmUsY2I7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9uZVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV0sW1wiaGVhcFpvbmVcIiwgWyRo4oCNX2EgPT4gKGhlYXBab25lID0gJGjigI1fYSldXV1dLFtcIi4vY2FsbGJhY2suanNcIiwgW1tcIipcIiwgWyRo4oCNX2EgPT4gKGNiID0gJGjigI1fYSldXV1dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VDaGFpblN0b3JhZ2VSb290LCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlQ2hhaW5TdG9yYWdlUm9vdFwifSk7JGjigI1fb25jZS5tYWtlQ2hhaW5TdG9yYWdlUm9vdChtYWtlQ2hhaW5TdG9yYWdlUm9vdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VTdG9yYWdlTm9kZUNoaWxkLCAnbmFtZScsIHt2YWx1ZTogXCJtYWtlU3RvcmFnZU5vZGVDaGlsZFwifSk7JGjigI1fb25jZS5tYWtlU3RvcmFnZU5vZGVDaGlsZChtYWtlU3RvcmFnZU5vZGVDaGlsZCk7ICAgXG5cblxuXG5cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGVkZWYge1JldHVyblR5cGU8dHlwZW9mIFhpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5tYWtlTWFyc2hhbD59IE1hcnNoYWxsZXIgKi9cbi8qKiBAdHlwZWRlZiB7UGljazxNYXJzaGFsbGVyLCAnZnJvbUNhcERhdGEnPn0gVW5zZXJpYWxpemVyICovXG5cbi8qKlxuICogRGVmaW5lZCBieSB2c3RvcmFnZVN0b3JlS2V5IGluIHZzdG9yYWdlLmdvXG4gKlxuICogQHR5cGVkZWYgVlN0b3JhZ2VLZXlcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBzdG9yZU5hbWVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBzdG9yZVN1YmtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IGRhdGFQcmVmaXhCeXRlc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IFtub0RhdGFWYWx1ZV1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBbVD11bmtub3duXVxuICogQHR5cGVkZWYgU3RyZWFtQ2VsbFxuICogQHByb3BlcnR5IHtzdHJpbmd9IGJsb2NrSGVpZ2h0IGRlY2ltYWwgcmVwcmVzZW50YXRpb24gb2YgYSBuYXR1cmFsIG51bWJlclxuICogQHByb3BlcnR5IHtUW119IHZhbHVlc1xuICovXG5cbi8qKlxuICogVGhpcyByZXByZXNlbnRzIGEgbm9kZSBpbiBhbiBJQVZMIHRyZWUuXG4gKlxuICogVGhlIGFjdGl2ZSBpbXBsZW1lbnRhdGlvbiBpcyB4L3ZzdG9yYWdlLCBhbiBBZ29yaWMgZXh0ZW5zaW9uIG9mIHRoZSBDb3Ntb3MgU0RLLlxuICpcbiAqIFZzdG9yYWdlIGlzIGEgaGllcmFyY2hpY2FsIGV4dGVybmFsbHktcmVhY2hhYmxlIHN0b3JhZ2Ugc3RydWN0dXJlIHRoYXRcbiAqIGlkZW50aWZpZXMgY2hpbGRyZW4gYnkgcmVzdHJpY3RlZCBBU0NJSSBuYW1lIGFuZCBpcyBhc3NvY2lhdGVkIHdpdGggYXJiaXRyYXJ5XG4gKiBzdHJpbmctdmFsdWVkIGRhdGEgZm9yIGVhY2ggbm9kZSwgZGVmYXVsdGluZyB0byB0aGUgZW1wdHkgc3RyaW5nLlxuICpcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN0b3JhZ2VOb2RlXG4gKiBAcHJvcGVydHkgeyhkYXRhOiBzdHJpbmcpID0+IFByb21pc2U8dm9pZD59IHNldFZhbHVlIHB1Ymxpc2hlcyBzb21lIGRhdGFcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gc3RyaW5nfSBnZXRQYXRoIHRoZSBjaGFpbiBzdG9yYWdlIHBhdGggYXQgd2hpY2ggdGhlIG5vZGUgd2FzIGNvbnN0cnVjdGVkXG4gKiBAcHJvcGVydHkgeygpID0+IFByb21pc2U8VlN0b3JhZ2VLZXk+fSBnZXRTdG9yZUtleSBERVBSRUNBVEVEIHVzZSBnZXRQYXRoXG4gKiBAcHJvcGVydHkgeyhzdWJQYXRoOiBzdHJpbmcsIG9wdGlvbnM/OiB7c2VxdWVuY2U/OiBib29sZWFufSkgPT4gU3RvcmFnZU5vZGV9IG1ha2VDaGlsZE5vZGVcbiAqL1xuXG5jb25zdCBDaGFpblN0b3JhZ2VOb2RlST1NLmludGVyZmFjZSgnU3RvcmFnZU5vZGUnLHtcbnNldFZhbHVlOk0uY2FsbFdoZW4oTS5zdHJpbmcoKSkucmV0dXJucygpLFxuZ2V0UGF0aDpNLmNhbGwoKS5yZXR1cm5zKE0uc3RyaW5nKCkpLFxuZ2V0U3RvcmVLZXk6TS5jYWxsV2hlbigpLnJldHVybnMoTS5yZWNvcmQoKSksXG5tYWtlQ2hpbGROb2RlOk0uY2FsbChNLnN0cmluZygpKS5cbm9wdGlvbmFsKE0uc3BsaXRSZWNvcmQoe30se3NlcXVlbmNlOk0uYm9vbGVhbigpfSx7fSkpLlxucmV0dXJucyhNLnJlbW90YWJsZSgnU3RvcmFnZU5vZGUnKSl9KTtcblxuXG4vKipcbiAqIFRoaXMgaXMgYW4gaW1wZXJmZWN0IGhldXJpc3RpYyB0byBuYXZpZ2F0ZSB0aGUgbWlncmF0aW9uIGZyb20gdmFsdWUgY2VsbHMgdG9cbiAqIHN0cmVhbSBjZWxscy5cbiAqIEF0IHRpbWUgb2Ygd3JpdGluZywgbm8gbGVnYWN5IGNlbGxzIGhhdmUgdGhlIHNhbWUgc2hhcGUgYXMgYSBzdHJlYW0gY2VsbCxcbiAqIGFuZCB3ZSBkbyBub3QgaW50ZW5kIHRvIGNyZWF0ZSBhbnkgbW9yZSBsZWdhY3kgdmFsdWUgY2VsbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IGNlbGxcbiAqIEByZXR1cm5zIHtjZWxsIGlzIFN0cmVhbUNlbGx9XG4gKi9cbmNvbnN0ICAgICAgICBpc1N0cmVhbUNlbGw9KGNlbGwpPT5cbmNlbGwmJlxudHlwZW9mIGNlbGw9PT0nb2JqZWN0JyYmXG5BcnJheS5pc0FycmF5KGNlbGwudmFsdWVzKSYmXG50eXBlb2YgY2VsbC5ibG9ja0hlaWdodD09PSdzdHJpbmcnJiZcbi9eMCR8XlsxLTldWzAtOV0qJC8udGVzdChjZWxsLmJsb2NrSGVpZ2h0KTskaOKAjV9vbmNlLmlzU3RyZWFtQ2VsbChpc1N0cmVhbUNlbGwpO1xuaGFyZGVuKGlzU3RyZWFtQ2VsbCk7XG5cbi8qIFRPRE86IENvbnNvbGlkYXRlIHdpdGggYGluc2lzdENhcERhdGFgIGZ1bmN0aW9ucyBmcm9tIHN3aW5nc2V0LWxpdmVzbG90cywqL1xuLyogc3dpbmdzZXQteHNuYXAtc3VwZXJ2aXNvciwgZXRjLiovXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gZGF0YVxuICogQHJldHVybnMge2Fzc2VydHMgZGF0YSBpcyBYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2FwRGF0YTxzdHJpbmc+fVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0Q2FwRGF0YT0oZGF0YSk9PntcbmFzc2VydC50eXBlb2YoZGF0YSwnb2JqZWN0Jyk7XG5hc3NlcnQoZGF0YSk7XG5hc3NlcnQudHlwZW9mKGRhdGEuYm9keSwnc3RyaW5nJyk7XG5hc3NlcnQoQXJyYXkuaXNBcnJheShkYXRhLnNsb3RzKSk7XG4vKiBYWFggY2hlY2sgdGhhdCB0aGUgLnNsb3RzIGFycmF5IGVsZW1lbnRzIGFyZSBhY3R1YWxseSBzdHJpbmdzKi9cbiB9OyRo4oCNX29uY2UuYXNzZXJ0Q2FwRGF0YShhc3NlcnRDYXBEYXRhKTtcbmhhcmRlbihhc3NlcnRDYXBEYXRhKTtcblxuLyoqXG4gKiBSZWFkIGFuZCB1bm1hcnNoYWwgYSB2YWx1ZSBmcm9tIGEgbWFwIHJlcHJlc2VudGF0aW9uIG9mIHZzdG9yYWdlIGRhdGFcbiAqXG4gKiBAcGFyYW0ge01hcDxzdHJpbmcsIHN0cmluZz59IGRhdGFcbiAqIEBwYXJhbSB7c3RyaW5nfSBrZXlcbiAqIEBwYXJhbSB7UmV0dXJuVHlwZTx0eXBlb2YgWGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLm1ha2VNYXJzaGFsPlsnZnJvbUNhcERhdGEnXX0gZnJvbUNhcERhdGFcbiAqIEBwYXJhbSB7bnVtYmVyfSBbaW5kZXg9LTFdIGluZGV4IG9mIHRoZSBkZXNpcmVkIHZhbHVlIGluIGEgZGVzZXJpYWxpemVkIHN0cmVhbSBjZWxsXG4gKi9cbmNvbnN0ICAgICAgICB1bm1hcnNoYWxGcm9tVnN0b3JhZ2U9KGRhdGEsa2V5LGZyb21DYXBEYXRhLGluZGV4PS0xKT0+e1xuY29uc3Qgc2VyaWFsaXplZD1kYXRhLmdldChrZXkpfHxGYWlsIGBubyBkYXRhIGZvciAke2tleX1gO1xuYXNzZXJ0LnR5cGVvZihzZXJpYWxpemVkLCdzdHJpbmcnKTtcblxuY29uc3Qgc3RyZWFtQ2VsbD1KU09OLnBhcnNlKHNlcmlhbGl6ZWQpO1xuaWYoIWlzU3RyZWFtQ2VsbChzdHJlYW1DZWxsKSl7XG50aHJvdyBGYWlsIGBub3QgYSBTdHJlYW1DZWxsOiAke3N0cmVhbUNlbGx9YDtcbiB9XG5cbmNvbnN0e3ZhbHVlc309c3RyZWFtQ2VsbDtcbnZhbHVlcy5sZW5ndGg+MHx8RmFpbCBgbm8gU3RyZWFtQ2VsbCB2YWx1ZXM6ICR7c3RyZWFtQ2VsbH1gO1xuXG5jb25zdCBtYXJzaGFsbGVkPXZhbHVlcy5hdChpbmRleCk7XG5hc3NlcnQudHlwZW9mKG1hcnNoYWxsZWQsJ3N0cmluZycpO1xuXG4vKiogQHR5cGUge1hpbXBvcnQoXCJAZW5kby9tYXJzaGFsXCIpLkNhcERhdGE8c3RyaW5nPn0gKi9cbmNvbnN0IGNhcERhdGE9aGFyZGVuKEpTT04ucGFyc2UobWFyc2hhbGxlZCkpO1xuYXNzZXJ0Q2FwRGF0YShjYXBEYXRhKTtcblxuY29uc3QgdW5tYXJzaGFsbGVkPWZyb21DYXBEYXRhKGNhcERhdGEpO1xucmV0dXJuIHVubWFyc2hhbGxlZDtcbiB9OyRo4oCNX29uY2UudW5tYXJzaGFsRnJvbVZzdG9yYWdlKHVubWFyc2hhbEZyb21Wc3RvcmFnZSk7XG5oYXJkZW4odW5tYXJzaGFsRnJvbVZzdG9yYWdlKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yZWRGYWNldFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPHN0cmluZz59IGdldFBhdGggdGhlIGNoYWluIHN0b3JhZ2UgcGF0aCBhdCB3aGljaCB0aGUgbm9kZSB3YXMgY29uc3RydWN0ZWRcbiAqIEBwcm9wZXJ0eSB7U3RvcmFnZU5vZGVbJ2dldFN0b3JlS2V5J119IGdldFN0b3JlS2V5IERFUFJFQ0FURUQgdXNlIGdldFBhdGhcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gVW5zZXJpYWxpemVyfSBnZXRVbnNlcmlhbGl6ZXIgZ2V0IHRoZSB1bnNlcmlhbGl6ZXIgZm9yIHRoZSBzdG9yZWQgZGF0YVxuICovXG5cbi8qIFRPRE86IEZvcm1hbGl6ZSBzZWdtZW50IGNvbnN0cmFpbnRzLiovXG4vKiBNdXN0IGJlIG5vbmVtcHR5IGFuZCBkaXNhbGxvdyAodW5lc2NhcGVkKSBgLmAsIGFuZCBmb3Igc2ltcGxpY2l0eSovXG4vKiAoYW5kIGZ1dHVyZSBwb3NzaWJpbGl0eSBvZiBlLmcuIGVzY2FwaW5nKSB3ZSBjdXJyZW50bHkgbGltaXQgdG8qL1xuLyogQVNDSUkgYWxwaGFudW1lcmljIHBsdXMgdW5kZXJzY29yZSBhbmQgZGFzaC4qL1xuY29uc3QgcGF0aFNlZ21lbnRQYXR0ZXJuPS9eW2EtekEtWjAtOV8tXXsxLDEwMH0kLztcblxuLyoqIEB0eXBlIHsobmFtZTogc3RyaW5nKSA9PiB2b2lkfSAqL1xuY29uc3QgICAgICAgIGFzc2VydFBhdGhTZWdtZW50PShuYW1lKT0+e1xucGF0aFNlZ21lbnRQYXR0ZXJuLnRlc3QobmFtZSl8fFxuRmFpbCBgUGF0aCBzZWdtZW50IG5hbWVzIG11c3QgY29uc2lzdCBvZiAxIHRvIDEwMCBjaGFyYWN0ZXJzIGxpbWl0ZWQgdG8gQVNDSUkgYWxwaGFudW1lcmljcywgdW5kZXJzY29yZXMsIGFuZC9vciBkYXNoZXM6ICR7bmFtZX1gO1xuIH07JGjigI1fb25jZS5hc3NlcnRQYXRoU2VnbWVudChhc3NlcnRQYXRoU2VnbWVudCk7XG5oYXJkZW4oYXNzZXJ0UGF0aFNlZ21lbnQpO1xuXG4vKipcbiAqIE11c3QgbWF0Y2ggdGhlIHN3aXRjaCBpbiB2c3RvcmFnZS5nbyB1c2luZyBgdnN0b3JhZ2VNZXNzYWdlYCB0eXBlXG4gKlxuICogQHR5cGVkZWYgeyAnZ2V0JyB8ICdnZXRTdG9yZUtleScgfCAnaGFzJyB8ICdjaGlsZHJlbicgfCAnZW50cmllcycgfCAndmFsdWVzJyB8J3NpemUnIH0gU3RvcmFnZUdldEJ5UGF0aE1lc3NhZ2VNZXRob2RcbiAqIEB0eXBlZGVmIHsgJ3NldCcgfCAnc2V0V2l0aG91dE5vdGlmeScgfCAnYXBwZW5kJyB9IFN0b3JhZ2VVcGRhdGVFbnRyaWVzTWVzc2FnZU1ldGhvZFxuICogQHR5cGVkZWYge1N0b3JhZ2VHZXRCeVBhdGhNZXNzYWdlTWV0aG9kIHwgU3RvcmFnZVVwZGF0ZUVudHJpZXNNZXNzYWdlTWV0aG9kIH0gU3RvcmFnZU1lc3NhZ2VNZXRob2RcbiAqIEB0eXBlZGVmIHsgW3BhdGg6IHN0cmluZ10gfSBTdG9yYWdlR2V0QnlQYXRoTWVzc2FnZUFyZ3NcbiAqIEB0eXBlZGVmIHsgW3BhdGg6IHN0cmluZywgdmFsdWU/OiBzdHJpbmcgfCBudWxsXSB9IFN0b3JhZ2VFbnRyeVxuICogQHR5cGVkZWYgeyBTdG9yYWdlRW50cnlbXSB9IFN0b3JhZ2VVcGRhdGVFbnRyaWVzTWVzc2FnZUFyZ3NcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIG1ldGhvZDogU3RvcmFnZUdldEJ5UGF0aE1lc3NhZ2VNZXRob2Q7XG4gKiAgIGFyZ3M6IFN0b3JhZ2VHZXRCeVBhdGhNZXNzYWdlQXJncztcbiAqICB9IHwge1xuICogICBtZXRob2Q6IFN0b3JhZ2VVcGRhdGVFbnRyaWVzTWVzc2FnZU1ldGhvZDtcbiAqICAgYXJnczogU3RvcmFnZVVwZGF0ZUVudHJpZXNNZXNzYWdlQXJncztcbiAqIH19IFN0b3JhZ2VNZXNzYWdlXG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9uZScpLlpvbmV9IHpvbmVcbiAqL1xuY29uc3QgICAgICAgIHByZXBhcmVDaGFpblN0b3JhZ2VOb2RlPSh6b25lKT0+e1xuLyoqXG4gKiBDcmVhdGUgYSBzdG9yYWdlIG5vZGUgZm9yIGEgZ2l2ZW4gYmFja2luZyBzdG9yYWdlIGludGVyZmFjZSBhbmQgcGF0aC5cbiAqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vY2FsbGJhY2snKS5DYWxsYmFjazwobWVzc2FnZTogU3RvcmFnZU1lc3NhZ2UpID0+IGFueT59IG1lc3NlbmdlciBhIGNhbGxiYWNrXG4gKiBmb3Igc2VuZGluZyBhIHN0b3JhZ2VNZXNzYWdlIG9iamVjdCB0byB0aGUgc3RvcmFnZSBpbXBsZW1lbnRhdGlvblxuICogKGNmLiBnb2xhbmcvY29zbW9zL3gvdnN0b3JhZ2UvdnN0b3JhZ2UuZ28pXG4gKiBAcGFyYW0ge3N0cmluZ30gcGF0aFxuICogQHBhcmFtIHtvYmplY3R9IFtvcHRpb25zXVxuICogQHBhcmFtIHtib29sZWFufSBbb3B0aW9ucy5zZXF1ZW5jZV0gc2V0IHZhbHVlcyB3aXRoIGBhcHBlbmRgIG1lc3NhZ2VzIHJhdGhlciB0aGFuIGBzZXRgIG1lc3NhZ2VzXG4gKiBzbyB0aGUgYmFja2luZyBpbXBsZW1lbnRhdGlvbiBlbXBsb3lzIGEgd3JhcHBpbmcgc3RydWN0dXJlIHRoYXRcbiAqIHByZXNlcnZlcyBlYWNoIHZhbHVlIHNldCB3aXRoaW4gYSBzaW5nbGUgYmxvY2suXG4gKiBDaGlsZCBub2RlcyBkZWZhdWx0IHRvIGluaGVyaXRpbmcgdGhpcyBvcHRpb24gZnJvbSB0aGVpciBwYXJlbnQuXG4gKiBAcmV0dXJucyB7U3RvcmFnZU5vZGV9XG4gKi9cbmNvbnN0IG1ha2VDaGFpblN0b3JhZ2VOb2RlPXpvbmUuZXhvQ2xhc3MoXG4nQ2hhaW5TdG9yYWdlTm9kZScsXG5DaGFpblN0b3JhZ2VOb2RlSSxcbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2NhbGxiYWNrJykuQ2FsbGJhY2s8KG1lc3NhZ2U6IFN0b3JhZ2VNZXNzYWdlKSA9PiBhbnk+fSBtZXNzZW5nZXJcbiAqIEBwYXJhbSB7c3RyaW5nfSBwYXRoXG4gKiBAcGFyYW0ge29iamVjdH0gW29wdGlvbnNdXG4gKiBAcGFyYW0ge2Jvb2xlYW59IFtvcHRpb25zLnNlcXVlbmNlXVxuICovXG4obWVzc2VuZ2VyLHBhdGgse3NlcXVlbmNlPWZhbHNlfT17fSk9PntcbmFzc2VydC50eXBlb2YocGF0aCwnc3RyaW5nJyk7XG5hc3NlcnQudHlwZW9mKHNlcXVlbmNlLCdib29sZWFuJyk7XG5yZXR1cm4gaGFyZGVuKHtwYXRoLG1lc3NlbmdlcixzZXF1ZW5jZX0pO1xuIH0sXG57XG5nZXRQYXRoKCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5wYXRoO1xuIH0sXG4vKipcbiAqIEBkZXByZWNhdGVkIHVzZSBnZXRQYXRoXG4gKiBAdHlwZSB7KCkgPT4gUHJvbWlzZTxWU3RvcmFnZUtleT59XG4gKi9cbiAgICAgIGFzeW5jIGdldFN0b3JlS2V5KCl7XG5jb25zdHtwYXRoLG1lc3Nlbmdlcn09dGhpcy5zdGF0ZTtcbnJldHVybiBjYi5jYWxsRShtZXNzZW5nZXIse1xubWV0aG9kOidnZXRTdG9yZUtleScsXG5hcmdzOltwYXRoXX0pO1xuXG4gfSxcbi8qKiBAdHlwZSB7KG5hbWU6IHN0cmluZywgY2hpbGROb2RlT3B0aW9ucz86IHtzZXF1ZW5jZT86IGJvb2xlYW59KSA9PiBTdG9yYWdlTm9kZX0gKi9cbm1ha2VDaGlsZE5vZGUobmFtZSxjaGlsZE5vZGVPcHRpb25zPXt9KXtcbmNvbnN0e3NlcXVlbmNlLHBhdGgsbWVzc2VuZ2VyfT10aGlzLnN0YXRlO1xuYXNzZXJ0UGF0aFNlZ21lbnQobmFtZSk7XG5jb25zdCBtZXJnZWRPcHRpb25zPXtzZXF1ZW5jZSwuLi5jaGlsZE5vZGVPcHRpb25zfTtcbnJldHVybiBtYWtlQ2hhaW5TdG9yYWdlTm9kZShcbm1lc3NlbmdlcixcbiBgJHtwYXRofS4ke25hbWV9YCxcbm1lcmdlZE9wdGlvbnMpO1xuXG4gfSxcbi8qKiBAdHlwZSB7KHZhbHVlOiBzdHJpbmcpID0+IFByb21pc2U8dm9pZD59ICovXG4gICAgICBhc3luYyBzZXRWYWx1ZSh2YWx1ZSl7XG5jb25zdHtzZXF1ZW5jZSxwYXRoLG1lc3Nlbmdlcn09dGhpcy5zdGF0ZTtcbmFzc2VydC50eXBlb2YodmFsdWUsJ3N0cmluZycpO1xuLyoqIEB0eXBlIHtTdG9yYWdlRW50cnl9ICovXG5sZXQgZW50cnk7XG5pZighc2VxdWVuY2UmJiF2YWx1ZSl7XG5lbnRyeT1bcGF0aF07XG4gfWVsc2V7XG5lbnRyeT1bcGF0aCx2YWx1ZV07XG4gfVxuYXdhaXQgY2IuY2FsbEUobWVzc2VuZ2VyLHtcbm1ldGhvZDpzZXF1ZW5jZT8nYXBwZW5kJzonc2V0JyxcbmFyZ3M6W2VudHJ5XX0pO1xuXG4gfVxuLyogUG9zc2libGUgZXh0ZW5zaW9uczoqL1xuLyogKiBnZXRWYWx1ZSgpKi9cbi8qICogZ2V0Q2hpbGROYW1lcygpIGFuZC9vciBtYWtlQ2hpbGROb2RlcygpKi9cbi8qICogZ2V0TmFtZSgpKi9cbi8qICogcmVjdXJzaXZlIGRlbGV0ZSovXG4vKiAqIGJhdGNoIG9wZXJhdGlvbnMqL1xuLyogKiBsb2NhbCBidWZmZXJpbmcgKHdpdGggZW5kLW9mLWJsb2NrIGNvbW1pdCkqL30pO1xuXG5cbnJldHVybiBtYWtlQ2hhaW5TdG9yYWdlTm9kZTtcbiB9OyRo4oCNX29uY2UucHJlcGFyZUNoYWluU3RvcmFnZU5vZGUocHJlcGFyZUNoYWluU3RvcmFnZU5vZGUpO1xuXG5jb25zdCBtYWtlSGVhcENoYWluU3RvcmFnZU5vZGU9cHJlcGFyZUNoYWluU3RvcmFnZU5vZGUoaGVhcFpvbmUpO1xuXG4vKipcbiAqIENyZWF0ZSBhIGhlYXAtYmFzZWQgcm9vdCBzdG9yYWdlIG5vZGUgZm9yIGEgZ2l2ZW4gYmFja2luZyBmdW5jdGlvbiBhbmQgcm9vdCBwYXRoLlxuICpcbiAqIEBwYXJhbSB7KG1lc3NhZ2U6IFN0b3JhZ2VNZXNzYWdlKSA9PiBhbnl9IGhhbmRsZVN0b3JhZ2VNZXNzYWdlIGEgZnVuY3Rpb24gZm9yXG4gKiBzZW5kaW5nIGEgc3RvcmFnZU1lc3NhZ2Ugb2JqZWN0IHRvIHRoZSBzdG9yYWdlIGltcGxlbWVudGF0aW9uXG4gKiAoY2YuIGdvbGFuZy9jb3Ntb3MveC92c3RvcmFnZS92c3RvcmFnZS5nbylcbiAqIEBwYXJhbSB7c3RyaW5nfSByb290UGF0aFxuICogQHBhcmFtIHtvYmplY3R9IFtyb290T3B0aW9uc11cbiAqIEBwYXJhbSB7Ym9vbGVhbn0gW3Jvb3RPcHRpb25zLnNlcXVlbmNlXSBlbXBsb3kgYSB3cmFwcGluZyBzdHJ1Y3R1cmUgdGhhdFxuICogcHJlc2VydmVzIGVhY2ggdmFsdWUgc2V0IHdpdGhpbiBhIHNpbmdsZSBibG9jaywgYW5kIGRlZmF1bHQgY2hpbGQgbm9kZXNcbiAqIHRvIGRvIHRoZSBzYW1lXG4gKi9cbmZ1bmN0aW9uICAgICAgICBtYWtlQ2hhaW5TdG9yYWdlUm9vdChcbmhhbmRsZVN0b3JhZ2VNZXNzYWdlLFxucm9vdFBhdGgsXG5yb290T3B0aW9ucz17fSlcbntcbmNvbnN0IG1lc3Nlbmdlcj1jYi5tYWtlRnVuY3Rpb25DYWxsYmFjayhoYW5kbGVTdG9yYWdlTWVzc2FnZSk7XG5cbi8qIFVzZSB0aGUgaGVhcFpvbmUgZGlyZWN0bHkuKi9cbmNvbnN0IHJvb3ROb2RlPW1ha2VIZWFwQ2hhaW5TdG9yYWdlTm9kZShtZXNzZW5nZXIscm9vdFBhdGgscm9vdE9wdGlvbnMpO1xucmV0dXJuIHJvb3ROb2RlO1xuIH1cblxuLyoqXG4gKiBAcmV0dXJucyB7U3RvcmFnZU5vZGV9IGFuIG9iamVjdCB0aGF0IGNvbmZpcm1zIHRvIFN0b3JhZ2VOb2RlIEFQSSBidXQgZG9lcyBub3Qgc3RvcmUgYW55d2hlcmUuXG4gKi9cbmNvbnN0IG1ha2VOdWxsU3RvcmFnZU5vZGU9KCk9Pntcbi8qIFhYWCByZS11c2UgXCJDaGFpblN0b3JhZ2VcIiBtZXRob2RzIGFib3ZlIHdoaWNoIGRvbid0IGFjdHVhbGx5IGRlcGVuZCBvbiBjaGFpbnMqL1xucmV0dXJuIG1ha2VDaGFpblN0b3JhZ2VSb290KCgpPT5udWxsLCdudWxsJyk7XG4gfTtcblxuLyoqXG4gKiBDb252ZW5pZW5jZSBmdW5jdGlvbiBmb3IgcmV0dXJuaW5nIGEgc3RvcmFnZSBub2RlIGF0IG9yIHVuZGVyIGl0cyBpbnB1dCxcbiAqIGZhbGxpbmcgYmFjayB0byBhbiBpbmVydCBvYmplY3Qgd2l0aCB0aGUgY29ycmVjdCBpbnRlcmZhY2UgKGJ1dCBpbmNvbXBsZXRlXG4gKiBiZWhhdmlvcikgd2hlbiB0aGF0IGlzIHVuYXZhaWxhYmxlLlxuICpcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjxTdG9yYWdlTm9kZT8+fSBzdG9yYWdlTm9kZVJlZlxuICogQHBhcmFtIHtzdHJpbmd9IGNoaWxkTmFtZVxuICogQHJldHVybnMge1Byb21pc2U8U3RvcmFnZU5vZGU+fVxuICovXG5hc3luYyBmdW5jdGlvbiAgICAgICAgbWFrZVN0b3JhZ2VOb2RlQ2hpbGQoc3RvcmFnZU5vZGVSZWYsY2hpbGROYW1lKXtcbmNvbnN0IGV4aXN0aW5nU3RvcmFnZU5vZGU9YXdhaXQgc3RvcmFnZU5vZGVSZWY7XG5jb25zdCBzdG9yYWdlTm9kZT1leGlzdGluZ1N0b3JhZ2VOb2RlfHxtYWtlTnVsbFN0b3JhZ2VOb2RlKCk7XG5yZXR1cm4gRShzdG9yYWdlTm9kZSkubWFrZUNoaWxkTm9kZShjaGlsZE5hbWUpO1xuIH1cbmhhcmRlbihtYWtlU3RvcmFnZU5vZGVDaGlsZCk7XG5cbi8qIFRPRE8gZmluZCBhIGJldHRlciBtb2R1bGUgZm9yIHRoaXMqL1xuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BlbmRvL2ZhcicpLkVSZWY8U3RvcmFnZU5vZGU+fSBzdG9yYWdlTm9kZVxuICogQHBhcmFtIHtYaW1wb3J0KCdAZW5kby9mYXInKS5FUmVmPE1hcnNoYWxsZXI+fSBtYXJzaGFsbGVyXG4gKiBAcmV0dXJucyB7KHZhbHVlOiB1bmtub3duKSA9PiBQcm9taXNlPHZvaWQ+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVNlcmlhbGl6ZVRvU3RvcmFnZT0oc3RvcmFnZU5vZGUsbWFyc2hhbGxlcik9PntcbnJldHVybiBhc3luYyh2YWx1ZSk9PntcbmNvbnN0IG1hcnNoYWxsZWQ9YXdhaXQgRShtYXJzaGFsbGVyKS50b0NhcERhdGEodmFsdWUpO1xuY29uc3Qgc2VyaWFsaXplZD1KU09OLnN0cmluZ2lmeShtYXJzaGFsbGVkKTtcbnJldHVybiBFKHN0b3JhZ2VOb2RlKS5zZXRWYWx1ZShzZXJpYWxpemVkKTtcbiB9O1xuIH07JGjigI1fb25jZS5tYWtlU2VyaWFsaXplVG9TdG9yYWdlKG1ha2VTZXJpYWxpemVUb1N0b3JhZ2UpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzU3RyZWFtQ2VsbCI6WyJpc1N0cmVhbUNlbGwiXSwiYXNzZXJ0Q2FwRGF0YSI6WyJhc3NlcnRDYXBEYXRhIl0sInVubWFyc2hhbEZyb21Wc3RvcmFnZSI6WyJ1bm1hcnNoYWxGcm9tVnN0b3JhZ2UiXSwiYXNzZXJ0UGF0aFNlZ21lbnQiOlsiYXNzZXJ0UGF0aFNlZ21lbnQiXSwicHJlcGFyZUNoYWluU3RvcmFnZU5vZGUiOlsicHJlcGFyZUNoYWluU3RvcmFnZU5vZGUiXSwibWFrZUNoYWluU3RvcmFnZVJvb3QiOlsibWFrZUNoYWluU3RvcmFnZVJvb3QiXSwibWFrZVN0b3JhZ2VOb2RlQ2hpbGQiOlsibWFrZVN0b3JhZ2VOb2RlQ2hpbGQiXSwibWFrZVNlcmlhbGl6ZVRvU3RvcmFnZSI6WyJtYWtlU2VyaWFsaXplVG9TdG9yYWdlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGnyxEAnDwAAJw8AADEAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvbWV0aG9kLXRvb2xzLmpzeyJpbXBvcnRzIjpbIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJiaW5kQWxsTWV0aG9kcyIsImdldE1ldGhvZE5hbWVzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzT2JqZWN0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL21hcnNoYWxcIiwgW1tcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cbi8qKlxuICogQGZpbGUgbWV0aG9kLXRvb2xzIHVzZSBkeW5hbWljIHByb3BlcnR5IGxvb2t1cCwgd2hpY2ggaXMgbm90IEplc3NpZS1jb21wYXRpYmxlXG4gKi9cblxuY29uc3R7Z2V0UHJvdG90eXBlT2YsY3JlYXRlLGZyb21FbnRyaWVzLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PVxuT2JqZWN0O1xuY29uc3R7b3duS2V5cyxhcHBseX09UmVmbGVjdDtcblxuLyoqXG4gKiBQcmlvcml0aXplIHN5bWJvbHMgYXMgZWFybGllciB0aGFuIHN0cmluZ3MuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd8c3ltYm9sfSBhXG4gKiBAcGFyYW0ge3N0cmluZ3xzeW1ib2x9IGJcbiAqIEByZXR1cm5zIHstMSB8IDAgfCAxfVxuICovXG5jb25zdCBjb21wYXJlU3RyaW5naWZpZWQ9KGEsYik9PntcbmlmKHR5cGVvZiBhPT09dHlwZW9mIGIpe1xuY29uc3QgbGVmdD1TdHJpbmcoYSk7XG5jb25zdCByaWdodD1TdHJpbmcoYik7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tbmVzdGVkLXRlcm5hcnkqL1xucmV0dXJuIGxlZnQ8cmlnaHQ/LTE6bGVmdD5yaWdodD8xOjA7XG4gfVxuaWYodHlwZW9mIGE9PT0nc3ltYm9sJyl7XG5hc3NlcnQodHlwZW9mIGI9PT0nc3RyaW5nJyk7XG5yZXR1cm4tMTtcbiB9XG5hc3NlcnQodHlwZW9mIGE9PT0nc3RyaW5nJyk7XG5hc3NlcnQodHlwZW9mIGI9PT0nc3ltYm9sJyk7XG5yZXR1cm4gMTtcbiB9O1xuXG4vKipcbiAqIFRPRE8gQ29uc29saWRhdGUgd2l0aCB0aGUgYGdldE1ldGhvZE5hbWVzYCBpbiBgQGVuZG8vZXZlbnR1YWwtc2VuZGBcbiAqXG4gKiBAdGVtcGxhdGUge1Byb3BlcnR5S2V5fSBLXG4gKiBAcGFyYW0ge1JlY29yZDxLLCBhbnk+fSB2YWxcbiAqIEByZXR1cm5zIHtLW119XG4gKi9cbmNvbnN0ICAgICAgICBnZXRNZXRob2ROYW1lcz0odmFsKT0+e1xubGV0IGxheWVyPXZhbDtcbmNvbnN0IG5hbWVzPW5ldyBTZXQoKTsvKiBTZXQgdG8gZGVkdXBsaWNhdGUqL1xud2hpbGUobGF5ZXIhPT1udWxsJiZsYXllciE9PU9iamVjdC5wcm90b3R5cGUpe1xuLyogYmUgdG9sZXJhbnQgb2Ygbm9uLW9iamVjdHMqL1xuY29uc3QgZGVzY3M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhsYXllcik7XG5jb25zdCBvd25OYW1lcz0vKiogQHR5cGUge0tbXX0gKi9vd25LZXlzKGRlc2NzKTtcbmZvcihjb25zdCBuYW1lIG9mIG93bk5hbWVzKXtcbi8qIEluIGNhc2UgYSBtZXRob2QgaXMgb3ZlcnJpZGRlbiBieSBhIG5vbi1tZXRob2QsKi9cbi8qIHRlc3QgYHZhbFtuYW1lXWAgcmF0aGVyIHRoYW4gYGxheWVyW25hbWVdYCovXG5pZih0eXBlb2YgdmFsW25hbWVdPT09J2Z1bmN0aW9uJyl7XG5uYW1lcy5hZGQobmFtZSk7XG4gfVxuIH1cbmlmKCFpc09iamVjdCh2YWwpKXtcbmJyZWFrO1xuIH1cbmxheWVyPWdldFByb3RvdHlwZU9mKGxheWVyKTtcbiB9XG5yZXR1cm4gaGFyZGVuKFsuLi5uYW1lc10uc29ydChjb21wYXJlU3RyaW5naWZpZWQpKTtcbiB9OyRo4oCNX29uY2UuZ2V0TWV0aG9kTmFtZXMoZ2V0TWV0aG9kTmFtZXMpO1xuaGFyZGVuKGdldE1ldGhvZE5hbWVzKTtcblxuLyoqXG4gKiBUT0RPIFRoaXMgZnVuY3Rpb24gZXhpc3RzIG9ubHkgdG8gZWFzZSB0aGVcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9wdWxsLzU5NzAgdHJhbnNpdGlvbiwgZnJvbSBhbGwgbWV0aG9kc1xuICogYmVpbmcgb3duIHByb3BlcnRpZXMgdG8gbWV0aG9kcyBiZWluZyBpbmhlcml0ZWQgZnJvbSBhIGNvbW1vbiBwcm90b3R5cGUuXG4gKiBUaGlzIHRyYW5zaXRpb24gYnJlYWtzIHR3byBwYXR0ZXJucyB1c2VkIGluIHByaW9yIGNvZGU6IGF1dG9iaW5kaW5nLFxuICogYW5kIGVudW1lcmF0aW5nIG1ldGhvZHMgYnkgZW51bWVyYXRpbmcgb3duIHByb3BlcnRpZXMuIEZvciBib3RoLCB0aGVcbiAqIHByZWZlcnJlZCByZXBhaXJzIGFyZVxuICogICAgKiBhdXRvYmluZGluZzogUmVwbGFjZSwgZm9yIGV4YW1wbGUsXG4gKiAgICAgIGBmb28ob2JqLm1ldGhvZClgIHdpdGggYGZvbyhhcmcgPT4gYG9iai5tZXRob2QoYXJnKSlgLiBJT1csIHN0b3AgcmVseWluZ1xuICogICAgICBvbiBleHByZXNzaW9ucyBsaWtlIGBvYmoubWV0aG9kYCB0byBleHRyYWN0IGEgbWV0aG9kIHN0aWxsIGJvdW5kIHRvIHRoZVxuICogICAgICBzdGF0ZSBvZiBgb2JqYCBiZWNhdXNlLCBmb3IgdmlydHVhbCBhbmQgZHVyYWJsZSBvYmplY3RzLFxuICogICAgICB0aGV5IG5vIGxvbmdlciB3aWxsIGFmdGVyICM1OTcwLlxuICogICAgKiBtZXRob2QgZW51bWVyYXRpb246IFJlcGxhY2UsIGZvciBleGFtcGxlXG4gKiAgICAgIGBSZWZsZWN0Lm93bktleXMob2JqKWAgd2l0aCBgZ2V0TWV0aG9kTmFtZXMob2JqKWAuXG4gKlxuICogT25jZSBhbGwgcHJvYmxlbWF0aWMgY2FzZXMgaGF2ZSBiZWVuIGNvbnZlcnRlZCBpbiB0aGlzIG1hbm5lciwgdGhpc1xuICogYGJpbmRBbGxNZXRob2RzYCBoYWNrIGNhbiBhbmQgVE9ETyBzaG91bGQgYmUgZGVsZXRlZC4gSG93ZXZlciwgd2UgY3VycmVudGx5XG4gKiBoYXZlIG5vIHJlbGlhYmxlIHN0YXRpYyB3YXkgdG8gdHJhY2sgZG93biBhbmQgZml4IGFsbCBhdXRvYmluZGluZyBzaXRlcy5cbiAqIEZvciB0aG9zZSBvYmplY3RzIHRoYXQgaGF2ZSBub3QgeWV0IGJlZW4gZnVsbHkgcmVwYWlyZWQgYnkgdGhlIGFib3ZlIHR3b1xuICogdGVjaG5pcXVlcywgYGJpbmRBbGxNZXRob2RzYCBjcmVhdGVzIGFuIG9iamVjdCB0aGF0IGFjdHMgbXVjaCBsaWtlIHRoZVxuICogcHJlLSM1OTcwIG9iamVjdHMsIHdpdGggYWxsIHRoZWlyIG1ldGhvZHMgYXMgaW5zdGFuY2UtYm91bmQgb3duIHByb3BlcnRpZXMuXG4gKiBJdCBkb2VzIHRoaXMgYnkgbWFraW5nIGEgbmV3IG9iamVjdCBpbmhlcml0aW5nIGZyb20gYG9iamAgd2hlcmUgdGhlIG5ld1xuICogb2JqZWN0IGhhcyBib3VuZCBvd24gbWV0aG9kcyBvdmVycmlkZGluZyBhbGwgdGhlIG1ldGhvZHMgaXQgd291bGQgaGF2ZVxuICogaW5oZXJpdGVkIGZyb20gYG9iamAuXG4gKlxuICogQHRlbXBsYXRlIHtSZWNvcmQ8UHJvcGVydHlLZXksIGFueT59IFRcbiAqIEBwYXJhbSB7VH0gb2JqXG4gKiBAcmV0dXJucyB7VH1cbiAqL1xuY29uc3QgICAgICAgIGJpbmRBbGxNZXRob2RzPShvYmopPT5cbmhhcmRlbihcbmNyZWF0ZShcbm9iaixcbmZyb21FbnRyaWVzKFxuZ2V0TWV0aG9kTmFtZXMob2JqKS5tYXAoKG5hbWUpPT5bXG5uYW1lLFxue1xudmFsdWU6KC8qKiBAdHlwZSB7dW5rbm93bltdfSAqLy4uLmFyZ3MpPT5cbmFwcGx5KG9ialtuYW1lXSxvYmosYXJncyksXG5lbnVtZXJhYmxlOnRydWV9XSkpKSk7JGjigI1fb25jZS5iaW5kQWxsTWV0aG9kcyhiaW5kQWxsTWV0aG9kcyk7XG5cblxuXG5cblxuaGFyZGVuKGJpbmRBbGxNZXRob2RzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRNZXRob2ROYW1lcyI6WyJnZXRNZXRob2ROYW1lcyJdLCJiaW5kQWxsTWV0aG9kcyI6WyJiaW5kQWxsTWV0aG9kcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADqQ+El3gMAAN4DAAAyAAAAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL3Rlc3RpbmctdXRpbHMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImV2ZW50TG9vcEl0ZXJhdGlvbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qKiBAZmlsZSBub3RlIHRoaXMgY2Fubm90IGJlIGNhbGxlZCB0ZXN0LXV0aWxzLmpzIGR1ZSB0byBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzc1MDMgKi9cbi8qIGdsb2JhbCBzZXRJbW1lZGlhdGUgKi9cblxuLyoqXG4gKiBBIHdvcmthcm91bmQgZm9yIHNvbWUgaXNzdWVzIHdpdGggZmFrZSB0aW1lIGluIHRlc3RzLlxuICpcbiAqIExpbmVzIG9mIHRlc3QgY29kZSBjYW4gZGVwZW5kIG9uIGFzeW5jIHByb21pc2VzIG91dHNpZGUgdGhlIHRlc3RcbiAqIHJlc29sdmluZyBiZWZvcmUgdGhleSBydW4uIEF3YWl0aW5nIHRoaXMgZnVuY3Rpb24gcmVzdWx0IGVuc3VyZXNcbiAqIHRoYXQgYWxsIHByb21pc2VzIHRoYXQgY2FuIGRvIHJlc29sdmUuXG4gKiBOb3RlIHRoYXQgdGhpcyBkb2Vzbid0IG1lYW4gYWxsIG91dHN0YW5kaW5nIHByb21pc2VzLlxuICovXG5jb25zdCAgICAgICAgZXZlbnRMb29wSXRlcmF0aW9uPWFzeW5jKCk9PlxubmV3IFByb21pc2UoKHJlc29sdmUpPT5zZXRJbW1lZGlhdGUocmVzb2x2ZSkpOyRo4oCNX29uY2UuZXZlbnRMb29wSXRlcmF0aW9uKGV2ZW50TG9vcEl0ZXJhdGlvbik7XG5oYXJkZW4oZXZlbnRMb29wSXRlcmF0aW9uKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJldmVudExvb3BJdGVyYXRpb24iOlsiZXZlbnRMb29wSXRlcmF0aW9uIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAFQ5+hEtAgAALQIAAC8AAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvdHlwZUd1YXJkcy5qc3siaW1wb3J0cyI6WyJAZW5kby9wYXR0ZXJucyJdLCJleHBvcnRzIjpbIlN0b3JhZ2VOb2RlU2hhcGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgTTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9wYXR0ZXJuc1wiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3QgICAgICAgIFN0b3JhZ2VOb2RlU2hhcGU9TS5yZW1vdGFibGUoJ1N0b3JhZ2VOb2RlJyk7JGjigI1fb25jZS5TdG9yYWdlTm9kZVNoYXBlKFN0b3JhZ2VOb2RlU2hhcGUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IlN0b3JhZ2VOb2RlU2hhcGUiOlsiU3RvcmFnZU5vZGVTaGFwZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADexqKMKwcAACsHAAAwAAAAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL3VwZ3JhZGUtYXBpLmpzeyJpbXBvcnRzIjpbIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJpc1VwZ3JhZGVEaXNjb25uZWN0aW9uIiwibWFrZVVwZ3JhZGVEaXNjb25uZWN0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzT2JqZWN0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL21hcnNoYWxcIiwgW1tcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuLyoqXG4gKiBAdHlwZWRlZiB7eyBuYW1lOiBzdHJpbmcsIHVwZ3JhZGVNZXNzYWdlOiBzdHJpbmcsIGluY2FybmF0aW9uTnVtYmVyOiBudW1iZXIgfX0gRGlzY29ubmVjdGlvbk9iamVjdFxuICovXG5cbi8qKlxuICogTWFrZXMgYW4gRXJyb3ItbGlrZSBvYmplY3QgZm9yIHVzZSBhcyB0aGUgcmVqZWN0aW9uIHZhbHVlIG9mIHByb21pc2VzXG4gKiBhYmFuZG9uZWQgYnkgdXBncmFkZS5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gdXBncmFkZU1lc3NhZ2VcbiAqIEBwYXJhbSB7bnVtYmVyfSB0b0luY2FybmF0aW9uTnVtYmVyXG4gKiBAcmV0dXJucyB7RGlzY29ubmVjdGlvbk9iamVjdH1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VVcGdyYWRlRGlzY29ubmVjdGlvbj0odXBncmFkZU1lc3NhZ2UsdG9JbmNhcm5hdGlvbk51bWJlcik9PlxuaGFyZGVuKHtcbm5hbWU6J3ZhdFVwZ3JhZGVkJyxcbnVwZ3JhZGVNZXNzYWdlLFxuaW5jYXJuYXRpb25OdW1iZXI6dG9JbmNhcm5hdGlvbk51bWJlcn0pOyRo4oCNX29uY2UubWFrZVVwZ3JhZGVEaXNjb25uZWN0aW9uKG1ha2VVcGdyYWRlRGlzY29ubmVjdGlvbik7XG5cbmhhcmRlbihtYWtlVXBncmFkZURpc2Nvbm5lY3Rpb24pO1xuXG4vKiBUT0RPOiBTaW1wbGlmeSBvbmNlIHdlIGhhdmUgQGVuZG8vcGF0dGVybnMgKG9yIGp1c3QgZXhwb3J0IHRoZSBzaGFwZSkuKi9cbi8qIGNvbnN0IHVwZ3JhZGVEaXNjb25uZWN0aW9uU2hhcGUgPSBoYXJkZW4oeyovXG4vKiBuYW1lOiAndmF0VXBncmFkZWQnLCovXG4vKiB1cGdyYWRlTWVzc2FnZTogTS5zdHJpbmcoKSwqL1xuLyogaW5jYXJuYXRpb25OdW1iZXI6IE0ubnVtYmVyKCksKi9cbi8qIH0pOyovXG4vKiBjb25zdCBpc1VwZ3JhZGVEaXNjb25uZWN0aW9uID0gZXJyID0+IG1hdGNoZXMoZXJyLCB1cGdyYWRlRGlzY29ubmVjdGlvblNoYXBlKTsqL1xuLyoqXG4gKiBAcGFyYW0ge2FueX0gZXJyXG4gKiBAcmV0dXJucyB7ZXJyIGlzIERpc2Nvbm5lY3Rpb25PYmplY3R9XG4gKi9cbmNvbnN0ICAgICAgICBpc1VwZ3JhZGVEaXNjb25uZWN0aW9uPShlcnIpPT5cbmlzT2JqZWN0KGVycikmJlxuZXJyLm5hbWU9PT0ndmF0VXBncmFkZWQnJiZcbnR5cGVvZiBlcnIudXBncmFkZU1lc3NhZ2U9PT0nc3RyaW5nJyYmXG50eXBlb2YgZXJyLmluY2FybmF0aW9uTnVtYmVyPT09J251bWJlcic7JGjigI1fb25jZS5pc1VwZ3JhZGVEaXNjb25uZWN0aW9uKGlzVXBncmFkZURpc2Nvbm5lY3Rpb24pO1xuaGFyZGVuKGlzVXBncmFkZURpc2Nvbm5lY3Rpb24pO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VVcGdyYWRlRGlzY29ubmVjdGlvbiI6WyJtYWtlVXBncmFkZURpc2Nvbm5lY3Rpb24iXSwiaXNVcGdyYWRlRGlzY29ubmVjdGlvbiI6WyJpc1VwZ3JhZGVEaXNjb25uZWN0aW9uIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAKLpsZLjPAAA4zwAACoAAABAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvdXRpbHMuanN7ImltcG9ydHMiOlsiQGVuZG8vZmFyIiwiQGVuZG8vbWFyc2hhbCIsIkBlbmRvL3Byb21pc2Uta2l0IiwiQGVuZG8vc3RyZWFtIiwiamVzc2llLmpzIl0sImV4cG9ydHMiOlsiQkFTSVNfUE9JTlRTIiwiUHJvbWlzZUFsbE9yRXJyb3JzIiwiYWdncmVnYXRlVHJ5RmluYWxseSIsImFsbFZhbHVlcyIsImFwcGx5TGFiZWxpbmdFcnJvciIsImFzc2VydEFsbERlZmluZWQiLCJkZWVwbHlGdWxmaWxsZWRPYmplY3QiLCJmb3JldmVyIiwiZnJvbVVuaXF1ZUVudHJpZXMiLCJsaXN0RGlmZmVyZW5jZSIsIm1ha2VBZ2dyZWdhdGVFcnJvciIsIm1ha2VNZWFzdXJlU2Vjb25kcyIsIm9iamVjdE1hcCIsInN5bmNocm9uaXplZFRlZSIsInRocm93TGFiZWxlZCIsInVudGlsVHJ1ZSIsIndoaWxlVHJ1ZSIsInppcCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLGRlZXBseUZ1bGZpbGxlZCxpc09iamVjdCxpc1Byb21pc2UsbWFrZVByb21pc2VLaXQsbWFrZVF1ZXVlLGFzeW5jR2VuZXJhdGUsbWFrZVNldDskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiZGVlcGx5RnVsZmlsbGVkXCIsIFskaOKAjV9hID0+IChkZWVwbHlGdWxmaWxsZWQgPSAkaOKAjV9hKV1dLFtcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wcm9taXNlLWtpdFwiLCBbW1wiaXNQcm9taXNlXCIsIFskaOKAjV9hID0+IChpc1Byb21pc2UgPSAkaOKAjV9hKV1dLFtcIm1ha2VQcm9taXNlS2l0XCIsIFskaOKAjV9hID0+IChtYWtlUHJvbWlzZUtpdCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9zdHJlYW1cIiwgW1tcIm1ha2VRdWV1ZVwiLCBbJGjigI1fYSA9PiAobWFrZVF1ZXVlID0gJGjigI1fYSldXV1dLFtcImplc3NpZS5qc1wiLCBbW1wiYXN5bmNHZW5lcmF0ZVwiLCBbJGjigI1fYSA9PiAoYXN5bmNHZW5lcmF0ZSA9ICRo4oCNX2EpXV0sW1wibWFrZVNldFwiLCBbJGjigI1fYSA9PiAobWFrZVNldCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cbmNvbnN0e2VudHJpZXMsZnJvbUVudHJpZXMsa2V5cyx2YWx1ZXN9PU9iamVjdDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuY29uc3QgICAgICAgIEJBU0lTX1BPSU5UUz0xMF8wMDBuO1xuXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5FUmVmPFQ+fSBFUmVmPFQ+ICovXG5cbi8qKlxuICogVGhyb3dzIGlmIG11bHRpcGxlIGVudHJpZXMgdXNlIHRoZSBzYW1lIHByb3BlcnR5IG5hbWUuIE90aGVyd2lzZSBhY3RzXG4gKiBsaWtlIGBPYmplY3QuZnJvbUVudHJpZXNgIGJ1dCBoYXJkZW5zIHRoZSByZXN1bHQuXG4gKiBVc2UgaXQgdG8gcHJvdGVjdCBmcm9tIHByb3BlcnR5IG5hbWVzIGNvbXB1dGVkIGZyb20gdXNlci1wcm92aWRlZCBkYXRhLlxuICpcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEBwYXJhbSB7SXRlcmFibGU8W0ssVl0+fSBhbGxFbnRyaWVzXG4gKiBAcmV0dXJucyB7e1trOiBLXTogVn19XG4gKi8kaOKAjV9vbmNlLkJBU0lTX1BPSU5UUyhCQVNJU19QT0lOVFMpO1xuY29uc3QgICAgICAgIGZyb21VbmlxdWVFbnRyaWVzPShhbGxFbnRyaWVzKT0+e1xuY29uc3QgZW50cmllc0FycmF5PVsuLi5hbGxFbnRyaWVzXTtcbmNvbnN0IHJlc3VsdD1oYXJkZW4oZnJvbUVudHJpZXMoZW50cmllc0FycmF5KSk7XG5pZihvd25LZXlzKHJlc3VsdCkubGVuZ3RoPT09ZW50cmllc0FycmF5Lmxlbmd0aCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmNvbnN0IG5hbWVzPW1ha2VTZXQoKTtcbmZvcihjb25zdFtuYW1lLF9db2YgZW50cmllc0FycmF5KXtcbmlmKG5hbWVzLmhhcyhuYW1lKSl7XG5GYWlsIGBjb2xsaXNpb24gb24gcHJvcGVydHkgbmFtZSAke3EobmFtZSl9OiAke2VudHJpZXNBcnJheX1gO1xuIH1cbm5hbWVzLmFkZChuYW1lKTtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogZmFpbGVkIHRvIGNyZWF0ZSBvYmplY3QgZnJvbSB1bmlxdWUgZW50cmllc2A7XG4gfTskaOKAjV9vbmNlLmZyb21VbmlxdWVFbnRyaWVzKGZyb21VbmlxdWVFbnRyaWVzKTtcbmhhcmRlbihmcm9tVW5pcXVlRW50cmllcyk7XG5cbi8qKlxuICogQnkgYW5hbG9neSB3aXRoIGhvdyBgQXJyYXkucHJvdG90eXBlLm1hcGAgd2lsbCBtYXAgdGhlIGVsZW1lbnRzIG9mXG4gKiBhbiBhcnJheSB0byB0cmFuc2Zvcm1lZCBlbGVtZW50cyBvZiBhbiBhcnJheSBvZiB0aGUgc2FtZSBzaGFwZSxcbiAqIGBvYmplY3RNYXBgIHdpbGwgZG8gbGlrZXdpc2UgZm9yIHRoZSBzdHJpbmctbmFtZWQgb3duIGVudW1lcmFibGVcbiAqIHByb3BlcnRpZXMgb2YgYW4gb2JqZWN0LlxuICpcbiAqIFR5cGljYWwgdXNhZ2UgYXBwbGllcyBgb2JqZWN0TWFwYCB0byBhIENvcHlSZWNvcmQsIGkuZS4sXG4gKiBhbiBvYmplY3QgZm9yIHdoaWNoIGBwYXNzU3R5bGVPZihvcmlnaW5hbCkgPT09ICdjb3B5UmVjb3JkJ2AuIEZvciB0aGVzZSxcbiAqIG5vbmUgb2YgdGhlIGZvbGxvd2luZyBlZGdlIGNhc2VzIGFyaXNlLiBUaGUgcmVzdWx0IHdpbGwgYmUgYSBDb3B5UmVjb3JkXG4gKiB3aXRoIGV4YWN0bHkgdGhlIHNhbWUgcHJvcGVydHkgbmFtZXMsIHdob3NlIHZhbHVlcyBhcmUgdGhlIG1hcHBlZCBmb3JtIG9mXG4gKiB0aGUgb3JpZ2luYWwncyB2YWx1ZXMuXG4gKlxuICogV2hlbiB0aGUgb3JpZ2luYWwgaXMgbm90IGEgQ29weVJlY29yZCwgc29tZSBlZGdlIGNhc2VzIHRvIGJlIGF3YXJlIG9mXG4gKiAgICAqIE5vIG1hdHRlciBob3cgbXV0YWJsZSB0aGUgb3JpZ2luYWwgb2JqZWN0LCB0aGUgcmV0dXJuZWQgb2JqZWN0IGlzXG4gKiAgICAgIGhhcmRlbmVkLlxuICogICAgKiBPbmx5IHRoZSBzdHJpbmctbmFtZWQgZW51bWVyYWJsZSBvd24gcHJvcGVydGllcyBvZiB0aGUgb3JpZ2luYWxcbiAqICAgICAgYXJlIG1hcHBlZC4gQWxsIG90aGVyIHByb3BlcnRpZXMgYXJlIGlnbm9yZWQuXG4gKiAgICAqIElmIGFueSBvZiB0aGUgb3JpZ2luYWwgcHJvcGVydGllcyB3ZXJlIGFjY2Vzc29ycywgYE9iamVjdC5lbnRyaWVzYFxuICogICAgICB3aWxsIGNhdXNlIGl0cyBgZ2V0dGVyYCB0byBiZSBjYWxsZWQgYW5kIHdpbGwgdXNlIHRoZSByZXN1bHRpbmdcbiAqICAgICAgdmFsdWUuXG4gKiAgICAqIE5vIG1hdHRlciB3aGV0aGVyIHRoZSBvcmlnaW5hbCBwcm9wZXJ0eSB3YXMgYW4gYWNjZXNzb3IsIHdyaXRhYmxlLFxuICogICAgICBvciBjb25maWd1cmFibGUsIGFsbCB0aGUgcHJvcGVydGllcyBvZiB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYmVcbiAqICAgICAgbm9uLXdyaXRhYmxlLCBub24tY29uZmlndXJhYmxlLCBkYXRhIHByb3BlcnRpZXMuXG4gKiAgICAqIE5vIG1hdHRlciB3aGF0IHRoZSBvcmlnaW5hbCBvYmplY3QgbWF5IGhhdmUgaW5oZXJpdGVkIGZyb20sIGFuZFxuICogICAgICBubyBtYXR0ZXIgd2hldGhlciBpdCB3YXMgYSBzcGVjaWFsIGtpbmQgb2Ygb2JqZWN0IHN1Y2ggYXMgYW4gYXJyYXksXG4gKiAgICAgIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBhbHdheXMgYmUgYSBwbGFpbiBvYmplY3QgaW5oZXJpdGluZyBkaXJlY3RseVxuICogICAgICBmcm9tIGBPYmplY3QucHJvdG90eXBlYCBhbmQgd2hvc2Ugc3RhdGUgaXMgb25seSB0aGVzZSBuZXcgbWFwcGVkXG4gKiAgICAgIG93biBwcm9wZXJ0aWVzLlxuICpcbiAqIFdpdGggdGhlc2UgZGlmZmVyZW5jZXMsIGV2ZW4gaWYgdGhlIG9yaWdpbmFsIG9iamVjdCB3YXMgbm90IGEgQ29weVJlY29yZCxcbiAqIGlmIGFsbCB0aGUgbWFwcGVkIHZhbHVlcyBhcmUgUGFzc2FibGUsIHRoZW4gdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGJlXG4gKiBhIENvcHlSZWNvcmQuXG4gKlxuICogQHRlbXBsYXRlIHtSZWNvcmQ8c3RyaW5nLCBhbnk+fSBPXG4gKiBAcGFyYW0ge099IG9yaWdpbmFsXG4gKiBAdGVtcGxhdGUgUiBtYXAgcmVzdWx0XG4gKiBAcGFyYW0geyh2YWx1ZTogT1trZXlvZiBPXSwga2V5OiBrZXlvZiBPKSA9PiBSfSBtYXBGblxuICogQHJldHVybnMge3sgW1AgaW4ga2V5b2YgT106IFJ9fVxuICovXG5jb25zdCAgICAgICAgb2JqZWN0TWFwPShvcmlnaW5hbCxtYXBGbik9PntcbmNvbnN0IGVudHM9ZW50cmllcyhvcmlnaW5hbCk7XG5jb25zdCBtYXBFbnRzPWVudHMubWFwKChbayx2XSk9PltrLG1hcEZuKHYsayldKTtcbnJldHVybiBoYXJkZW4oZnJvbUVudHJpZXMobWFwRW50cykpO1xuIH07JGjigI1fb25jZS5vYmplY3RNYXAob2JqZWN0TWFwKTtcbmhhcmRlbihvYmplY3RNYXApO1xuXG4vKipcbiAqIEBwYXJhbSB7QXJyYXk8c3RyaW5nIHwgc3ltYm9sPn0gbGVmdE5hbWVzXG4gKiBAcGFyYW0ge0FycmF5PHN0cmluZyB8IHN5bWJvbD59IHJpZ2h0TmFtZXNcbiAqL1xuY29uc3QgICAgICAgIGxpc3REaWZmZXJlbmNlPShsZWZ0TmFtZXMscmlnaHROYW1lcyk9PntcbmNvbnN0IHJpZ2h0U2V0PW1ha2VTZXQocmlnaHROYW1lcyk7XG5yZXR1cm4gbGVmdE5hbWVzLmZpbHRlcigobmFtZSk9PiFyaWdodFNldC5oYXMobmFtZSkpO1xuIH07JGjigI1fb25jZS5saXN0RGlmZmVyZW5jZShsaXN0RGlmZmVyZW5jZSk7XG5oYXJkZW4obGlzdERpZmZlcmVuY2UpO1xuXG4vKipcbiAqIEBwYXJhbSB7RXJyb3J9IGlubmVyRXJyXG4gKiBAcGFyYW0ge3N0cmluZ3xudW1iZXJ9IGxhYmVsXG4gKiBAcGFyYW0ge0Vycm9yQ29uc3RydWN0b3J9IFtFcnJvckNvbnN0cnVjdG9yXVxuICogQHJldHVybnMge25ldmVyfVxuICovXG5jb25zdCAgICAgICAgdGhyb3dMYWJlbGVkPShpbm5lckVycixsYWJlbCxFcnJvckNvbnN0cnVjdG9yPXVuZGVmaW5lZCk9PntcbmlmKHR5cGVvZiBsYWJlbD09PSdudW1iZXInKXtcbmxhYmVsPSBgWyR7bGFiZWx9XWA7XG4gfVxuY29uc3Qgb3V0ZXJFcnI9YXNzZXJ0LmVycm9yKFxuIGAke2xhYmVsfTogJHtpbm5lckVyci5tZXNzYWdlfWAsXG5FcnJvckNvbnN0cnVjdG9yKTtcblxuYXNzZXJ0Lm5vdGUob3V0ZXJFcnIsWCBgQ2F1c2VkIGJ5ICR7aW5uZXJFcnJ9YCk7XG50aHJvdyBvdXRlckVycjtcbiB9OyRo4oCNX29uY2UudGhyb3dMYWJlbGVkKHRocm93TGFiZWxlZCk7XG5oYXJkZW4odGhyb3dMYWJlbGVkKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgQSxSXG4gKiBAcGFyYW0geyguLi5hcmdzOiBBW10pID0+IFJ9IGZ1bmNcbiAqIEBwYXJhbSB7QVtdfSBhcmdzXG4gKiBAcGFyYW0ge3N0cmluZ3xudW1iZXJ9IFtsYWJlbF1cbiAqIEByZXR1cm5zIHtSfVxuICovXG5jb25zdCAgICAgICAgYXBwbHlMYWJlbGluZ0Vycm9yPShmdW5jLGFyZ3MsbGFiZWw9dW5kZWZpbmVkKT0+e1xuaWYobGFiZWw9PT11bmRlZmluZWQpe1xucmV0dXJuIGZ1bmMoLi4uYXJncyk7XG4gfVxubGV0IHJlc3VsdDtcbnRyeXtcbnJlc3VsdD1mdW5jKC4uLmFyZ3MpO1xuIH1jYXRjaChlcnIpe1xudGhyb3dMYWJlbGVkKGVycixsYWJlbCk7XG4gfVxuaWYoaXNQcm9taXNlKHJlc3VsdCkpe1xuLyogSWYgcmVzdWx0IGlzIGEgcmVqZWN0ZWQgcHJvbWlzZSwgdGhpcyB3aWxsIHJldHVybiBhIHByb21pc2Ugd2l0aCBhKi9cbi8qIGRpZmZlcmVudCByZWplY3Rpb24gcmVhc29uLiBCdXQgdGhpcyBjb25mdXNlcyBUeXBlU2NyaXB0IGJlY2F1c2UgaXQgdHlwZXMqL1xuLyogdGhhdCBjYXNlIGFzIGBQcm9taXNlPG5ldmVyPmAgd2hpY2ggaXMgY29vbCBmb3IgYSBwcm9taXNlIHRoYXQgd2lsbCBuZXZlciovXG4vKiBmdWxmaWxsLiAgQnV0IFR5cGVTY3JpcHQgZG9lc24ndCB1bmRlcnN0YW5kIHRoYXQgdGhpcyB3aWxsIG9ubHkgaGFwcGVuKi9cbi8qIHdoZW4gYHJlc3VsdGAgd2FzIGEgcmVqZWN0ZWQgcHJvbWlzZS4gSW4gb25seSB0aGlzIGNhc2UgYFJgIHNob3VsZCovXG4vKiBhbHJlYWR5IGFsbG93IGBQcm9taXNlPG5ldmVyPmAgYXMgYSBzdWJ0eXBlLiovXG4vKiogQHR5cGUge3Vua25vd259ICovXG5jb25zdCByZWxhYmVsZWQ9RS53aGVuKHJlc3VsdCx1bmRlZmluZWQsKHJlYXNvbik9PlxudGhyb3dMYWJlbGVkKHJlYXNvbixsYWJlbCkpO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7Un0gKi9yZWxhYmVsZWQpO1xuIH1lbHNle1xucmV0dXJuIHJlc3VsdDtcbiB9XG4gfTskaOKAjV9vbmNlLmFwcGx5TGFiZWxpbmdFcnJvcihhcHBseUxhYmVsaW5nRXJyb3IpO1xuaGFyZGVuKGFwcGx5TGFiZWxpbmdFcnJvcik7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHt7W0tleVR5cGUgaW4ga2V5b2YgVF06IFRbS2V5VHlwZV19ICYge319IFNpbXBsaWZ5XG4gKiBmbGF0dGVuIHRoZSB0eXBlIG91dHB1dCB0byBpbXByb3ZlIHR5cGUgaGludHMgc2hvd24gaW4gZWRpdG9yc1xuICogaHR0cHM6Ly9naXRodWIuY29tL3NpbmRyZXNvcmh1cy90eXBlLWZlc3QvYmxvYi9tYWluL3NvdXJjZS9zaW1wbGlmeS5kLnRzXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7KC4uLmFyZ3M6IGFueVtdKSA9PiBhbnl9IENhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAdHlwZWRlZiB7eyBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIENhbGxhYmxlID8gVFtLXSA6IERlZXBseUF3YWl0ZWQ8VFtLXT4gfX0gRGVlcGx5QXdhaXRlZE9iamVjdFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtUIGV4dGVuZHMgUHJvbWlzZUxpa2U8YW55PiA/IEF3YWl0ZWQ8VD4gOiBUIGV4dGVuZHMge30gPyBTaW1wbGlmeTxEZWVwbHlBd2FpdGVkT2JqZWN0PFQ+PiA6IEF3YWl0ZWQ8VD59IERlZXBseUF3YWl0ZWRcbiAqL1xuXG4vKipcbiAqIEEgbW9yZSBjb25zdHJhaW5lZCB2ZXJzaW9uIG9mIHtkZWVwbHlGdWxmaWxsZWR9IGZvciB0eXBlIHNhZmV0eSB1bnRpbFxuICogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xMjU3XG4gKiBVc2VmdWwgaW4gc3RhcnRpbmcgY29udHJhY3RzIHRoYXQgbmVlZCBhbGwgdGVybXMgdG8gYmUgZnVsZmlsbGVkXG4gKiBpbiBvcmRlciB0byBiZSBkdXJhYmxlLlxuICpcbiAqIEB0eXBlIHs8VCBleHRlbmRzIHt9Pih1bmZ1bGZpbGxlZFRlcm1zOiBUKSA9PiBQcm9taXNlPERlZXBseUF3YWl0ZWQ8VD4+fVxuICovXG5jb25zdCAgICAgICAgZGVlcGx5RnVsZmlsbGVkT2JqZWN0PWFzeW5jKG9iaik9PntcbmlzT2JqZWN0KG9iail8fEZhaWwgYHBhcmFtIG11c3QgYmUgYW4gb2JqZWN0YDtcbnJldHVybiBkZWVwbHlGdWxmaWxsZWQob2JqKTtcbiB9O1xuXG4vKipcbiAqIFJldHVybnMgYSBmdW5jdGlvbiB0aGF0IHVzZXMgYSBtaWxsaXNlY29uZC1iYXNlZCB0aW1lLXNpbmNlLWVwb2NoIGNhcGFiaWxpdHlcbiAqIChzdWNoIGFzIGBwZXJmb3JtYW5jZS5ub3dgKSB0byBtZWFzdXJlIGV4ZWN1dGlvbiB0aW1lIG9mIGFuIGFzeW5jIGZ1bmN0aW9uXG4gKiBhbmQgcmVwb3J0IHRoZSByZXN1bHQgaW4gc2Vjb25kcyB0byBtYXRjaCBvdXIgdGVsZW1ldHJ5IHN0YW5kYXJkLlxuICpcbiAqIEBwYXJhbSB7dHlwZW9mIFhpbXBvcnQoJ3BlcmZfaG9va3MnKS5wZXJmb3JtYW5jZS5ub3d9IGN1cnJlbnRUaW1lTWlsbGlzZWNcbiAqIEByZXR1cm5zIHs8VD4oZm46ICgpID0+IFByb21pc2U8VD4pID0+IFByb21pc2U8eyByZXN1bHQ6IFQsIGR1cmF0aW9uOiBudW1iZXIgfT59XG4gKi8kaOKAjV9vbmNlLmRlZXBseUZ1bGZpbGxlZE9iamVjdChkZWVwbHlGdWxmaWxsZWRPYmplY3QpO1xuY29uc3QgICAgICAgIG1ha2VNZWFzdXJlU2Vjb25kcz0oY3VycmVudFRpbWVNaWxsaXNlYyk9Pntcbi8qKiBAcGFyYW0geygpID0+IGFueX0gZm4gKi9cbmNvbnN0IG1lYXN1cmVTZWNvbmRzPWFzeW5jKGZuKT0+e1xuY29uc3QgdDA9Y3VycmVudFRpbWVNaWxsaXNlYygpO1xuY29uc3QgcmVzdWx0PWF3YWl0IGZuKCk7XG5jb25zdCBkdXJhdGlvbk1pbGxpc2VjPWN1cnJlbnRUaW1lTWlsbGlzZWMoKS10MDtcbnJldHVybntyZXN1bHQsZHVyYXRpb246ZHVyYXRpb25NaWxsaXNlYy8xMDAwfTtcbiB9O1xucmV0dXJuIG1lYXN1cmVTZWNvbmRzO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtFcnJvcltdfSBlcnJvcnNcbiAqIEBwYXJhbSB7c3RyaW5nfSBbbWVzc2FnZV1cbiAqLyRo4oCNX29uY2UubWFrZU1lYXN1cmVTZWNvbmRzKG1ha2VNZWFzdXJlU2Vjb25kcyk7XG5jb25zdCAgICAgICAgbWFrZUFnZ3JlZ2F0ZUVycm9yPShlcnJvcnMsbWVzc2FnZSk9PntcbmNvbnN0IGVycj1FcnJvcihtZXNzYWdlKTtcbk9iamVjdC5kZWZpbmVQcm9wZXJ0aWVzKGVycix7XG5uYW1lOntcbnZhbHVlOidBZ2dyZWdhdGVFcnJvcid9LFxuXG5lcnJvcnM6e1xudmFsdWU6ZXJyb3JzfX0pO1xuXG5cbnJldHVybiBlcnI7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtyZWFkb25seSAoVCB8IFByb21pc2VMaWtlPFQ+KVtdfSBpdGVtc1xuICogQHJldHVybnMge1Byb21pc2U8VFtdPn1cbiAqLyRo4oCNX29uY2UubWFrZUFnZ3JlZ2F0ZUVycm9yKG1ha2VBZ2dyZWdhdGVFcnJvcik7XG5jb25zdCAgICAgICAgUHJvbWlzZUFsbE9yRXJyb3JzPWFzeW5jKGl0ZW1zKT0+e1xucmV0dXJuIFByb21pc2UuYWxsU2V0dGxlZChpdGVtcykudGhlbigocmVzdWx0cyk9PntcbmNvbnN0IGVycm9ycz0vKiogQHR5cGUge1Byb21pc2VSZWplY3RlZFJlc3VsdFtdfSAqL1xucmVzdWx0cy5maWx0ZXIoKHtzdGF0dXN9KT0+c3RhdHVzPT09J3JlamVjdGVkJykuXG5tYXAoKHJlc3VsdCk9PnJlc3VsdC5yZWFzb24pO1xuaWYoIWVycm9ycy5sZW5ndGgpe1xucmV0dXJuICgvKiogQHR5cGUge1Byb21pc2VGdWxmaWxsZWRSZXN1bHQ8VD5bXX0gKi9yZXN1bHRzLm1hcChcbihyZXN1bHQpPT5yZXN1bHQudmFsdWUpKTtcblxuIH1lbHNlIGlmKGVycm9ycy5sZW5ndGg9PT0xKXtcbnRocm93IGVycm9yc1swXTtcbiB9ZWxzZXtcbnRocm93IG1ha2VBZ2dyZWdhdGVFcnJvcihlcnJvcnMpO1xuIH1cbiB9KTtcbiB9O1xuXG4vKipcbiAqIEB0eXBlIHs8VD4oXG4gKiAgIHRyaWVyOiAoKSA9PiBQcm9taXNlPFQ+LFxuICogIGZpbmFsaXplcjogKGVycm9yPzogdW5rbm93bikgPT4gUHJvbWlzZTx2b2lkPixcbiAqICkgPT4gUHJvbWlzZTxUPn1cbiAqLyRo4oCNX29uY2UuUHJvbWlzZUFsbE9yRXJyb3JzKFByb21pc2VBbGxPckVycm9ycyk7Y29uc3QgYWdncmVnYXRlVHJ5RmluYWxseT1hc3luYyh0cmllcixmaW5hbGl6ZXIpPT5cbnRyaWVyKCkudGhlbihcbmFzeW5jKHJlc3VsdCk9PmZpbmFsaXplcigpLnRoZW4oKCk9PnJlc3VsdCksXG5hc3luYyh0cnlFcnJvcik9PlxuZmluYWxpemVyKHRyeUVycm9yKS5cbnRoZW4oXG4oKT0+dHJ5RXJyb3IsXG4oZmluYWxpemVFcnJvcik9Pm1ha2VBZ2dyZWdhdGVFcnJvcihbdHJ5RXJyb3IsZmluYWxpemVFcnJvcl0pKS5cblxudGhlbigoZXJyb3IpPT5Qcm9taXNlLnJlamVjdChlcnJvcikpKTtcblxuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgdW5rbm93bj59IFRcbiAqIEB0eXBlZGVmIHt7W1AgaW4ga2V5b2YgVF06IEV4Y2x1ZGU8VFtQXSwgdW5kZWZpbmVkPjt9fSBBbGxEZWZpbmVkXG4gKi9cblxuLyoqXG4gKiBDb25jaXNlIHdheSB0byBjaGVjayB2YWx1ZXMgYXJlIGF2YWlsYWJsZSBmcm9tIG9iamVjdCBsaXRlcmFsIHNob3J0aGFuZC5cbiAqIFRocm93cyBlcnJvciBtZXNzYWdlIHRvIHNwZWNpZnkgdGhlIG1pc3NpbmcgdmFsdWVzLlxuICpcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgdW5rbm93bj59IFRcbiAqIEBwYXJhbSB7VH0gb2JqXG4gKiBAdGhyb3dzIGlmIGFueSB2YWx1ZSBpbiB0aGUgb2JqZWN0IGVudHJpZXMgaXMgbm90IGRlZmluZWRcbiAqIEByZXR1cm5zIHthc3NlcnRzIG9iaiBpcyBBbGxEZWZpbmVkPFQ+fVxuICovJGjigI1fb25jZS5hZ2dyZWdhdGVUcnlGaW5hbGx5KGFnZ3JlZ2F0ZVRyeUZpbmFsbHkpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0QWxsRGVmaW5lZD0ob2JqKT0+e1xuY29uc3QgbWlzc2luZz1bXTtcbmZvcihjb25zdFtrZXksdmFsXW9mIE9iamVjdC5lbnRyaWVzKG9iaikpe1xuaWYodmFsPT09dW5kZWZpbmVkKXtcbm1pc3NpbmcucHVzaChrZXkpO1xuIH1cbiB9XG5pZihtaXNzaW5nLmxlbmd0aD4wKXtcbkZhaWwgYG1pc3NpbmcgJHtxKG1pc3NpbmcpfWA7XG4gfVxuIH07XG5cbi8qKiBAdHlwZSB7SXRlcmF0b3JSZXN1bHQ8dW5kZWZpbmVkLCBuZXZlcj59ICovJGjigI1fb25jZS5hc3NlcnRBbGxEZWZpbmVkKGFzc2VydEFsbERlZmluZWQpO1xuY29uc3Qgbm90RG9uZT1oYXJkZW4oe2RvbmU6ZmFsc2UsdmFsdWU6dW5kZWZpbmVkfSk7XG5cbi8qKiBAdHlwZSB7SXRlcmF0b3JSZXN1bHQ8bmV2ZXIsIHZvaWQ+fSAqL1xuY29uc3QgYWx3YXlzRG9uZT1oYXJkZW4oe2RvbmU6dHJ1ZSx2YWx1ZTp1bmRlZmluZWR9KTtcblxuY29uc3QgICAgICAgIGZvcmV2ZXI9YXN5bmNHZW5lcmF0ZSgoKT0+bm90RG9uZSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7KCkgPT4gVH0gcHJvZHVjZVxuICogVGhlIHZhbHVlIG9mIGBhd2FpdCBwcm9kdWNlKClgIGlzIHVzZWQgZm9yIGl0cyB0cnV0aGluZXNzIHZzIGZhbHNpbmVzcy5cbiAqIElPVywgaXQgaXMgY29lcmNlZCB0byBhIGJvb2xlYW4gc28gdGhlIGNhbGxlciBuZWVkIG5vdCBib3RoZXIgZG9pbmcgdGhpc1xuICogdGhlbXNlbHZlcy5cbiAqIEByZXR1cm5zIHtBc3luY0l0ZXJhYmxlPEF3YWl0ZWQ8VD4+fVxuICovJGjigI1fb25jZS5mb3JldmVyKGZvcmV2ZXIpO1xuY29uc3QgICAgICAgIHdoaWxlVHJ1ZT0ocHJvZHVjZSk9PlxuYXN5bmNHZW5lcmF0ZShhc3luYygpPT57XG5jb25zdCB2YWx1ZT1hd2FpdCBwcm9kdWNlKCk7XG5pZighdmFsdWUpe1xucmV0dXJuIGFsd2F5c0RvbmU7XG4gfVxucmV0dXJuIGhhcmRlbih7XG5kb25lOmZhbHNlLFxudmFsdWV9KTtcblxuIH0pO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0geygpID0+IFR9IHByb2R1Y2VcbiAqIFRoZSB2YWx1ZSBvZiBgYXdhaXQgcHJvZHVjZSgpYCBpcyB1c2VkIGZvciBpdHMgdHJ1dGhpbmVzcyB2cyBmYWxzaW5lc3MuXG4gKiBJT1csIGl0IGlzIGNvZXJjZWQgdG8gYSBib29sZWFuIHNvIHRoZSBjYWxsZXIgbmVlZCBub3QgYm90aGVyIGRvaW5nIHRoaXNcbiAqIHRoZW1zZWx2ZXMuXG4gKiBAcmV0dXJucyB7QXN5bmNJdGVyYWJsZTxBd2FpdGVkPFQ+Pn1cbiAqLyRo4oCNX29uY2Uud2hpbGVUcnVlKHdoaWxlVHJ1ZSk7XG5jb25zdCAgICAgICAgdW50aWxUcnVlPShwcm9kdWNlKT0+XG5hc3luY0dlbmVyYXRlKGFzeW5jKCk9PntcbmNvbnN0IHZhbHVlPWF3YWl0IHByb2R1Y2UoKTtcbmlmKHZhbHVlKXtcbnJldHVybiBoYXJkZW4oe1xuZG9uZTp0cnVlLFxudmFsdWV9KTtcblxuIH1cbnJldHVybiBoYXJkZW4oe1xuZG9uZTpmYWxzZSxcbnZhbHVlfSk7XG5cbiB9KTtcblxuLyoqIEB0eXBlIHsgPFgsIFk+KHhzOiBYW10sIHlzOiBZW10pID0+IFtYLCBZXVtdfSAqLyRo4oCNX29uY2UudW50aWxUcnVlKHVudGlsVHJ1ZSk7XG5jb25zdCAgICAgICAgemlwPSh4cyx5cyk9PmhhcmRlbih4cy5tYXAoKHgsaSk9Plt4LHlzWytpXV0pKTtcblxuLyoqIEB0eXBlIHsgPFQgZXh0ZW5kcyBSZWNvcmQ8c3RyaW5nLCBFUmVmPGFueT4+PihvYmo6IFQpID0+IFByb21pc2U8eyBbSyBpbiBrZXlvZiBUXTogQXdhaXRlZDxUW0tdPn0+IH0gKi8kaOKAjV9vbmNlLnppcCh6aXApO1xuY29uc3QgICAgICAgIGFsbFZhbHVlcz1hc3luYyhvYmopPT57XG5jb25zdCByZXNvbHZlZD1hd2FpdCBQcm9taXNlLmFsbCh2YWx1ZXMob2JqKSk7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGNhc3QqL1xucmV0dXJuIGhhcmRlbihmcm9tRW50cmllcyh6aXAoa2V5cyhvYmopLHJlc29sdmVkKSkpO1xuIH07XG5cbi8qKlxuICogQSB0ZWUgaW1wbGVtZW50YXRpb24gd2hlcmUgYWxsIHJlYWRlcnMgYXJlIHN5bmNocm9uaXplZCB3aXRoIGVhY2ggb3RoZXIuXG4gKiBUaGV5IGFsbCBjb25zdW1lIHRoZSBzb3VyY2Ugc3RyZWFtIGluIGxvY2tzdGVwLCBhbmQgYW55IG9uZSByZXR1cm5pbmcgb3JcbiAqIHRocm93aW5nIGVhcmx5IHdpbGwgYWZmZWN0IHRoZSBvdGhlcnMuXG4gKlxuICogQHRlbXBsYXRlIFtUPXVua25vd25dXG4gKiBAcGFyYW0ge0FzeW5jSXRlcmF0b3I8VCwgdm9pZCwgdm9pZD59IHNvdXJjZVN0cmVhbVxuICogQHBhcmFtIHtudW1iZXJ9IHJlYWRlckNvdW50XG4gKi8kaOKAjV9vbmNlLmFsbFZhbHVlcyhhbGxWYWx1ZXMpO1xuY29uc3QgICAgICAgIHN5bmNocm9uaXplZFRlZT0oc291cmNlU3RyZWFtLHJlYWRlckNvdW50KT0+e1xuLyoqIEB0eXBlIHtJdGVyYXRvclJldHVyblJlc3VsdDx2b2lkPiB8IHVuZGVmaW5lZH0gKi9cbmxldCBkb25lUmVzdWx0O1xuXG4vKiogQHR5cGVkZWYge0l0ZXJhdG9yUmVzdWx0PCh2YWx1ZTogUHJvbWlzZUxpa2U8SXRlcmF0b3JSZXN1bHQ8VD4+KSA9PiB2b2lkPn0gUXVldWVQYXlsb2FkICovXG4vKiogQHR5cGUge1hpbXBvcnQoJ0BlbmRvL3N0cmVhbScpLkFzeW5jUXVldWU8UXVldWVQYXlsb2FkPltdfSAqL1xuY29uc3QgcXVldWVzPVtdO1xuXG4vKiogQHJldHVybnMge1Byb21pc2U8dm9pZD59ICovXG5jb25zdCBwdWxsTmV4dD1hc3luYygpPT57XG5jb25zdCByZXF1ZXN0cz1hd2FpdCBQcm9taXNlLmFsbFNldHRsZWQocXVldWVzLm1hcCgocXVldWUpPT5xdWV1ZS5nZXQoKSkpO1xuY29uc3QgcmVqZWN0aW9ucz1bXTtcbi8qKiBAdHlwZSB7QXJyYXk8KHZhbHVlOiBQcm9taXNlTGlrZTxJdGVyYXRvclJlc3VsdDxUPj4pID0+IHZvaWQ+fSAqL1xuY29uc3QgcmVzb2x2ZXJzPVtdO1xubGV0IGRvbmU9ZmFsc2U7XG5mb3IoY29uc3Qgc2V0dGxlZFJlc3VsdCBvZiByZXF1ZXN0cyl7XG5pZihzZXR0bGVkUmVzdWx0LnN0YXR1cz09PSdyZWplY3RlZCcpe1xucmVqZWN0aW9ucy5wdXNoKHNldHRsZWRSZXN1bHQucmVhc29uKTtcbiB9ZWxzZXtcbmRvbmV8fD0hIXNldHRsZWRSZXN1bHQudmFsdWUuZG9uZTtcbnJlc29sdmVycy5wdXNoKHNldHRsZWRSZXN1bHQudmFsdWUudmFsdWUpO1xuIH1cbiB9XG4vKiogQHR5cGUge1Byb21pc2U8SXRlcmF0b3JSZXN1bHQ8VD4+fSAqL1xubGV0IHJlc3VsdDtcbmlmKGRvbmVSZXN1bHQpe1xucmVzdWx0PVByb21pc2UucmVzb2x2ZShkb25lUmVzdWx0KTtcbiB9ZWxzZSBpZihyZWplY3Rpb25zLmxlbmd0aCl7XG5jb25zdCBlcnJvcj1hc3NlcnQuZXJyb3IoYXNzZXJ0LmRldGFpbHMgYFRlZWQgc3RyZWFtIHRocmV3YCk7XG5hc3NlcnQubm90ZShlcnJvcixhc3NlcnQuZGV0YWlscyBgVGVlZCByZWplY3Rpb25zOiAke3JlamVjdGlvbnN9YCk7XG5yZXN1bHQ9XG5zb3VyY2VTdHJlYW0udGhyb3c/LihlcnJvcil8fFxuUHJvbWlzZS5yZXNvbHZlKHNvdXJjZVN0cmVhbS5yZXR1cm4/LigpKS50aGVuKCgpPT5cblByb21pc2UucmVqZWN0KGVycm9yKSk7XG5cbiB9ZWxzZSBpZihkb25lKXtcbnJlc3VsdD1cbnNvdXJjZVN0cmVhbS5yZXR1cm4/LigpfHxcblByb21pc2UucmVzb2x2ZSh7ZG9uZTp0cnVlLHZhbHVlOnVuZGVmaW5lZH0pO1xuIH1lbHNle1xucmVzdWx0PXNvdXJjZVN0cmVhbS5uZXh0KCk7XG4gfVxucmVzdWx0LnRoZW4oXG4ocik9PntcbmlmKHIuZG9uZSl7XG5kb25lUmVzdWx0PXI7XG4gfVxuIH0sXG4oKT0+e1xuZG9uZVJlc3VsdD17ZG9uZTp0cnVlLHZhbHVlOnVuZGVmaW5lZH07XG4gfSk7XG5cbnJlc29sdmVycy5mb3JFYWNoKChyZXNvbHZlKT0+cmVzb2x2ZShyZXN1bHQpKTtcbnJldHVybiBwdWxsTmV4dCgpO1xuIH07XG5cbmNvbnN0IHJlYWRlcnM9QXJyYXkuZnJvbSh7bGVuZ3RoOnJlYWRlckNvdW50fSkubWFwKCgpPT57XG4vKiogQHR5cGUge1hpbXBvcnQoJ0BlbmRvL3N0cmVhbScpLkFzeW5jUXVldWU8UXVldWVQYXlsb2FkPn0gKi9cbmNvbnN0IHF1ZXVlPW1ha2VRdWV1ZSgpO1xucXVldWVzLnB1c2gocXVldWUpO1xuXG4vKiogQHR5cGUge0FzeW5jR2VuZXJhdG9yPFQsIHZvaWQsIHZvaWQ+fSAqL1xuY29uc3QgcmVhZGVyPWhhcmRlbih7XG4gICAgICBhc3luYyBuZXh0KCl7XG4vKiogQHR5cGUge1hpbXBvcnQoJ0BlbmRvL3Byb21pc2Uta2l0JykuUHJvbWlzZUtpdDxJdGVyYXRvclJlc3VsdDxUPj59ICovXG5jb25zdHtwcm9taXNlLHJlc29sdmV9PW1ha2VQcm9taXNlS2l0KCk7XG5xdWV1ZS5wdXQoe3ZhbHVlOnJlc29sdmUsZG9uZTpmYWxzZX0pO1xucmV0dXJuIHByb21pc2U7XG4gfSxcbiAgICAgIGFzeW5jIHJldHVybigpe1xuLyoqIEB0eXBlIHtYaW1wb3J0KCdAZW5kby9wcm9taXNlLWtpdCcpLlByb21pc2VLaXQ8SXRlcmF0b3JSZXN1bHQ8VD4+fSAqL1xuY29uc3R7cHJvbWlzZSxyZXNvbHZlfT1tYWtlUHJvbWlzZUtpdCgpO1xucXVldWUucHV0KHt2YWx1ZTpyZXNvbHZlLGRvbmU6dHJ1ZX0pO1xucmV0dXJuIHByb21pc2U7XG4gfSxcbiAgICAgIGFzeW5jIHRocm93KHJlYXNvbil7XG5jb25zdCByZWplY3Rpb249UHJvbWlzZS5yZWplY3QocmVhc29uKTtcbnF1ZXVlLnB1dChyZWplY3Rpb24pO1xucmV0dXJuIHJlamVjdGlvbjtcbiB9LFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXJlc3RyaWN0ZWQtZ2xvYmFscyovXG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCl7XG5yZXR1cm4gcmVhZGVyO1xuIH19KTtcblxucmV0dXJuIHJlYWRlcjtcbiB9KTtcblxudm9pZCBwdWxsTmV4dCgpO1xucmV0dXJuIHJlYWRlcnM7XG4gfTskaOKAjV9vbmNlLnN5bmNocm9uaXplZFRlZShzeW5jaHJvbml6ZWRUZWUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkJBU0lTX1BPSU5UUyI6WyJCQVNJU19QT0lOVFMiXSwiZnJvbVVuaXF1ZUVudHJpZXMiOlsiZnJvbVVuaXF1ZUVudHJpZXMiXSwib2JqZWN0TWFwIjpbIm9iamVjdE1hcCJdLCJsaXN0RGlmZmVyZW5jZSI6WyJsaXN0RGlmZmVyZW5jZSJdLCJ0aHJvd0xhYmVsZWQiOlsidGhyb3dMYWJlbGVkIl0sImFwcGx5TGFiZWxpbmdFcnJvciI6WyJhcHBseUxhYmVsaW5nRXJyb3IiXSwiZGVlcGx5RnVsZmlsbGVkT2JqZWN0IjpbImRlZXBseUZ1bGZpbGxlZE9iamVjdCJdLCJtYWtlTWVhc3VyZVNlY29uZHMiOlsibWFrZU1lYXN1cmVTZWNvbmRzIl0sIm1ha2VBZ2dyZWdhdGVFcnJvciI6WyJtYWtlQWdncmVnYXRlRXJyb3IiXSwiUHJvbWlzZUFsbE9yRXJyb3JzIjpbIlByb21pc2VBbGxPckVycm9ycyJdLCJhZ2dyZWdhdGVUcnlGaW5hbGx5IjpbImFnZ3JlZ2F0ZVRyeUZpbmFsbHkiXSwiYXNzZXJ0QWxsRGVmaW5lZCI6WyJhc3NlcnRBbGxEZWZpbmVkIl0sImZvcmV2ZXIiOlsiZm9yZXZlciJdLCJ3aGlsZVRydWUiOlsid2hpbGVUcnVlIl0sInVudGlsVHJ1ZSI6WyJ1bnRpbFRydWUiXSwiemlwIjpbInppcCJdLCJhbGxWYWx1ZXMiOlsiYWxsVmFsdWVzIl0sInN5bmNocm9uaXplZFRlZSI6WyJzeW5jaHJvbml6ZWRUZWUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAq4ojpmwBAABsAQAAKQAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL2V4cG9ydGVkLmpzeyJpbXBvcnRzIjpbIi4vc3JjL3R5cGVzLWFtYmllbnQuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9zcmMvdHlwZXMtYW1iaWVudC5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAZ9DFitUSAADVEgAAOQAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9hc3luY0l0ZXJhYmxlQWRhcHRvci5qc3siaW1wb3J0cyI6WyIuL3N1YnNjcmliZS5qcyIsIi4vdHlwZXMtYW1iaWVudC5qcyIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbIm1ha2VBc3luY0l0ZXJhYmxlRnJvbU5vdGlmaWVyIiwib2JzZXJ2ZUl0ZXJhdGlvbiIsIm9ic2VydmVJdGVyYXRvciIsIm9ic2VydmVOb3RpZmllciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLHN1YnNjcmliZUxhdGVzdDskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiLi9zdWJzY3JpYmUuanNcIiwgW1tcInN1YnNjcmliZUxhdGVzdFwiLCBbJGjigI1fYSA9PiAoc3Vic2NyaWJlTGF0ZXN0ID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZXMtYW1iaWVudC5qc1wiLCBbXV1dKTsgICBcblxuXG5cblxuXG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgVXNlIGBzdWJzY3JpYmVMYXRlc3RgIGZyb20gYEBhZ29yaWMvbm90aWZpZXIvc3Vic2NyaWJlLmpzYCBpbnN0ZWFkLlxuICpcbiAqIEFkYXB0b3IgZnJvbSBhIG5vdGlmaWVyUCB0byBhbiBhc3luYyBpdGVyYWJsZS5cbiAqIFRoZSBub3RpZmllclAgY2FuIGJlIGFueSBvYmplY3QgdGhhdCBoYXMgYW4gZXZlbnR1YWxseSBpbnZvY2FibGVcbiAqIGBnZXRVcGRhdGVTaW5jZWAgbWV0aG9kIHRoYXQgYmVoYXZlcyBhY2NvcmRpbmcgdG8gdGhlIG5vdGlmaWVyXG4gKiBzcGVjLiBUaGlzIGNhbiBiZSBhIG5vdGlmaWVyLCBhIHByb21pc2UgZm9yIGEgbG9jYWwgb3IgcmVtb3RlXG4gKiBub3RpZmllciwgb3IgYSBwcmVzZW5jZSBvZiBhIHJlbW90ZSBub3RpZmllci5cbiAqXG4gKiBJdCBpcyBhbHNvIHVzZWQgaW50ZXJuYWxseSBieSBub3RpZmllci5qcyBzbyB0aGF0IGEgbm90aWZpZXIgaXRzZWxmIGlzIGFuXG4gKiBhc3luYyBpdGVyYWJsZS5cbiAqXG4gKiBBbiBhc3luYyBpdGVyYWJsZSBpcyBhbiBvYmplY3Qgd2l0aCBhIGBbU3ltYm9sLmFzeW5jSXRlcmF0b3JdKClgIG1ldGhvZFxuICogdGhhdCByZXR1cm5zIGFuIGFzeW5jIGl0ZXJhdG9yLiBUaGUgYXN5bmMgaXRlcmF0b3Igd2UgcmV0dXJuIGhlcmUgaGFzIG9ubHlcbiAqIGEgYG5leHQoKWAgbWV0aG9kLCB3aXRob3V0IHRoZSBvcHRpb25hbCBgcmV0dXJuYCBhbmQgYHRocm93YCBtZXRob2RzLiBUaGVcbiAqIG9taXR0ZWQgbWV0aG9kcywgaWYgcHJlc2VudCwgd291bGQgYmUgdXNlZCBieSB0aGUgZm9yL2F3YWl0L29mIGxvb3AgdG9cbiAqIGluZm9ybSB0aGUgaXRlcmF0b3Igb2YgZWFybHkgdGVybWluYXRpb24uIEJ1dCB0aGlzIGFkYXB0b3Igd291bGQgbm90IGRvXG4gKiBhbnl0aGluZyB1c2VmdWwgaW4gcmVhY3Rpb24gdG8gdGhpcyBub3RpZmljYXRpb24uXG4gKlxuICogQW4gYXN5bmMgaXRlcmF0b3IncyBgbmV4dCgpYCBtZXRob2QgcmV0dXJucyBhIHByb21pc2UgZm9yIGFuIGl0ZXJhdGlvblxuICogcmVzdWx0LiBBbiBpdGVyYXRpb24gcmVzdWx0IGlzIGEgcmVjb3JkIHdpdGggYHZhbHVlYCBhbmQgYGRvbmVgIHByb3BlcnRpZXMuXG4gKlxuICogVGhlIHB1cnBvc2Ugb2YgYnVpbGRpbmcgb24gdGhlIG5vdGlmaWVyIHByb3RvY29sIGlzIHRvIGhhdmUgYSBsb3NzeVxuICogYWRhcHRvciwgd2hlcmUgaW50ZXJtZWRpYXRlIHJlc3VsdHMgY2FuIGJlIG1pc3NlZCBpbiBmYXZvciBvZiBtb3JlIHJlY2VudFxuICogcmVzdWx0cyB3aGljaCBhcmUgdGhlcmVmb3JlIGxlc3Mgc3RhbGUuIFNlZVxuICogaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9kb2N1bWVudGF0aW9uL2Jsb2IvSEVBRC9tYWluL2d1aWRlcy9qcy1wcm9ncmFtbWluZy9ub3RpZmllcnMubWRcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPEJhc2VOb3RpZmllcjxUPj59IG5vdGlmaWVyUFxuICogQHJldHVybnMge0ZvcmthYmxlQXN5bmNJdGVyYWJsZTxUPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VBc3luY0l0ZXJhYmxlRnJvbU5vdGlmaWVyPXN1YnNjcmliZUxhdGVzdDtcblxuLyoqXG4gKiBUaGlzIGFkdmFuY2VzIGBhc3luY0l0ZXJhdG9yUGAgdXBkYXRpbmcgYGl0ZXJhdGlvbk9ic2VydmVyYCB3aXRoIGVhY2hcbiAqIHN1Y2Nlc3NpdmUgdmFsdWUuIFRoZSBgaXRlcmF0aW9uT2JzZXJ2ZXJgIG1heSBvbmx5IGJlIGludGVyZXN0ZWQgaW4gY2VydGFpblxuICogb2NjdXJyZW5jZXMgKGB1cGRhdGVTdGF0ZWAsIGBmaW5pc2hgLCBgZmFpbGApLCBzbyBmb3IgY29udmVuaWVuY2UsXG4gKiBgb2JzZXJ2ZUl0ZXJhdG9yYCBmZWF0dXJlIHRlc3RzIGZvciB0aG9zZSBtZXRob2RzIGJlZm9yZSBjYWxsaW5nIHRoZW0uXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxBc3luY0l0ZXJhdG9yPFQ+Pn0gYXN5bmNJdGVyYXRvclBcbiAqIEBwYXJhbSB7UGFydGlhbDxJdGVyYXRpb25PYnNlcnZlcjxUPj59IGl0ZXJhdGlvbk9ic2VydmVyXG4gKiBAcmV0dXJucyB7UHJvbWlzZTx1bmRlZmluZWQ+fVxuICovJGjigI1fb25jZS5tYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllcihtYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllcik7XG5jb25zdCAgICAgICAgb2JzZXJ2ZUl0ZXJhdG9yPShhc3luY0l0ZXJhdG9yUCxpdGVyYXRpb25PYnNlcnZlcik9PntcbnJldHVybiBuZXcgUHJvbWlzZSgoYWNrLG9ic2VydmVyRXJyb3IpPT57XG5jb25zdCByZWN1cj0oKT0+e1xuRS53aGVuKFxuRShhc3luY0l0ZXJhdG9yUCkubmV4dCgpLFxuKHt2YWx1ZSxkb25lfSk9PntcbmlmKGRvbmUpe1xuaXRlcmF0aW9uT2JzZXJ2ZXIuZmluaXNoJiZpdGVyYXRpb25PYnNlcnZlci5maW5pc2godmFsdWUpO1xuYWNrKHVuZGVmaW5lZCk7XG4gfWVsc2V7XG5pdGVyYXRpb25PYnNlcnZlci51cGRhdGVTdGF0ZSYmXG5pdGVyYXRpb25PYnNlcnZlci51cGRhdGVTdGF0ZSh2YWx1ZSk7XG5yZWN1cigpO1xuIH1cbiB9LFxuKHJlYXNvbik9Pntcbml0ZXJhdGlvbk9ic2VydmVyLmZhaWwmJml0ZXJhdGlvbk9ic2VydmVyLmZhaWwocmVhc29uKTtcbmFjayh1bmRlZmluZWQpO1xuIH0pLlxuY2F0Y2gob2JzZXJ2ZXJFcnJvcik7XG4gfTtcbnJlY3VyKCk7XG4gfSk7XG4gfTtcblxuLyoqXG4gKiBUaGlzIHJlYWRzIGZyb20gYGFzeW5jSXRlcmFibGVQYCB1cGRhdGluZyBgaXRlcmF0aW9uT2JzZXJ2ZXJgIHdpdGggZWFjaFxuICogc3VjY2Vzc2l2ZSB2YWx1ZS4gVGhlIGBpdGVyYXRpb25PYnNlcnZlcmAgbWF5IG9ubHkgYmUgaW50ZXJlc3RlZCBpbiBjZXJ0YWluXG4gKiBvY2N1cnJlbmNlcyAoYHVwZGF0ZVN0YXRlYCwgYGZpbmlzaGAsIGBmYWlsYCksIHNvIGZvciBjb252ZW5pZW5jZSxcbiAqIGBvYnNlcnZlSXRlcmF0aW9uYCBmZWF0dXJlIHRlc3RzIGZvciB0aG9zZSBtZXRob2RzIGJlZm9yZSBjYWxsaW5nIHRoZW0uXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxBc3luY0l0ZXJhYmxlPFQ+Pn0gYXN5bmNJdGVyYWJsZVBcbiAqIEBwYXJhbSB7UGFydGlhbDxJdGVyYXRpb25PYnNlcnZlcjxUPj59IGl0ZXJhdGlvbk9ic2VydmVyXG4gKiBAcmV0dXJucyB7UHJvbWlzZTx1bmRlZmluZWQ+fVxuICovJGjigI1fb25jZS5vYnNlcnZlSXRlcmF0b3Iob2JzZXJ2ZUl0ZXJhdG9yKTtcbmNvbnN0ICAgICAgICBvYnNlcnZlSXRlcmF0aW9uPShhc3luY0l0ZXJhYmxlUCxpdGVyYXRpb25PYnNlcnZlcik9PntcbmNvbnN0IGl0ZXJhdG9yUD1FKGFzeW5jSXRlcmFibGVQKVtTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKTtcbnJldHVybiBvYnNlcnZlSXRlcmF0b3IoaXRlcmF0b3JQLGl0ZXJhdGlvbk9ic2VydmVyKTtcbiB9O1xuXG4vKipcbiAqIEFzIHVwZGF0ZXMgY29tZSBpbiBmcm9tIHRoZSBwb3NzaWJseSByZW1vdGUgYG5vdGlmaWVyUGAsIHVwZGF0ZVxuICogdGhlIGxvY2FsIGB1cGRhdGVyYC4gU2luY2UgdGhlIHVwZGF0ZXMgY29tZSBmcm9tIGEgbm90aWZpZXIsIHRoZXlcbiAqIGFyZSBsb3NzeSwgaS5lLiwgb25jZSBhIG1vcmUgcmVjZW50IHN0YXRlIGNhbiBiZSByZXBvcnRlZCwgbGVzcyByZWNlbnRcbiAqIHN0YXRlcyBhcmUgYXNzdW1lZCBpcnJlbGV2YW50IGFuZCBkcm9wcGVkLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8TGF0ZXN0VG9waWM8VD4+fSBub3RpZmllclBcbiAqIEBwYXJhbSB7UGFydGlhbDxJdGVyYXRpb25PYnNlcnZlcjxUPj59IGl0ZXJhdGlvbk9ic2VydmVyXG4gKiBAcmV0dXJucyB7UHJvbWlzZTx1bmRlZmluZWQ+fVxuICovJGjigI1fb25jZS5vYnNlcnZlSXRlcmF0aW9uKG9ic2VydmVJdGVyYXRpb24pO1xuY29uc3QgICAgICAgIG9ic2VydmVOb3RpZmllcj0obm90aWZpZXJQLGl0ZXJhdGlvbk9ic2VydmVyKT0+XG5vYnNlcnZlSXRlcmF0aW9uKHN1YnNjcmliZUxhdGVzdChub3RpZmllclApLGl0ZXJhdGlvbk9ic2VydmVyKTskaOKAjV9vbmNlLm9ic2VydmVOb3RpZmllcihvYnNlcnZlTm90aWZpZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VBc3luY0l0ZXJhYmxlRnJvbU5vdGlmaWVyIjpbIm1ha2VBc3luY0l0ZXJhYmxlRnJvbU5vdGlmaWVyIl0sIm9ic2VydmVJdGVyYXRvciI6WyJvYnNlcnZlSXRlcmF0b3IiXSwib2JzZXJ2ZUl0ZXJhdGlvbiI6WyJvYnNlcnZlSXRlcmF0aW9uIl0sIm9ic2VydmVOb3RpZmllciI6WyJvYnNlcnZlTm90aWZpZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAsL4vTxwHAAAcBwAAKgAAAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6WyIuL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzIiwiLi9ub3RpZmllci5qcyIsIi4vcHVibGlzaC1raXQuanMiLCIuL3N0b3JlZC1ub3RpZmllci5qcyIsIi4vc3RvcmVzdWIuanMiLCIuL3N1YnNjcmliZS5qcyIsIi4vc3Vic2NyaWJlci5qcyJdLCJleHBvcnRzIjpbIm1ha2VOb3RpZmllcktpdCIsIm1ha2VOb3RpZmllcktpdCIsIm1ha2VTdWJzY3JpcHRpb25LaXQiLCJtYWtlU3Vic2NyaXB0aW9uS2l0Iiwib2JzZXJ2ZUl0ZXJhdG9yIiwib2JzZXJ2ZUl0ZXJhdG9yIiwicHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0IiwicHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0Iiwic3Vic2NyaWJlTGF0ZXN0Iiwic3Vic2NyaWJlTGF0ZXN0Il0sInJlZXhwb3J0cyI6WyIuL3N0b3JlZC1ub3RpZmllci5qcyIsIi4vc3RvcmVzdWIuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3B1Ymxpc2gta2l0LmpzXCIsIFtdXSxbXCIuL3N1YnNjcmliZS5qc1wiLCBbXV0sW1wiLi9ub3RpZmllci5qc1wiLCBbXV0sW1wiLi9zdWJzY3JpYmVyLmpzXCIsIFtdXSxbXCIuL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzXCIsIFtdXSxbXCIuL3N0b3Jlc3ViLmpzXCIsIFtdXSxbXCIuL3N0b3JlZC1ub3RpZmllci5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3B1Ymxpc2gta2l0LmpzIjpbWyJtYWtlUHVibGlzaEtpdCIsIm1ha2VQdWJsaXNoS2l0Il0sWyJwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQiLCJwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQiXSxbIkZvcmthYmxlQXN5bmNJdGVyYWJsZUl0ZXJhdG9yU2hhcGUiLCJGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclNoYXBlIl0sWyJJdGVyYWJsZUVhY2hUb3BpY0kiLCJJdGVyYWJsZUVhY2hUb3BpY0kiXSxbIkl0ZXJhYmxlTGF0ZXN0VG9waWNJIiwiSXRlcmFibGVMYXRlc3RUb3BpY0kiXSxbIlN1YnNjcmliZXJTaGFwZSIsIlN1YnNjcmliZXJTaGFwZSJdXSwiLi9zdWJzY3JpYmUuanMiOltbInN1YnNjcmliZUVhY2giLCJzdWJzY3JpYmVFYWNoIl0sWyJzdWJzY3JpYmVMYXRlc3QiLCJzdWJzY3JpYmVMYXRlc3QiXV0sIi4vbm90aWZpZXIuanMiOltbIm1ha2VOb3RpZmllciIsIm1ha2VOb3RpZmllciJdLFsibWFrZU5vdGlmaWVyS2l0IiwibWFrZU5vdGlmaWVyS2l0Il0sWyJtYWtlTm90aWZpZXJGcm9tQXN5bmNJdGVyYWJsZSIsIm1ha2VOb3RpZmllckZyb21Bc3luY0l0ZXJhYmxlIl0sWyJtYWtlTm90aWZpZXJGcm9tU3Vic2NyaWJlciIsIm1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyIl1dLCIuL3N1YnNjcmliZXIuanMiOltbIm1ha2VTdWJzY3JpcHRpb24iLCJtYWtlU3Vic2NyaXB0aW9uIl0sWyJtYWtlU3Vic2NyaXB0aW9uS2l0IiwibWFrZVN1YnNjcmlwdGlvbktpdCJdXSwiLi9hc3luY0l0ZXJhYmxlQWRhcHRvci5qcyI6W1sib2JzZXJ2ZU5vdGlmaWVyIiwib2JzZXJ2ZU5vdGlmaWVyIl0sWyJvYnNlcnZlSXRlcmF0b3IiLCJvYnNlcnZlSXRlcmF0b3IiXSxbIm9ic2VydmVJdGVyYXRpb24iLCJvYnNlcnZlSXRlcmF0aW9uIl0sWyJtYWtlQXN5bmNJdGVyYWJsZUZyb21Ob3RpZmllciIsIm1ha2VBc3luY0l0ZXJhYmxlRnJvbU5vdGlmaWVyIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADysAhlWhgAAFoYAAAtAAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL25vdGlmaWVyLmpzeyJpbXBvcnRzIjpbIi4vcHVibGlzaC1raXQuanMiLCIuL3N1YnNjcmliZS5qcyIsIi4vdHlwZXMtYW1iaWVudC5qcyIsIkBhZ29yaWMvYXNzZXJ0IiwiQGVuZG8vZmFyIl0sImV4cG9ydHMiOlsibWFrZU5vdGlmaWVyIiwibWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGUiLCJtYWtlTm90aWZpZXJGcm9tU3Vic2NyaWJlciIsIm1ha2VOb3RpZmllcktpdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnQsRSxGYXIsbWFrZVB1Ymxpc2hLaXQsc3Vic2NyaWJlTGF0ZXN0OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJhc3NlcnRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZXMtYW1iaWVudC5qc1wiLCBbXV0sW1wiLi9wdWJsaXNoLWtpdC5qc1wiLCBbW1wibWFrZVB1Ymxpc2hLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VQdWJsaXNoS2l0ID0gJGjigI1fYSldXV1dLFtcIi4vc3Vic2NyaWJlLmpzXCIsIFtbXCJzdWJzY3JpYmVMYXRlc3RcIiwgWyRo4oCNX2EgPT4gKHN1YnNjcmliZUxhdGVzdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxMYXRlc3RUb3BpYzxUPj59IHNoYXJhYmxlSW50ZXJuYWxzUFxuICogQHJldHVybnMge05vdGlmaWVyPFQ+fVxuICovXG5jb25zdCAgICAgICAgbWFrZU5vdGlmaWVyPShzaGFyYWJsZUludGVybmFsc1ApPT57XG4vKiogQHR5cGUge05vdGlmaWVyPFQ+fSAqL1xuY29uc3Qgbm90aWZpZXI9RmFyKCdub3RpZmllcicse1xuLi4uc3Vic2NyaWJlTGF0ZXN0KHNoYXJhYmxlSW50ZXJuYWxzUCksXG5nZXRVcGRhdGVTaW5jZTphc3luYyh1cGRhdGVDb3VudCk9PlxuRShzaGFyYWJsZUludGVybmFsc1ApLmdldFVwZGF0ZVNpbmNlKHVwZGF0ZUNvdW50KSxcblxuLyoqXG4gKiBVc2UgdGhpcyB0byBkaXN0cmlidXRlIGEgTm90aWZpZXIgZWZmaWNpZW50bHkgb3ZlciB0aGUgbmV0d29yayxcbiAqIGJ5IG9idGFpbmluZyB0aGlzIGZyb20gdGhlIE5vdGlmaWVyIHRvIGJlIHJlcGxpY2F0ZWQsIGFuZCBhcHBseWluZ1xuICogYG1ha2VOb3RpZmllcmAgdG8gaXQgYXQgdGhlIG5ldyBzaXRlIHRvIGdldCBhbiBlcXVpdmFsZW50IGxvY2FsXG4gKiBOb3RpZmllciBhdCB0aGF0IHNpdGUuXG4gKi9cbmdldFNoYXJhYmxlTm90aWZpZXJJbnRlcm5hbHM6YXN5bmMoKT0+c2hhcmFibGVJbnRlcm5hbHNQLFxuLyoqXG4gKiBAZGVwcmVjYXRlZFxuICogVXNlZCBvbmx5IGJ5IGBtYWtlQ2FzdGluZ1NwZWNGcm9tUmVmYC4gIEluc3RlYWQgdGhhdCBmdW5jdGlvbiBzaG91bGQgdXNlXG4gKiB0aGUgYFN0b3JlZEZhY2V0YCBBUEkuXG4gKi9cbmdldFN0b3JlS2V5OigpPT5oYXJkZW4oe25vdGlmaWVyfSl9KTtcblxucmV0dXJuIG5vdGlmaWVyO1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxTdWJzY3JpYmVyPFQ+Pn0gc3Vic2NyaWJlclxuICogQHJldHVybnMge05vdGlmaWVyPFQ+fVxuICovJGjigI1fb25jZS5tYWtlTm90aWZpZXIobWFrZU5vdGlmaWVyKTtcbmNvbnN0ICAgICAgICBtYWtlTm90aWZpZXJGcm9tU3Vic2NyaWJlcj0oc3Vic2NyaWJlcik9Pntcbi8qKlxuICogQHR5cGUge0xhdGVzdFRvcGljPFQ+fVxuICovXG5jb25zdCBiYXNlTm90aWZpZXI9aGFyZGVuKHtcbmdldFVwZGF0ZVNpbmNlOih1cGRhdGVDb3VudD11bmRlZmluZWQpPT5cbkUoc3Vic2NyaWJlcikuZ2V0VXBkYXRlU2luY2UodXBkYXRlQ291bnQpfSk7XG5cblxuLyoqIEB0eXBlIHtOb3RpZmllcjxUPn0gKi9cbmNvbnN0IG5vdGlmaWVyPUZhcignbm90aWZpZXInLHtcbi4uLm1ha2VOb3RpZmllcihiYXNlTm90aWZpZXIpLFxuLi4uYmFzZU5vdGlmaWVyfSk7XG5cbnJldHVybiBub3RpZmllcjtcbiB9OyRo4oCNX29uY2UubWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXIobWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXIpO1xuaGFyZGVuKG1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyKTtcblxuLyoqXG4gKiBQcm9kdWNlcyBhIHBhaXIgb2Ygb2JqZWN0cywgd2hpY2ggYWxsb3cgYSBzZXJ2aWNlIHRvIHByb2R1Y2UgYSBzdHJlYW0gb2ZcbiAqIHVwZGF0ZSBwcm9taXNlcy5cbiAqXG4gKiBUaGUgaW5pdGlhbCBzdGF0ZSBhcmd1bWVudCBoYXMgdG8gYmUgdHJ1bHkgb3B0aW9uYWwgZXZlbiB0aG91Z2ggaXQgY2FuXG4gKiBiZSBhbnkgZmlyc3QgY2xhc3MgdmFsdWUgaW5jbHVkaW5nIGB1bmRlZmluZWRgLiBXZSBuZWVkIHRvIGRpc3Rpbmd1aXNoIHRoZVxuICogcHJlc2VuY2UgdnMgdGhlIGFic2VuY2Ugb2YgaXQsIHdoaWNoIHdlIGNhbm5vdCBkbyB3aXRoIHRoZSBvcHRpb25hbCBhcmd1bWVudFxuICogc3ludGF4LiBSYXRoZXIgd2UgdXNlIHRoZSBhcml0eSBvZiB0aGUgYGluaXRpYWxTdGF0ZUFycmAgYXJyYXkuXG4gKlxuICogSWYgbm8gaW5pdGlhbCBzdGF0ZSBpcyBwcm92aWRlZCB0byBgbWFrZU5vdGlmaWVyS2l0YCwgdGhlbiBpdCBzdGFydHMgd2l0aG91dFxuICogYW4gaW5pdGlhbCBzdGF0ZS4gSXRzIGluaXRpYWwgc3RhdGUgd2lsbCBpbnN0ZWFkIGJlIHRoZSBzdGF0ZSBvZiB0aGUgZmlyc3RcbiAqIHVwZGF0ZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtbXSB8IFtUXX0gaW5pdGlhbFN0YXRlQXJyIHRoZSBmaXJzdCBzdGF0ZSB0byBiZSByZXR1cm5lZCAodHlwZWQgYXMgcmVzdCBhcnJheSB0byBwZXJtaXQgYHVuZGVmaW5lZGApXG4gKiBAcmV0dXJucyB7Tm90aWZpZXJSZWNvcmQ8VD59IHRoZSBub3RpZmllciBhbmQgdXBkYXRlclxuICovXG5jb25zdCAgICAgICAgbWFrZU5vdGlmaWVyS2l0PSguLi5pbml0aWFsU3RhdGVBcnIpPT57XG4vKiogQHR5cGUge1B1Ymxpc2hLaXQ8VD59ICovXG5jb25zdHtwdWJsaXNoZXIsc3Vic2NyaWJlcn09bWFrZVB1Ymxpc2hLaXQoKTtcblxuY29uc3Qgbm90aWZpZXI9bWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXIoc3Vic2NyaWJlcik7XG5cbmNvbnN0IHVwZGF0ZXI9RmFyKCd1cGRhdGVyJyx7XG51cGRhdGVTdGF0ZTooc3RhdGUpPT5wdWJsaXNoZXIucHVibGlzaChzdGF0ZSksXG5maW5pc2g6KGNvbXBsZXRpb24pPT5wdWJsaXNoZXIuZmluaXNoKGNvbXBsZXRpb24pLFxuZmFpbDoocmVhc29uKT0+cHVibGlzaGVyLmZhaWwocmVhc29uKX0pO1xuXG5cbmFzc2VydChpbml0aWFsU3RhdGVBcnIubGVuZ3RoPD0xLCd0b28gbWFueSBhcmd1bWVudHMnKTtcbmlmKGluaXRpYWxTdGF0ZUFyci5sZW5ndGg9PT0xKXtcbnVwZGF0ZXIudXBkYXRlU3RhdGUoaW5pdGlhbFN0YXRlQXJyWzBdKTtcbiB9XG5cbi8qIG5vdGlmaWVyIGZhY2V0IGlzIHNlcGFyYXRlIHNvIGl0IGNhbiBiZSBoYW5kZWQgb3V0IHdoaWxlIHVwZGF0ZXIqL1xuLyogaXMgdGlnaHRseSBoZWxkKi9cbnJldHVybiBoYXJkZW4oe25vdGlmaWVyLHVwZGF0ZXJ9KTtcbiB9O1xuXG4vKipcbiAqIEFkYXB0b3IgZnJvbSBhc3luYyBpdGVyYWJsZSB0byBub3RpZmllci5cbiAqXG4gKiBAZGVwcmVjYXRlZCBUaGUgcmVzdWx0aW5nIG5vdGlmaWVyIGlzIGxvc3NsZXNzLCB3aGljaCBpcyBub3QgZGVzaXJhYmxlLlxuICogUHJlZmVyIG1ha2VOb3RpZmllckZyb21TdWJzY3JpYmVyLCBhbmQgcmVmZXIgdG9cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNTQxMyBhbmRcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9wdWxsLzU2OTUgZm9yIGNvbnRleHQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxBc3luY0l0ZXJhYmxlPFQ+Pn0gYXN5bmNJdGVyYWJsZVBcbiAqIEByZXR1cm5zIHtOb3RpZmllcjxUPn1cbiAqLyRo4oCNX29uY2UubWFrZU5vdGlmaWVyS2l0KG1ha2VOb3RpZmllcktpdCk7XG5jb25zdCAgICAgICAgbWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGU9KGFzeW5jSXRlcmFibGVQKT0+e1xuY29uc3QgaXRlcmF0b3JQPUUoYXN5bmNJdGVyYWJsZVApW1N5bWJvbC5hc3luY0l0ZXJhdG9yXSgpO1xuXG4vKiogQHR5cGUge1Byb21pc2U8VXBkYXRlUmVjb3JkPFQ+Pnx1bmRlZmluZWR9ICovXG5sZXQgb3B0TmV4dFByb21pc2U7XG5sZXQgY3VycmVudFVwZGF0ZUNvdW50PTBuO1xuLyoqIEB0eXBlIHtFUmVmPFVwZGF0ZVJlY29yZDxUPj58dW5kZWZpbmVkfSAqL1xubGV0IGN1cnJlbnRSZXNwb25zZTtcbmxldCBmaW5hbD1mYWxzZTtcblxuLyoqXG4gKiBAdHlwZSB7TGF0ZXN0VG9waWM8VD59XG4gKi9cbmNvbnN0IGJhc2VOb3RpZmllcj1GYXIoJ2Jhc2VOb3RpZmllcicse1xuZ2V0VXBkYXRlU2luY2UodXBkYXRlQ291bnQ9LTFuKXtcbmlmKHVwZGF0ZUNvdW50PGN1cnJlbnRVcGRhdGVDb3VudCl7XG5pZihjdXJyZW50UmVzcG9uc2Upe1xucmV0dXJuIFByb21pc2UucmVzb2x2ZShjdXJyZW50UmVzcG9uc2UpO1xuIH1cbiB9ZWxzZSBpZih1cGRhdGVDb3VudCE9PWN1cnJlbnRVcGRhdGVDb3VudCl7XG50aHJvdyBFcnJvcihcbidnZXRVcGRhdGVTaW5jZSBhcmd1bWVudCBtdXN0IGJlIGEgcHJldmlvdXNseS1pc3N1ZWQgdXBkYXRlQ291bnQuJyk7XG5cbiB9XG5cbi8qIFJldHVybiBhIGZpbmFsIHJlc3BvbnNlIGlmIHdlIGhhdmUgb25lLCBvdGhlcndpc2UgYSBwcm9taXNlIGZvciB0aGUgbmV4dCBzdGF0ZS4qL1xuaWYoZmluYWwpe1xuYXNzZXJ0KGN1cnJlbnRSZXNwb25zZSE9PXVuZGVmaW5lZCk7XG5yZXR1cm4gUHJvbWlzZS5yZXNvbHZlKGN1cnJlbnRSZXNwb25zZSk7XG4gfVxuaWYoIW9wdE5leHRQcm9taXNlKXtcbmNvbnN0IG5leHRJdGVyUmVzdWx0UD1FKGl0ZXJhdG9yUCkubmV4dCgpO1xub3B0TmV4dFByb21pc2U9RS53aGVuKFxubmV4dEl0ZXJSZXN1bHRQLFxuKHtkb25lLHZhbHVlfSk9PntcbmFzc2VydCghZmluYWwpO1xuaWYoZG9uZSl7XG5maW5hbD10cnVlO1xuIH1cbmN1cnJlbnRVcGRhdGVDb3VudCs9MW47XG5jdXJyZW50UmVzcG9uc2U9aGFyZGVuKHtcbnZhbHVlLFxudXBkYXRlQ291bnQ6ZG9uZT91bmRlZmluZWQ6Y3VycmVudFVwZGF0ZUNvdW50fSk7XG5cbm9wdE5leHRQcm9taXNlPXVuZGVmaW5lZDtcbnJldHVybiBjdXJyZW50UmVzcG9uc2U7XG4gfSxcbihfcmVhc29uKT0+e1xuZmluYWw9dHJ1ZTtcbmN1cnJlbnRSZXNwb25zZT1cbi8qKiBAdHlwZSB7UHJvbWlzZTxVcGRhdGVSZWNvcmQ8VD4+fSAqL1xubmV4dEl0ZXJSZXN1bHRQO1xub3B0TmV4dFByb21pc2U9dW5kZWZpbmVkO1xucmV0dXJuIGN1cnJlbnRSZXNwb25zZTtcbiB9KTtcblxuIH1cbnJldHVybiBvcHROZXh0UHJvbWlzZTtcbiB9fSk7XG5cblxuLyoqIEB0eXBlIHtOb3RpZmllcjxUPn0gKi9cbmNvbnN0IG5vdGlmaWVyPUZhcignbm90aWZpZXInLHtcbi8qIERvbid0IGxlYWsgdGhlIG9yaWdpbmFsIGFzeW5jSXRlcmFibGVQIHNpbmNlIGl0IG1heSBiZSByZW1vdGUgYW5kIHdlIGFsc28qL1xuLyogd2FudCB0aGUgc2FtZSBzZW1hbnRpY3MgZm9yIHRoaXMgZXhwb3NlZCBpdGVyYWJsZSBhbmQgdGhlIGJhc2VOb3RpZmllci4qL1xuLi4ubWFrZU5vdGlmaWVyKGJhc2VOb3RpZmllciksXG4uLi5iYXNlTm90aWZpZXJ9KTtcblxucmV0dXJuIG5vdGlmaWVyO1xuIH07JGjigI1fb25jZS5tYWtlTm90aWZpZXJGcm9tQXN5bmNJdGVyYWJsZShtYWtlTm90aWZpZXJGcm9tQXN5bmNJdGVyYWJsZSk7XG5oYXJkZW4obWFrZU5vdGlmaWVyRnJvbUFzeW5jSXRlcmFibGUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VOb3RpZmllciI6WyJtYWtlTm90aWZpZXIiXSwibWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXIiOlsibWFrZU5vdGlmaWVyRnJvbVN1YnNjcmliZXIiXSwibWFrZU5vdGlmaWVyS2l0IjpbIm1ha2VOb3RpZmllcktpdCJdLCJtYWtlTm90aWZpZXJGcm9tQXN5bmNJdGVyYWJsZSI6WyJtYWtlTm90aWZpZXJGcm9tQXN5bmNJdGVyYWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABWf4dIfjgAAH44AAAwAAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3B1Ymxpc2gta2l0LmpzeyJpbXBvcnRzIjpbIi4vdHlwZXMtYW1iaWVudC5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIiwiQGVuZG8vZmFyIiwiQGVuZG8vcHJvbWlzZS1raXQiXSwiZXhwb3J0cyI6WyJGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclNoYXBlIiwiSXRlcmFibGVFYWNoVG9waWNJIiwiSXRlcmFibGVMYXRlc3RUb3BpY0kiLCJQdWJsaXNoZXJJIiwiU3Vic2NyaWJlckkiLCJTdWJzY3JpYmVyU2hhcGUiLCJVcGRhdGVDb3VudFNoYXBlIiwibWFrZVB1Ymxpc2hLaXQiLCJwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQiLCJwdWJsaXNoS2l0SUtpdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlUHJvbWlzZUtpdCxFLEZhcixNLGNhbkJlRHVyYWJsZSxwcmVwYXJlRXhvQ2xhc3NLaXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcIm1ha2VQcm9taXNlS2l0XCIsIFskaOKAjV9hID0+IChtYWtlUHJvbWlzZUtpdCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wiY2FuQmVEdXJhYmxlXCIsIFskaOKAjV9hID0+IChjYW5CZUR1cmFibGUgPSAkaOKAjV9hKV1dLFtcInByZXBhcmVFeG9DbGFzc0tpdFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4b0NsYXNzS2l0ID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZXMtYW1iaWVudC5qc1wiLCBbXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5jb25zdHtGYWlsLHF1b3RlOnF9PWFzc2VydDtcblxuY29uc3Qgc2luaz0oKT0+eyB9O1xuY29uc3QgbWFrZVF1aWV0UmVqZWN0aW9uPShyZWFzb24pPT57XG5jb25zdCByZWplY3Rpb249aGFyZGVuKFByb21pc2UucmVqZWN0KHJlYXNvbikpO1xudm9pZCBFLndoZW4ocmVqZWN0aW9uLHNpbmssc2luayk7XG5yZXR1cm4gcmVqZWN0aW9uO1xuIH07XG5jb25zdCB0b29GYXJSZWplY3Rpb249bWFrZVF1aWV0UmVqZWN0aW9uKFxuaGFyZGVuKG5ldyBFcnJvcignQ2Fubm90IHJlYWQgcGFzdCBlbmQgb2YgaXRlcmF0aW9uLicpKSk7XG5cblxuY29uc3QgICAgICAgIFB1Ymxpc2hlckk9TS5pbnRlcmZhY2UoJ1B1Ymxpc2hlcicse1xucHVibGlzaDpNLmNhbGwoTS5hbnkoKSkucmV0dXJucygpLFxuZmluaXNoOk0uY2FsbChNLmFueSgpKS5yZXR1cm5zKCksXG5mYWlsOk0uY2FsbChNLmFueSgpKS5yZXR1cm5zKCl9KTtcblxuXG4vKiBGb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkgd2l0aCBOb3RpZmllciBgZ2V0VXBkYXRlU2luY2VgLiovJGjigI1fb25jZS5QdWJsaXNoZXJJKFB1Ymxpc2hlckkpO1xuY29uc3QgICAgICAgIFVwZGF0ZUNvdW50U2hhcGU9TS5vcihNLmJpZ2ludCgpLE0ubnVtYmVyKCkpOyRo4oCNX29uY2UuVXBkYXRlQ291bnRTaGFwZShVcGRhdGVDb3VudFNoYXBlKTtcbmNvbnN0ICAgICAgICBTdWJzY3JpYmVyST1NLmludGVyZmFjZSgnU3Vic2NyaWJlcicse1xuc3Vic2NyaWJlQWZ0ZXI6TS5jYWxsKCkub3B0aW9uYWwoTS5iaWdpbnQoKSkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRVcGRhdGVTaW5jZTpNLmNhbGwoKS5vcHRpb25hbChVcGRhdGVDb3VudFNoYXBlKS5yZXR1cm5zKE0ucHJvbWlzZSgpKX0pOyRo4oCNX29uY2UuU3Vic2NyaWJlckkoU3Vic2NyaWJlckkpO1xuXG5jb25zdCAgICAgICAgcHVibGlzaEtpdElLaXQ9aGFyZGVuKHtcbnB1Ymxpc2hlcjpQdWJsaXNoZXJJLFxuc3Vic2NyaWJlcjpTdWJzY3JpYmVySX0pOyRo4oCNX29uY2UucHVibGlzaEtpdElLaXQocHVibGlzaEtpdElLaXQpO1xuXG5cbmNvbnN0ICAgICAgICBGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclNoYXBlPU0uaW50ZXJmYWNlKFxuJ0ZvcmthYmxlQXN5bmNJdGVyYWJsZUl0ZXJhdG9yJyxcbntcbmZvcms6TS5jYWxsKCkucmV0dXJucyhNLmFueSgpKSxcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06TS5jYWxsKCkucmV0dXJucyhNLmFueSgpKSwvKiBvb3BzOiByZWN1cnNpdmUgdHlwZSovXG5uZXh0Ok0uY2FsbFdoZW4oKS5yZXR1cm5zKE0uYW55KCkpfSk7JGjigI1fb25jZS5Gb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclNoYXBlKEZvcmthYmxlQXN5bmNJdGVyYWJsZUl0ZXJhdG9yU2hhcGUpO1xuXG5cblxuY29uc3QgICAgICAgIEl0ZXJhYmxlRWFjaFRvcGljST1NLmludGVyZmFjZSgnSXRlcmFibGVFYWNoVG9waWMnLHtcbnN1YnNjcmliZUFmdGVyOlN1YnNjcmliZXJJLm1ldGhvZEd1YXJkcy5zdWJzY3JpYmVBZnRlcixcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06TS5jYWxsKCkucmV0dXJucyhcbk0ucmVtb3RhYmxlKCdGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvcicpKX0pOyRo4oCNX29uY2UuSXRlcmFibGVFYWNoVG9waWNJKEl0ZXJhYmxlRWFjaFRvcGljSSk7XG5cblxuXG5jb25zdCAgICAgICAgSXRlcmFibGVMYXRlc3RUb3BpY0k9TS5pbnRlcmZhY2UoJ0l0ZXJhYmxlTGF0ZXN0VG9waWMnLHtcbmdldFVwZGF0ZVNpbmNlOlN1YnNjcmliZXJJLm1ldGhvZEd1YXJkcy5nZXRVcGRhdGVTaW5jZSxcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06TS5jYWxsKCkucmV0dXJucyhcbk0ucmVtb3RhYmxlKCdGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvcicpKX0pO1xuXG5cblxuLyoqXG4gKiBAdGVtcGxhdGUge29iamVjdH0gQXJnXG4gKiBAdGVtcGxhdGUgUmV0XG4gKiBAcGFyYW0geyhhcmc6IEFyZykgPT4gUmV0fSBmblxuICogQHJldHVybnMgeyhhcmc6IEFyZykgPT4gUmV0fVxuICovJGjigI1fb25jZS5JdGVyYWJsZUxhdGVzdFRvcGljSShJdGVyYWJsZUxhdGVzdFRvcGljSSk7XG5jb25zdCB3ZWFrTWVtb2l6ZVVuYXJ5PShmbik9PntcbmNvbnN0IGNhY2hlPW5ldyBXZWFrTWFwKCk7XG5yZXR1cm4oYXJnKT0+e1xuLyoqIEB0eXBlIHtvYmplY3R9ICovXG5jb25zdCBvYXJnPWFyZztcbmlmKGNhY2hlLmhhcyhvYXJnKSl7XG5yZXR1cm4gY2FjaGUuZ2V0KG9hcmcpO1xuIH1cbmNvbnN0IHJlc3VsdD1mbihhcmcpO1xuY2FjaGUuc2V0KG9hcmcscmVzdWx0KTtcbnJldHVybiByZXN1bHQ7XG4gfTtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1B1YmxpY2F0aW9uUmVjb3JkPFQ+fSByZWNvcmRcbiAqIEByZXR1cm5zIHtVcGRhdGVSZWNvcmQ8VD59XG4gKi9cbmNvbnN0IG1ha2VVcGRhdGVSZWNvcmRGcm9tUHVibGljYXRpb25SZWNvcmQ9KHJlY29yZCk9PntcbmNvbnN0e1xuaGVhZDp7dmFsdWUsZG9uZX0sXG5wdWJsaXNoQ291bnR9PVxucmVjb3JkO1xuaWYoZG9uZSl7XG4vKiBGaW5hbCByZXN1bHRzIGhhdmUgdW5kZWZpbmVkIHVwZGF0ZUNvdW50LiovXG5yZXR1cm4gaGFyZGVuKHt2YWx1ZSx1cGRhdGVDb3VudDp1bmRlZmluZWR9KTtcbiB9XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZSx1cGRhdGVDb3VudDpwdWJsaXNoQ291bnR9KTtcbiB9O1xuXG4vKipcbiAqIE1ha2VzIGEgYHsgcHVibGlzaGVyLCBzdWJzY3JpYmVyIH1gIHBhaXIgZm9yIGRvaW5nIGVmZmljaWVudFxuICogZGlzdHJpYnV0ZWQgcHViL3N1YiBzdXBwb3J0aW5nIGJvdGggXCJlYWNoXCIgYW5kIFwibGF0ZXN0XCIgaXRlcmF0aW9uXG4gKiBvZiBwdWJsaXNoZWQgdmFsdWVzLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcmV0dXJucyB7UHVibGlzaEtpdDxUPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VQdWJsaXNoS2l0PSgpPT57XG4vKiogQHR5cGUge1Byb21pc2U8UHVibGljYXRpb25SZWNvcmQ8VD4+fSAqL1xubGV0IHRhaWxQO1xuLyoqIEB0eXBlIHt1bmRlZmluZWQgfCAoKHZhbHVlOiBFUmVmPFB1YmxpY2F0aW9uUmVjb3JkPFQ+PikgPT4gdm9pZCl9ICovXG5sZXQgdGFpbFI7XG4oe3Byb21pc2U6dGFpbFAscmVzb2x2ZTp0YWlsUn09bWFrZVByb21pc2VLaXQoKSk7XG5cbmxldCBjdXJyZW50UHVibGlzaENvdW50PTBuO1xubGV0IGN1cnJlbnRQPXRhaWxQO1xuY29uc3QgYWR2YW5jZUN1cnJlbnQ9KGRvbmUsdmFsdWUscmVqZWN0aW9uKT0+e1xuaWYodGFpbFI9PT11bmRlZmluZWQpe1xudGhyb3cgRXJyb3IoJ0Nhbm5vdCB1cGRhdGUgc3RhdGUgYWZ0ZXIgdGVybWluYXRpb24uJyk7XG4gfVxuXG5jdXJyZW50UHVibGlzaENvdW50Kz0xbjtcbmN1cnJlbnRQPXRhaWxQO1xuY29uc3QgcmVzb2x2ZUN1cnJlbnQ9dGFpbFI7XG5cbmlmKGRvbmUpe1xudGFpbFA9dG9vRmFyUmVqZWN0aW9uO1xudGFpbFI9dW5kZWZpbmVkO1xuIH1lbHNle1xuKHtwcm9taXNlOnRhaWxQLHJlc29sdmU6dGFpbFJ9PW1ha2VQcm9taXNlS2l0KCkpO1xuIH1cblxuaWYocmVqZWN0aW9uKXtcbnJlc29sdmVDdXJyZW50KHJlamVjdGlvbik7XG4gfWVsc2V7XG5yZXNvbHZlQ3VycmVudChcbmhhcmRlbih7XG5oZWFkOnt2YWx1ZSxkb25lfSxcbnB1Ymxpc2hDb3VudDpjdXJyZW50UHVibGlzaENvdW50LFxudGFpbDp0YWlsUH0pKTtcblxuXG4gfVxuIH07XG5cbmNvbnN0IG1ha2VNZW1vaXplZFVwZGF0ZVJlY29yZD13ZWFrTWVtb2l6ZVVuYXJ5KFxubWFrZVVwZGF0ZVJlY29yZEZyb21QdWJsaWNhdGlvblJlY29yZCk7XG5cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGUge1N1YnNjcmliZXI8VD59XG4gKi9cbmNvbnN0IHN1YnNjcmliZXI9RmFyKCdTdWJzY3JpYmVyJyx7XG5zdWJzY3JpYmVBZnRlcjoocHVibGlzaENvdW50PS0xbik9PntcbmFzc2VydC50eXBlb2YocHVibGlzaENvdW50LCdiaWdpbnQnKTtcbmlmKHB1Ymxpc2hDb3VudD09PWN1cnJlbnRQdWJsaXNoQ291bnQpe1xucmV0dXJuIHRhaWxQO1xuIH1lbHNlIGlmKHB1Ymxpc2hDb3VudDxjdXJyZW50UHVibGlzaENvdW50KXtcbnJldHVybiBjdXJyZW50UDtcbiB9ZWxzZXtcbnRocm93IEVycm9yKFxuJ3N1YnNjcmliZUFmdGVyIGFyZ3VtZW50IG11c3QgYmUgYSBwcmV2aW91c2x5LWlzc3VlZCBwdWJsaXNoQ291bnQuJyk7XG5cbiB9XG4gfSxcbmdldFVwZGF0ZVNpbmNlOih1cGRhdGVDb3VudCk9PntcbmlmKHVwZGF0ZUNvdW50PT09dW5kZWZpbmVkKXtcbnJldHVybiBzdWJzY3JpYmVyLnN1YnNjcmliZUFmdGVyKCkudGhlbihtYWtlTWVtb2l6ZWRVcGRhdGVSZWNvcmQpO1xuIH1cbnVwZGF0ZUNvdW50PUJpZ0ludCh1cGRhdGVDb3VudCk7XG5yZXR1cm4oXG5zdWJzY3JpYmVyXG4vKiBgc3Vic2NyaWJlQWZ0ZXJgIG1heSByZXNvbHZlIHdpdGggdGhlIHVwZGF0ZSByZWNvcmQgbnVtYmVyZWQqL1xuLyogYHVwZGF0ZUNvdW50ICsgMWAsIGV2ZW4gaWYgc2V2ZXJhbCB1cGRhdGVzIGFyZSBwdWJsaXNoZWQgaW4gdGhlKi9cbi8qIHNhbWUgY3JhbmsuLi4qLy5cbnN1YnNjcmliZUFmdGVyKHVwZGF0ZUNvdW50KVxuLyogLi4uIHNvIHdlIHBvbGwgdGhlIGxhdGVzdCBwdWJsaXNoZWQgdXBkYXRlLCB3aXRob3V0IHdhaXRpbmcgZm9yIGFueSovXG4vKiBmdXJ0aGVyIG9uZXMuKi8uXG50aGVuKCgpPT5zdWJzY3JpYmVyLmdldFVwZGF0ZVNpbmNlKCkpKTtcblxuIH19KTtcblxuXG4vKiogQHR5cGUge1B1Ymxpc2hlcjxUPn0gKi9cbmNvbnN0IHB1Ymxpc2hlcj1GYXIoJ1B1Ymxpc2hlcicse1xucHVibGlzaDoodmFsdWUpPT57XG5hZHZhbmNlQ3VycmVudChmYWxzZSx2YWx1ZSk7XG4gfSxcbmZpbmlzaDooZmluYWxWYWx1ZSk9PntcbmFkdmFuY2VDdXJyZW50KHRydWUsZmluYWxWYWx1ZSk7XG4gfSxcbmZhaWw6KHJlYXNvbik9PntcbmFkdmFuY2VDdXJyZW50KHRydWUsdW5kZWZpbmVkLG1ha2VRdWlldFJlamVjdGlvbihyZWFzb24pKTtcbiB9fSk7XG5cbnJldHVybiBoYXJkZW4oe3B1Ymxpc2hlcixzdWJzY3JpYmVyfSk7XG4gfTskaOKAjV9vbmNlLm1ha2VQdWJsaXNoS2l0KG1ha2VQdWJsaXNoS2l0KTtcbmhhcmRlbihtYWtlUHVibGlzaEtpdCk7XG5cbmNvbnN0IER1cmFibGVQdWJsaXNoS2l0U3RhdGVTaGFwZT1oYXJkZW4oe1xudmFsdWVEdXJhYmlsaXR5Ok0uYW55KCksXG5wdWJsaXNoQ291bnQ6TS5hbnkoKSxcbnN0YXR1czpNLmFueSgpLFxuaGFzVmFsdWU6TS5hbnkoKSxcbnZhbHVlOk0uYW55KCl9KTtcblxuXG4vKiBUT0RPOiBNb3ZlIGR1cmFibGUgcHVibGlzaCBraXQgdG8gYSBuZXcgZmlsZT8qL1xuXG4vKipcbiAqIEBwYXJhbSB7b2JqZWN0fSBbb3B0aW9uc11cbiAqIEBwYXJhbSB7RHVyYWJsZVB1Ymxpc2hLaXRWYWx1ZUR1cmFiaWxpdHkgJiAnbWFuZGF0b3J5J30gW29wdGlvbnMudmFsdWVEdXJhYmlsaXR5PSdtYW5kYXRvcnknXVxuICogQHJldHVybnMge0R1cmFibGVQdWJsaXNoS2l0U3RhdGV9XG4gKi9cbmNvbnN0IGluaXREdXJhYmxlUHVibGlzaEtpdFN0YXRlPShvcHRpb25zPXt9KT0+e1xuY29uc3R7dmFsdWVEdXJhYmlsaXR5PSdtYW5kYXRvcnknfT1vcHRpb25zO1xuYXNzZXJ0LmVxdWFsKHZhbHVlRHVyYWJpbGl0eSwnbWFuZGF0b3J5Jyk7XG5yZXR1cm57XG4vKiBjb25maWd1cmF0aW9uKi9cbnZhbHVlRHVyYWJpbGl0eSxcblxuLyogbGlmZWN5Y2xlIHByb2dyZXNzKi9cbnB1Ymxpc2hDb3VudDowbixcbnN0YXR1czonbGl2ZScsLyogfCAnZmluaXNoZWQnIHwgJ2ZhaWxlZCcqL1xuXG4vKiBwZXJzaXN0ZWQgcmVzdWx0IGRhdGEqL1xuLyogTm90ZSB0aGF0IGluIGFkZGl0aW9uIHRvIG5vbi10ZXJtaW5hbCB2YWx1ZXMgZnJvbSBgcHVibGlzaGAsKi9cbi8qIHZhbHVlIGFsc28gaG9sZHMgdGhlIHRlcm1pbmFsIHZhbHVlIGZyb20gYGZpbmlzaGAgb3IgYGZhaWxgLiovXG5oYXNWYWx1ZTpmYWxzZSxcbnZhbHVlOnVuZGVmaW5lZH07XG5cbiB9O1xuXG4vKiBXZSBuZWVkIHRoZSBXZWFrTWFwIGtleSBmb3IgYSBraXQgdG8gYmUgYSB2cmVmLWJlYXJpbmcgb2JqZWN0Ki9cbi8qIGluIGl0cyBjb2hvcnQsIGFuZCBoYXZlIGFyYml0cmFyaWx5IGNob3NlbiB0aGUgcHVibGlzaGVyIGZhY2V0LiovXG4vKiogQHR5cGVkZWYge1B1Ymxpc2hlcjwqPn0gRHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxLZXkgKi9cbi8qKlxuICogQHBhcmFtIHtQdWJsaXNoS2l0PCo+fSBmYWNldHNcbiAqIEByZXR1cm5zIHtEdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbEtleX1cbiAqL1xuY29uc3QgZ2V0RXBoZW1lcmFsS2V5PShmYWNldHMpPT5mYWNldHMucHVibGlzaGVyO1xuXG4vKipcbiAqIEB0eXBlZGVmIER1cmFibGVQdWJsaXNoS2l0RXBoZW1lcmFsRGF0YVxuICogQHByb3BlcnR5IHtQcm9taXNlPCo+IHwgdW5kZWZpbmVkfSBjdXJyZW50UCBUaGUgY3VycmVudC1yZXN1bHQgcHJvbWlzZVxuICogICAodW5kZWZpbmVkIHVubGVzcyByZXNvbHZlZCB3aXRoIHVucmVjb3ZlcmFibGUgZXBoZW1lcmFsIGRhdGEpXG4gKiBAcHJvcGVydHkge1Byb21pc2U8Kj59IHRhaWxQIFRoZSBuZXh0LXJlc3VsdCBwcm9taXNlXG4gKiBAcHJvcGVydHkgeygodmFsdWU6IGFueSkgPT4gdm9pZCkgfCB1bmRlZmluZWR9IHRhaWxSIFRoZSBuZXh0LXJlc3VsdCByZXNvbHZlclxuICogICAodW5kZWZpbmVkIHdoZW4gdGhlIHB1Ymxpc2gga2l0IGhhcyB0ZXJtaW5hdGVkKVxuICovXG5cbi8qKiBAdHlwZSB7V2Vha01hcDxEdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbEtleSwgRHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhPn0gKi9cbmNvbnN0IGR1cmFibGVQdWJsaXNoS2l0RXBoZW1lcmFsRGF0YT1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIFJldHVybnMgdGhlIGN1cnJlbnQtcmVzdWx0IHByb21pc2UgYXNzb2NpYXRlZCB3aXRoIGEgZ2l2ZW4gZHVyYWJsZVxuICogcHVibGlzaCBraXQsIHJlY3JlYXRlZCB1bmxlc3Mgd2UgYWxyZWFkeSBoYXZlIG9uZSB3aXRoIHJldGFpbmVkXG4gKiBlcGhlbWVyYWwgZGF0YS5cbiAqXG4gKiBAcGFyYW0ge0R1cmFibGVQdWJsaXNoS2l0U3RhdGV9IHN0YXRlXG4gKiBAcGFyYW0ge1B1Ymxpc2hLaXQ8Kj59IGZhY2V0c1xuICogQHBhcmFtIHtQcm9taXNlPCo+fSB0YWlsXG4gKiBAcmV0dXJucyB7UHJvbWlzZTwqPn1cbiAqL1xuY29uc3QgcHJvdmlkZUN1cnJlbnRQPShzdGF0ZSxmYWNldHMsdGFpbCk9PntcbmNvbnN0IGVwaGVtZXJhbEtleT1nZXRFcGhlbWVyYWxLZXkoZmFjZXRzKTtcbmNvbnN0IGZvdW5kRGF0YT1kdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGEuZ2V0KGVwaGVtZXJhbEtleSk7XG5jb25zdCBjdXJyZW50UD1mb3VuZERhdGEmJmZvdW5kRGF0YS5jdXJyZW50UDtcbmlmKGN1cnJlbnRQKXtcbnJldHVybiBjdXJyZW50UDtcbiB9XG5cbmNvbnN0e3B1Ymxpc2hDb3VudCxzdGF0dXMsaGFzVmFsdWUsdmFsdWV9PXN0YXRlO1xuaWYoIWhhc1ZhbHVlKXtcbmFzc2VydChzdGF0dXM9PT0nbGl2ZScpO1xucmV0dXJuIHRhaWw7XG4gfVxuaWYoc3RhdHVzPT09J2xpdmUnfHxzdGF0dXM9PT0nZmluaXNoZWQnKXtcbmNvbnN0IGNlbGw9aGFyZGVuKHtcbmhlYWQ6e3ZhbHVlLGRvbmU6c3RhdHVzIT09J2xpdmUnfSxcbnB1Ymxpc2hDb3VudCxcbnRhaWx9KTtcblxucmV0dXJuIEUucmVzb2x2ZShjZWxsKTtcbiB9ZWxzZSBpZihzdGF0dXM9PT0nZmFpbGVkJyl7XG5yZXR1cm4gbWFrZVF1aWV0UmVqZWN0aW9uKHZhbHVlKTtcbiB9ZWxzZXtcbnRocm93IEZhaWwgYEludmFsaWQgZHVyYWJsZSBwcm9taXNlIGtpdCBzdGF0dXM6ICR7cShzdGF0dXMpfWA7XG4gfVxuIH07XG5cbi8qKlxuICogUmV0dXJucyB0aGUgbmV4dC1yZXN1bHQgcHJvbWlzZSBhbmQgcmVzb2x2ZXIgYXNzb2NpYXRlZCB3aXRoIGEgZ2l2ZW5cbiAqIGR1cmFibGUgcHVibGlzaCBraXQuXG4gKiBUaGVzZSBhcmUgbG9zdCBvbiB1cGdyYWRlIGJ1dCByZWNyZWF0ZWQgb24tZGVtYW5kLCBwcmVzZXJ2aW5nIHRoZVxuICogdmFsdWUgaW4gKGJ1dCBub3QgdGhlIGlkZW50aXR5IG9mKSB0aGUgY3VycmVudCB7IHZhbHVlLCBkb25lIH0gcmVzdWx0XG4gKiB3aGVuIHBvc3NpYmxlLCB3aGljaCBpcyBhbHdheXMgdGhlIGNhc2Ugd2hlbiB0aGF0IHZhbHVlIGlzIHRlcm1pbmFsXG4gKiAoaS5lLiwgZnJvbSBgZmluaXNoYCBvciBgZmFpbGApIG9yIHdoZW4gdGhlIGR1cmFibGUgcHVibGlzaCBraXQgaXNcbiAqIGNvbmZpZ3VyZWQgd2l0aCBgdmFsdWVEdXJhYmlsaXR5OiAnbWFuZGF0b3J5J2AuXG4gKlxuICogQHBhcmFtIHtEdXJhYmxlUHVibGlzaEtpdFN0YXRlfSBzdGF0ZVxuICogQHBhcmFtIHtQdWJsaXNoS2l0PCo+fSBmYWNldHNcbiAqIEByZXR1cm5zIHtEdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGF9XG4gKi9cbmNvbnN0IHByb3ZpZGVEdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGE9KHN0YXRlLGZhY2V0cyk9PntcbmNvbnN0IGVwaGVtZXJhbEtleT1nZXRFcGhlbWVyYWxLZXkoZmFjZXRzKTtcbmNvbnN0IGZvdW5kRGF0YT1kdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGEuZ2V0KGVwaGVtZXJhbEtleSk7XG5pZihmb3VuZERhdGEpe1xucmV0dXJuIGZvdW5kRGF0YTtcbiB9XG5cbmNvbnN0e3N0YXR1c309c3RhdGU7XG5sZXQgdGFpbFA7XG5sZXQgdGFpbFI7XG5pZihzdGF0dXM9PT0nbGl2ZScpe1xuKHtwcm9taXNlOnRhaWxQLHJlc29sdmU6dGFpbFJ9PW1ha2VQcm9taXNlS2l0KCkpO1xudm9pZCBFLndoZW4odGFpbFAsc2luayxzaW5rKTtcbiB9ZWxzZSBpZihzdGF0dXM9PT0nZmluaXNoZWQnfHxzdGF0dXM9PT0nZmFpbGVkJyl7XG50YWlsUD10b29GYXJSZWplY3Rpb247XG4gfWVsc2V7XG50aHJvdyBGYWlsIGBJbnZhbGlkIGR1cmFibGUgcHJvbWlzZSBraXQgc3RhdHVzOiAke3Eoc3RhdHVzKX1gO1xuIH1cbi8qIGN1cnJlbnRQIGlzIG5vdCBlcGhlbWVyYWwgd2hlbiByZXN0b3JpbmcgZnJvbSBwZXJzaXN0ZWQgc3RhdGUuKi9cbmNvbnN0IG9iaj1oYXJkZW4oe2N1cnJlbnRQOnVuZGVmaW5lZCx0YWlsUCx0YWlsUn0pO1xuZHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhLnNldChlcGhlbWVyYWxLZXksb2JqKTtcbnJldHVybiBvYmo7XG4gfTtcblxuLyoqXG4gKiBFeHRlbmRzIHRoZSBzZXF1ZW5jZSBvZiByZXN1bHRzLlxuICpcbiAqIEBwYXJhbSB7e3N0YXRlOiBEdXJhYmxlUHVibGlzaEtpdFN0YXRlLCBmYWNldHM6IFB1Ymxpc2hLaXQ8Kj59fSBjb250ZXh0XG4gKiBAcGFyYW0ge2FueX0gdmFsdWVcbiAqIEBwYXJhbSB7RHVyYWJsZVB1Ymxpc2hLaXRTdGF0ZVsnc3RhdHVzJ119IFt0YXJnZXRTdGF0dXNdXG4gKi9cbmNvbnN0IGFkdmFuY2VEdXJhYmxlUHVibGlzaEtpdD0oY29udGV4dCx2YWx1ZSx0YXJnZXRTdGF0dXM9J2xpdmUnKT0+e1xuY29uc3R7c3RhdGUsZmFjZXRzfT1jb250ZXh0O1xuY29uc3R7dmFsdWVEdXJhYmlsaXR5LHN0YXR1c309c3RhdGU7XG5pZihzdGF0dXMhPT0nbGl2ZScpe1xudGhyb3cgRXJyb3IoJ0Nhbm5vdCB1cGRhdGUgc3RhdGUgYWZ0ZXIgdGVybWluYXRpb24uJyk7XG4gfVxuY29uc3QgZG9uZT10YXJnZXRTdGF0dXMhPT0nbGl2ZSc7XG5pZihkb25lfHx2YWx1ZUR1cmFiaWxpdHk9PT0nbWFuZGF0b3J5Jyl7XG5jYW5CZUR1cmFibGUodmFsdWUpfHxGYWlsIGBDYW5ub3QgYWNjZXB0IG5vbi1kdXJhYmxlIHZhbHVlOiAke3ZhbHVlfWA7XG4gfVxuY29uc3R7dGFpbFA6b2xkVGFpbFAsdGFpbFI6cmVzb2x2ZU9sZFRhaWx9PVxucHJvdmlkZUR1cmFibGVQdWJsaXNoS2l0RXBoZW1lcmFsRGF0YShzdGF0ZSxmYWNldHMpO1xuYXNzZXJ0LnR5cGVvZihyZXNvbHZlT2xkVGFpbCwnZnVuY3Rpb24nKTtcblxuY29uc3QgcHVibGlzaENvdW50PXN0YXRlLnB1Ymxpc2hDb3VudCsxbjtcbnN0YXRlLnB1Ymxpc2hDb3VudD1wdWJsaXNoQ291bnQ7XG5cbmxldCB0YWlsUDtcbmxldCB0YWlsUjtcbmlmKGRvbmUpe1xuc3RhdGUuc3RhdHVzPXRhcmdldFN0YXR1cztcbnRhaWxQPXRvb0ZhclJlamVjdGlvbjtcbnRhaWxSPXVuZGVmaW5lZDtcbiB9ZWxzZXtcbih7cHJvbWlzZTp0YWlsUCxyZXNvbHZlOnRhaWxSfT1tYWtlUHJvbWlzZUtpdCgpKTtcbnZvaWQgRS53aGVuKHRhaWxQLHNpbmssc2luayk7XG4gfVxuXG5sZXQgY3VycmVudFA7XG5pZih0YXJnZXRTdGF0dXM9PT0nZmFpbGVkJyl7XG5zdGF0ZS5oYXNWYWx1ZT10cnVlO1xuc3RhdGUudmFsdWU9dmFsdWU7XG5jb25zdCByZWplY3Rpb249bWFrZVF1aWV0UmVqZWN0aW9uKHZhbHVlKTtcbnJlc29sdmVPbGRUYWlsKHJlamVjdGlvbik7XG4gfWVsc2V7XG4vKiBQZXJzaXN0IGEgdGVybWluYWwgdmFsdWUsIG9yIGEgbm9uLXRlcm1pbmFsIHZhbHVlKi9cbi8qIGlmIGNvbmZpZ3VyZWQgYXMgJ21hbmRhdG9yeScgb3IgJ29wcG9ydHVuaXN0aWMnLiovXG5pZihkb25lfHx2YWx1ZUR1cmFiaWxpdHkhPT0naWdub3JlZCcmJmNhbkJlRHVyYWJsZSh2YWx1ZSkpe1xuc3RhdGUuaGFzVmFsdWU9dHJ1ZTtcbnN0YXRlLnZhbHVlPXZhbHVlO1xuIH1lbHNle1xuc3RhdGUuaGFzVmFsdWU9ZmFsc2U7XG5zdGF0ZS52YWx1ZT11bmRlZmluZWQ7XG4vKiBSZXRhaW4gYW55IHByb21pc2Ugd2l0aCBub24tZHVyYWJsZSByZXNvbHV0aW9uLiovXG5jdXJyZW50UD1vbGRUYWlsUDtcbiB9XG5cbnJlc29sdmVPbGRUYWlsKFxuaGFyZGVuKHtcbmhlYWQ6e3ZhbHVlLGRvbmV9LFxucHVibGlzaENvdW50LFxudGFpbDp0YWlsUH0pKTtcblxuXG4gfVxuXG5kdXJhYmxlUHVibGlzaEtpdEVwaGVtZXJhbERhdGEuc2V0KFxuZ2V0RXBoZW1lcmFsS2V5KGZhY2V0cyksXG5oYXJkZW4oe2N1cnJlbnRQLHRhaWxQLHRhaWxSfSkpO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4uLy4uL3ZhdC1kYXRhL3NyYy90eXBlcy5qcycpLkJhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBraW5kTmFtZVxuICovXG5jb25zdCAgICAgICAgcHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0PShiYWdnYWdlLGtpbmROYW1lKT0+e1xuLyogVE9ETzogT25jZSB3ZSB1bmlmeSB3aXRoIG1ha2VQdWJsaXNoS2l0LCB3ZSB3aWxsIHVzZSBhIFpvbmUtY29tcGF0aWJsZSB3ZWFrKi9cbi8qIG1hcCBmb3IgbWVtb2l6YXRpb24uKi9cbmNvbnN0IG1ha2VNZW1vaXplZFVwZGF0ZVJlY29yZD1tYWtlVXBkYXRlUmVjb3JkRnJvbVB1YmxpY2F0aW9uUmVjb3JkO1xuXG4vKipcbiAqIEByZXR1cm5zIHsoKSA9PiBQdWJsaXNoS2l0PCo+fVxuICovXG5yZXR1cm4gcHJlcGFyZUV4b0NsYXNzS2l0KFxuYmFnZ2FnZSxcbmtpbmROYW1lLFxucHVibGlzaEtpdElLaXQsXG5pbml0RHVyYWJsZVB1Ymxpc2hLaXRTdGF0ZSxcbntcbi8qIFRoZSBwdWJsaXNoZXIgZmFjZXQgb2YgYSBkdXJhYmxlIHB1Ymxpc2gga2l0Ki9cbi8qIGFjY2VwdHMgbmV3IHZhbHVlcy4qL1xucHVibGlzaGVyOntcbnB1Ymxpc2godmFsdWUpe1xuYWR2YW5jZUR1cmFibGVQdWJsaXNoS2l0KHRoaXMsdmFsdWUpO1xuIH0sXG5maW5pc2goZmluYWxWYWx1ZSl7XG5hZHZhbmNlRHVyYWJsZVB1Ymxpc2hLaXQodGhpcyxmaW5hbFZhbHVlLCdmaW5pc2hlZCcpO1xuIH0sXG5mYWlsKHJlYXNvbil7XG5hZHZhbmNlRHVyYWJsZVB1Ymxpc2hLaXQodGhpcyxyZWFzb24sJ2ZhaWxlZCcpO1xuIH19LFxuXG5cbi8qIFRoZSBzdWJzY3JpYmVyIGZhY2V0IG9mIGEgZHVyYWJsZSBwdWJsaXNoIGtpdCovXG4vKiBwcm9wYWdhdGVzIHZhbHVlcy4qL1xuc3Vic2NyaWJlcjp7XG5zdWJzY3JpYmVBZnRlcihwdWJsaXNoQ291bnQ9LTFuKXtcbmNvbnN0e3N0YXRlLGZhY2V0c309dGhpcztcbmNvbnN0e3B1Ymxpc2hDb3VudDpjdXJyZW50UHVibGlzaENvdW50fT1zdGF0ZTtcbmNvbnN0e2N1cnJlbnRQLHRhaWxQfT1wcm92aWRlRHVyYWJsZVB1Ymxpc2hLaXRFcGhlbWVyYWxEYXRhKFxuc3RhdGUsXG5mYWNldHMpO1xuXG5pZihwdWJsaXNoQ291bnQ9PT1jdXJyZW50UHVibGlzaENvdW50KXtcbnJldHVybiB0YWlsUDtcbiB9ZWxzZSBpZihwdWJsaXNoQ291bnQ8Y3VycmVudFB1Ymxpc2hDb3VudCl7XG5yZXR1cm4gY3VycmVudFB8fHByb3ZpZGVDdXJyZW50UChzdGF0ZSxmYWNldHMsdGFpbFApO1xuIH1lbHNle1xudGhyb3cgRXJyb3IoXG4nc3Vic2NyaWJlQWZ0ZXIgYXJndW1lbnQgbXVzdCBiZSBhIHByZXZpb3VzbHktaXNzdWVkIHB1Ymxpc2hDb3VudC4nKTtcblxuIH1cbiB9LFxuZ2V0VXBkYXRlU2luY2UodXBkYXRlQ291bnQpe1xuY29uc3R7XG5mYWNldHM6e3N1YnNjcmliZXJ9fT1cbnRoaXM7XG5pZih1cGRhdGVDb3VudD09PXVuZGVmaW5lZCl7XG5yZXR1cm4gc3Vic2NyaWJlci5zdWJzY3JpYmVBZnRlcigpLnRoZW4obWFrZU1lbW9pemVkVXBkYXRlUmVjb3JkKTtcbiB9XG51cGRhdGVDb3VudD1CaWdJbnQodXBkYXRlQ291bnQpO1xucmV0dXJuKFxuc3Vic2NyaWJlclxuLyogYHN1YnNjcmliZUFmdGVyYCBtYXkgcmVzb2x2ZSB3aXRoIHRoZSB1cGRhdGUgcmVjb3JkIG51bWJlcmVkKi9cbi8qIGB1cGRhdGVDb3VudCArIDFgLCBldmVuIGlmIHNldmVyYWwgdXBkYXRlcyBhcmUgcHVibGlzaGVkIGluIHRoZSovXG4vKiBzYW1lIGNyYW5rLi4uKi8uXG5zdWJzY3JpYmVBZnRlcih1cGRhdGVDb3VudClcbi8qIC4uLiBzbyB3ZSBwb2xsIHRoZSBsYXRlc3QgcHVibGlzaGVkIHVwZGF0ZSwgd2l0aG91dCB3YWl0aW5nIGZvciBhbnkqL1xuLyogZnVydGhlciBvbmVzLiovLlxudGhlbigoKT0+c3Vic2NyaWJlci5nZXRVcGRhdGVTaW5jZSgpKSk7XG5cbiB9fX0sXG5cblxue1xuc3RhdGVTaGFwZTpEdXJhYmxlUHVibGlzaEtpdFN0YXRlU2hhcGV9KTtcblxuXG4gfTskaOKAjV9vbmNlLnByZXBhcmVEdXJhYmxlUHVibGlzaEtpdChwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQpO1xuaGFyZGVuKHByZXBhcmVEdXJhYmxlUHVibGlzaEtpdCk7XG5cbmNvbnN0ICAgICAgICBTdWJzY3JpYmVyU2hhcGU9TS5yZW1vdGFibGUoJ1N1YnNjcmliZXInKTskaOKAjV9vbmNlLlN1YnNjcmliZXJTaGFwZShTdWJzY3JpYmVyU2hhcGUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IlB1Ymxpc2hlckkiOlsiUHVibGlzaGVySSJdLCJVcGRhdGVDb3VudFNoYXBlIjpbIlVwZGF0ZUNvdW50U2hhcGUiXSwiU3Vic2NyaWJlckkiOlsiU3Vic2NyaWJlckkiXSwicHVibGlzaEtpdElLaXQiOlsicHVibGlzaEtpdElLaXQiXSwiRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3JTaGFwZSI6WyJGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclNoYXBlIl0sIkl0ZXJhYmxlRWFjaFRvcGljSSI6WyJJdGVyYWJsZUVhY2hUb3BpY0kiXSwiSXRlcmFibGVMYXRlc3RUb3BpY0kiOlsiSXRlcmFibGVMYXRlc3RUb3BpY0kiXSwibWFrZVB1Ymxpc2hLaXQiOlsibWFrZVB1Ymxpc2hLaXQiXSwicHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0IjpbInByZXBhcmVEdXJhYmxlUHVibGlzaEtpdCJdLCJTdWJzY3JpYmVyU2hhcGUiOlsiU3Vic2NyaWJlclNoYXBlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAL4BMCSDCgAAgwoAADQAAABAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvc3RvcmVkLW5vdGlmaWVyLmpzeyJpbXBvcnRzIjpbIi4vYXN5bmNJdGVyYWJsZUFkYXB0b3IuanMiLCJAYWdvcmljL2ludGVybmFsIiwiQGFnb3JpYy9pbnRlcm5hbC9zcmMvbGliLWNoYWluU3RvcmFnZS5qcyIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbIm1ha2VTdG9yZWROb3RpZmllciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRBbGxEZWZpbmVkLG1ha2VTZXJpYWxpemVUb1N0b3JhZ2UsRSxGYXIsb2JzZXJ2ZU5vdGlmaWVyOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvaW50ZXJuYWxcIiwgW1tcImFzc2VydEFsbERlZmluZWRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydEFsbERlZmluZWQgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9pbnRlcm5hbC9zcmMvbGliLWNoYWluU3RvcmFnZS5qc1wiLCBbW1wibWFrZVNlcmlhbGl6ZVRvU3RvcmFnZVwiLCBbJGjigI1fYSA9PiAobWFrZVNlcmlhbGl6ZVRvU3RvcmFnZSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIi4vYXN5bmNJdGVyYWJsZUFkYXB0b3IuanNcIiwgW1tcIm9ic2VydmVOb3RpZmllclwiLCBbJGjigI1fYSA9PiAob2JzZXJ2ZU5vdGlmaWVyID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7QmFzZU5vdGlmaWVyPFQ+ICYgT21pdDxTdG9yZWRGYWNldCwgJ2dldFN0b3JlS2V5Jz59IFN0b3JlZE5vdGlmaWVyXG4gKi9cblxuLyoqXG4gKiBCZWdpbiBpdGVyYXRpbmcgdGhlIHNvdXJjZSwgc3RvcmluZyBzZXJpYWxpemVkIGl0ZXJhdGlvbiB2YWx1ZXMuICBJZiB0aGVcbiAqIHN0b3JhZ2VOb2RlJ3MgYHNldFZhbHVlYCBvcGVyYXRpb24gcmVqZWN0cywgbm8gZnVydGhlciB3cml0ZXMgdG8gaXQgd2lsbFxuICogYmUgYXR0ZW1wdGVkIChidXQgcmVzdWx0cyB3aWxsIHJlbWFpbiBhdmFpbGFibGUgZnJvbSB0aGUgc3Vic2NyaWJlcikuXG4gKlxuICogUmV0dXJucyBhIFN0b3JlZE5vdGlmaWVyIHRoYXQgY2FuIGJlIHVzZWQgYnkgYSBjbGllbnQgdG8gZGlyZWN0bHkgZm9sbG93XG4gKiB0aGUgaXRlcmF0aW9uIHRoZW1zZWx2ZXMsIG9yIG9idGFpbiBpbmZvcm1hdGlvbiB0byBzdWJzY3JpYmUgdG8gdGhlIHN0b3JlZFxuICogZGF0YSBvdXQtb2YtYmFuZC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPE5vdGlmaWVyPFQ+Pn0gbm90aWZpZXJcbiAqIEBwYXJhbSB7RVJlZjxTdG9yYWdlTm9kZT59IHN0b3JhZ2VOb2RlXG4gKiBAcGFyYW0ge0VSZWY8TWFyc2hhbGxlcj59IG1hcnNoYWxsZXJcbiAqIEByZXR1cm5zIHtTdG9yZWROb3RpZmllcjxUPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VTdG9yZWROb3RpZmllcj0obm90aWZpZXIsc3RvcmFnZU5vZGUsbWFyc2hhbGxlcik9PntcbmFzc2VydEFsbERlZmluZWQoe25vdGlmaWVyLHN0b3JhZ2VOb2RlLG1hcnNoYWxsZXJ9KTtcblxuY29uc3QgbWFyc2hhbGxUb1N0b3JhZ2U9bWFrZVNlcmlhbGl6ZVRvU3RvcmFnZShzdG9yYWdlTm9kZSxtYXJzaGFsbGVyKTtcblxub2JzZXJ2ZU5vdGlmaWVyKG5vdGlmaWVyLHtcbnVwZGF0ZVN0YXRlKHZhbHVlKXtcbm1hcnNoYWxsVG9TdG9yYWdlKHZhbHVlKS5jYXRjaCgocmVhc29uKT0+XG5jb25zb2xlLmVycm9yKCdTdG9yZWROb3RpZmllciBmYWlsZWQgdG8gdXBkYXRlU3RhdGUnLHJlYXNvbikpO1xuXG4gfSxcbmZhaWwocmVhc29uKXtcbmNvbnNvbGUuZXJyb3IoJ1N0b3JlZE5vdGlmaWVyIGZhaWxlZCB0byBpdGVyYXRlJyxyZWFzb24pO1xuIH19KS5cbmNhdGNoKChyZWFzb24pPT57XG5jb25zb2xlLmVycm9yKCdTdG9yZWROb3RpZmllciBoYWx0ZWQgaXRlcmF0aW9uJyxyZWFzb24pO1xuIH0pO1xuXG4vKiogQHR5cGUge1Vuc2VyaWFsaXplcn0gKi9cbmNvbnN0IHVuc2VyaWFsaXplcj1GYXIoJ3Vuc2VyaWFsaXplcicse1xuZnJvbUNhcERhdGE6KGRhdGEpPT5FKG1hcnNoYWxsZXIpLmZyb21DYXBEYXRhKGRhdGEpLFxudW5zZXJpYWxpemU6KGRhdGEpPT5FKG1hcnNoYWxsZXIpLmZyb21DYXBEYXRhKGRhdGEpfSk7XG5cblxuLyoqIEB0eXBlIHtTdG9yZWROb3RpZmllcjxUPn0gKi9cbmNvbnN0IHN0b3JlZE5vdGlmaWVyPUZhcignU3RvcmVkTm90aWZpZXInLHtcbmdldFVwZGF0ZVNpbmNlOih1cGRhdGVDb3VudCk9PkUobm90aWZpZXIpLmdldFVwZGF0ZVNpbmNlKHVwZGF0ZUNvdW50KSxcbmdldFBhdGg6KCk9PkUoc3RvcmFnZU5vZGUpLmdldFBhdGgoKSxcbmdldFVuc2VyaWFsaXplcjooKT0+dW5zZXJpYWxpemVyfSk7XG5cbnJldHVybiBzdG9yZWROb3RpZmllcjtcbiB9OyRo4oCNX29uY2UubWFrZVN0b3JlZE5vdGlmaWVyKG1ha2VTdG9yZWROb3RpZmllcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVN0b3JlZE5vdGlmaWVyIjpbIm1ha2VTdG9yZWROb3RpZmllciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADrPlRqsCIAALAiAAAtAAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3N0b3Jlc3ViLmpzeyJpbXBvcnRzIjpbIi4vYXN5bmNJdGVyYWJsZUFkYXB0b3IuanMiLCIuL3B1Ymxpc2gta2l0LmpzIiwiLi9zdWJzY3JpYmUuanMiLCIuL3N1YnNjcmliZXIuanMiLCJAYWdvcmljL2ludGVybmFsIiwiQGFnb3JpYy9pbnRlcm5hbC9zcmMvbGliLWNoYWluU3RvcmFnZS5qcyIsIkBlbmRvL2ZhciIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJmb3JFYWNoUHVibGljYXRpb25SZWNvcmQiLCJtYWtlU3RvcmVkUHVibGlzaEtpdCIsIm1ha2VTdG9yZWRQdWJsaXNoZXJLaXQiLCJtYWtlU3RvcmVkU3Vic2NyaWJlciIsIm1ha2VTdG9yZWRTdWJzY3JpcHRpb24iXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRSxGYXIsbWFrZU1hcnNoYWwsYXNzZXJ0QWxsRGVmaW5lZCxtYWtlU2VyaWFsaXplVG9TdG9yYWdlLG9ic2VydmVJdGVyYXRpb24sbWFrZVB1Ymxpc2hLaXQsbWFrZVN1YnNjcmlwdGlvbktpdCxzdWJzY3JpYmVFYWNoOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2ZhclwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV0sW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wibWFrZU1hcnNoYWxcIiwgWyRo4oCNX2EgPT4gKG1ha2VNYXJzaGFsID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvaW50ZXJuYWxcIiwgW1tcImFzc2VydEFsbERlZmluZWRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydEFsbERlZmluZWQgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9pbnRlcm5hbC9zcmMvbGliLWNoYWluU3RvcmFnZS5qc1wiLCBbW1wibWFrZVNlcmlhbGl6ZVRvU3RvcmFnZVwiLCBbJGjigI1fYSA9PiAobWFrZVNlcmlhbGl6ZVRvU3RvcmFnZSA9ICRo4oCNX2EpXV1dXSxbXCIuL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzXCIsIFtbXCJvYnNlcnZlSXRlcmF0aW9uXCIsIFskaOKAjV9hID0+IChvYnNlcnZlSXRlcmF0aW9uID0gJGjigI1fYSldXV1dLFtcIi4vcHVibGlzaC1raXQuanNcIiwgW1tcIm1ha2VQdWJsaXNoS2l0XCIsIFskaOKAjV9hID0+IChtYWtlUHVibGlzaEtpdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3N1YnNjcmliZXIuanNcIiwgW1tcIm1ha2VTdWJzY3JpcHRpb25LaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VTdWJzY3JpcHRpb25LaXQgPSAkaOKAjV9hKV1dXV0sW1wiLi9zdWJzY3JpYmUuanNcIiwgW1tcInN1YnNjcmliZUVhY2hcIiwgWyRo4oCNX2EgPT4gKHN1YnNjcmliZUVhY2ggPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG4vKipcbiAqIE5COiBkb2VzIG5vdCB5ZXQgc3Vydml2ZSB1cGdyYWRlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjg5M1xuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1N1YnNjcmliZXI8VD59IHN1YnNjcmliZXJcbiAqIEBwYXJhbSB7KHY6IFQpID0+IHZvaWR9IGNvbnN1bWVWYWx1ZVxuICovXG5jb25zdCAgICAgICAgZm9yRWFjaFB1YmxpY2F0aW9uUmVjb3JkPWFzeW5jKHN1YnNjcmliZXIsY29uc3VtZVZhbHVlKT0+e1xuLyogV2Ugb3Blbi1jb2RlIHRoZSBmb3ItYXdhaXQtb2YgaW1wbGVtZW50YXRpb24gcmF0aGVyIHRoYW4gdXNpbmcgdGhhdCBzeW50YXgqL1xuLyogZGlyZWN0bHkgYmVjYXVzZSB3ZSB3YW50IHRvIHJ1biB0aGUgY29uc3VtZXIgb24gdGhlIGRvbmUgdmFsdWUgYXMgd2VsbC4qL1xuY29uc3QgaXRlcmF0b3I9c3Vic2NyaWJlRWFjaChzdWJzY3JpYmVyKVtTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKTtcblxubGV0IGZpbmlzaGVkPWZhbHNlO1xud2hpbGUoIWZpbmlzaGVkKXtcbi8qIEFsbG93IG5lc3RlZCBhd2FpdHMgKGluIGxvb3ApIGJlY2F1c2UgaXQncyBzYWZlIGZvciBlYWNoIHRvIHJ1biBpbiBhIHR1cm4qL1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWF3YWl0LWluLWxvb3AsIEBqZXNzaWUuanMvbm8tbmVzdGVkLWF3YWl0Ki9cbmNvbnN0e3ZhbHVlLGRvbmV9PWF3YWl0IGl0ZXJhdG9yLm5leHQoKTtcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1hd2FpdC1pbi1sb29wLCBAamVzc2llLmpzL25vLW5lc3RlZC1hd2FpdCovXG5hd2FpdCBjb25zdW1lVmFsdWUodmFsdWUpO1xuZmluaXNoZWQ9ISFkb25lO1xuIH1cbiB9O1xuXG4vKipcbiAqIEJlZ2luIGl0ZXJhdGluZyB0aGUgc291cmNlLCBzdG9yaW5nIHNlcmlhbGl6ZWQgaXRlcmF0aW9uIHZhbHVlcy4gIElmIHRoZVxuICogc3RvcmFnZU5vZGUncyBgc2V0VmFsdWVgIG9wZXJhdGlvbiByZWplY3RzLCBubyBmdXJ0aGVyIHdyaXRlcyB0byBpdCB3aWxsXG4gKiBiZSBhdHRlbXB0ZWQgKGJ1dCByZXN1bHRzIHdpbGwgcmVtYWluIGF2YWlsYWJsZSBmcm9tIHRoZSBzdWJzY3JpYmVyKS5cbiAqXG4gKiBSZXR1cm5zIGEgU3RvcmVkU3Vic2NyaWJlciB0aGF0IGNhbiBiZSB1c2VkIGJ5IGEgY2xpZW50IHRvIGRpcmVjdGx5IGZvbGxvd1xuICogdGhlIGl0ZXJhdGlvbiB0aGVtc2VsdmVzLCBvciBvYnRhaW4gaW5mb3JtYXRpb24gdG8gc3Vic2NyaWJlIHRvIHRoZSBzdG9yZWRcbiAqIGRhdGEgb3V0LW9mLWJhbmQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7U3Vic2NyaWJlcjxUPn0gc3Vic2NyaWJlclxuICogQHBhcmFtIHtFUmVmPFN0b3JhZ2VOb2RlPn0gc3RvcmFnZU5vZGVcbiAqIEBwYXJhbSB7RVJlZjxSZXR1cm5UeXBlPHR5cGVvZiBtYWtlTWFyc2hhbD4+fSBtYXJzaGFsbGVyXG4gKiBAcmV0dXJucyB7U3RvcmVkU3Vic2NyaWJlcjxUPn1cbiAqLyRo4oCNX29uY2UuZm9yRWFjaFB1YmxpY2F0aW9uUmVjb3JkKGZvckVhY2hQdWJsaWNhdGlvblJlY29yZCk7XG5jb25zdCAgICAgICAgbWFrZVN0b3JlZFN1YnNjcmliZXI9KHN1YnNjcmliZXIsc3RvcmFnZU5vZGUsbWFyc2hhbGxlcik9PntcbmFzc2VydEFsbERlZmluZWQoe3N1YnNjcmliZXIsc3RvcmFnZU5vZGUsbWFyc2hhbGxlcn0pO1xuXG5jb25zdCBtYXJzaGFsbFRvU3RvcmFnZT1tYWtlU2VyaWFsaXplVG9TdG9yYWdlKHN0b3JhZ2VOb2RlLG1hcnNoYWxsZXIpO1xuXG4vKiBTdGFydCBwdWJsaXNoaW5nIHRoZSBzb3VyY2UuKi9cbmZvckVhY2hQdWJsaWNhdGlvblJlY29yZChzdWJzY3JpYmVyLG1hcnNoYWxsVG9TdG9yYWdlKS5jYXRjaCgoZXJyKT0+e1xuLyogVE9ETzogSG93IHNob3VsZCB3ZSBoYW5kbGUgYW5kL29yIHN1cmZhY2UgdGhpcyBmYWlsdXJlPyovXG4vKiBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvcHVsbC81NzY2I2Rpc2N1c3Npb25fcjkyMjQ5ODA4OCovXG5jb25zb2xlLmVycm9yKCdTdG9yZWRTdWJzY3JpYmVyIGZhaWxlZCB0byBpdGVyYXRlJyxlcnIpO1xuIH0pO1xuXG4vKiogQHR5cGUge1Vuc2VyaWFsaXplcn0gKi9cbmNvbnN0IHVuc2VyaWFsaXplcj1GYXIoJ3Vuc2VyaWFsaXplcicse1xuZnJvbUNhcERhdGE6KGRhdGEpPT5FKG1hcnNoYWxsZXIpLmZyb21DYXBEYXRhKGRhdGEpLFxudW5zZXJpYWxpemU6KGRhdGEpPT5FKG1hcnNoYWxsZXIpLmZyb21DYXBEYXRhKGRhdGEpfSk7XG5cblxuLyoqIEB0eXBlIHtTdG9yZWRTdWJzY3JpYmVyPFQ+fSAqL1xuY29uc3Qgc3RvcmVzdWI9RmFyKCdTdG9yZWRTdWJzY3JpYmVyJyx7XG5zdWJzY3JpYmVBZnRlcjoocHVibGlzaENvdW50KT0+c3Vic2NyaWJlci5zdWJzY3JpYmVBZnRlcihwdWJsaXNoQ291bnQpLFxuZ2V0VXBkYXRlU2luY2U6KHVwZGF0ZUNvdW50KT0+c3Vic2NyaWJlci5nZXRVcGRhdGVTaW5jZSh1cGRhdGVDb3VudCksXG5nZXRQYXRoOigpPT5FKHN0b3JhZ2VOb2RlKS5nZXRQYXRoKCksXG5nZXRTdG9yZUtleTooKT0+RShzdG9yYWdlTm9kZSkuZ2V0U3RvcmVLZXkoKSxcbmdldFVuc2VyaWFsaXplcjooKT0+dW5zZXJpYWxpemVyfSk7XG5cbnJldHVybiBzdG9yZXN1YjtcbiB9O1xuXG4vKipcbiAqIEBkZXByZWNhdGVkIHVzZSBtYWtlU3RvcmVkU3Vic2NyaWJlclxuICpcbiAqIEJlZ2luIGl0ZXJhdGluZyB0aGUgc291cmNlLCBzdG9yaW5nIHNlcmlhbGl6ZWQgaXRlcmF0aW9uIHZhbHVlcy4gIElmIHRoZVxuICogc3RvcmFnZU5vZGUncyBgc2V0VmFsdWVgIG9wZXJhdGlvbiByZWplY3RzLCB0aGUgaXRlcmF0aW9uIHdpbGwgYmUgdGVybWluYXRlZC5cbiAqXG4gKiBSZXR1cm5zIGEgU3RvcmVkU3Vic2NyaXB0aW9uIHRoYXQgY2FuIGJlIHVzZWQgYnkgYSBjbGllbnQgdG8gZGlyZWN0bHkgZm9sbG93XG4gKiB0aGUgaXRlcmF0aW9uIHRoZW1zZWx2ZXMsIG9yIG9idGFpbiBpbmZvcm1hdGlvbiB0byBzdWJzY3JpYmUgdG8gdGhlIHN0b3JlZFxuICogZGF0YSBvdXQtb2YtYmFuZC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtTdWJzY3JpcHRpb248VD59IHN1YnNjcmlwdGlvblxuICogQHBhcmFtIHtFUmVmPFN0b3JhZ2VOb2RlPn0gW3N0b3JhZ2VOb2RlXVxuICogQHBhcmFtIHtFUmVmPFJldHVyblR5cGU8dHlwZW9mIG1ha2VNYXJzaGFsPj59IFttYXJzaGFsbGVyXVxuICogQHJldHVybnMge1N0b3JlZFN1YnNjcmlwdGlvbjxUPn1cbiAqLyRo4oCNX29uY2UubWFrZVN0b3JlZFN1YnNjcmliZXIobWFrZVN0b3JlZFN1YnNjcmliZXIpO1xuY29uc3QgICAgICAgIG1ha2VTdG9yZWRTdWJzY3JpcHRpb249KFxuc3Vic2NyaXB0aW9uLFxuc3RvcmFnZU5vZGUsXG5tYXJzaGFsbGVyPW1ha2VNYXJzaGFsKHVuZGVmaW5lZCx1bmRlZmluZWQse1xubWFyc2hhbFNhdmVFcnJvcjooKT0+eyB9LFxuc2VyaWFsaXplQm9keUZvcm1hdDonc21hbGxjYXBzJ30pKT0+XG5cbntcbi8qKiBAdHlwZSB7VW5zZXJpYWxpemVyfSAqL1xuY29uc3QgdW5zZXJpYWxpemVyPUZhcigndW5zZXJpYWxpemVyJyx7XG5mcm9tQ2FwRGF0YTooZGF0YSk9PkUobWFyc2hhbGxlcikuZnJvbUNhcERhdGEoZGF0YSksXG51bnNlcmlhbGl6ZTooZGF0YSk9PkUobWFyc2hhbGxlcikuZnJvbUNhcERhdGEoZGF0YSl9KTtcblxuXG4vKiBBYm9ydCB0aGUgaXRlcmF0aW9uIG9uIHRoZSBuZXh0IG9ic2VydmF0aW9uIGlmIHRoZSBwdWJsaXNoZXIgZXZlciBmYWlscy4qL1xubGV0IHB1Ymxpc2hGYWlsZWQ9ZmFsc2U7XG5sZXQgcHVibGlzaEV4Y2VwdGlvbjtcblxuY29uc3QgZmFpbD0oZXJyKT0+e1xucHVibGlzaEZhaWxlZD10cnVlO1xucHVibGlzaEV4Y2VwdGlvbj1lcnI7XG4gfTtcblxuLyogTXVzdCAqbm90KiBiZSBhbiBhc3luYyBmdW5jdGlvbiwgYmVjYXVzZSBpdCBzb21ldGltZXMgbXVzdCB0aHJvdyB0byBhYm9ydCovXG4vKiB0aGUgaXRlcmF0aW9uLiovXG5jb25zdCBwdWJsaXNoVmFsdWU9KG9iaik9PntcbmFzc2VydChzdG9yYWdlTm9kZSk7XG5pZihwdWJsaXNoRmFpbGVkKXtcbi8qIFRvIHByb3Blcmx5IGFib3J0IHRoZSBpdGVyYXRpb24sIHRoaXMgbXVzdCBiZSBhIHN5bmNocm9ub3VzIGV4Y2VwdGlvbi4qL1xudGhyb3cgcHVibGlzaEV4Y2VwdGlvbjtcbiB9XG5cbi8qIFB1Ymxpc2ggdGhlIHZhbHVlLCBjYXB0dXJpbmcgYW55IGVycm9yLiovXG5FKG1hcnNoYWxsZXIpLlxudG9DYXBEYXRhKG9iaikuXG50aGVuKChzZXJpYWxpemVkKT0+e1xuY29uc3QgZW5jb2RlZD1KU09OLnN0cmluZ2lmeShzZXJpYWxpemVkKTtcbnJldHVybiBFKHN0b3JhZ2VOb2RlKS5zZXRWYWx1ZShlbmNvZGVkKTtcbiB9KS5cbmNhdGNoKGZhaWwpO1xuIH07XG5cbmlmKHN0b3JhZ2VOb2RlKXtcbi8qIFN0YXJ0IHB1Ymxpc2hpbmcgdGhlIHNvdXJjZS4qL1xub2JzZXJ2ZUl0ZXJhdGlvbihzdWJzY3JpcHRpb24se1xudXBkYXRlU3RhdGU6cHVibGlzaFZhbHVlLFxuZmluaXNoOnB1Ymxpc2hWYWx1ZX0pLlxuY2F0Y2goZmFpbCk7XG4gfVxuXG4vKiogQHR5cGUge1N0b3JlZFN1YnNjcmlwdGlvbjxUPn0gKi9cbmNvbnN0IHN0b3Jlc3ViPUZhcignU3RvcmVkU3Vic2NyaXB0aW9uJyx7XG4vKiBAdHMtZXhwZWN0LWVycm9yIGdldFN0b3JlS2V5IHR5cGUgZG9lcyBub3QgaGF2ZSBgc3Vic2NyaXB0aW9uYCovXG5nZXRTdG9yZUtleTphc3luYygpPT57XG5pZighc3RvcmFnZU5vZGUpe1xucmV0dXJuIGhhcmRlbih7c3Vic2NyaXB0aW9ufSk7XG4gfVxuY29uc3Qgc3RvcmVLZXk9YXdhaXQgRShzdG9yYWdlTm9kZSkuZ2V0U3RvcmVLZXkoKTtcbnJldHVybiBoYXJkZW4oey4uLnN0b3JlS2V5LHN1YnNjcmlwdGlvbn0pO1xuIH0sXG5nZXRVbnNlcmlhbGl6ZXI6KCk9PnVuc2VyaWFsaXplcixcbmdldFNoYXJhYmxlU3Vic2NyaXB0aW9uSW50ZXJuYWxzOigpPT5cbnN1YnNjcmlwdGlvbi5nZXRTaGFyYWJsZVN1YnNjcmlwdGlvbkludGVybmFscygpLFxuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXTooKT0+c3Vic2NyaXB0aW9uW1N5bWJvbC5hc3luY0l0ZXJhdG9yXSgpLFxuc3Vic2NyaWJlQWZ0ZXI6KHB1Ymxpc2hDb3VudCk9PnN1YnNjcmlwdGlvbi5zdWJzY3JpYmVBZnRlcihwdWJsaXNoQ291bnQpfSk7XG5cbnJldHVybiBzdG9yZXN1YjtcbiB9OyRo4oCNX29uY2UubWFrZVN0b3JlZFN1YnNjcmlwdGlvbihtYWtlU3RvcmVkU3Vic2NyaXB0aW9uKTtcbmhhcmRlbihtYWtlU3RvcmVkU3Vic2NyaXB0aW9uKTtcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCB1c2UgU3RvcmVkUHVibGlzaEtpdFxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN0b3JlZFB1Ymxpc2hlcktpdFxuICogQHByb3BlcnR5IHtTdG9yZWRTdWJzY3JpcHRpb248VD59IHN1YnNjcmliZXJcbiAqIEBwcm9wZXJ0eSB7SXRlcmF0aW9uT2JzZXJ2ZXI8VD59IHB1Ymxpc2hlclxuICovXG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgaW5jb21wYXRpYmxlIHdpdGggZHVyYWJpbGl0eTsgaW5zdGVhZCBoYW5kbGUgdnN0b3JhZ2UgZXBoZW1lcmFsbHkgb24gYSBkdXJhYmxlIFB1Ymxpc2hLaXRcbiAqXG4gKiBAdGVtcGxhdGUgW1Q9dW5rbm93bl1cbiAqIEBwYXJhbSB7RVJlZjxTdG9yYWdlTm9kZT59IFtzdG9yYWdlTm9kZV1cbiAqIEBwYXJhbSB7RVJlZjxNYXJzaGFsbGVyPn0gW21hcnNoYWxsZXJdXG4gKiBAcGFyYW0ge3N0cmluZ30gW2NoaWxkUGF0aF1cbiAqIEByZXR1cm5zIHtTdG9yZWRQdWJsaXNoZXJLaXQ8VD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlU3RvcmVkUHVibGlzaGVyS2l0PShzdG9yYWdlTm9kZSxtYXJzaGFsbGVyLGNoaWxkUGF0aCk9PntcbmNvbnN0e3B1YmxpY2F0aW9uLHN1YnNjcmlwdGlvbn09bWFrZVN1YnNjcmlwdGlvbktpdCgpO1xuXG5pZihzdG9yYWdlTm9kZSYmY2hpbGRQYXRoKXtcbnN0b3JhZ2VOb2RlPUUoc3RvcmFnZU5vZGUpLm1ha2VDaGlsZE5vZGUoY2hpbGRQYXRoKTtcbiB9XG5cbi8qIHdyYXAgdGhlIHN1YnNjcmlwdGlvbiB0byB0ZWUgZXZlbnRzIHRvIHN0b3JhZ2UsIHJlcGVhdGluZyB0byB0aGlzIGBzdWJzY3JpYmVyYCovXG5jb25zdCBzdWJzY3JpYmVyPW1ha2VTdG9yZWRTdWJzY3JpcHRpb24oXG5zdWJzY3JpcHRpb24sXG5zdG9yYWdlTm9kZSxcbm1hcnNoYWxsZXIpO1xuXG5cbnJldHVybntcbnB1Ymxpc2hlcjpwdWJsaWNhdGlvbixcbnN1YnNjcmliZXJ9O1xuXG4gfTtcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBpbmNvbXBhdGlibGUgd2l0aCBkdXJhYmlsaXR5OyBpbnN0ZWFkIGhhbmRsZSB2c3RvcmFnZSBlcGhlbWVyYWxseSBvbiBhIGR1cmFibGUgUHVibGlzaEtpdFxuICpcbiAqIExpa2UgbWFrZVB1Ymxpc2hLaXQgdGhpcyBtYWtlcyBhIGB7IHB1Ymxpc2hlciwgc3Vic2NyaWJlciB9YCBwYWlyIGZvciBkb2luZyBlZmZpY2llbnRcbiAqIGRpc3RyaWJ1dGVkIHB1Yi9zdWIgc3VwcG9ydGluZyBib3RoIFwiZWFjaFwiIGFuZCBcImxhdGVzdFwiIGl0ZXJhdGlvblxuICogb2YgcHVibGlzaGVkIHZhbHVlcy5cbiAqXG4gKiBXaGF0J3MgZGlmZmVyZW50IGlzIGBzdWJzY3JpYmVyYCB0ZWVzIHJlY29yZHMsIHdyaXRpbmcgb3V0IHRvIHN0b3JhZ2VOb2RlLlxuICpcbiAqIEB0ZW1wbGF0ZSBbVD11bmtub3duXVxuICogQHBhcmFtIHtFUmVmPFN0b3JhZ2VOb2RlPn0gc3RvcmFnZU5vZGVcbiAqIEBwYXJhbSB7RVJlZjxNYXJzaGFsbGVyPn0gbWFyc2hhbGxlclxuICogQHJldHVybnMge1N0b3JlZFB1Ymxpc2hLaXQ8VD59XG4gKi8kaOKAjV9vbmNlLm1ha2VTdG9yZWRQdWJsaXNoZXJLaXQobWFrZVN0b3JlZFB1Ymxpc2hlcktpdCk7XG5jb25zdCAgICAgICAgbWFrZVN0b3JlZFB1Ymxpc2hLaXQ9KHN0b3JhZ2VOb2RlLG1hcnNoYWxsZXIpPT57XG5jb25zdHtwdWJsaXNoZXIsc3Vic2NyaWJlcn09bWFrZVB1Ymxpc2hLaXQoKTtcblxucmV0dXJue1xucHVibGlzaGVyLFxuLyogd3JhcCB0aGUgc3Vic2NyaWJlciB0byB0ZWUgZXZlbnRzIHRvIHN0b3JhZ2UqL1xuc3Vic2NyaWJlcjptYWtlU3RvcmVkU3Vic2NyaWJlcihzdWJzY3JpYmVyLHN0b3JhZ2VOb2RlLG1hcnNoYWxsZXIpfTtcblxuIH07JGjigI1fb25jZS5tYWtlU3RvcmVkUHVibGlzaEtpdChtYWtlU3RvcmVkUHVibGlzaEtpdCk7XG5oYXJkZW4obWFrZVN0b3JlZFB1Ymxpc2hLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImZvckVhY2hQdWJsaWNhdGlvblJlY29yZCI6WyJmb3JFYWNoUHVibGljYXRpb25SZWNvcmQiXSwibWFrZVN0b3JlZFN1YnNjcmliZXIiOlsibWFrZVN0b3JlZFN1YnNjcmliZXIiXSwibWFrZVN0b3JlZFN1YnNjcmlwdGlvbiI6WyJtYWtlU3RvcmVkU3Vic2NyaXB0aW9uIl0sIm1ha2VTdG9yZWRQdWJsaXNoZXJLaXQiOlsibWFrZVN0b3JlZFB1Ymxpc2hlcktpdCJdLCJtYWtlU3RvcmVkUHVibGlzaEtpdCI6WyJtYWtlU3RvcmVkUHVibGlzaEtpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAB1YuMobiQAAG4kAAAuAAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3N1YnNjcmliZS5qc3siaW1wb3J0cyI6WyIuL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL2ludGVybmFsL3NyYy91cGdyYWRlLWFwaS5qcyIsIkBlbmRvL2ZhciIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJzdWJzY3JpYmUiLCJzdWJzY3JpYmVFYWNoIiwic3Vic2NyaWJlTGF0ZXN0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsRmFyLGlzT2JqZWN0LGlzVXBncmFkZURpc2Nvbm5lY3Rpb247JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXSxbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJpc09iamVjdFwiLCBbJGjigI1fYSA9PiAoaXNPYmplY3QgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9pbnRlcm5hbC9zcmMvdXBncmFkZS1hcGkuanNcIiwgW1tcImlzVXBncmFkZURpc2Nvbm5lY3Rpb25cIiwgWyRo4oCNX2EgPT4gKGlzVXBncmFkZURpc2Nvbm5lY3Rpb24gPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlcy1hbWJpZW50LmpzXCIsIFtdXV0pOyAgIFxuXG5cblxuXG5cbmNvbnN0e2RldGFpbHM6WCxGYWlsfT1hc3NlcnQ7XG5jb25zdCBzaW5rPSgpPT57IH07XG5cbi8qKlxuICogQ2hlY2sgdGhlIHByb21pc2UgcmV0dXJuZWQgYnkgYSBmdW5jdGlvbiBmb3IgcmVqZWN0aW9uIGJ5IHZhdCB1cGdyYWRlLFxuICogYW5kIHJlZmV0Y2ggdXBvbiBlbmNvdW50ZXJpbmcgdGhhdCBjb25kaXRpb24uXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7KCkgPT4gRVJlZjxUPn0gZ2V0dGVyXG4gKiBAcGFyYW0ge0VSZWY8VD5bXX0gW3NlZWRdXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxUPn1cbiAqL1xuY29uc3QgcmVjb25uZWN0QXNOZWVkZWQ9YXN5bmMoZ2V0dGVyLHNlZWQ9W10pPT57XG5sZXQgZGlzY29ubmVjdGlvbjtcbmxldCBsYXN0VmVyc2lvbj0tSW5maW5pdHk7XG4vKiBFbmQgc3luY2hyb25vdXMgcHJlbHVkZS4qL1xuYXdhaXQgbnVsbDtcbmZvcihsZXQgaT0wOztpKz0xKXtcbnRyeXtcbmNvbnN0IHJlc3VsdFA9aTxzZWVkLmxlbmd0aD9zZWVkW2ldOmdldHRlcigpO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWF3YWl0LWluLWxvb3AsIEBqZXNzaWUuanMvbm8tbmVzdGVkLWF3YWl0Ki9cbmNvbnN0IHJlc3VsdD1hd2FpdCByZXN1bHRQO1xucmV0dXJuIHJlc3VsdDtcbiB9Y2F0Y2goZXJyKXtcbmlmKGlzVXBncmFkZURpc2Nvbm5lY3Rpb24oZXJyKSl7XG5pZighZGlzY29ubmVjdGlvbil7XG5kaXNjb25uZWN0aW9uPWVycjtcbiB9XG5jb25zdHtpbmNhcm5hdGlvbk51bWJlcjp2ZXJzaW9ufT1lcnI7XG5pZih2ZXJzaW9uPmxhc3RWZXJzaW9uKXtcbi8qIFdlIGRvbid0IGV4cGVjdCBhbm90aGVyIHVwZ3JhZGUgaW4gYmV0d2VlbiByZWNlaXZpbmcqL1xuLyogYSBkaXNjb25uZWN0aW9uIGFuZCByZS1yZXF1ZXN0aW5nIGFuIHVwZGF0ZSwgYnV0IG11c3QqL1xuLyogbmV2ZXJ0aGVsZXNzIGJlIHByZXBhcmVkIGZvciB0aGF0LiovXG5sYXN0VmVyc2lvbj12ZXJzaW9uO1xuY29udGludWU7XG4gfVxuIH1cbi8qIGlmIGBlcnJgIGlzIGFuIChFcnJvcikgb2JqZWN0LCB3ZSBjYW4gdHJ5IHRvIGFzc29jaWF0ZSBpdCB3aXRoKi9cbi8qIGluZm9ybWF0aW9uIGFib3V0IHRoZSBkaXNjb25uZWN0aW9uIHRoYXQgcHJvbXB0ZWQgdGhlIHJlcXVlc3QqL1xuLyogZm9yIHdoaWNoIGl0IGlzIGEgcmVzdWx0LiovXG5pZihpc09iamVjdChlcnIpJiZkaXNjb25uZWN0aW9uJiZkaXNjb25uZWN0aW9uIT09ZXJyKXtcbnRyeXtcbmFzc2VydC5ub3RlKFxuZXJyLFxuWCBgQXR0ZW1wdGluZyB0byByZWNvdmVyIGZyb20gZGlzY29ubmVjdGlvbjogJHtkaXNjb25uZWN0aW9ufWApO1xuXG4gfWNhdGNoKF9lcnIpe1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWVtcHR5Ki9cbiB9XG4gfVxudGhyb3cgZXJyO1xuIH1cbiB9XG4gfTtcblxuLyoqXG4gKiBDcmVhdGUgYSBuZWFyIGl0ZXJhYmxlIHRoYXQgY29ycmVzcG9uZHMgdG8gYSBwb3RlbnRpYWxseSBmYXIgb25lLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8QXN5bmNJdGVyYWJsZUl0ZXJhdG9yPFQ+Pn0gaXRQXG4gKi9cbmNvbnN0ICAgICAgICBzdWJzY3JpYmU9KGl0UCk9PlxuRmFyKCdBc3luY0l0ZXJhYmxlJyx7XG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOigpPT57XG5jb25zdCBpdD1FKGl0UClbU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCk7XG5jb25zdCBzZWxmPUZhcignQXN5bmNJdGVyYWJsZUl0ZXJhdG9yJyx7XG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOigpPT5zZWxmLFxubmV4dDphc3luYygpPT5FKGl0KS5uZXh0KCl9KTtcblxucmV0dXJuIHNlbGY7XG4gfX0pO1xuXG5cbi8qKlxuICogQXN5bmNyb25vdXNseSBpdGVyYXRlcyBvdmVyIHRoZSBjb250ZW50cyBvZiBhIFB1YmxpY2F0aW9uUmVjb3JkIGNoYWluIGFzIHRoZXlcbiAqIGFwcGVhci4gIFRoaXMgaXRlcmF0aW9uIG11c3QgZHJvcCBwYXJ0cyBvZiBwdWJsaWNhdGlvbiByZWNvcmRzIHRoYXQgYXJlIG5vXG4gKiBsb25nZXIgbmVlZGVkIHNvIHRoZXkgY2FuIGJlIGdhcmJhZ2UgY29sbGVjdGVkLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8RWFjaFRvcGljPFQ+Pn0gdG9waWNcbiAqIEBwYXJhbSB7RVJlZjxQdWJsaWNhdGlvblJlY29yZDxUPj59IG5leHRDZWxsUFxuICogICBQdWJsaWNhdGlvblJlY29yZCBjb3JyZXNwb25kaW5nIHdpdGggdGhlIGZpcnN0IGl0ZXJhdGlvbiByZXN1bHRcbiAqIEByZXR1cm5zIHtGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvcjxULCBUPn1cbiAqLyRo4oCNX29uY2Uuc3Vic2NyaWJlKHN1YnNjcmliZSk7XG5jb25zdCBtYWtlRWFjaEl0ZXJhdG9yPSh0b3BpYyxuZXh0Q2VsbFApPT57XG4vKiBUbyB1bmRlcnN0YW5kIHRoZSBpbXBsZW1lbnRhdGlvbiwgc3RhcnQgd2l0aCovXG4vKiBodHRwczovL3dlYi5hcmNoaXZlLm9yZy93ZWIvMjAxNjA0MDQxMjIyNTAvaHR0cDovL3dpa2kuZWNtYXNjcmlwdC5vcmcvZG9rdS5waHA/aWQ9c3RyYXdtYW46Y29uY3VycmVuY3kjaW5maW5pdGVfcXVldWUqL1xuY29uc3Qgc2VsZj1GYXIoJ0VhY2hJdGVyYXRvcicse1xuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXTooKT0+c2VsZixcbm5leHQ6KCk9PntcbmNvbnN0e1xuaGVhZDpyZXN1bHRQLFxucHVibGlzaENvdW50OnB1Ymxpc2hDb3VudFAsXG50YWlsOnRhaWxQfT1cbkUuZ2V0KG5leHRDZWxsUCk7XG5cbi8qIElmIHRhaWxQIGlzIGJyb2tlbiBieSB1cGdyYWRlLCB3ZSB3aWxsIG5lZWQgdG8gcmUtcmVxdWVzdCBpdCovXG4vKiBkaXJlY3RseSBmcm9tIGB0b3BpY2AuKi9cbmNvbnN0IGdldFN1Y2Nlc3Nvcj1hc3luYygpPT57XG5jb25zdCBwdWJsaXNoQ291bnQ9YXdhaXQgcHVibGlzaENvdW50UDtcbmFzc2VydC50eXBlb2YocHVibGlzaENvdW50LCdiaWdpbnQnKTtcbmNvbnN0IHN1Y2Nlc3Nvcj1hd2FpdCBFKHRvcGljKS5zdWJzY3JpYmVBZnRlcihwdWJsaXNoQ291bnQpO1xuY29uc3QgbmV3UHVibGlzaENvdW50PXN1Y2Nlc3Nvci5wdWJsaXNoQ291bnQ7XG5pZihuZXdQdWJsaXNoQ291bnQhPT1wdWJsaXNoQ291bnQrMW4pe1xuRmFpbCBgZWFjaEl0ZXJhdG9yIGJyb2tlbiBieSBnYXAgZnJvbSBwdWJsaXNoQ291bnQgJHtwdWJsaXNoQ291bnR9IHRvICR7bmV3UHVibGlzaENvdW50fWA7XG4gfVxucmV0dXJuIHN1Y2Nlc3NvcjtcbiB9O1xuXG4vKiBSZXBsYWNlIG5leHRDZWxsUCBvbiBldmVyeSBjYWxsIHRvIG5leHQoKSBzbyB0aGluZ3Mgd29yayBldmVuKi9cbi8qIHdpdGggYW4gZWFnZXIgY29uc3VtZXIgdGhhdCBkb2Vzbid0IHdhaXQgZm9yIHJlc3VsdHMgdG8gc2V0dGxlLiovXG5uZXh0Q2VsbFA9cmVjb25uZWN0QXNOZWVkZWQoZ2V0U3VjY2Vzc29yLFt0YWlsUF0pO1xuXG4vKiBBdm9pZCB1bmhhbmRsZWQgcmVqZWN0aW9uIHdhcm5pbmdzIGhlcmUgaWYgdGhlIHByZXZpb3VzIGNlbGwgd2FzIHJlamVjdGVkIG9yKi9cbi8qIHRoZXJlIGlzIG5vIGZ1cnRoZXIgcmVxdWVzdCBvZiB0aGlzIGl0ZXJhdG9yLiovXG4vKiBgdGFpbFBgIGlzIGhhbmRsZWQgaW5zaWRlIGByZWNvbm5lY3RBc05lZWRlZGAgYW5kIGByZXN1bHRQYCBpcyB0aGUgY2FsbGVyJ3MqL1xuLyogY29uY2VybiwgbGVhdmluZyBvbmx5IGBwdWJsaXNoQ291bnRQYCBhbmQgdGhlIG5ldyBgbmV4dENlbGxQYC4qL1xudm9pZCBFLndoZW4ocHVibGlzaENvdW50UCxzaW5rLHNpbmspO1xudm9pZCBFLndoZW4obmV4dENlbGxQLHNpbmssc2luayk7XG5yZXR1cm4gcmVzdWx0UDtcbiB9LFxuZm9yazooKT0+bWFrZUVhY2hJdGVyYXRvcih0b3BpYyxuZXh0Q2VsbFApfSk7XG5cbnJldHVybiBzZWxmO1xuIH07XG5cbi8qKlxuICogR2l2ZW4gYSBsb2NhbCBvciByZW1vdGUgc3Vic2NyaWJlciwgcmV0dXJucyBhIGxvY2FsIEFzeW5jSXRlcmFibGUgd2hpY2hcbiAqIHByb3ZpZGVzIFwicHJlZml4IGxvc3N5XCIgaXRlcmF0aW9ucyBvZiB0aGUgdW5kZXJseWluZyBQdWJsaWNhdGlvbkxpc3QuXG4gKiBCeSBcInByZWZpeCBsb3NzeVwiLCB3ZSBtZWFuIHRoYXQgeW91IG1heSBtaXNzIGV2ZXJ5dGhpbmcgcHVibGlzaGVkIGJlZm9yZVxuICogeW91IGFzayB0aGUgcmV0dXJuZWQgaXRlcmFibGUgZm9yIGFuIGl0ZXJhdG9yLiBCdXQgdGhlIHJldHVybmVkIGl0ZXJhdG9yXG4gKiB3aWxsIGVudW1lcmF0ZSBlYWNoIHRoaW5nIHB1Ymxpc2hlZCBmcm9tIHRoYXQgaXRlcmF0b3IncyBzdGFydGluZyBwb2ludFxuICogdXAgdG8gYSBkaXNjb25uZWN0aW9uIHJlc3VsdCBpbmRpY2F0aW5nIHVwZ3JhZGUgb2YgdGhlIHByb2R1Y2VyXG4gKiAod2hpY2ggYnJlYWtzIHRoZSBnYXAtZnJlZSBndWFyYW50ZWUgYW5kIHRoZXJlZm9yZSB0ZXJtaW5hdGVzIGFueSBhY3RpdmVcbiAqIGl0ZXJhdG9yIHdoaWxlIHN0aWxsIHN1cHBvcnRpbmcgY3JlYXRpb24gb2YgbmV3IGl0ZXJhdG9ycykuXG4gKlxuICogSWYgdGhlIHVuZGVybHlpbmcgUHVibGljYXRpb25MaXN0IGlzIHRlcm1pbmF0ZWQsIHRoYXQgdGVybWluYWwgdmFsdWUgd2lsbCBiZVxuICogcmVwb3J0ZWQgbG9zc2xlc3NseS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPEVhY2hUb3BpYzxUPj59IHRvcGljXG4gKi9cbmNvbnN0ICAgICAgICBzdWJzY3JpYmVFYWNoPSh0b3BpYyk9PntcbmNvbnN0IGl0ZXJhYmxlPUZhcignRWFjaEl0ZXJhYmxlJyx7XG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOigpPT57XG5jb25zdCBmaXJzdENlbGxQPXJlY29ubmVjdEFzTmVlZGVkKCgpPT5FKHRvcGljKS5zdWJzY3JpYmVBZnRlcigpKTtcbnJldHVybiBtYWtlRWFjaEl0ZXJhdG9yKHRvcGljLGZpcnN0Q2VsbFApO1xuIH19KTtcblxucmV0dXJuIGl0ZXJhYmxlO1xuIH07JGjigI1fb25jZS5zdWJzY3JpYmVFYWNoKHN1YnNjcmliZUVhY2gpO1xuaGFyZGVuKHN1YnNjcmliZUVhY2gpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8TGF0ZXN0VG9waWM8VD4+fSB0b3BpY1xuICogQHBhcmFtIHtiaWdpbnR9IFtsb2NhbFVwZGF0ZUNvdW50XVxuICogQHBhcmFtIHtJdGVyYXRvclJldHVyblJlc3VsdDxUPn0gW3Rlcm1pbmFsUmVzdWx0XVxuICogQHJldHVybnMge0ZvcmthYmxlQXN5bmNJdGVyYWJsZUl0ZXJhdG9yPFQsIFQ+fVxuICovXG5jb25zdCBjbG9uZUxhdGVzdEl0ZXJhdG9yPSh0b3BpYyxsb2NhbFVwZGF0ZUNvdW50LHRlcm1pbmFsUmVzdWx0KT0+e1xubGV0IG11dGV4PVByb21pc2UucmVzb2x2ZSgpO1xuXG4vKipcbiAqIFJlcXVlc3QgdGhlIG5leHQgdXBkYXRlIHJlY29yZCBmcm9tIHRoZSB0b3BpYywgdXBkYXRpbmcgb3VyIGxvY2FsIHN0YXRlLFxuICogYW5kIGNvbnZlcnQgaXQgdG8gYW4gaXRlcmF0b3IgcmVzdWx0LlxuICpcbiAqIEByZXR1cm5zIHtQcm9taXNlPEl0ZXJhdG9yUmVzdWx0PFQsIFQ+Pn1cbiAqL1xuY29uc3QgbWF5YmVSZXF1ZXN0TmV4dFJlc3VsdD1hc3luYygpPT57XG5pZih0ZXJtaW5hbFJlc3VsdCl7XG4vKiBXZSd2ZSByZWFjaGVkIHRoZSBlbmQgb2YgdGhlIHRvcGljLCBqdXN0IGtlZXAgcmV0dXJuaW5nIHRoZSBsYXN0IHJlc3VsdCovXG4vKiB3aXRob3V0IGZ1cnRoZXIgcmVxdWVzdHMuKi9cbnJldHVybiB0ZXJtaW5hbFJlc3VsdDtcbiB9XG5cbi8qIFNlbmQgdGhlIG5leHQgcmVxdWVzdCBub3csIHNraXBwaW5nIHBhc3QgaW50ZXJtZWRpYXRlIHVwZGF0ZXMqL1xuLyogYW5kIHVwZ3JhZGUgZGlzY29ubmVjdGlvbnMuKi9cbmNvbnN0e3ZhbHVlLHVwZGF0ZUNvdW50fT1hd2FpdCByZWNvbm5lY3RBc05lZWRlZCgoKT0+XG5FKHRvcGljKS5nZXRVcGRhdGVTaW5jZShsb2NhbFVwZGF0ZUNvdW50KSk7XG5cbi8qIE1ha2Ugc3VyZSB0aGUgbmV4dCByZXF1ZXN0IGlzIGZvciBhIGZyZXNoZXIgdmFsdWUuKi9cbmxvY2FsVXBkYXRlQ291bnQ9dXBkYXRlQ291bnQ7XG5cbi8qIE1ha2UgYW4gSXRlcmF0b3JSZXN1bHQuKi9cbmlmKHVwZGF0ZUNvdW50PT09dW5kZWZpbmVkKXtcbnRlcm1pbmFsUmVzdWx0PWhhcmRlbih7ZG9uZTp0cnVlLHZhbHVlfSk7XG5yZXR1cm4gdGVybWluYWxSZXN1bHQ7XG4gfVxucmV0dXJuIGhhcmRlbih7ZG9uZTpmYWxzZSx2YWx1ZX0pO1xuIH07XG5cbmNvbnN0IHNlbGY9RmFyKCdMYXRlc3RJdGVyYXRvcicse1xuZm9yazooKT0+Y2xvbmVMYXRlc3RJdGVyYXRvcih0b3BpYyxsb2NhbFVwZGF0ZUNvdW50LHRlcm1pbmFsUmVzdWx0KSxcbltTeW1ib2wuYXN5bmNJdGVyYXRvcl06KCk9PnNlbGYsXG5uZXh0OmFzeW5jKCk9Pntcbi8qIEluIHRoaXMgYWRhcHRvciwgb25jZSBgbmV4dCgpYCBpcyBjYWxsZWQgYW5kIHJldHVybnMgYW4gdW5yZXNvbHZlZCovXG4vKiBwcm9taXNlLCBmdXJ0aGVyIGBuZXh0KClgIGNhbGxzIHdpbGwgYWxzbyByZXR1cm4gdW5yZXNvbHZlZCBwcm9taXNlcyovXG4vKiBidXQgZWFjaCBjYWxsIHdpbGwgbm90IHRyaWdnZXIgYW5vdGhlciBgdG9waWNgIHJlcXVlc3QgdW50aWwgdGhlIHByaW9yKi9cbi8qIG9uZSBoYXMgc2V0dGxlZC4qL1xuLyoqL1xuLyogVGhpcyBsaW5lYXIgcXVldWVpbmcgYmVoYXZpb3IgaXMgb25seSBuZWVkZWQgZm9yIGNvZGUgdGhhdCB1c2VzIHRoZSovXG4vKiBhc3luYyBpdGVyYXRvciBwcm90b2NvbCBleHBsaWNpdGx5LiBXaGVuIHRoaXMgYXN5bmMgaXRlcmF0b3IgaXMqL1xuLyogY29uc3VtZWQgYnkgYSBmb3IvYXdhaXQvb2YgbG9vcCwgYG5leHQoKWAgd2lsbCBvbmx5IGJlIGNhbGxlZCBhZnRlciB0aGUqL1xuLyogcHJvbWlzZSBmb3IgdGhlIHByZXZpb3VzIGl0ZXJhdGlvbiByZXN1bHQgaGFzIGZ1bGZpbGxlZC4gSWYgaXQgZnVsZmlsbHMqL1xuLyogd2l0aCBgZG9uZTogdHJ1ZWAsIHRoZSBmb3IvYXdhaXQvb2YgbG9vcCB3aWxsIG5ldmVyIGNhbGwgYG5leHQoKWAqL1xuLyogYWdhaW4uKi9cbi8qKi9cbi8qIFNlZSovXG4vKiBodHRwczovLzJhbGl0eS5jb20vMjAxNi8xMC9hc3luY2hyb25vdXMtaXRlcmF0aW9uLmh0bWwjcXVldWluZy1uZXh0KCktaW52b2NhdGlvbnMqL1xuLyogZm9yIGFuIGV4cGxpY2l0IHVzZSB0aGF0IHNlbmRzIGBuZXh0KClgIHdpdGhvdXQgd2FpdGluZy4qL1xuXG5pZih0ZXJtaW5hbFJlc3VsdCl7XG4vKiBXZSd2ZSByZWFjaGVkIHRoZSBlbmQgb2YgdGhlIHRvcGljLCBqdXN0IGtlZXAgcmV0dXJuaW5nIHRoZSBsYXN0Ki9cbi8qIHJlc3VsdC4qL1xucmV0dXJuIHRlcm1pbmFsUmVzdWx0O1xuIH1cblxuLyogQkVHSU4gQ1JJVElDQUwgU0VDVElPTiAtIHN5bmNocm9ub3VzbHkgZW5xdWV1ZSBhbmQgcmVhc3NpZ24gYG11dGV4YCovXG4vKiovXG4vKiBVc2UgYG11dGV4YCB0byBlbnN1cmUgdGhhdCB3ZSBoYXZlIG5vIG1vcmUgdGhhbiBhIHNpbmdsZSByZXF1ZXN0IGluKi9cbi8qIGZsaWdodC4qL1xuY29uc3QgbmV4dFJlc3VsdD1tdXRleC50aGVuKG1heWJlUmVxdWVzdE5leHRSZXN1bHQpO1xubXV0ZXg9bmV4dFJlc3VsdC50aGVuKHNpbmssc2luayk7XG4vKiBFTkQgQ1JJVElDQUwgU0VDVElPTiovXG5cbnJldHVybiBuZXh0UmVzdWx0O1xuIH19KTtcblxucmV0dXJuIHNlbGY7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtFUmVmPExhdGVzdFRvcGljPFQ+Pn0gdG9waWNcbiAqIEByZXR1cm5zIHtGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvcjxULCBUPn1cbiAqL1xuY29uc3QgbWFrZUxhdGVzdEl0ZXJhdG9yPSh0b3BpYyk9PmNsb25lTGF0ZXN0SXRlcmF0b3IodG9waWMpO1xuXG4vKipcbiAqIEdpdmVuIGEgbG9jYWwgb3IgcmVtb3RlIHN1YnNjcmliZXIsIHJldHVybnMgYSBsb2NhbCBBc3luY0l0ZXJhYmxlIHdoaWNoXG4gKiBwcm92aWRlcyBcImxvc3N5XCIgaXRlcmF0aW9ucyBvZiB0aGUgdW5kZXJseWluZyBQdWJsaWNhdGlvbkxpc3QuXG4gKiBCeSBcImxvc3N5XCIsIHdlIG1lYW4gdGhhdCB5b3UgbWF5IG1pc3MgYW55IHB1Ymxpc2hlZCBzdGF0ZSBpZiBhIG1vcmVcbiAqIHJlY2VudCBwdWJsaXNoZWQgc3RhdGUgY2FuIGJlIHJlcG9ydGVkIGluc3RlYWQuXG4gKlxuICogSWYgdGhlIHVuZGVybHlpbmcgUHVibGljYXRpb25MaXN0IGlzIHRlcm1pbmF0ZWQgYnkgdXBncmFkZSBvZiB0aGUgcHJvZHVjZXIsXG4gKiBpdCB3aWxsIGJlIHJlLXJlcXVlc3RlZC4gQWxsIG90aGVyIHRlcm1pbmFsIHZhbHVlcyB3aWxsIGJlIGxvc3NsZXNzbHlcbiAqIHByb3BhZ2F0ZWQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RVJlZjxMYXRlc3RUb3BpYzxUPj59IHRvcGljXG4gKi9cbmNvbnN0ICAgICAgICBzdWJzY3JpYmVMYXRlc3Q9KHRvcGljKT0+e1xuY29uc3QgaXRlcmFibGU9RmFyKCdMYXRlc3RJdGVyYWJsZScse1xuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXTooKT0+bWFrZUxhdGVzdEl0ZXJhdG9yKHRvcGljKX0pO1xuXG5yZXR1cm4gaXRlcmFibGU7XG4gfTskaOKAjV9vbmNlLnN1YnNjcmliZUxhdGVzdChzdWJzY3JpYmVMYXRlc3QpO1xuaGFyZGVuKHN1YnNjcmliZUxhdGVzdCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsic3Vic2NyaWJlIjpbInN1YnNjcmliZSJdLCJzdWJzY3JpYmVFYWNoIjpbInN1YnNjcmliZUVhY2giXSwic3Vic2NyaWJlTGF0ZXN0IjpbInN1YnNjcmliZUxhdGVzdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAnsjsjxQsAAMULAAAvAAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3N1YnNjcmliZXIuanN7ImltcG9ydHMiOlsiLi9wdWJsaXNoLWtpdC5qcyIsIi4vc3Vic2NyaWJlLmpzIiwiLi90b3BpYy5qcyIsIi4vdHlwZXMtYW1iaWVudC5qcyIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbIm1ha2VTdWJzY3JpcHRpb24iLCJtYWtlU3Vic2NyaXB0aW9uS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsRmFyLHN1YnNjcmliZUVhY2gsbWFrZVB1Ymxpc2hLaXQsbWFrZVBpbm5lZEhpc3RvcnlUb3BpYzskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIi4vc3Vic2NyaWJlLmpzXCIsIFtbXCJzdWJzY3JpYmVFYWNoXCIsIFskaOKAjV9hID0+IChzdWJzY3JpYmVFYWNoID0gJGjigI1fYSldXV1dLFtcIi4vcHVibGlzaC1raXQuanNcIiwgW1tcIm1ha2VQdWJsaXNoS2l0XCIsIFskaOKAjV9hID0+IChtYWtlUHVibGlzaEtpdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3RvcGljLmpzXCIsIFtbXCJtYWtlUGlubmVkSGlzdG9yeVRvcGljXCIsIFskaOKAjV9hID0+IChtYWtlUGlubmVkSGlzdG9yeVRvcGljID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZXMtYW1iaWVudC5qc1wiLCBbXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8RWFjaFRvcGljPFQ+Pn0gdG9waWNcbiAqIEByZXR1cm5zIHtTdWJzY3JpcHRpb248VD59XG4gKi9cbmNvbnN0IG1ha2VTdWJzY3JpcHRpb249KHRvcGljKT0+e1xuY29uc3Qgc3Vic2NyaXB0aW9uPUZhcignU3Vic2NyaXB0aW9uJyx7XG4uLi5zdWJzY3JpYmVFYWNoKHRvcGljKSxcbnN1YnNjcmliZUFmdGVyOmFzeW5jKHB1Ymxpc2hDb3VudCk9PkUodG9waWMpLnN1YnNjcmliZUFmdGVyKHB1Ymxpc2hDb3VudCksXG5cbi8qKlxuICogVXNlIHRoaXMgdG8gZGlzdHJpYnV0ZSBhIFN1YnNjcmlwdGlvbiBlZmZpY2llbnRseSBvdmVyIHRoZSBuZXR3b3JrLFxuICogYnkgb2J0YWluaW5nIHRoaXMgZnJvbSB0aGUgU3Vic2NyaXB0aW9uIHRvIGJlIHJlcGxpY2F0ZWQsIGFuZCBhcHBseWluZ1xuICogYG1ha2VTdWJzY3JpcHRpb25gIHRvIGl0IGF0IHRoZSBuZXcgc2l0ZSB0byBnZXQgYW4gZXF1aXZhbGVudCBsb2NhbFxuICogU3Vic2NyaXB0aW9uIGF0IHRoYXQgc2l0ZS5cbiAqL1xuZ2V0U2hhcmFibGVTdWJzY3JpcHRpb25JbnRlcm5hbHM6YXN5bmMoKT0+dG9waWMsXG5cbmdldFN0b3JlS2V5OigpPT5oYXJkZW4oe3N1YnNjcmlwdGlvbn0pfSk7XG5cbnJldHVybiBzdWJzY3JpcHRpb247XG4gfTskaOKAjV9vbmNlLm1ha2VTdWJzY3JpcHRpb24obWFrZVN1YnNjcmlwdGlvbik7XG5oYXJkZW4obWFrZVN1YnNjcmlwdGlvbik7XG5cblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBQcm9kdWNlcnMgc2hvdWxkIHVzZVxuICogYGBganNcbiAqIGNvbnN0IHsgcHVibGlzaGVyLCBzdWJzY3JpYmVyIH0gPSBtYWtlUHVibGlzaEtpdCgpO1xuICogY29uc3QgdG9waWMgPSBtYWtlUGlubmVkSGlzdG9yeVRvcGljKHN1YnNjcmliZXIpO1xuICogYGBgXG4gKiBpbnN0ZWFkLCB3aGljaCBtYWtlcyBpdCBjbGVhcmVyIHRoYXQgYWxsIHRoZSBzdWJzY3JpYmVyJ3MgaGlzdG9yeSBpc1xuICogcmV0YWluZWQsIHByZXZlbnRpbmcgR0MuICBQb3RlbnRpYWxseSByZW1vdGUgY29uc3VtZXJzIHVzZVxuICogYGBganNcbiAqIGZvciBhd2FpdCAoY29uc3QgdmFsdWUgb2Ygc3Vic2NyaWJlRWFjaCh0b3BpYykpIHsgLi4uIH1cbiAqIGBgYFxuICpcbiAqIE1ha2VzIGEgYHsgcHVibGljYXRpb24sIHN1YnNjcmlwdGlvbiB9YCBmb3IgZG9pbmcgbG9zc2xlc3MgZWZmaWNpZW50XG4gKiBkaXN0cmlidXRlZCBwdWIvc3ViLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcmV0dXJucyB7U3Vic2NyaXB0aW9uUmVjb3JkPFQ+fVxuICovXG5jb25zdCBtYWtlU3Vic2NyaXB0aW9uS2l0PSgpPT57XG5jb25zdHtwdWJsaXNoZXIsc3Vic2NyaWJlcn09bWFrZVB1Ymxpc2hLaXQoKTtcblxuLyogVGhlIHB1Ymxpc2gga2l0IHN1YnNjcmliZXIgaXMgcHJlZml4LWxvc3N5LCBzbyBtYWtpbmcgKnRoaXMqIHN1YnNjcmliZXIgY29tcGxldGVseSovXG4vKiBsb3NzbGVzcyBmcm9tIGluaXRpYWxpc2F0aW9uIHJlcXVpcmVzIHBpbm5pbmcgdGhlIGZvcm1lcidzIGhpc3RvcnkuKi9cblxuY29uc3QgcGlubmVkSGlzdG9yeVRvcGljPW1ha2VQaW5uZWRIaXN0b3J5VG9waWMoc3Vic2NyaWJlcik7XG5jb25zdCBzdWJzY3JpcHRpb249bWFrZVN1YnNjcmlwdGlvbihwaW5uZWRIaXN0b3J5VG9waWMpO1xuXG4vKiogQHR5cGUge0l0ZXJhdGlvbk9ic2VydmVyPFQ+fSAqL1xuY29uc3QgcHVibGljYXRpb249RmFyKCdwdWJsaWNhdGlvbicse1xudXBkYXRlU3RhdGU6KG5vbkZpbmFsVmFsdWUpPT5wdWJsaXNoZXIucHVibGlzaChub25GaW5hbFZhbHVlKSxcbmZpbmlzaDooY29tcGxldGlvbik9PnB1Ymxpc2hlci5maW5pc2goY29tcGxldGlvbiksXG5mYWlsOihyZWFzb24pPT5wdWJsaXNoZXIuZmFpbChyZWFzb24pfSk7XG5cblxucmV0dXJuIGhhcmRlbih7cHVibGljYXRpb24sc3Vic2NyaXB0aW9ufSk7XG4gfTskaOKAjV9vbmNlLm1ha2VTdWJzY3JpcHRpb25LaXQobWFrZVN1YnNjcmlwdGlvbktpdCk7XG5oYXJkZW4obWFrZVN1YnNjcmlwdGlvbktpdCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVN1YnNjcmlwdGlvbiI6WyJtYWtlU3Vic2NyaXB0aW9uIl0sIm1ha2VTdWJzY3JpcHRpb25LaXQiOlsibWFrZVN1YnNjcmlwdGlvbktpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAhgRZyDAYAAAwGAAAqAAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3RvcGljLmpzeyJpbXBvcnRzIjpbIi4vdHlwZXMtYW1iaWVudC5qcyIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbIm1ha2VQaW5uZWRIaXN0b3J5VG9waWMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRmFyOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2ZhclwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlcy1hbWJpZW50LmpzXCIsIFtdXV0pOyAgIFxuXG5cblxuXG4vKipcbiAqIEBkZXByZWNhdGVkIEEgcGlubmVkLWhpc3RvcnkgdG9waWMgcHJlc2VydmVzIGFsbCBvZiBpdHMgcHVibGlzaGVkIHZhbHVlcyBpblxuICogbWVtb3J5LiAgVXNlIGEgcHJlZml4LWxvc3N5IG1ha2VQdWJsaXNoS2l0IGluc3RlYWQuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7RWFjaFRvcGljPFQ+ICYgTGF0ZXN0VG9waWM8VD59IHRvcGljIG5lZWRzIHRvIGJlIG5lYXIgaW4gb3JkZXIgdG9cbiAqIHByZXNlcnZlIHN1YnNjcmlwdGlvbiB0aW1pbmdzLiAgVE9ETzogZHJvcCBMYXRlc3RUb3BpYzxUPiByZXF1aXJlbWVudFxuICogQHJldHVybnMge0VhY2hUb3BpYzxUPiAmIExhdGVzdFRvcGljPFQ+fVxuICovXG5jb25zdCAgICAgICAgbWFrZVBpbm5lZEhpc3RvcnlUb3BpYz0odG9waWMpPT57XG4vKiBTdWNoIGxvc3NsZXNzbmVzcyBpbmhpYml0cyBHQywgd2hpY2ggaXMgd2h5IHdlJ3JlIG1vdmluZyBhd2F5IGZyb20gaXQuKi9cblxuLyogV2UgbmVlZCB0byB0YWtlIGFuIGltbWVkaWF0ZSBzbmFwc2hvdCBvZiB0aGUgdG9waWMncyBjdXJyZW50IHN0YXRlLiovXG5jb25zdCBwaW5uZWRQdWJMaXN0PXRvcGljLnN1YnNjcmliZUFmdGVyKCk7XG5cbnJldHVybiBGYXIoJ1Bpbm5lZEhpc3RvcnlUb3BpYycse1xuc3Vic2NyaWJlQWZ0ZXI6YXN5bmMocHVibGlzaENvdW50PS0xbik9PntcbmlmKHB1Ymxpc2hDb3VudD09PS0xbil7XG5yZXR1cm4gcGlubmVkUHViTGlzdDtcbiB9XG5yZXR1cm4gdG9waWMuc3Vic2NyaWJlQWZ0ZXIocHVibGlzaENvdW50KTtcbiB9LFxuZ2V0VXBkYXRlU2luY2U6YXN5bmModXBkYXRlQ291bnQ9dW5kZWZpbmVkKT0+e1xuLyogVE9ETzogQnVpbGQgdGhpcyBvdXQgb2YgRWFjaFRvcGljPFQ+LiovXG5yZXR1cm4gdG9waWMuZ2V0VXBkYXRlU2luY2UodXBkYXRlQ291bnQpO1xuIH19KTtcblxuIH07JGjigI1fb25jZS5tYWtlUGlubmVkSGlzdG9yeVRvcGljKG1ha2VQaW5uZWRIaXN0b3J5VG9waWMpO1xuaGFyZGVuKG1ha2VQaW5uZWRIaXN0b3J5VG9waWMpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VQaW5uZWRIaXN0b3J5VG9waWMiOlsibWFrZVBpbm5lZEhpc3RvcnlUb3BpYyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAD4UQ8TPzAAAD8wAAAyAAAAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3R5cGVzLWFtYmllbnQuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAamVzc2llLWNoZWNrKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL2ZhcicpLkVSZWY8VD59IEVSZWZcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcHJvbWlzZS1raXQnKS5Qcm9taXNlS2l0PFQ+fSBQcm9taXNlS2l0XG4gKi9cblxuLyoqXG4gKiBEZXByZWNhdGVkLiBVc2UgUHJvbWlzZUtpdCBpbnN0ZWFkLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcHJvbWlzZS1raXQnKS5Qcm9taXNlUmVjb3JkPFQ+fSBQcm9taXNlUmVjb3JkXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFtUUmV0dXJuPWFueV1cbiAqIEB0ZW1wbGF0ZSBbVE5leHQ9dW5kZWZpbmVkXVxuICogQHR5cGVkZWYge0FzeW5jSXRlcmF0b3I8VCwgVFJldHVybiwgVE5leHQ+ICYge1xuICogICBmb3JrKCk6IEZvcmthYmxlQXN5bmNJdGVyYXRvcjxULCBUUmV0dXJuLCBUTmV4dD5cbiAqIH19IEZvcmthYmxlQXN5bmNJdGVyYXRvciBBbiBBc3luY0l0ZXJhdG9yIHRoYXQgY2FuIGJlIGZvcmtlZCBhdCBhIGdpdmVuIHBvc2l0aW9uXG4gKiBpbnRvIG11bHRpcGxlIGluZGVwZW5kZW50IEZvcmthYmxlQXN5bmNJdGVyYXRvcnMgc3RhcnRpbmcgZnJvbSB0aGF0IHBvc2l0aW9uLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0ZW1wbGF0ZSBbVFJldHVybj1hbnldXG4gKiBAdGVtcGxhdGUgW1ROZXh0PXVuZGVmaW5lZF1cbiAqIEB0eXBlZGVmIHt7IFtTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKTogQXN5bmNJdGVyYWJsZUl0ZXJhdG9yPFQsIFRSZXR1cm4sIFROZXh0PiB9fSBBc3luY0l0ZXJhYmxlT25seVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0ZW1wbGF0ZSBbVFJldHVybj1hbnldXG4gKiBAdGVtcGxhdGUgW1ROZXh0PXVuZGVmaW5lZF1cbiAqIEB0eXBlZGVmIHt7XG4gKiAgIFtTeW1ib2wuYXN5bmNJdGVyYXRvcl0oKTogRm9ya2FibGVBc3luY0l0ZXJhYmxlSXRlcmF0b3I8VCwgVFJldHVybiwgVE5leHQ+LFxuICogICBmb3JrKCk6IEZvcmthYmxlQXN5bmNJdGVyYWJsZUl0ZXJhdG9yPFQsIFRSZXR1cm4sIFROZXh0PiB9ICZcbiAqICAgRm9ya2FibGVBc3luY0l0ZXJhdG9yPFQsIFRSZXR1cm4sIFROZXh0PlxuICogfSBGb3JrYWJsZUFzeW5jSXRlcmFibGVJdGVyYXRvclxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0ZW1wbGF0ZSBbVFJldHVybj1hbnldXG4gKiBAdGVtcGxhdGUgW1ROZXh0PXVuZGVmaW5lZF1cbiAqIEB0eXBlZGVmIHt7XG4gKiAgIFtTeW1ib2wuYXN5bmNJdGVyYXRvcl06ICgpID0+IEZvcmthYmxlQXN5bmNJdGVyYXRvcjxULCBUUmV0dXJuLCBUTmV4dD5cbiAqIH19IEZvcmthYmxlQXN5bmNJdGVyYWJsZVxuICogQW4gQXN5bmNJdGVyYWJsZSB0aGF0IHByb2R1Y2VzIEZvcmthYmxlQXN5bmNJdGVyYXRvcnMuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gSXRlcmF0aW9uT2JzZXJ2ZXI8VD5cbiAqIEEgdmFsaWQgc2VxdWVuY2Ugb2YgY2FsbHMgdG8gdGhlIG1ldGhvZHMgb2YgYW4gYEl0ZXJhdGlvbk9ic2VydmVyYFxuICogcmVwcmVzZW50cyBhbiBpdGVyYXRpb24uIEEgdmFsaWQgc2VxdWVuY2UgY29uc2lzdHMgb2YgYW55IG51bWJlciBvZiBjYWxsc1xuICogdG8gYHVwZGF0ZVN0YXRlYCB3aXRoIHRoZSBzdWNjZXNzaXZlIG5vbi1maW5hbCB2YWx1ZXMsIGZvbGxvd2VkIGJ5IGFcbiAqIGZpbmFsIGNhbGwgdG8gZWl0aGVyIGBmaW5pc2hgIHdpdGggYSBzdWNjZXNzZnVsIGBjb21wbGV0aW9uYCB2YWx1ZVxuICogb3IgYGZhaWxgIHdpdGggdGhlIGFsbGVnZWQgYHJlYXNvbmAgZm9yIGZhaWx1cmUuIEFmdGVyIGF0IG1vc3Qgb25lXG4gKiB0ZXJtaW5hdGluZyBjYWxscywgbm8gZnVydGhlciBjYWxscyB0byB0aGVzZSBtZXRob2RzIGFyZSB2YWxpZCBhbmQgbXVzdCBiZVxuICogcmVqZWN0ZWQuXG4gKiBAcHJvcGVydHkgeyhub25GaW5hbFZhbHVlOiBUKSA9PiB2b2lkfSB1cGRhdGVTdGF0ZVxuICogQHByb3BlcnR5IHsoY29tcGxldGlvbjogVCkgPT4gdm9pZH0gZmluaXNoXG4gKiBAcHJvcGVydHkgeyhyZWFzb246IHVua25vd24pID0+IHZvaWR9IGZhaWxcbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFB1YmxpY2F0aW9uUmVjb3JkXG4gKiBXaWxsIGJlIHNoYXJlZCBiZXR3ZWVuIG1hY2hpbmVzLCBzbyBpdCBtdXN0IGJlIHNhZmUgdG8gZXhwb3NlLiBCdXQgc29mdHdhcmVcbiAqIG91dHNpZGUgdGhlIGN1cnJlbnQgcGFja2FnZSBzaG91bGQgY29uc2lkZXIgaXQgb3BhcXVlLCBub3QgZGVwZW5kaW5nIG9uIGl0c1xuICogaW50ZXJuYWwgc3RydWN0dXJlLlxuICogQHByb3BlcnR5IHtJdGVyYXRvclJlc3VsdDxUPn0gaGVhZFxuICogQHByb3BlcnR5IHtiaWdpbnR9IHB1Ymxpc2hDb3VudCBzdGFydHMgYXQgMSBmb3IgdGhlIGZpcnN0IHJlc3VsdFxuICogICBhbmQgYWR2YW5jZXMgYnkgMSBmb3IgZWFjaCBzdWJzZXF1ZW50IHJlc3VsdFxuICogQHByb3BlcnR5IHtQcm9taXNlPFB1YmxpY2F0aW9uUmVjb3JkPFQ+Pn0gdGFpbFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVhY2hUb3BpY1xuICogQHByb3BlcnR5IHsocHVibGlzaENvdW50PzogYmlnaW50KSA9PiBQcm9taXNlPFB1YmxpY2F0aW9uUmVjb3JkPFQ+Pn0gc3Vic2NyaWJlQWZ0ZXJcbiAqIFJldHVybnMgYSBwcm9taXNlIGZvciBhIFwiY3VycmVudFwiIFB1YmxpY2F0aW9uUmVjb3JkIChyZWZlcmVuY2luZyBpdHNcbiAqIGltbWVkaWF0ZSBzdWNjZXNzb3IgdmlhIGEgYHRhaWxgIHByb21pc2UpIHRoYXQgaXMgbGF0ZXIgdGhhbiB0aGVcbiAqIHByb3ZpZGVkIHB1Ymxpc2hDb3VudC5cbiAqIFVzZWQgdG8gbWFrZSBmb3J3YXJkLWxvc3NsZXNzIChcImVhY2hcIikgaXRlcmF0b3JzLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtGb3JrYWJsZUFzeW5jSXRlcmFibGU8VCwgVD4gJiBFYWNoVG9waWM8VD59IEl0ZXJhYmxlRWFjaFRvcGljXG4gKiBBbiBFYWNoVG9waWMgd2l0aCBkZWZhdWx0IGFzeW5jSXRlcmFibGUgYmVoYXZpb3VyLlxuICpcbiAqIE5PVEU6IHRoZSBwdWJsaWNhdGlvbiByZWNvcmRzIGFuZCBpdGVyYXRvcnMgcmV0dXJuZWQgYnkgdGhpcyBvYmplY3QgYXJlXG4gKiBlcGhlbWVyYWwgYW5kIHdpbGwgYmUgc2V2ZXJlZCBkdXJpbmcgdXBncmFkZS4gIEEgY2FsbGVyIHNob3VsZCB1c2VcbiAqIGBzdWJzY3JpYmVFYWNoYCB0byB3cmFwIHRoaXMgdG9waWMgaW4gYSBsb2NhbCBpdGVyYWJsZSB3aGljaCBhdXRvbWF0aWNhbGx5XG4gKiBhdHRlbXB0cyB0byByZWNvbm5lY3QgdXBvbiBiZWluZyBzZXZlcmVkLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtBc3luY0l0ZXJhYmxlT25seTxULCBUPiAmIExhdGVzdFRvcGljPFQ+fSBJdGVyYWJsZUxhdGVzdFRvcGljXG4gKiBBIExhdGVzdFRvcGljIHdpdGggZGVmYXVsdCBhc3luY0l0ZXJhYmxlIGJlaGF2aW91ci5cbiAqXG4gKiBOT1RFOiB0aGUgaXRlcmF0b3JzIHJldHVybmVkIGJ5IHRoaXMgb2JqZWN0IGFyZSBlcGhlbWVyYWwgYW5kIHdpbGwgYmUgc2V2ZXJlZFxuICogZHVyaW5nIHVwZ3JhZGUuICBBIGNhbGxlciBzaG91bGQgdXNlIGBzdWJzY3JpYmVMYXRlc3RgIHRvIHdyYXAgdGhpcyB0b3BpYyBpblxuICogYSBsb2NhbCBpdGVyYWJsZSB3aGljaCBhdXRvbWF0aWNhbGx5IGF0dGVtcHRzIHRvIHJlY29ubmVjdCB1cG9uIGJlaW5nXG4gKiBzZXZlcmVkLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IExhdGVzdFRvcGljXG4gKiBAcHJvcGVydHkgeyh1cGRhdGVDb3VudD86IGJpZ2ludCB8IG51bWJlcikgPT4gUHJvbWlzZTxVcGRhdGVSZWNvcmQ8VD4+fSBnZXRVcGRhdGVTaW5jZVxuICogUmV0dXJucyBhIHByb21pc2UgZm9yIGFuIHVwZGF0ZSByZWNvcmQgYXMgb2YgYW4gdXBkYXRlIGNvdW50LlxuICogSWYgdGhlIGB1cGRhdGVDb3VudGAgYXJndW1lbnQgaXMgb21pdHRlZCBvciBkaWZmZXJzIGZyb20gdGhlIGN1cnJlbnQgdXBkYXRlIGNvdW50LFxuICogdGhlIHByb21pc2UgcHJvbXB0bHkgcmVzb2x2ZXMgdG8gdGhlIGN1cnJlbnQgcmVjb3JkLlxuICogT3RoZXJ3aXNlLCBhZnRlciB0aGUgbmV4dCBzdGF0ZSBjaGFuZ2UsIHRoZSBwcm9taXNlIHJlc29sdmVzIHRvIHRoZSByZXN1bHRpbmcgcmVjb3JkLlxuICogVGhpcyBpcyBhbiBhdHRlbnVhdGVkIGZvcm0gb2YgYHN1YnNjcmliZUFmdGVyYCB3aG9zZSByZXR1cm4gdmFsdWUgc3RhbmRzIGFsb25lIGFuZFxuICogZG9lcyBub3QgYWxsb3cgY29uc3VtZXJzIHRvIHBpbiBhIGNoYWluIG9mIGhpc3RvcmljYWwgUHVibGljYXRpb25SZWNvcmRzLlxuICogVXNlZCB0byBtYWtlIGxvc3N5IChcImxhdGVzdFwiKSBpdGVyYXRvcnMuXG4gKiBOT1RFOiBVc2Ugb2YgYG51bWJlcmAgYXMgYW4gYHVwZGF0ZUNvdW50YCBpcyBkZXByZWNhdGVkLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtMYXRlc3RUb3BpYzxUPn0gQmFzZU5vdGlmaWVyIFRoaXMgdHlwZSBpcyBkZXByZWNhdGVkIGJ1dCBpcyBzdGlsbFxuICogdXNlZCBleHRlcm5hbGx5LlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtMYXRlc3RUb3BpYzxUPiAmIEVhY2hUb3BpYzxUPn0gU3Vic2NyaWJlclxuICogQSBzdHJlYW0gb2YgcmVzdWx0cyB0aGF0IGFsbG93cyBjb25zdW1lcnMgdG8gY29uZmlndXJlXG4gKiBmb3J3YXJkLWxvc3NsZXNzIFwiZWFjaFwiIGl0ZXJhdGlvbiB3aXRoIGBzdWJzY3JpYmVFYWNoYCBhbmRcbiAqIGxvc3N5IFwibGF0ZXN0XCIgaXRlcmF0aW9uIHdpdGggYHN1YnNjcmliZUxhdGVzdGAuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gUHVibGlzaGVyXG4gKiBBIHZhbGlkIHNlcXVlbmNlIG9mIGNhbGxzIHRvIHRoZSBtZXRob2RzIG9mIGFuIGBJdGVyYXRpb25PYnNlcnZlcmBcbiAqIHJlcHJlc2VudHMgYW4gaXRlcmF0aW9uLiBBIHZhbGlkIHNlcXVlbmNlIGNvbnNpc3RzIG9mIGFueSBudW1iZXIgb2YgY2FsbHNcbiAqIHRvIGBwdWJsaXNoYCB3aXRoIHRoZSBzdWNjZXNzaXZlIG5vbi1maW5hbCB2YWx1ZXMsIGZvbGxvd2VkIGJ5IGFcbiAqIGZpbmFsIGNhbGwgdG8gZWl0aGVyIGBmaW5pc2hgIHdpdGggYSBzdWNjZXNzZnVsIGBjb21wbGV0aW9uYCB2YWx1ZVxuICogb3IgYGZhaWxgIHdpdGggdGhlIGFsbGVnZWQgYHJlYXNvbmAgZm9yIGZhaWx1cmUuIEFmdGVyIGF0IG1vc3Qgb25lXG4gKiB0ZXJtaW5hdGluZyBjYWxscywgbm8gZnVydGhlciBjYWxscyB0byB0aGVzZSBtZXRob2RzIGFyZSB2YWxpZCBhbmQgbXVzdCBiZVxuICogcmVqZWN0ZWQuXG4gKiBAcHJvcGVydHkgeyhub25GaW5hbFZhbHVlOiBUKSA9PiB2b2lkfSBwdWJsaXNoXG4gKiBAcHJvcGVydHkgeyhjb21wbGV0aW9uOiBUKSA9PiB2b2lkfSBmaW5pc2hcbiAqIEBwcm9wZXJ0eSB7KHJlYXNvbjogYW55KSA9PiB2b2lkfSBmYWlsXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1BhcnRpYWw8UHVibGlzaGVyPFQ+Pn0gUHVibGlzaE9ic2VydmVyXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gUHVibGlzaEtpdDxUPlxuICogQHByb3BlcnR5IHtQdWJsaXNoZXI8VD59IHB1Ymxpc2hlclxuICogQHByb3BlcnR5IHtTdWJzY3JpYmVyPFQ+fSBzdWJzY3JpYmVyXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gU3RvcmVkUHVibGlzaEtpdDxUPlxuICogQHByb3BlcnR5IHtQdWJsaXNoZXI8VD59IHB1Ymxpc2hlclxuICogQHByb3BlcnR5IHtTdG9yZWRTdWJzY3JpYmVyPFQ+fSBzdWJzY3JpYmVyXG4gKi9cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsnbWFuZGF0b3J5JyB8ICdvcHBvcnR1bmlzdGljJyB8ICdpZ25vcmVkJ30gRHVyYWJsZVB1Ymxpc2hLaXRWYWx1ZUR1cmFiaWxpdHlcbiAqXG4gKiBEdXJhYmlsaXR5IGNvbmZpZ3VyZXMgY29uc3RyYWludHMgb24gbm9uLXRlcm1pbmFsIHZhbHVlcyB0aGF0IGNhbiBiZVxuICogcHVibGlzaGVkIHRvIGEgZHVyYWJsZSBwdWJsaXNoIGtpdCAodGVybWluYWwgdmFsdWVzIHNlbnQgdG8gZmluaXNoIG9yIGZhaWxcbiAqIG11c3QgYWx3YXlzIGJlIGR1cmFibGUpLlxuICogLSAnbWFuZGF0b3J5JyBtZWFucyB0aGF0IGVhY2ggdmFsdWUgbXVzdCBiZSBkdXJhYmxlLCBzbyBpdCBjYW4gYmUgcmVzdG9yZWRcbiAqICAgb24gdXBncmFkZS5cbiAqIC0gJ29wcG9ydHVuaXN0aWMnIG1lYW5zIHRoYXQgYSBkdXJhYmxlIHZhbHVlIGlzIHBlcnNpc3RlZCBmb3IgcG9zdC11cGdyYWRlXG4gKiAgIHJlc3RvcmF0aW9uLCBidXQgYSBub24tZHVyYWJsZSB2YWx1ZSBpcyBzdGlsbCBhY2NlcHRlZCAoYW5kIHdpbGwgcmVzdWx0IGluXG4gKiAgIHZhbHVlbGVzcyByZXN0b3JhdGlvbikuXG4gKiAtICdpZ25vcmVkJyBtZWFucyB0aGF0IGEgdmFsdWUgaXMgbm90IHBlcnNpc3RlZCBmb3IgcmVzdG9yYXRpb24gZXZlbiBpZiBpdFxuICogICBpcyBkdXJhYmxlLlxuICpcbiAqICdtYW5kYXRvcnknIGlzIHRoZSBvbmx5IGN1cnJlbnRseS1zdXBwb3J0ZWQgdmFsdWUsIGFuZCBvdGhlcnMgbXVzdCBub3QgYmVcbiAqIGVuYWJsZWQgd2l0aG91dCB0ZXN0IGNvdmVyYWdlLlxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRHVyYWJsZVB1Ymxpc2hLaXRTdGF0ZVxuICpcbiAqIEBwcm9wZXJ0eSB7RHVyYWJsZVB1Ymxpc2hLaXRWYWx1ZUR1cmFiaWxpdHl9IHZhbHVlRHVyYWJpbGl0eVxuICpcbiAqIEBwcm9wZXJ0eSB7YmlnaW50fSBwdWJsaXNoQ291bnRcbiAqXG4gKiBAcHJvcGVydHkgeydsaXZlJyB8ICdmaW5pc2hlZCcgfCAnZmFpbGVkJ30gc3RhdHVzXG4gKlxuICogQHByb3BlcnR5IHtib29sZWFufSBoYXNWYWx1ZVxuICogaGFzVmFsdWUgaW5kaWNhdGVzIHRoZSBwcmVzZW5jZSBvZiB2YWx1ZS4gSXQgc3RhcnRzIG9mZiBmYWxzZSxcbiAqIGFuZCBjYW4gYmUgcmVzZXQgdG8gZmFsc2Ugd2hlbiBhIGR1cmFibGUgcHVibGlzaCBraXQgaXMgcmVzdG9yZWQgYW5kXG4gKiB0aGUgcHJldmlvdXMgdmFsdWUgd2FzIG5vdCBkdXJhYmxlLCBvciBub24tdGVybWluYWwgYW5kIHZhbHVlRHVyYWJsaXR5IGlzICdpZ25vcmVkJy5cbiAqXG4gKiBAcHJvcGVydHkge2FueX0gdmFsdWVcbiAqIHZhbHVlIGhvbGRzIGVpdGhlciBhIG5vbi10ZXJtaW5hbCB2YWx1ZSBmcm9tIGBwdWJsaXNoYCBvciBhIHRlcm1pbmFsIHZhbHVlXG4gKiBmcm9tIGBmaW5pc2hgIG9yIGBmYWlsYCwgZGVwZW5kaW5nIHVwb24gdGhlIHZhbHVlIGluIHN0YXR1cy5cbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFVwZGF0ZVJlY29yZDxUPlxuICogQHByb3BlcnR5IHtUfSB2YWx1ZSBpcyB3aGF0ZXZlciBzdGF0ZSB0aGUgc2VydmljZSB3YW50cyB0byBwdWJsaXNoXG4gKiBAcHJvcGVydHkge2JpZ2ludH0gW3VwZGF0ZUNvdW50XSBpcyBhIHZhbHVlIHRoYXQgaWRlbnRpZmllcyB0aGUgdXBkYXRlLiAgRm9yXG4gKiB0aGUgbGFzdCB1cGRhdGUsIGl0IGlzIGB1bmRlZmluZWRgLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtCYXNlTm90aWZpZXI8VD59IE5vdGlmaWVySW50ZXJuYWxzIFdpbGwgYmUgc2hhcmVkIGJldHdlZW4gbWFjaGluZXMsXG4gKiBzbyBpdCBtdXN0IGJlIHNhZmUgdG8gZXhwb3NlLiBCdXQgb3RoZXIgc29mdHdhcmUgc2hvdWxkIGF2b2lkIGRlcGVuZGluZyBvblxuICogaXRzIGludGVybmFsIHN0cnVjdHVyZS5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7Tm90aWZpZXJJbnRlcm5hbHM8VD4gJlxuICogICBGb3JrYWJsZUFzeW5jSXRlcmFibGU8VCwgVD4gJlxuICogICBTaGFyYWJsZU5vdGlmaWVyPFQ+XG4gKiB9IE5vdGlmaWVyPFQ+IGFuIG9iamVjdCB0aGF0IGNhbiBiZSB1c2VkIHRvIGdldCB0aGUgY3VycmVudCBzdGF0ZSBvciB1cGRhdGVzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gU2hhcmFibGVOb3RpZmllclxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPE5vdGlmaWVySW50ZXJuYWxzPFQ+Pn0gZ2V0U2hhcmFibGVOb3RpZmllckludGVybmFsc1xuICogVXNlZCB0byByZXBsaWNhdGUgdGhlIG11bHRpY2FzdCB2YWx1ZXMgYXQgb3RoZXIgc2l0ZXMuIFRvIG1hbnVhbGx5IGNyZWF0ZSBhXG4gKiBsb2NhbCByZXByZXNlbnRhdGl2ZSBvZiBhIE5vdGlmaWNhdGlvbiwgZG9cbiAqIGBgYGpzXG4gKiBsb2NhbEl0ZXJhYmxlID1cbiAqICAgbWFrZU5vdGlmaWVyKEUocmVtb3RlSXRlcmFibGUpLmdldFNoYXJhYmxlTm90aWZpZXJJbnRlcm5hbHMoKSk7XG4gKiBgYGBcbiAqIFRoZSByZXN1bHRpbmcgYGxvY2FsSXRlcmFibGVgIGFsc28gc3VwcG9ydHMgc3VjaCByZW1vdGUgdXNlLCBhbmRcbiAqIHdpbGwgcmV0dXJuIGFjY2VzcyB0byB0aGUgc2FtZSByZXByZXNlbnRhdGlvbi5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBOb3RpZmllclJlY29yZDxUPiB0aGUgcHJvZHVjZWQgbm90aWZpZXIvdXBkYXRlciBwYWlyXG4gKiBAcHJvcGVydHkge0l0ZXJhdGlvbk9ic2VydmVyPFQ+fSB1cGRhdGVyIHRoZSAoY2xvc2VseS1oZWxkKSBub3RpZmllciBwcm9kdWNlclxuICogQHByb3BlcnR5IHtOb3RpZmllcjxUPn0gbm90aWZpZXIgdGhlICh3aWRlbHktaGVsZCkgbm90aWZpZXIgY29uc3VtZXJcbiAqL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtJdGVyYWJsZUVhY2hUb3BpYzxUPiAmIEVhY2hUb3BpYzxUPiAmXG4gKiAgIFNoYXJhYmxlU3Vic2NyaXB0aW9uPFQ+fSBTdWJzY3JpcHRpb248VD5cbiAqIEEgZm9ybSBvZiBBc3luY0l0ZXJhYmxlIHN1cHBvcnRpbmcgZGlzdHJpYnV0ZWQgYW5kIG11bHRpY2FzdCB1c2FnZS5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTaGFyYWJsZVN1YnNjcmlwdGlvblxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEVhY2hUb3BpYzxUPj59IGdldFNoYXJhYmxlU3Vic2NyaXB0aW9uSW50ZXJuYWxzXG4gKiBVc2VkIHRvIHJlcGxpY2F0ZSB0aGUgbXVsdGljYXN0IHZhbHVlcyBhdCBvdGhlciBzaXRlcy4gVG8gbWFudWFsbHkgY3JlYXRlIGFcbiAqIGxvY2FsIHJlcHJlc2VudGF0aXZlIG9mIGEgU3Vic2NyaXB0aW9uLCBkb1xuICogYGBganNcbiAqIGxvY2FsSXRlcmFibGUgPVxuICogICBtYWtlU3Vic2NyaXB0aW9uKEUocmVtb3RlSXRlcmFibGUpLmdldFNoYXJhYmxlU3Vic2NyaXB0aW9uSW50ZXJuYWxzKCkpO1xuICogYGBgXG4gKiBUaGUgcmVzdWx0aW5nIGBsb2NhbEl0ZXJhYmxlYCBhbHNvIHN1cHBvcnRzIHN1Y2ggcmVtb3RlIHVzZSwgYW5kXG4gKiB3aWxsIHJldHVybiBhY2Nlc3MgdG8gdGhlIHNhbWUgcmVwcmVzZW50YXRpb24uXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge29iamVjdH0gU3Vic2NyaXB0aW9uUmVjb3JkPFQ+XG4gKiBAcHJvcGVydHkge0l0ZXJhdGlvbk9ic2VydmVyPFQ+fSBwdWJsaWNhdGlvblxuICogQHByb3BlcnR5IHtTdWJzY3JpcHRpb248VD59IHN1YnNjcmlwdGlvblxuICovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqIEB0ZW1wbGF0ZSBbU2xvdD11bmtub3duXSBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLk1hcnNoYWw8U2xvdD59IE1hcnNoYWxsZXIgKi9cbi8qKiBAdHlwZWRlZiB7UGljazxNYXJzaGFsbGVyLCAnZnJvbUNhcERhdGEnPn0gVW5zZXJpYWxpemVyICovXG5cbi8qKlxuICogRGVmaW5lZCBieSB2c3RvcmFnZVN0b3JlS2V5IGluIHZzdG9yYWdlLmdvXG4gKlxuICogQHR5cGVkZWYgVlN0b3JhZ2VLZXlcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBzdG9yZU5hbWVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBzdG9yZVN1YmtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IGRhdGFQcmVmaXhCeXRlc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IFtub0RhdGFWYWx1ZV1cbiAqL1xuXG4vKipcbiAqIFRoaXMgcmVwcmVzZW50cyBhIG5vZGUgaW4gYW4gSUFWTCB0cmVlLlxuICpcbiAqIFRoZSBhY3RpdmUgaW1wbGVtZW50YXRpb24gaXMgeC92c3RvcmFnZSwgYW4gQWdvcmljIGV4dGVuc2lvbiBvZiB0aGUgQ29zbW9zIFNESy5cbiAqXG4gKiBWc3RvcmFnZSBpcyBhIGhpZXJhcmNoaWNhbCBleHRlcm5hbGx5LXJlYWNoYWJsZSBzdG9yYWdlIHN0cnVjdHVyZSB0aGF0XG4gKiBpZGVudGlmaWVzIGNoaWxkcmVuIGJ5IHJlc3RyaWN0ZWQgQVNDSUkgbmFtZSBhbmQgaXMgYXNzb2NpYXRlZCB3aXRoIGFyYml0cmFyeVxuICogc3RyaW5nLXZhbHVlZCBkYXRhIGZvciBlYWNoIG5vZGUsIGRlZmF1bHRpbmcgdG8gdGhlIGVtcHR5IHN0cmluZy5cbiAqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yYWdlTm9kZVxuICogQHByb3BlcnR5IHsoZGF0YTogc3RyaW5nKSA9PiBQcm9taXNlPHZvaWQ+fSBzZXRWYWx1ZSBwdWJsaXNoZXMgc29tZSBkYXRhIChhcHBlbmQgdG8gdGhlIG5vZGUpXG4gKiBAcHJvcGVydHkgeygpID0+IHN0cmluZ30gZ2V0UGF0aCB0aGUgY2hhaW4gc3RvcmFnZSBwYXRoIGF0IHdoaWNoIHRoZSBub2RlIHdhcyBjb25zdHJ1Y3RlZFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPFZTdG9yYWdlS2V5Pn0gZ2V0U3RvcmVLZXkgREVQUkVDQVRFRCB1c2UgZ2V0UGF0aFxuICogQHByb3BlcnR5IHsoc3ViUGF0aDogc3RyaW5nLCBvcHRpb25zPzoge3NlcXVlbmNlPzogYm9vbGVhbn0pID0+IFN0b3JhZ2VOb2RlfSBtYWtlQ2hpbGROb2RlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yZWRGYWNldFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPHN0cmluZz59IGdldFBhdGggdGhlIGNoYWluIHN0b3JhZ2UgcGF0aCBhdCB3aGljaCB0aGUgbm9kZSB3YXMgY29uc3RydWN0ZWRcbiAqIEBwcm9wZXJ0eSB7U3RvcmFnZU5vZGVbJ2dldFN0b3JlS2V5J119IGdldFN0b3JlS2V5IERFUFJFQ0FURUQgdXNlIGdldFBhdGhcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gVW5zZXJpYWxpemVyfSBnZXRVbnNlcmlhbGl6ZXIgZ2V0IHRoZSB1bnNlcmlhbGl6ZXIgZm9yIHRoZSBzdG9yZWQgZGF0YVxuICovXG5cbi8qKlxuICogQGRlcHJlY2F0ZWQgdXNlIFN0b3JlZFN1YnNjcmliZXJcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7U3Vic2NyaXB0aW9uPFQ+ICYge1xuICogICBnZXRTdG9yZUtleTogKCkgPT4gUHJvbWlzZTxWU3RvcmFnZUtleSAmIHsgc3Vic2NyaXB0aW9uOiBTdWJzY3JpcHRpb248VD4gfT4sXG4gKiAgIGdldFVuc2VyaWFsaXplcjogKCkgPT4gVW5zZXJpYWxpemVyLFxuICogfX0gU3RvcmVkU3Vic2NyaXB0aW9uXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge1N1YnNjcmliZXI8VD4gJiBTdG9yZWRGYWNldH0gU3RvcmVkU3Vic2NyaWJlclxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAANhcAn32BgAA9gYAADMAAABAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC90b29scy90ZXN0U3VwcG9ydHMuanN7ImltcG9ydHMiOlsiLi4vc3JjL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL2ludGVybmFsL3NyYy90ZXN0aW5nLXV0aWxzLmpzIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbIm1ha2VGYWtlTWFyc2hhbGxlciIsIm1ha2VGYWtlU3RvcmFnZSIsbnVsbF0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhcixtYWtlTWFyc2hhbDskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV0sW1wibWFrZU1hcnNoYWxcIiwgWyRo4oCNX2EgPT4gKG1ha2VNYXJzaGFsID0gJGjigI1fYSldXV1dLFtcIi4uL3NyYy90eXBlcy1hbWJpZW50LmpzXCIsIFtdXSxbXCJAYWdvcmljL2ludGVybmFsL3NyYy90ZXN0aW5nLXV0aWxzLmpzXCIsIFtdXV0pOyAgIFxuXG5cblxuXG5cblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gcGF0aFxuICogQHBhcmFtIHtJdGVyYXRpb25PYnNlcnZlcjx1bmtub3duPn0gW3B1YmxpY2F0aW9uXVxuICovXG5jb25zdCAgICAgICAgbWFrZUZha2VTdG9yYWdlPShwYXRoLHB1YmxpY2F0aW9uKT0+e1xubGV0IHNldFZhbHVlQ2FsbHM9MDtcbmNvbnN0IGZ1bGxQYXRoPSBgcHVibGlzaC4ke3BhdGh9YDtcbmNvbnN0IHN0b3JlS2V5PWhhcmRlbih7XG5zdG9yZU5hbWU6J3N3aW5nc2V0JyxcbnN0b3JlU3Via2V5OiBgc3dpbmdzZXQvZGF0YToke2Z1bGxQYXRofWAsXG5kYXRhUHJlZml4Qnl0ZXM6Jyd9KTtcblxuLyoqIEB0eXBlIHtTdG9yYWdlTm9kZSAmIHsgY291bnRTZXRWYWx1ZUNhbGxzOiAoKSA9PiBudW1iZXJ9fSAqL1xuY29uc3Qgc3RvcmFnZT1GYXIoJ1N0b3JhZ2VOb2RlJyx7XG5nZXRQYXRoOigpPT5wYXRoLFxuZ2V0U3RvcmVLZXk6YXN5bmMoKT0+c3RvcmVLZXksXG5zZXRWYWx1ZTphc3luYyh2YWx1ZSk9PntcbnNldFZhbHVlQ2FsbHMrPTE7XG5hc3NlcnQudHlwZW9mKHZhbHVlLCdzdHJpbmcnKTtcbmlmKHB1YmxpY2F0aW9uKXtcbnB1YmxpY2F0aW9uLnVwZGF0ZVN0YXRlKHZhbHVlKTtcbiB9XG4gfSxcbm1ha2VDaGlsZE5vZGU6KCk9PnN0b3JhZ2UsXG5jb3VudFNldFZhbHVlQ2FsbHM6KCk9PnNldFZhbHVlQ2FsbHN9KTtcblxucmV0dXJuIHN0b3JhZ2U7XG4gfTskaOKAjV9vbmNlLm1ha2VGYWtlU3RvcmFnZShtYWtlRmFrZVN0b3JhZ2UpO1xuaGFyZGVuKG1ha2VGYWtlU3RvcmFnZSk7XG5cbmNvbnN0ICAgICAgICBtYWtlRmFrZU1hcnNoYWxsZXI9KCk9PlxubWFrZU1hcnNoYWwodW5kZWZpbmVkLHVuZGVmaW5lZCx7XG5tYXJzaGFsU2F2ZUVycm9yOigpPT57IH19KTskaOKAjV9vbmNlLm1ha2VGYWtlTWFyc2hhbGxlcihtYWtlRmFrZU1hcnNoYWxsZXIpO1xuXG5oYXJkZW4obWFrZUZha2VNYXJzaGFsbGVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyJAYWdvcmljL2ludGVybmFsL3NyYy90ZXN0aW5nLXV0aWxzLmpzIjpbWyJldmVudExvb3BJdGVyYXRpb24iLCJldmVudExvb3BJdGVyYXRpb24iXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZUZha2VTdG9yYWdlIjpbIm1ha2VGYWtlU3RvcmFnZSJdLCJtYWtlRmFrZU1hcnNoYWxsZXIiOlsibWFrZUZha2VNYXJzaGFsbGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAD5iXDZcAQAAXAEAACYAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9leHBvcnRlZC5qc3siaW1wb3J0cyI6WyIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAaoCo79wLAADcCwAAJwAAAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6WyIuL2xlZ2FjeS9sZWdhY3lNYXAuanMiLCIuL2xlZ2FjeS9sZWdhY3lXZWFrTWFwLmpzIiwiLi9zdG9yZXMvc2NhbGFyTWFwU3RvcmUuanMiLCIuL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qcyIsIi4vc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qcyIsIi4vc3RvcmVzL3NjYWxhcldlYWtTZXRTdG9yZS5qcyIsIi4vc3RvcmVzL3N0b3JlLXV0aWxzLmpzIiwiQGVuZG8vZXhvIiwiQGVuZG8vcGF0dGVybnMiXSwiZXhwb3J0cyI6WyJhc3NlcnRLZXkiLCJhc3NlcnRLZXkiLCJkZWZpbmVFeG9DbGFzcyIsImRlZmluZUV4b0NsYXNzIixudWxsLG51bGwsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9wYXR0ZXJuc1wiLCBbXV0sW1wiQGVuZG8vZXhvXCIsIFtdXSxbXCIuL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanNcIiwgW11dLFtcIi4vc3RvcmVzL3NjYWxhclNldFN0b3JlLmpzXCIsIFtdXSxbXCIuL3N0b3Jlcy9zY2FsYXJXZWFrTWFwU3RvcmUuanNcIiwgW11dLFtcIi4vc3RvcmVzL3NjYWxhck1hcFN0b3JlLmpzXCIsIFtdXSxbXCIuL3N0b3Jlcy9zdG9yZS11dGlscy5qc1wiLCBbXV0sW1wiLi9sZWdhY3kvbGVnYWN5TWFwLmpzXCIsIFtdXSxbXCIuL2xlZ2FjeS9sZWdhY3lXZWFrTWFwLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7IkBlbmRvL3BhdHRlcm5zIjpbWyJpc0tleSIsImlzS2V5Il0sWyJhc3NlcnRLZXkiLCJhc3NlcnRLZXkiXSxbImFzc2VydFNjYWxhcktleSIsImFzc2VydFNjYWxhcktleSJdLFsibWFrZUNvcHlTZXQiLCJtYWtlQ29weVNldCJdLFsiZ2V0Q29weVNldEtleXMiLCJnZXRDb3B5U2V0S2V5cyJdLFsibWFrZUNvcHlCYWciLCJtYWtlQ29weUJhZyJdLFsibWFrZUNvcHlCYWdGcm9tRWxlbWVudHMiLCJtYWtlQ29weUJhZ0Zyb21FbGVtZW50cyJdLFsiZ2V0Q29weUJhZ0VudHJpZXMiLCJnZXRDb3B5QmFnRW50cmllcyJdLFsibWFrZUNvcHlNYXAiLCJtYWtlQ29weU1hcCJdLFsiZ2V0Q29weU1hcEVudHJpZXMiLCJnZXRDb3B5TWFwRW50cmllcyJdLFsiY29lcmNlVG9FbGVtZW50cyIsImNvZXJjZVRvRWxlbWVudHMiXSxbImNvZXJjZVRvQmFnRW50cmllcyIsImNvZXJjZVRvQmFnRW50cmllcyJdLFsiY29tcGFyZUtleXMiLCJjb21wYXJlS2V5cyJdLFsia2V5TFQiLCJrZXlMVCJdLFsia2V5TFRFIiwia2V5TFRFIl0sWyJrZXlFUSIsImtleUVRIl0sWyJrZXlHVEUiLCJrZXlHVEUiXSxbImtleUdUIiwia2V5R1QiXSxbImVsZW1lbnRzSXNTdXBlcnNldCIsImVsZW1lbnRzSXNTdXBlcnNldCJdLFsiZWxlbWVudHNJc0Rpc2pvaW50IiwiZWxlbWVudHNJc0Rpc2pvaW50Il0sWyJlbGVtZW50c0NvbXBhcmUiLCJlbGVtZW50c0NvbXBhcmUiXSxbImVsZW1lbnRzVW5pb24iLCJlbGVtZW50c1VuaW9uIl0sWyJlbGVtZW50c0Rpc2pvaW50VW5pb24iLCJlbGVtZW50c0Rpc2pvaW50VW5pb24iXSxbImVsZW1lbnRzSW50ZXJzZWN0aW9uIiwiZWxlbWVudHNJbnRlcnNlY3Rpb24iXSxbImVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCIsImVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCJdLFsic2V0SXNTdXBlcnNldCIsInNldElzU3VwZXJzZXQiXSxbInNldElzRGlzam9pbnQiLCJzZXRJc0Rpc2pvaW50Il0sWyJzZXRDb21wYXJlIiwic2V0Q29tcGFyZSJdLFsic2V0VW5pb24iLCJzZXRVbmlvbiJdLFsic2V0RGlzam9pbnRVbmlvbiIsInNldERpc2pvaW50VW5pb24iXSxbInNldEludGVyc2VjdGlvbiIsInNldEludGVyc2VjdGlvbiJdLFsic2V0RGlzam9pbnRTdWJ0cmFjdCIsInNldERpc2pvaW50U3VidHJhY3QiXSxbImJhZ0lzU3VwZXJiYWciLCJiYWdJc1N1cGVyYmFnIl0sWyJiYWdDb21wYXJlIiwiYmFnQ29tcGFyZSJdLFsiYmFnVW5pb24iLCJiYWdVbmlvbiJdLFsiYmFnSW50ZXJzZWN0aW9uIiwiYmFnSW50ZXJzZWN0aW9uIl0sWyJiYWdEaXNqb2ludFN1YnRyYWN0IiwiYmFnRGlzam9pbnRTdWJ0cmFjdCJdLFsiTSIsIk0iXSxbImdldFJhbmtDb3ZlciIsImdldFJhbmtDb3ZlciJdLFsiaXNQYXR0ZXJuIiwiaXNQYXR0ZXJuIl0sWyJhc3NlcnRQYXR0ZXJuIiwiYXNzZXJ0UGF0dGVybiJdLFsibWF0Y2hlcyIsIm1hdGNoZXMiXSxbIm11c3RNYXRjaCIsIm11c3RNYXRjaCJdXSwiQGVuZG8vZXhvIjpbWyJpbml0RW1wdHkiLCJpbml0RW1wdHkiXSxbImRlZmluZUV4b0NsYXNzIiwiZGVmaW5lRXhvQ2xhc3MiXSxbImRlZmluZUV4b0NsYXNzS2l0IiwiZGVmaW5lRXhvQ2xhc3NLaXQiXSxbIm1ha2VFeG8iLCJtYWtlRXhvIl1dLCIuL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanMiOltbIm1ha2VTY2FsYXJXZWFrU2V0U3RvcmUiLCJtYWtlU2NhbGFyV2Vha1NldFN0b3JlIl1dLCIuL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qcyI6W1sibWFrZVNjYWxhclNldFN0b3JlIiwibWFrZVNjYWxhclNldFN0b3JlIl1dLCIuL3N0b3Jlcy9zY2FsYXJXZWFrTWFwU3RvcmUuanMiOltbIm1ha2VTY2FsYXJXZWFrTWFwU3RvcmUiLCJtYWtlU2NhbGFyV2Vha01hcFN0b3JlIl1dLCIuL3N0b3Jlcy9zY2FsYXJNYXBTdG9yZS5qcyI6W1sibWFrZVNjYWxhck1hcFN0b3JlIiwibWFrZVNjYWxhck1hcFN0b3JlIl1dLCIuL3N0b3Jlcy9zdG9yZS11dGlscy5qcyI6W1sicHJvdmlkZUxhenkiLCJwcm92aWRlTGF6eSJdXSwiLi9sZWdhY3kvbGVnYWN5TWFwLmpzIjpbWyJtYWtlTGVnYWN5TWFwIiwibWFrZUxlZ2FjeU1hcCJdXSwiLi9sZWdhY3kvbGVnYWN5V2Vha01hcC5qcyI6W1sibWFrZUxlZ2FjeVdlYWtNYXAiLCJtYWtlTGVnYWN5V2Vha01hcCJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA4q+AfUYLAABGCwAAMgAAAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy9sZWdhY3kvbGVnYWN5TWFwLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLmpzIiwiQGFnb3JpYy9hc3NlcnQiXSwiZXhwb3J0cyI6WyJtYWtlTGVnYWN5TWFwIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHEsRmFpbDskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2Fzc2VydFwiLCBbW1wicVwiLCBbJGjigI1fYSA9PiAocSA9ICRo4oCNX2EpXV0sW1wiRmFpbFwiLCBbJGjigI1fYSA9PiAoRmFpbCA9ICRo4oCNX2EpXV1dXSxbXCIuLi90eXBlcy5qc1wiLCBbXV1dKTsgICBcblxuXG5cbi8qKlxuICogVGhpcyBtb2R1bGUgYW5kIGl0cyBmcmF0ZXJuYWwgc2libGluZyBsZWdhY3lXZWFrTWFwIGV4aXN0IG9ubHkgdG9cbiAqIGVhc2UgYSB0cmFuc2l0aW9uIHRvIHRoZSBtb2Rlcm4gYHN0b3JlYCBzeXN0ZW0sIGFyZSBkZXByZWNhdGVkLFxuICogYW5kIHdpbGwgZXZlbnR1YWxseSBkaXNhcHBlYXIuIFRoZXkgYXJlIG5lZWRlZCBmb3Igbm93IHRvIHN1cHBvcnRcbiAqIHNvbWUgb2YgdGhlIHVzZXMgb2YgdGhlIG9sZCBiZWhhdmlvciB0aGF0IGFyZSBub3QgY29tcGF0aWJsZSB3aXRoXG4gKiB0aGUgbmV3LiBUaGUgY29uc3RyYWludCBpbXBvc2VkIGJ5IHRoZSBuZXcgaXMgdGhhdCBvbmx5IHBhc3NhYmxlcyBjYW5cbiAqIGJlIHVzZWQgYXMgdmFsdWVzLCBhbmQgb25seSBrZXlzIChyb3VnaGx5LCBzdHJ1Y3R1cmVzLCBha2EgY29tcGFyYWJsZXMpXG4gKiBjYW4gYmUgdXNlZCBhcyB2YWx1ZXMuXG4gKlxuICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9wdWxsLzM1NjdcbiAqIFRPRE8gT25jZSB0aGF0IFBSIGlzIG1lcmdlZCwgbGluayB0byB0aGUgZG9jdW1lbnRzIHJhdGhlciB0aGFuIHRoZSBQUnMuXG4gKlxuICogRWFjaCBvZiB0aGVzZSBub24tY29uZm9ybWluZyB1c2VzIHNob3VsZCBiZSBtYXJrZWQgd2l0aCBhXG4gKiBgYGBqc1xuICogLy8gTGVnYWN5IGJlY2F1c2UuLi5cbiAqIGBgYFxuICogY29tbWVudCBleHBsYWluaW5nIHRoZSBwcm9ibGVtIGluaGliaXRpbmcgY29udmVyc2lvbiB0byB0aGUgbmV3XG4gKiBzeXN0ZW0uIFNvbWUgb2YgdGhlc2UgcHJvYmxlbXMgYXMgb2YgdGhpcyB3cml0aW5nOlxuICogICAgKiBBIHByb21pc2VLaXQgdXNlZCBhcyBhIHZhbHVlLCBldmVuIHRob3VnaCBhIHByb21pc2VLaXQgaXMgbm90XG4gKiAgICAgIGEgcGFzc2FibGUuIFNvbHV0aW9ucyBhcmUgdG8gbWFrZSBpdCBhIHBhc3NhYmxlLCBvciB0byBjb252ZXJ0XG4gKiAgICAgIHRoZSBjb250YWluZXIgYmFjayB0byBhIGNvbnZlbnRpb25hbCBKYXZhU2NyaXB0IE1hcC5cbiAqICAgICogQSBtdXRhYmxlIGFycmF5IHVzZWQgYXMgYSB2YWx1ZSwgdGhhdCBpcyBzdWJzZXF1ZW50bHkgbXV0YXRlZC5cbiAqICAgICAgRnJlZXppbmcgdGhlIGFycmF5IHdvdWxkbid0IHdvcmsgb2YgY291cnNlIGJlY2F1c2UgaXQgd291bGQgYnJlYWtcbiAqICAgICAgdGhlIHN1YnNlcXVlbnQgbXV0YXRpb24uIFVzaW5nIGEgZmFyIG9iamVjdCB3cmFwcGluZyBhbiBhcnJheSB3b3VsZFxuICogICAgICBsaWtlbHkgd29yayBmaW5lLlxuICpcbiAqIEBkZXByZWNhdGVkIHN3aXRjaCB0byBTY2FsYXJNYXAgaWYgcG9zc2libGUsIE1hcCBvdGhlcndpc2VcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEBwYXJhbSB7c3RyaW5nfSBbdGFnPSdrZXknXSAtIHRhZyBmb3IgZGVidWdnaW5nXG4gKiBAcmV0dXJucyB7TGVnYWN5TWFwPEssVj59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlTGVnYWN5TWFwPSh0YWc9J2tleScpPT57XG5jb25zdCBtPW5ldyBNYXAoKTtcbmNvbnN0IGFzc2VydEtleURvZXNOb3RFeGlzdD0oa2V5KT0+XG4hbS5oYXMoa2V5KXx8RmFpbCBgJHtxKHRhZyl9IGFscmVhZHkgcmVnaXN0ZXJlZDogJHtrZXl9YDtcbmNvbnN0IGFzc2VydEtleUV4aXN0cz0oa2V5KT0+XG5tLmhhcyhrZXkpfHxGYWlsIGAke3EodGFnKX0gbm90IGZvdW5kOiAke2tleX1gO1xucmV0dXJuIGhhcmRlbih7XG5oYXM6KGtleSk9Pntcbi8qIENoZWNrIGlmIGEga2V5IGV4aXN0cy4gVGhlIGtleSBjYW4gYmUgYW55IEphdmFTY3JpcHQgdmFsdWUsKi9cbi8qIHRob3VnaCB0aGUgYW5zd2VyIHdpbGwgYWx3YXlzIGJlIGZhbHNlIGZvciBrZXlzIHRoYXQgY2Fubm90IGJlIGZvdW5kKi9cbi8qIGluIHRoaXMgbWFwLiovXG5yZXR1cm4gbS5oYXMoa2V5KTtcbiB9LFxuaW5pdDooa2V5LHZhbHVlKT0+e1xuYXNzZXJ0S2V5RG9lc05vdEV4aXN0KGtleSk7XG5tLnNldChrZXksdmFsdWUpO1xuIH0sXG5nZXQ6KGtleSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xucmV0dXJuIG0uZ2V0KGtleSk7XG4gfSxcbnNldDooa2V5LHZhbHVlKT0+e1xuYXNzZXJ0S2V5RXhpc3RzKGtleSk7XG5tLnNldChrZXksdmFsdWUpO1xuIH0sXG5kZWxldGU6KGtleSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xubS5kZWxldGUoa2V5KTtcbiB9LFxua2V5czooKT0+bS5rZXlzKCksXG52YWx1ZXM6KCk9Pm0udmFsdWVzKCksXG5lbnRyaWVzOigpPT5tLmVudHJpZXMoKSxcbmdldFNpemU6KCk9Pm0uc2l6ZSxcbmNsZWFyOigpPT5tLmNsZWFyKCl9KTtcblxuIH07JGjigI1fb25jZS5tYWtlTGVnYWN5TWFwKG1ha2VMZWdhY3lNYXApO1xuaGFyZGVuKG1ha2VMZWdhY3lNYXApO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VMZWdhY3lNYXAiOlsibWFrZUxlZ2FjeU1hcCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACmg020wgYAAMIGAAA2AAAAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL2xlZ2FjeS9sZWdhY3lXZWFrTWFwLmpzeyJpbXBvcnRzIjpbIi4uL3R5cGVzLmpzIiwiQGFnb3JpYy9hc3NlcnQiXSwiZXhwb3J0cyI6WyJtYWtlTGVnYWN5V2Vha01hcCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBxLEZhaWw7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9hc3NlcnRcIiwgW1tcInFcIiwgWyRo4oCNX2EgPT4gKHEgPSAkaOKAjV9hKV1dLFtcIkZhaWxcIiwgWyRo4oCNX2EgPT4gKEZhaWwgPSAkaOKAjV9hKV1dXV0sW1wiLi4vdHlwZXMuanNcIiwgW11dXSk7ICAgXG5cblxuLyoqXG4gKiBTZWUgZG9jY29tbWVudCBpbiB0aGUgY2xvc2VseSByZWxhdGVkIGBsZWdhY3lNYXAuanNgIG1vZHVsZS5cbiAqXG4gKiBAZGVwcmVjYXRlZCBzd2l0Y2ggdG8gU2NhbGFyV2Vha01hcCBpZiBwb3NzaWJsZSwgV2Vha01hcCBvdGhlcndpc2VcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEBwYXJhbSB7c3RyaW5nfSBbdGFnPSdrZXknXSAtIHRhZyBmb3IgZGVidWdnaW5nXG4gKiBAcmV0dXJucyB7TGVnYWN5V2Vha01hcDxLLFY+fVxuICovXG5jb25zdCAgICAgICAgbWFrZUxlZ2FjeVdlYWtNYXA9KHRhZz0na2V5Jyk9Pntcbi8qKiBAdHlwZSB7V2Vha01hcDxLICYgb2JqZWN0LCBWPn0gKi9cbmNvbnN0IHdtPW5ldyBXZWFrTWFwKCk7XG5jb25zdCBhc3NlcnRLZXlEb2VzTm90RXhpc3Q9KGtleSk9PlxuIXdtLmhhcyhrZXkpfHxGYWlsIGAke3EodGFnKX0gYWxyZWFkeSByZWdpc3RlcmVkOiAke2tleX1gO1xuY29uc3QgYXNzZXJ0S2V5RXhpc3RzPShrZXkpPT5cbndtLmhhcyhrZXkpfHxGYWlsIGAke3EodGFnKX0gbm90IGZvdW5kOiAke2tleX1gO1xucmV0dXJuIGhhcmRlbih7XG5oYXM6KGtleSk9Pntcbi8qIENoZWNrIGlmIGEga2V5IGV4aXN0cy4gVGhlIGtleSBjYW4gYmUgYW55IEphdmFTY3JpcHQgdmFsdWUsKi9cbi8qIHRob3VnaCB0aGUgYW5zd2VyIHdpbGwgYWx3YXlzIGJlIGZhbHNlIGZvciBrZXlzIHRoYXQgY2Fubm90IGJlIGZvdW5kKi9cbi8qIGluIHRoaXMgbWFwLiovXG5yZXR1cm4gd20uaGFzKGtleSk7XG4gfSxcbmluaXQ6KGtleSx2YWx1ZSk9PntcbmFzc2VydEtleURvZXNOb3RFeGlzdChrZXkpO1xud20uc2V0KGtleSx2YWx1ZSk7XG4gfSxcbmdldDooa2V5KT0+e1xuYXNzZXJ0S2V5RXhpc3RzKGtleSk7XG4vKiBIb3cgdG8gdGVsbCB0eXBlc2NyaXB0IEkgYmVsaWV2ZSB0aGUgYGdldGAgd2lsbCBzdWNjZWVkLiovXG5yZXR1cm4gKC8qKiBAdHlwZSB7Vn0gKi93bS5nZXQoa2V5KSk7XG4gfSxcbnNldDooa2V5LHZhbHVlKT0+e1xuYXNzZXJ0S2V5RXhpc3RzKGtleSk7XG53bS5zZXQoa2V5LHZhbHVlKTtcbiB9LFxuZGVsZXRlOihrZXkpPT57XG5hc3NlcnRLZXlFeGlzdHMoa2V5KTtcbndtLmRlbGV0ZShrZXkpO1xuIH19KTtcblxuIH07JGjigI1fb25jZS5tYWtlTGVnYWN5V2Vha01hcChtYWtlTGVnYWN5V2Vha01hcCk7XG5oYXJkZW4obWFrZUxlZ2FjeVdlYWtNYXApO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VMZWdhY3lXZWFrTWFwIjpbIm1ha2VMZWdhY3lXZWFrTWFwIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJoDutcWFgAAFhYAADcAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3NjYWxhck1hcFN0b3JlLmpzeyJpbXBvcnRzIjpbIi4vc2NhbGFyV2Vha01hcFN0b3JlLmpzIiwiLi9zdG9yZS11dGlscy5qcyIsIkBlbmRvL21hcnNoYWwiLCJAZW5kby9wYXNzLXN0eWxlIiwiQGVuZG8vcGF0dGVybnMiXSwiZXhwb3J0cyI6WyJtYWtlTWFwU3RvcmVNZXRob2RzIiwibWFrZVNjYWxhck1hcFN0b3JlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhcixhc3NlcnRQYXNzYWJsZSxmaWx0ZXJJdGVyYWJsZSxtYXBJdGVyYWJsZSxjb21wYXJlUmFuayxhc3NlcnRTY2FsYXJLZXksbWFrZUNvcHlNYXAsbWF0Y2hlcyxtdXN0TWF0Y2gsYXNzZXJ0UGF0dGVybixtYWtlV2Vha01hcFN0b3JlTWV0aG9kcyxtYWtlQ3VycmVudEtleXNLaXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dLFtcImFzc2VydFBhc3NhYmxlXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXNzYWJsZSA9ICRo4oCNX2EpXV0sW1wiZmlsdGVySXRlcmFibGVcIiwgWyRo4oCNX2EgPT4gKGZpbHRlckl0ZXJhYmxlID0gJGjigI1fYSldXSxbXCJtYXBJdGVyYWJsZVwiLCBbJGjigI1fYSA9PiAobWFwSXRlcmFibGUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiY29tcGFyZVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVSYW5rID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3BhdHRlcm5zXCIsIFtbXCJhc3NlcnRTY2FsYXJLZXlcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFNjYWxhcktleSA9ICRo4oCNX2EpXV0sW1wibWFrZUNvcHlNYXBcIiwgWyRo4oCNX2EgPT4gKG1ha2VDb3B5TWFwID0gJGjigI1fYSldXSxbXCJtYXRjaGVzXCIsIFskaOKAjV9hID0+IChtYXRjaGVzID0gJGjigI1fYSldXSxbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UGF0dGVyblwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGF0dGVybiA9ICRo4oCNX2EpXV1dXSxbXCIuL3NjYWxhcldlYWtNYXBTdG9yZS5qc1wiLCBbW1wibWFrZVdlYWtNYXBTdG9yZU1ldGhvZHNcIiwgWyRo4oCNX2EgPT4gKG1ha2VXZWFrTWFwU3RvcmVNZXRob2RzID0gJGjigI1fYSldXV1dLFtcIi4vc3RvcmUtdXRpbHMuanNcIiwgW1tcIm1ha2VDdXJyZW50S2V5c0tpdFwiLCBbJGjigI1fYSA9PiAobWFrZUN1cnJlbnRLZXlzS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e3F1b3RlOnF9PWFzc2VydDtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gS1xuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVlxuICogQHBhcmFtIHtNYXA8SyxWPn0ganNtYXBcbiAqIEBwYXJhbSB7KGs6IEssIHY6IFYpID0+IHZvaWR9IGFzc2VydEtWT2tUb0FkZFxuICogQHBhcmFtIHsoazogSywgdjogVikgPT4gdm9pZH0gYXNzZXJ0S1ZPa1RvU2V0XG4gKiBAcGFyYW0geygoazogSykgPT4gdm9pZCl9IFthc3NlcnRLZXlPa1RvRGVsZXRlXVxuICogQHBhcmFtIHtzdHJpbmd9IFt0YWddXG4gKiBAcmV0dXJucyB7TWFwU3RvcmU8SyxWPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VNYXBTdG9yZU1ldGhvZHM9KFxuanNtYXAsXG5hc3NlcnRLVk9rVG9BZGQsXG5hc3NlcnRLVk9rVG9TZXQsXG5hc3NlcnRLZXlPa1RvRGVsZXRlPXVuZGVmaW5lZCxcbnRhZz0na2V5Jyk9Plxue1xuY29uc3R7YXNzZXJ0VXBkYXRlT25BZGQsYXNzZXJ0VXBkYXRlT25EZWxldGUsaXRlcmFibGVLZXlzfT1cbm1ha2VDdXJyZW50S2V5c0tpdChcbigpPT5qc21hcC5rZXlzKCksXG4oayk9PmpzbWFwLmhhcyhrKSxcbmNvbXBhcmVSYW5rLFxuYXNzZXJ0S1ZPa1RvQWRkLFxuYXNzZXJ0S2V5T2tUb0RlbGV0ZSxcbnRhZyk7XG5cblxuLyoqXG4gKiBAcGFyYW0ge1BhdHRlcm59IFtrZXlQYXR0XVxuICogQHBhcmFtIHtQYXR0ZXJufSBbdmFsdWVQYXR0XVxuICogQHJldHVybnMge0l0ZXJhYmxlPEs+fVxuICovXG5jb25zdCBrZXlzPShrZXlQYXR0PXVuZGVmaW5lZCx2YWx1ZVBhdHQ9dW5kZWZpbmVkKT0+e1xuaWYoa2V5UGF0dD09PXVuZGVmaW5lZCYmdmFsdWVQYXR0PT09dW5kZWZpbmVkKXtcbnJldHVybiBpdGVyYWJsZUtleXM7XG4gfVxuY29uc3QgZmlsdGVyPShrKT0+e1xuaWYoa2V5UGF0dCE9PXVuZGVmaW5lZCYmIW1hdGNoZXMoayxrZXlQYXR0KSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuLyogVXNlcyB0aGUgY3VycmVudCBqc21hcCB2YWx1ZSwgc2luY2UgdGhlIGl0ZXJhdGF0b3Igc3Vydml2ZXMgYC5zZXRgKi9cbmlmKHZhbHVlUGF0dCE9PXVuZGVmaW5lZCYmIW1hdGNoZXMoanNtYXAuZ2V0KGspLHZhbHVlUGF0dCkpe1xucmV0dXJuIGZhbHNlO1xuIH1cbnJldHVybiB0cnVlO1xuIH07XG5yZXR1cm4gZmlsdGVySXRlcmFibGUoaXRlcmFibGVLZXlzLGZpbHRlcik7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1BhdHRlcm59IFtrZXlQYXR0XVxuICogQHBhcmFtIHtQYXR0ZXJufSBbdmFsdWVQYXR0XVxuICogQHJldHVybnMge0l0ZXJhYmxlPFY+fVxuICovXG5jb25zdCB2YWx1ZXM9KGtleVBhdHQ9dW5kZWZpbmVkLHZhbHVlUGF0dD11bmRlZmluZWQpPT5cbm1hcEl0ZXJhYmxlKGtleXMoa2V5UGF0dCx2YWx1ZVBhdHQpLChrKT0+LyoqIEB0eXBlIHtWfSAqL2pzbWFwLmdldChrKSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXR0ZXJufSBba2V5UGF0dF1cbiAqIEBwYXJhbSB7UGF0dGVybn0gW3ZhbHVlUGF0dF1cbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxbSyxWXT59XG4gKi9cbmNvbnN0IGVudHJpZXM9KGtleVBhdHQ9dW5kZWZpbmVkLHZhbHVlUGF0dD11bmRlZmluZWQpPT5cbm1hcEl0ZXJhYmxlKGtleXMoa2V5UGF0dCx2YWx1ZVBhdHQpLChrKT0+W1xuayxcbi8qKiBAdHlwZSB7Vn0gKi9qc21hcC5nZXQoayldKTtcblxuXG5yZXR1cm4gaGFyZGVuKHtcbi4uLm1ha2VXZWFrTWFwU3RvcmVNZXRob2RzKFxuanNtYXAsXG4vKiogQHR5cGUgeyhrOiBLLCB2OiBWKSA9PiB2b2lkfSAqL2Fzc2VydFVwZGF0ZU9uQWRkLFxuYXNzZXJ0S1ZPa1RvU2V0LFxuYXNzZXJ0VXBkYXRlT25EZWxldGUsXG50YWcpLFxuXG5rZXlzLFxudmFsdWVzLFxuZW50cmllcyxcblxuc25hcHNob3Q6KGtleVBhdHQ9dW5kZWZpbmVkLHZhbHVlUGF0dD11bmRlZmluZWQpPT5cbm1ha2VDb3B5TWFwKGVudHJpZXMoa2V5UGF0dCx2YWx1ZVBhdHQpKSxcblxuZ2V0U2l6ZTooa2V5UGF0dD11bmRlZmluZWQsdmFsdWVQYXR0PXVuZGVmaW5lZCk9Plxua2V5UGF0dD09PXVuZGVmaW5lZCYmdmFsdWVQYXR0PT09dW5kZWZpbmVkP1xuanNtYXAuc2l6ZTpcblsuLi5rZXlzKGtleVBhdHQsdmFsdWVQYXR0KV0ubGVuZ3RoLFxuXG5jbGVhcjooa2V5UGF0dD11bmRlZmluZWQsdmFsdWVQYXR0PXVuZGVmaW5lZCk9PntcbmlmKGtleVBhdHQ9PT11bmRlZmluZWQmJnZhbHVlUGF0dD09PXVuZGVmaW5lZCl7XG5qc21hcC5jbGVhcigpO1xuIH1cbmZvcihjb25zdCBrZXkgb2Yga2V5cyhrZXlQYXR0LHZhbHVlUGF0dCkpe1xuanNtYXAuZGVsZXRlKGtleSk7XG4gfVxuIH19KTtcblxuIH07XG5cbi8qKlxuICogRGlzdGluZ3Vpc2hlcyBiZXR3ZWVuIGFkZGluZyBhIG5ldyBrZXkgKGluaXQpIGFuZCB1cGRhdGluZyBvclxuICogcmVmZXJlbmNpbmcgYSBrZXkgKGdldCwgc2V0LCBkZWxldGUpLlxuICpcbiAqIGBpbml0YCBpcyBvbmx5IGFsbG93ZWQgaWYgdGhlIGtleSBkb2VzIG5vdCBhbHJlYWR5IGV4aXN0LiBgR2V0YCxcbiAqIGBzZXRgIGFuZCBgZGVsZXRlYCBhcmUgb25seSBhbGxvd2VkIGlmIHRoZSBrZXkgZG9lcyBhbHJlYWR5IGV4aXN0LlxuICpcbiAqIFRoaXMgaXMgYSAqc2NhbGFyKiBtYXAgaW4gdGhhdCB0aGUga2V5cyBjYW4gb25seSBiZSBhdG9taWMgdmFsdWVzLCBwcmltaXRpdmVzXG4gKiBvciByZW1vdGFibGVzLiBPdGhlciBzdG9yZU1hcHMgd2lsbCBhY2NlcHQsIGZvciBleGFtcGxlLCBjb3B5QXJyYXlzIGFuZFxuICogY29weVJlY29yZHMsIGFzIGtleXMgYW5kIGxvb2sgdGhlbSB1cCBiYXNlZCBvbiBlcXVhbGl0eSBvZiB0aGVpciBjb250ZW50cy5cbiAqXG4gKiBAdGVtcGxhdGUge0tleX0gS1xuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVlxuICogQHBhcmFtIHtzdHJpbmd9IFt0YWc9J2tleSddIC0gdGhlIGNvbHVtbiBuYW1lIGZvciB0aGUga2V5XG4gKiBAcGFyYW0ge1N0b3JlT3B0aW9uc30gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7TWFwU3RvcmU8SyxWPn1cbiAqLyRo4oCNX29uY2UubWFrZU1hcFN0b3JlTWV0aG9kcyhtYWtlTWFwU3RvcmVNZXRob2RzKTtcbmNvbnN0ICAgICAgICBtYWtlU2NhbGFyTWFwU3RvcmU9KFxudGFnPSdrZXknLFxue2tleVNoYXBlPXVuZGVmaW5lZCx2YWx1ZVNoYXBlPXVuZGVmaW5lZH09e30pPT5cbntcbmNvbnN0IGpzbWFwPW5ldyBNYXAoKTtcbmlmKGtleVNoYXBlIT09dW5kZWZpbmVkKXtcbmFzc2VydFBhdHRlcm4oa2V5U2hhcGUpO1xuIH1cbmlmKHZhbHVlU2hhcGUhPT11bmRlZmluZWQpe1xuYXNzZXJ0UGF0dGVybih2YWx1ZVNoYXBlKTtcbiB9XG5cbmNvbnN0IGFzc2VydEtWT2tUb1NldD0oX2tleSx2YWx1ZSk9Pntcbi8qIFRPRE86IEp1c3QgYSB0cmFuc2l0aW9uIGtsdWRnZS4gUmVtb3ZlIHdoZW4gcG9zc2libGUuKi9cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzM2MDYqL1xuaGFyZGVuKHZhbHVlKTtcblxuYXNzZXJ0UGFzc2FibGUodmFsdWUpO1xuaWYodmFsdWVTaGFwZSE9PXVuZGVmaW5lZCl7XG5tdXN0TWF0Y2godmFsdWUsdmFsdWVTaGFwZSwnbWFwU3RvcmUgdmFsdWUnKTtcbiB9XG4gfTtcblxuY29uc3QgYXNzZXJ0S1ZPa1RvQWRkPShrZXksdmFsdWUpPT57XG4vKiBUT0RPOiBKdXN0IGEgdHJhbnNpdGlvbiBrbHVkZ2UuIFJlbW92ZSB3aGVuIHBvc3NpYmxlLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNjA2Ki9cbmhhcmRlbihrZXkpO1xuXG5hc3NlcnRTY2FsYXJLZXkoa2V5KTtcbmlmKGtleVNoYXBlIT09dW5kZWZpbmVkKXtcbm11c3RNYXRjaChrZXksa2V5U2hhcGUsJ21hcFN0b3JlIGtleScpO1xuIH1cbmFzc2VydEtWT2tUb1NldChrZXksdmFsdWUpO1xuIH07XG5cbnJldHVybiBGYXIoIGBzY2FsYXIgTWFwU3RvcmUgb2YgJHtxKHRhZyl9YCx7XG4uLi5tYWtlTWFwU3RvcmVNZXRob2RzKFxuanNtYXAsXG5hc3NlcnRLVk9rVG9BZGQsXG5hc3NlcnRLVk9rVG9TZXQsXG51bmRlZmluZWQsXG50YWcpfSk7XG5cblxuIH07JGjigI1fb25jZS5tYWtlU2NhbGFyTWFwU3RvcmUobWFrZVNjYWxhck1hcFN0b3JlKTtcbmhhcmRlbihtYWtlU2NhbGFyTWFwU3RvcmUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VNYXBTdG9yZU1ldGhvZHMiOlsibWFrZU1hcFN0b3JlTWV0aG9kcyJdLCJtYWtlU2NhbGFyTWFwU3RvcmUiOlsibWFrZVNjYWxhck1hcFN0b3JlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJ0DliBBDwAAQQ8AADcAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3NjYWxhclNldFN0b3JlLmpzeyJpbXBvcnRzIjpbIi4vc2NhbGFyV2Vha1NldFN0b3JlLmpzIiwiLi9zdG9yZS11dGlscy5qcyIsIkBlbmRvL21hcnNoYWwiLCJAZW5kby9wYXNzLXN0eWxlIiwiQGVuZG8vcGF0dGVybnMiXSwiZXhwb3J0cyI6WyJtYWtlU2NhbGFyU2V0U3RvcmUiLCJtYWtlU2V0U3RvcmVNZXRob2RzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhcixmaWx0ZXJJdGVyYWJsZSxjb21wYXJlUmFuayxhc3NlcnRTY2FsYXJLZXksbWFrZUNvcHlTZXQsbWF0Y2hlcyxtdXN0TWF0Y2gsYXNzZXJ0UGF0dGVybixtYWtlV2Vha1NldFN0b3JlTWV0aG9kcyxtYWtlQ3VycmVudEtleXNLaXQ7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dLFtcImZpbHRlckl0ZXJhYmxlXCIsIFskaOKAjV9hID0+IChmaWx0ZXJJdGVyYWJsZSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJjb21wYXJlUmFua1wiLCBbJGjigI1fYSA9PiAoY29tcGFyZVJhbmsgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcGF0dGVybnNcIiwgW1tcImFzc2VydFNjYWxhcktleVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0U2NhbGFyS2V5ID0gJGjigI1fYSldXSxbXCJtYWtlQ29weVNldFwiLCBbJGjigI1fYSA9PiAobWFrZUNvcHlTZXQgPSAkaOKAjV9hKV1dLFtcIm1hdGNoZXNcIiwgWyRo4oCNX2EgPT4gKG1hdGNoZXMgPSAkaOKAjV9hKV1dLFtcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJhc3NlcnRQYXR0ZXJuXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXR0ZXJuID0gJGjigI1fYSldXV1dLFtcIi4vc2NhbGFyV2Vha1NldFN0b3JlLmpzXCIsIFtbXCJtYWtlV2Vha1NldFN0b3JlTWV0aG9kc1wiLCBbJGjigI1fYSA9PiAobWFrZVdlYWtTZXRTdG9yZU1ldGhvZHMgPSAkaOKAjV9hKV1dXV0sW1wiLi9zdG9yZS11dGlscy5qc1wiLCBbW1wibWFrZUN1cnJlbnRLZXlzS2l0XCIsIFskaOKAjV9hID0+IChtYWtlQ3VycmVudEtleXNLaXQgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtxdW90ZTpxfT1hc3NlcnQ7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7U2V0PEs+fSBqc3NldFxuICogQHBhcmFtIHsoazogSykgPT4gdm9pZH0gYXNzZXJ0S2V5T2tUb0FkZFxuICogQHBhcmFtIHsoazogSykgPT4gdm9pZH0gW2Fzc2VydEtleU9rVG9EZWxldGVdXG4gKiBAcGFyYW0ge3N0cmluZ30gW2tleU5hbWVdXG4gKiBAcmV0dXJucyB7U2V0U3RvcmU8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlU2V0U3RvcmVNZXRob2RzPShcbmpzc2V0LFxuYXNzZXJ0S2V5T2tUb0FkZCxcbmFzc2VydEtleU9rVG9EZWxldGU9dW5kZWZpbmVkLFxua2V5TmFtZT0na2V5Jyk9Plxue1xuY29uc3R7YXNzZXJ0VXBkYXRlT25BZGQsYXNzZXJ0VXBkYXRlT25EZWxldGUsaXRlcmFibGVLZXlzfT1cbm1ha2VDdXJyZW50S2V5c0tpdChcbigpPT5qc3NldC5rZXlzKCksXG4oayk9Pmpzc2V0LmhhcyhrKSxcbmNvbXBhcmVSYW5rLFxuYXNzZXJ0S2V5T2tUb0FkZCxcbmFzc2VydEtleU9rVG9EZWxldGUsXG5rZXlOYW1lKTtcblxuXG4vKipcbiAqIEBwYXJhbSB7UGF0dGVybn0gW2tleVBhdHRdXG4gKiBAcmV0dXJucyB7SXRlcmFibGU8Sz59XG4gKi9cbmNvbnN0IGtleXM9KGtleVBhdHQ9dW5kZWZpbmVkKT0+XG5rZXlQYXR0PT09dW5kZWZpbmVkP1xuaXRlcmFibGVLZXlzOlxuZmlsdGVySXRlcmFibGUoaXRlcmFibGVLZXlzLChrKT0+bWF0Y2hlcyhrLGtleVBhdHQpKTtcblxucmV0dXJuIGhhcmRlbih7XG4uLi5tYWtlV2Vha1NldFN0b3JlTWV0aG9kcyhcbmpzc2V0LFxuYXNzZXJ0VXBkYXRlT25BZGQsXG5hc3NlcnRVcGRhdGVPbkRlbGV0ZSxcbmtleU5hbWUpLFxuXG5cbmtleXMsXG5cbnZhbHVlczprZXlzLFxuXG5zbmFwc2hvdDooa2V5UGF0dD11bmRlZmluZWQpPT5tYWtlQ29weVNldChrZXlzKGtleVBhdHQpKSxcblxuZ2V0U2l6ZTooa2V5UGF0dD11bmRlZmluZWQpPT5cbmtleVBhdHQ9PT11bmRlZmluZWQ/anNzZXQuc2l6ZTpbLi4ua2V5cyhrZXlQYXR0KV0ubGVuZ3RoLFxuXG5jbGVhcjooa2V5UGF0dD11bmRlZmluZWQpPT57XG5pZihrZXlQYXR0PT09dW5kZWZpbmVkKXtcbmpzc2V0LmNsZWFyKCk7XG4gfVxuZm9yKGNvbnN0IGtleSBvZiBrZXlzKGtleVBhdHQpKXtcbmpzc2V0LmRlbGV0ZShrZXkpO1xuIH1cbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIERpc3Rpbmd1aXNoZXMgYmV0d2VlbiBhZGRpbmcgYSBuZXcga2V5IChpbml0KSBhbmQgdXBkYXRpbmcgb3JcbiAqIHJlZmVyZW5jaW5nIGEga2V5IChnZXQsIHNldCwgZGVsZXRlKS5cbiAqXG4gKiBgaW5pdGAgaXMgb25seSBhbGxvd2VkIGlmIHRoZSBrZXkgZG9lcyBub3QgYWxyZWFkeSBleGlzdC4gYEdldGAsXG4gKiBgc2V0YCBhbmQgYGRlbGV0ZWAgYXJlIG9ubHkgYWxsb3dlZCBpZiB0aGUga2V5IGRvZXMgYWxyZWFkeSBleGlzdC5cbiAqXG4gKiBUaGlzIGlzIGEgKnNjYWxhciogc2V0IGluIHRoYXQgdGhlIGtleXMgY2FuIG9ubHkgYmUgYXRvbWljIHZhbHVlcywgcHJpbWl0aXZlc1xuICogb3IgcmVtb3RhYmxlcy4gT3RoZXIgc3RvcmVTZXRzIHdpbGwgYWNjZXB0LCBmb3IgZXhhbXBsZSwgY29weUFycmF5cyBhbmRcbiAqIGNvcHlSZWNvcmRzLCBhcyBrZXlzIGFuZCBsb29rIHRoZW0gdXAgYmFzZWQgb24gZXF1YWxpdHkgb2YgdGhlaXIgY29udGVudHMuXG4gKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7c3RyaW5nfSBbdGFnPSdrZXknXSAtIHRhZyBmb3IgZGVidWdnaW5nXG4gKiBAcGFyYW0ge1N0b3JlT3B0aW9uc30gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7U2V0U3RvcmU8Sz59XG4gKi8kaOKAjV9vbmNlLm1ha2VTZXRTdG9yZU1ldGhvZHMobWFrZVNldFN0b3JlTWV0aG9kcyk7XG5jb25zdCAgICAgICAgbWFrZVNjYWxhclNldFN0b3JlPShcbnRhZz0na2V5JyxcbntrZXlTaGFwZT11bmRlZmluZWR9PXt9KT0+XG57XG5jb25zdCBqc3NldD1uZXcgU2V0KCk7XG5pZihrZXlTaGFwZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnRQYXR0ZXJuKGtleVNoYXBlKTtcbiB9XG5cbmNvbnN0IGFzc2VydEtleU9rVG9BZGQ9KGtleSk9Pntcbi8qIFRPRE86IEp1c3QgYSB0cmFuc2l0aW9uIGtsdWRnZS4gUmVtb3ZlIHdoZW4gcG9zc2libGUuKi9cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzM2MDYqL1xuaGFyZGVuKGtleSk7XG5cbmFzc2VydFNjYWxhcktleShrZXkpO1xuaWYoa2V5U2hhcGUhPT11bmRlZmluZWQpe1xubXVzdE1hdGNoKGtleSxrZXlTaGFwZSwnc2V0U3RvcmUga2V5Jyk7XG4gfVxuIH07XG5cbnJldHVybiBGYXIoIGBzY2FsYXIgU2V0U3RvcmUgb2YgJHtxKHRhZyl9YCx7XG4uLi5tYWtlU2V0U3RvcmVNZXRob2RzKGpzc2V0LGFzc2VydEtleU9rVG9BZGQsdW5kZWZpbmVkLHRhZyl9KTtcblxuIH07JGjigI1fb25jZS5tYWtlU2NhbGFyU2V0U3RvcmUobWFrZVNjYWxhclNldFN0b3JlKTtcbmhhcmRlbihtYWtlU2NhbGFyU2V0U3RvcmUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VTZXRTdG9yZU1ldGhvZHMiOlsibWFrZVNldFN0b3JlTWV0aG9kcyJdLCJtYWtlU2NhbGFyU2V0U3RvcmUiOlsibWFrZVNjYWxhclNldFN0b3JlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAABlBadjjEgAA4xIAADsAAABAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qc3siaW1wb3J0cyI6WyIuL3N0b3JlLXV0aWxzLmpzIiwiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL3BhdHRlcm5zIl0sImV4cG9ydHMiOlsibWFrZVNjYWxhcldlYWtNYXBTdG9yZSIsIm1ha2VXZWFrTWFwU3RvcmVNZXRob2RzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhcixhc3NlcnRQYXNzYWJsZSxwYXNzU3R5bGVPZixnZXRDb3B5TWFwRW50cmllcyxtdXN0TWF0Y2gsYXNzZXJ0UGF0dGVybixpc0NvcHlNYXA7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dLFtcImFzc2VydFBhc3NhYmxlXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXNzYWJsZSA9ICRo4oCNX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3BhdHRlcm5zXCIsIFtbXCJnZXRDb3B5TWFwRW50cmllc1wiLCBbJGjigI1fYSA9PiAoZ2V0Q29weU1hcEVudHJpZXMgPSAkaOKAjV9hKV1dLFtcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXSxbXCJhc3NlcnRQYXR0ZXJuXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXR0ZXJuID0gJGjigI1fYSldXV1dLFtcIi4vc3RvcmUtdXRpbHMuanNcIiwgW1tcImlzQ29weU1hcFwiLCBbJGjigI1fYSA9PiAoaXNDb3B5TWFwID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuLyoqXG4gKiBAdGVtcGxhdGUgSyxWXG4gKiBAcGFyYW0ge1dlYWtNYXA8SyAmIG9iamVjdCwgVj59IGpzbWFwXG4gKiBAcGFyYW0geyhrOiBLLCB2OiBWKSA9PiB2b2lkfSBhc3NlcnRLVk9rVG9BZGRcbiAqIEBwYXJhbSB7KGs6IEssIHY6IFYpID0+IHZvaWR9IGFzc2VydEtWT2tUb1NldFxuICogQHBhcmFtIHsoazogSykgPT4gdm9pZH0gW2Fzc2VydEtleU9rVG9EZWxldGVdXG4gKiBAcGFyYW0ge3N0cmluZ30gW2tleU5hbWVdXG4gKiBAcmV0dXJucyB7V2Vha01hcFN0b3JlPEssVj59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlV2Vha01hcFN0b3JlTWV0aG9kcz0oXG5qc21hcCxcbmFzc2VydEtWT2tUb0FkZCxcbmFzc2VydEtWT2tUb1NldCxcbmFzc2VydEtleU9rVG9EZWxldGU9dW5kZWZpbmVkLFxua2V5TmFtZT0na2V5Jyk9Plxue1xuY29uc3QgYXNzZXJ0S2V5RG9lc05vdEV4aXN0PShrZXkpPT5cbiFqc21hcC5oYXMoa2V5KXx8RmFpbCBgJHtxKGtleU5hbWUpfSBhbHJlYWR5IHJlZ2lzdGVyZWQ6ICR7a2V5fWA7XG5cbmNvbnN0IGFzc2VydEtleUV4aXN0cz0oa2V5KT0+XG5qc21hcC5oYXMoa2V5KXx8RmFpbCBgJHtxKGtleU5hbWUpfSBub3QgZm91bmQ6ICR7a2V5fWA7XG5cbnJldHVybiBoYXJkZW4oe1xuaGFzOihrZXkpPT57XG4vKiBDaGVjayBpZiBhIGtleSBleGlzdHMuIFRoZSBrZXkgY2FuIGJlIGFueSBKYXZhU2NyaXB0IHZhbHVlLCovXG4vKiB0aG91Z2ggdGhlIGFuc3dlciB3aWxsIGFsd2F5cyBiZSBmYWxzZSBmb3Iga2V5cyB0aGF0IGNhbm5vdCBiZSBmb3VuZCovXG4vKiBpbiB0aGlzIG1hcC4qL1xucmV0dXJuIGpzbWFwLmhhcyhrZXkpO1xuIH0sXG5nZXQ6KGtleSk9PntcbmFzc2VydEtleUV4aXN0cyhrZXkpO1xuLyogSG93IHRvIHRlbGwgdHlwZXNjcmlwdCBJIGJlbGlldmUgdGhlIGBnZXRgIHdpbGwgc3VjY2VlZC4qL1xucmV0dXJuICgvKiogQHR5cGUge1Z9ICovanNtYXAuZ2V0KGtleSkpO1xuIH0sXG5cbmluaXQ6KGtleSx2YWx1ZSk9PntcbmFzc2VydEtleURvZXNOb3RFeGlzdChrZXkpO1xuYXNzZXJ0S1ZPa1RvQWRkKGtleSx2YWx1ZSk7XG5qc21hcC5zZXQoa2V5LHZhbHVlKTtcbiB9LFxuc2V0OihrZXksdmFsdWUpPT57XG5hc3NlcnRLZXlFeGlzdHMoa2V5KTtcbmFzc2VydEtWT2tUb1NldChrZXksdmFsdWUpO1xuanNtYXAuc2V0KGtleSx2YWx1ZSk7XG4gfSxcbmRlbGV0ZTooa2V5KT0+e1xuYXNzZXJ0S2V5RXhpc3RzKGtleSk7XG5pZihhc3NlcnRLZXlPa1RvRGVsZXRlIT09dW5kZWZpbmVkKXtcbmFzc2VydEtleU9rVG9EZWxldGUoa2V5KTtcbiB9XG5qc21hcC5kZWxldGUoa2V5KTtcbiB9LFxuXG5hZGRBbGw6KGVudHJpZXMpPT57XG5pZihpc0NvcHlNYXAoZW50cmllcykpe1xuZW50cmllcz1nZXRDb3B5TWFwRW50cmllcyhlbnRyaWVzKTtcbiB9XG5mb3IoY29uc3Rba2V5LHZhbHVlXW9mLyoqIEB0eXBlIHtJdGVyYWJsZTxbSywgVl0+fSAqL2VudHJpZXMpe1xuLyogRG9uJ3QgYXNzZXJ0IHRoYXQgdGhlIGtleSBlaXRoZXIgZG9lcyBvciBkb2VzIG5vdCBleGlzdC4qL1xuYXNzZXJ0S1ZPa1RvQWRkKGtleSx2YWx1ZSk7XG5qc21hcC5zZXQoa2V5LHZhbHVlKTtcbiB9XG4gfX0pO1xuXG4gfTtcblxuLyoqXG4gKiBUaGlzIGlzIGEgKnNjYWxhciogbWFwU3RvcmUgaW4gdGhhdCB0aGUga2V5cyBjYW4gb25seSBiZSBhdG9taWMgdmFsdWVzOlxuICogcHJpbWl0aXZlcyBvciByZW1vdGFibGVzLlxuICogT3RoZXIgbWFwU3RvcmVzIHdpbGwgYWNjZXB0LCBmb3IgZXhhbXBsZSwgY29weUFycmF5cyBhbmRcbiAqIGNvcHlSZWNvcmRzIGFzIGtleXMgYW5kIGxvb2sgdGhlbSB1cCBiYXNlZCBvbiBlcXVhbGl0eSBvZiB0aGVpciBjb250ZW50cy5cbiAqXG4gKiBUT0RPIEZvciBub3csIHRoaXMgc2NhbGFyV2Vha01hcCBhY2NlcHRzIG9ubHkgcmVtb3RhYmxlcywgcmVmbGVjdGluZyB0aGVcbiAqIGNvbnN0cmFpbnRzIG9mIHRoZSB1bmRlcmx5aW5nIEphdmFTY3JpcHQgV2Vha01hcCBpdCB1c2VzIGludGVybmFsbHkuIEJ1dFxuICogaXQgc2hvdWxkIGFjY2VwdCB0aGUgcHJpbWl0aXZlcyBhcyB3ZWxsLCBzdG9yaW5nIHRoZW0gaW4gYSBzZXBhcmF0ZSBpbnRlcm5hbFxuICogbWFwLiBXaGF0IG1ha2VzIGl0IFwid2Vha1wiIGlzIHRoYXQgaXQgcHJvdmlkZXMgbm8gQVBJIGZvciBlbnVtZXJhdGluZyB3aGF0J3NcbiAqIHRoZXJlLiBUaG91Z2ggbm90ZSB0aGF0IHRoaXMgd291bGQgb25seSBlbmFibGVzIGNvbGxlY3Rpb24gb2YgdGhlXG4gKiByZW1vdGFibGVzLCBzaW5jZSB0aGUgb3RoZXIgcHJpbWl0aXZlcyBtYXkgYWx3YXlzIHJlYXBwZWFyLlxuICpcbiAqIEB0ZW1wbGF0ZSBLLFZcbiAqIEBwYXJhbSB7c3RyaW5nfSBbdGFnPSdrZXknXSAtIHRhZyBmb3IgZGVidWdnaW5nXG4gKiBAcGFyYW0ge1N0b3JlT3B0aW9uc30gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7V2Vha01hcFN0b3JlPEssVj59XG4gKi8kaOKAjV9vbmNlLm1ha2VXZWFrTWFwU3RvcmVNZXRob2RzKG1ha2VXZWFrTWFwU3RvcmVNZXRob2RzKTtcbmNvbnN0ICAgICAgICBtYWtlU2NhbGFyV2Vha01hcFN0b3JlPShcbnRhZz0na2V5Jyxcbntsb25nTGl2ZWQ9dHJ1ZSxrZXlTaGFwZT11bmRlZmluZWQsdmFsdWVTaGFwZT11bmRlZmluZWR9PXt9KT0+XG57XG5jb25zdCBqc21hcD1uZXcobG9uZ0xpdmVkP1dlYWtNYXA6TWFwKSgpO1xuaWYoa2V5U2hhcGUhPT11bmRlZmluZWQpe1xuYXNzZXJ0UGF0dGVybihrZXlTaGFwZSk7XG4gfVxuaWYodmFsdWVTaGFwZSE9PXVuZGVmaW5lZCl7XG5hc3NlcnRQYXR0ZXJuKHZhbHVlU2hhcGUpO1xuIH1cblxuY29uc3QgYXNzZXJ0S1ZPa1RvU2V0PShfa2V5LHZhbHVlKT0+e1xuLyogVE9ETzogSnVzdCBhIHRyYW5zaXRpb24ga2x1ZGdlLiBSZW1vdmUgd2hlbiBwb3NzaWJsZS4qL1xuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvMzYwNiovXG5oYXJkZW4odmFsdWUpO1xuXG5hc3NlcnRQYXNzYWJsZSh2YWx1ZSk7XG5pZih2YWx1ZVNoYXBlIT09dW5kZWZpbmVkKXtcbm11c3RNYXRjaCh2YWx1ZSx2YWx1ZVNoYXBlLCd3ZWFrTWFwU3RvcmUgdmFsdWUnKTtcbiB9XG4gfTtcblxuY29uc3QgYXNzZXJ0S1ZPa1RvQWRkPShrZXksdmFsdWUpPT57XG4vKiBUT0RPOiBKdXN0IGEgdHJhbnNpdGlvbiBrbHVkZ2UuIFJlbW92ZSB3aGVuIHBvc3NpYmxlLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNjA2Ki9cbmhhcmRlbihrZXkpO1xucGFzc1N0eWxlT2Yoa2V5KT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYE9ubHkgcmVtb3RhYmxlcyBjYW4gYmUga2V5cyBvZiBzY2FsYXIgV2Vha01hcFN0b3JlczogJHtrZXl9YDtcbmlmKGtleVNoYXBlIT09dW5kZWZpbmVkKXtcbm11c3RNYXRjaChrZXksa2V5U2hhcGUsJ3dlYWtNYXBTdG9yZSBrZXknKTtcbiB9XG5hc3NlcnRLVk9rVG9TZXQoa2V5LHZhbHVlKTtcbiB9O1xuXG5yZXR1cm4gRmFyKCBgc2NhbGFyIFdlYWtNYXBTdG9yZSBvZiAke3EodGFnKX1gLHtcbi4uLm1ha2VXZWFrTWFwU3RvcmVNZXRob2RzKFxuanNtYXAsXG5hc3NlcnRLVk9rVG9BZGQsXG5hc3NlcnRLVk9rVG9TZXQsXG51bmRlZmluZWQsXG50YWcpfSk7XG5cblxuIH07JGjigI1fb25jZS5tYWtlU2NhbGFyV2Vha01hcFN0b3JlKG1ha2VTY2FsYXJXZWFrTWFwU3RvcmUpO1xuaGFyZGVuKG1ha2VTY2FsYXJXZWFrTWFwU3RvcmUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VXZWFrTWFwU3RvcmVNZXRob2RzIjpbIm1ha2VXZWFrTWFwU3RvcmVNZXRob2RzIl0sIm1ha2VTY2FsYXJXZWFrTWFwU3RvcmUiOlsibWFrZVNjYWxhcldlYWtNYXBTdG9yZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABtrD+9hA4AAIQOAAA7AAAAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL3N0b3Jlcy9zY2FsYXJXZWFrU2V0U3RvcmUuanN7ImltcG9ydHMiOlsiLi9zdG9yZS11dGlscy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiLCJAZW5kby9wYXR0ZXJucyJdLCJleHBvcnRzIjpbIm1ha2VTY2FsYXJXZWFrU2V0U3RvcmUiLCJtYWtlV2Vha1NldFN0b3JlTWV0aG9kcyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYXIscGFzc1N0eWxlT2YsZ2V0Q29weVNldEtleXMsbXVzdE1hdGNoLGFzc2VydFBhdHRlcm4saXNDb3B5U2V0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXSxbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcGF0dGVybnNcIiwgW1tcImdldENvcHlTZXRLZXlzXCIsIFskaOKAjV9hID0+IChnZXRDb3B5U2V0S2V5cyA9ICRo4oCNX2EpXV0sW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dLFtcImFzc2VydFBhdHRlcm5cIiwgWyRo4oCNX2EgPT4gKGFzc2VydFBhdHRlcm4gPSAkaOKAjV9hKV1dXV0sW1wiLi9zdG9yZS11dGlscy5qc1wiLCBbW1wiaXNDb3B5U2V0XCIsIFskaOKAjV9hID0+IChpc0NvcHlTZXQgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cbmNvbnN0e3F1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAcGFyYW0ge1dlYWtTZXQ8SyAmIG9iamVjdD59IGpzc2V0XG4gKiBAcGFyYW0geyhrOiBLKSA9PiB2b2lkfSBhc3NlcnRLZXlPa1RvQWRkXG4gKiBAcGFyYW0geyhrOiBLKSA9PiB2b2lkfSBbYXNzZXJ0S2V5T2tUb0RlbGV0ZV1cbiAqIEBwYXJhbSB7c3RyaW5nfSBba2V5TmFtZV1cbiAqIEByZXR1cm5zIHtXZWFrU2V0U3RvcmU8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlV2Vha1NldFN0b3JlTWV0aG9kcz0oXG5qc3NldCxcbmFzc2VydEtleU9rVG9BZGQsXG5hc3NlcnRLZXlPa1RvRGVsZXRlPXVuZGVmaW5lZCxcbmtleU5hbWU9J2tleScpPT5cbntcbmNvbnN0IGFzc2VydEtleUV4aXN0cz0oa2V5KT0+XG5qc3NldC5oYXMoa2V5KXx8RmFpbCBgJHtxKGtleU5hbWUpfSBub3QgZm91bmQ6ICR7a2V5fWA7XG5cbnJldHVybiBoYXJkZW4oe1xuaGFzOihrZXkpPT57XG4vKiBDaGVjayBpZiBhIGtleSBleGlzdHMuIFRoZSBrZXkgY2FuIGJlIGFueSBKYXZhU2NyaXB0IHZhbHVlLCovXG4vKiB0aG91Z2ggdGhlIGFuc3dlciB3aWxsIGFsd2F5cyBiZSBmYWxzZSBmb3Iga2V5cyB0aGF0IGNhbm5vdCBiZSBmb3VuZCovXG4vKiBpbiB0aGlzIHNldC4qL1xucmV0dXJuIGpzc2V0LmhhcyhrZXkpO1xuIH0sXG5cbmFkZDooa2V5KT0+e1xuYXNzZXJ0S2V5T2tUb0FkZChrZXkpO1xuanNzZXQuYWRkKGtleSk7XG4gfSxcbmRlbGV0ZTooa2V5KT0+e1xuYXNzZXJ0S2V5RXhpc3RzKGtleSk7XG5pZihhc3NlcnRLZXlPa1RvRGVsZXRlIT09dW5kZWZpbmVkKXtcbmFzc2VydEtleU9rVG9EZWxldGUoa2V5KTtcbiB9XG5qc3NldC5kZWxldGUoa2V5KTtcbiB9LFxuXG5hZGRBbGw6KGtleXMpPT57XG5pZihpc0NvcHlTZXQoa2V5cykpe1xua2V5cz1nZXRDb3B5U2V0S2V5cyhrZXlzKTtcbiB9XG5mb3IoY29uc3Qga2V5IG9mLyoqIEB0eXBlIHtJdGVyYWJsZTxLPn0gKi9rZXlzKXtcbmFzc2VydEtleU9rVG9BZGQoa2V5KTtcbmpzc2V0LmFkZChrZXkpO1xuIH1cbiB9fSk7XG5cbiB9O1xuXG4vKipcbiAqIFRoaXMgaXMgYSAqc2NhbGFyKiBzZXQgaW4gdGhhdCB0aGUga2V5cyBjYW4gb25seSBiZSBhdG9taWMgdmFsdWVzLCBwcmltaXRpdmVzXG4gKiBvciByZW1vdGFibGVzLiBPdGhlciBzdG9yZVNldHMgd2lsbCBhY2NlcHQsIGZvciBleGFtcGxlLCBjb3B5QXJyYXlzIGFuZFxuICogY29weVJlY29yZHMsIGFzIGtleXMgYW5kIGxvb2sgdGhlbSB1cCBiYXNlZCBvbiBlcXVhbGl0eSBvZiB0aGVpciBjb250ZW50cy5cbiAqXG4gKiBUT0RPIEZvciBub3csIHRoaXMgc2NhbGFyV2Vha1NldCBhY2NlcHRzIG9ubHkgcmVtb3RhYmxlcywgcmVmbGVjdGluZyB0aGVcbiAqIGNvbnN0cmFpbnRzIG9mIHRoZSB1bmRlcmx5aW5nIEphdmFTY3JpcHQgV2Vha1NldCBpdCB1c2VzIGludGVybmFsbHkuIEJ1dFxuICogaXQgc2hvdWxkIGFjY2VwdCB0aGUgcHJpbWl0aXZlcyBhcyB3ZWxsLCBzdG9yaW5nIHRoZW0gaW4gYSBzZXBhcmF0ZSBpbnRlcm5hbFxuICogc2V0LiBXaGF0IG1ha2VzIGl0IFwid2Vha1wiIGlzIHRoYXQgaXQgcHJvdmlkZXMgbm8gQVBJIGZvciBlbnVtZXJhdGluZyB3aGF0J3NcbiAqIHRoZXJlLiBUaG91Z2ggbm90ZSB0aGF0IHRoaXMgd291bGQgb25seSBlbmFibGVzIGNvbGxlY3Rpb24gb2YgdGhlXG4gKiByZW1vdGFibGVzLCBzaW5jZSB0aGUgb3RoZXIgcHJpbWl0aXZlcyBtYXkgYWx3YXlzIGFwcGVhci5cbiAqXG4gKiBAdGVtcGxhdGUgS1xuICogQHBhcmFtIHtzdHJpbmd9IFt0YWc9J2tleSddIC0gdGFnIGZvciBkZWJ1Z2dpbmdcbiAqIEBwYXJhbSB7U3RvcmVPcHRpb25zfSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHtXZWFrU2V0U3RvcmU8Sz59XG4gKi8kaOKAjV9vbmNlLm1ha2VXZWFrU2V0U3RvcmVNZXRob2RzKG1ha2VXZWFrU2V0U3RvcmVNZXRob2RzKTtcbmNvbnN0ICAgICAgICBtYWtlU2NhbGFyV2Vha1NldFN0b3JlPShcbnRhZz0na2V5Jyxcbntsb25nTGl2ZWQ9dHJ1ZSxrZXlTaGFwZT11bmRlZmluZWR9PXt9KT0+XG57XG5jb25zdCBqc3NldD1uZXcobG9uZ0xpdmVkP1dlYWtTZXQ6U2V0KSgpO1xuaWYoa2V5U2hhcGUhPT11bmRlZmluZWQpe1xuYXNzZXJ0UGF0dGVybihrZXlTaGFwZSk7XG4gfVxuXG5jb25zdCBhc3NlcnRLZXlPa1RvQWRkPShrZXkpPT57XG4vKiBUT0RPOiBKdXN0IGEgdHJhbnNpdGlvbiBrbHVkZ2UuIFJlbW92ZSB3aGVuIHBvc3NpYmxlLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy8zNjA2Ki9cbmhhcmRlbihrZXkpO1xucGFzc1N0eWxlT2Yoa2V5KT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYE9ubHkgcmVtb3RhYmxlcyBjYW4gYmUga2V5cyBvZiBzY2FsYXIgV2Vha1N0b3JlczogJHtrZXl9YDtcbmlmKGtleVNoYXBlIT09dW5kZWZpbmVkKXtcbm11c3RNYXRjaChrZXksa2V5U2hhcGUsJ3dlYWtTZXRTdG9yZSBrZXknKTtcbiB9XG4gfTtcblxucmV0dXJuIEZhciggYHNjYWxhciBXZWFrU2V0U3RvcmUgb2YgJHtxKHRhZyl9YCx7XG4uLi5tYWtlV2Vha1NldFN0b3JlTWV0aG9kcyhqc3NldCxhc3NlcnRLZXlPa1RvQWRkLHVuZGVmaW5lZCx0YWcpfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZVNjYWxhcldlYWtTZXRTdG9yZShtYWtlU2NhbGFyV2Vha1NldFN0b3JlKTtcbmhhcmRlbihtYWtlU2NhbGFyV2Vha1NldFN0b3JlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlV2Vha1NldFN0b3JlTWV0aG9kcyI6WyJtYWtlV2Vha1NldFN0b3JlTWV0aG9kcyJdLCJtYWtlU2NhbGFyV2Vha1NldFN0b3JlIjpbIm1ha2VTY2FsYXJXZWFrU2V0U3RvcmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAstdjCJ0ZAACdGQAANAAAAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy9zdG9yZXMvc3RvcmUtdXRpbHMuanN7ImltcG9ydHMiOlsiQGVuZG8vbWFyc2hhbCIsIkBlbmRvL3BhdHRlcm5zIl0sImV4cG9ydHMiOlsiYXBwZW5kVG9TdG9yZWRBcnJheSIsImlzQ29weU1hcCIsImlzQ29weVNldCIsIm1ha2VBdG9taWNQcm92aWRlciIsIm1ha2VDdXJyZW50S2V5c0tpdCIsInByb3ZpZGVMYXp5Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhcixNLG1hdGNoZXM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcGF0dGVybnNcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dLFtcIm1hdGNoZXNcIiwgWyRo4oCNX2EgPT4gKG1hdGNoZXMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5jb25zdHtGYWlsLHF1b3RlOnF9PWFzc2VydDtcblxuLyoqXG4gKiBTaG91bGQgYmVoYXZlIGlkZW50aWNhbGx5IHRvIHRoZSBvbmUgaW4gYEBlbmRvL3BhdHRlcm5zYCwgYnV0XG4gKiByZWltcGxlbWVudGVkIGZvciBub3cgYmVjYXVzZSBgQGVuZG8vcGF0dGVybnNgIGZvcmdvdCB0byBleHBvcnQgdGhpcyBvbmUuXG4gKiBUaGlzIG9uZSBpcyBzaW1wbGUgZW5vdWdoIHRoYXQgSSBwcmVmZXIgYSByZWltcGxlbWVudGF0aW9uIHRvIGEgZGVlcCBpbXBvcnQuXG4gKiBUT0RPOiBVbmRhdGUgYEBlbmRvL3BhdHRlcm5zYCB0byBleHBvcnQgdGhlIG9yaWdpbmFsLCBhbmQgZGVsZXRlIHRoZVxuICogcmVpbXBsZW1lbnRhdGlvbiBoZXJlLlxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNcbiAqIEByZXR1cm5zIHtzIGlzIENvcHlTZXR9XG4gKi9cbmNvbnN0ICAgICAgICBpc0NvcHlTZXQ9KHMpPT5tYXRjaGVzKHMsTS5zZXQoKSk7XG5cbi8qKlxuICogU2hvdWxkIGJlaGF2ZSBpZGVudGljYWxseSB0byB0aGUgb25lIGluIGBAZW5kby9wYXR0ZXJuc2AsIGJ1dFxuICogcmVpbXBsZW1lbnRlZCBmb3Igbm93IGJlY2F1c2UgYEBlbmRvL3BhdHRlcm5zYCBmb3Jnb3QgdG8gZXhwb3J0IHRoaXMgb25lLlxuICogVGhpcyBvbmUgaXMgc2ltcGxlIGVub3VnaCB0aGF0IEkgcHJlZmVyIGEgcmVpbXBsZW1lbnRhdGlvbiB0byBhIGRlZXAgaW1wb3J0LlxuICogVE9ETzogVW5kYXRlIGBAZW5kby9wYXR0ZXJuc2AgdG8gZXhwb3J0IHRoZSBvcmlnaW5hbCwgYW5kIGRlbGV0ZSB0aGVcbiAqIHJlaW1wbGVtZW50YXRpb24gaGVyZS5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBtXG4gKiBAcmV0dXJucyB7bSBpcyBDb3B5TWFwfVxuICovJGjigI1fb25jZS5pc0NvcHlTZXQoaXNDb3B5U2V0KTtcbmNvbnN0ICAgICAgICBpc0NvcHlNYXA9KG0pPT5tYXRjaGVzKG0sTS5tYXAoKSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEssVlxuICogQHR5cGVkZWYge29iamVjdH0gQ3VycmVudEtleXNLaXRcbiAqIEBwcm9wZXJ0eSB7KGs6IEssIHY/OiBWKSA9PiB2b2lkfSBhc3NlcnRVcGRhdGVPbkFkZFxuICogQHByb3BlcnR5IHsoazogSykgPT4gdm9pZH0gYXNzZXJ0VXBkYXRlT25EZWxldGVcbiAqIEBwcm9wZXJ0eSB7SXRlcmFibGU8Sz59IGl0ZXJhYmxlS2V5c1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIEssVlxuICogQHBhcmFtIHsoKSA9PiBJdGVyYWJsZTxLPn0gZ2V0UmF3S2V5c1xuICogQHBhcmFtIHsoazogSykgPT4gYm9vbGVhbn0gY2hlY2tIYXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEBwYXJhbSB7KGs6IEssIHY/OiBWKSA9PiB2b2lkfSBhc3NlcnRPa1RvQWRkXG4gKiBAcGFyYW0geyhrOiBLKSA9PiB2b2lkfSBbYXNzZXJ0T2tUb0RlbGV0ZV1cbiAqIEBwYXJhbSB7c3RyaW5nfSBba2V5TmFtZV1cbiAqIEByZXR1cm5zIHtDdXJyZW50S2V5c0tpdDxLLFY+fVxuICovJGjigI1fb25jZS5pc0NvcHlNYXAoaXNDb3B5TWFwKTtcbmNvbnN0ICAgICAgICBtYWtlQ3VycmVudEtleXNLaXQ9KFxuZ2V0UmF3S2V5cyxcbmNoZWNrSGFzLFxuY29tcGFyZSxcbmFzc2VydE9rVG9BZGQsXG5hc3NlcnRPa1RvRGVsZXRlPXVuZGVmaW5lZCxcbmtleU5hbWU9J2tleScpPT5cbntcbmxldCB1cGRhdGVDb3VudD0wO1xubGV0IHNvcnRlZEtleXNNZW1vO1xuXG5jb25zdCBhc3NlcnRVcGRhdGVPbkFkZD0oayx2PXVuZGVmaW5lZCk9PntcbmFzc2VydE9rVG9BZGQoayx2KTtcbnVwZGF0ZUNvdW50Kz0xO1xuc29ydGVkS2V5c01lbW89dW5kZWZpbmVkO1xuIH07XG5cbmNvbnN0IGFzc2VydFVwZGF0ZU9uRGVsZXRlPShrKT0+YXNzZXJ0T2tUb0RlbGV0ZSYmYXNzZXJ0T2tUb0RlbGV0ZShrKTtcblxuY29uc3QgZ2V0U29ydGVkS2V5cz0oKT0+e1xuaWYoc29ydGVkS2V5c01lbW89PT11bmRlZmluZWQpe1xuc29ydGVkS2V5c01lbW89aGFyZGVuKFsuLi5nZXRSYXdLZXlzKCldLnNvcnQoY29tcGFyZSkpO1xuIH1cbnJldHVybiBzb3J0ZWRLZXlzTWVtbztcbiB9O1xuXG5jb25zdCBpdGVyYWJsZUtleXM9RmFyKCdJdGVyYWJsZSBvZiBrZXlzJyx7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xuY29uc3QgZ2VuZXJhdGlvbj11cGRhdGVDb3VudDtcbmdldFNvcnRlZEtleXMoKTtcbmNvbnN0IGxlbj1zb3J0ZWRLZXlzTWVtby5sZW5ndGg7XG5sZXQgaT0wO1xucmV0dXJuIEZhcignSXRlcmF0b3Igb2Yga2V5cycse1xubmV4dDooKT0+e1xuZ2VuZXJhdGlvbj09PXVwZGF0ZUNvdW50fHxGYWlsIGBTdG9yZSAke3Eoa2V5TmFtZSl9IGN1cnNvciBzdGFsZWA7XG4vKiBJZiB0aGV5J3JlIGVxdWFsLCB0aGVuIHRoZSBzb3J0ZWRLZXlNZW1vIGlzIHRoZSBzYW1lIG9uZSovXG4vKiB3ZSBzdGFydGVkIHdpdGguKi9cbmZvcig7Oyl7XG5pZihpPGxlbil7XG5jb25zdCB2YWx1ZT1zb3J0ZWRLZXlzTWVtb1tpXTtcbmkrPTE7XG5pZihjaGVja0hhcyh2YWx1ZSkpe1xucmV0dXJuIGhhcmRlbih7ZG9uZTpmYWxzZSx2YWx1ZX0pO1xuIH1cbiB9ZWxzZXtcbnJldHVybiBoYXJkZW4oe2RvbmU6dHJ1ZSx2YWx1ZTp1bmRlZmluZWR9KTtcbiB9XG4gfVxuIH19KTtcblxuIH19KTtcblxuXG5yZXR1cm4gaGFyZGVuKHtcbmFzc2VydFVwZGF0ZU9uQWRkLFxuYXNzZXJ0VXBkYXRlT25EZWxldGUsXG5pdGVyYWJsZUtleXN9KTtcblxuIH07JGjigI1fb25jZS5tYWtlQ3VycmVudEtleXNLaXQobWFrZUN1cnJlbnRLZXlzS2l0KTtcbmhhcmRlbihtYWtlQ3VycmVudEtleXNLaXQpO1xuXG4vKipcbiAqIENhbGwgYHByb3ZpZGVMYXp5YCB0byBnZXQgb3IgbWFrZSB0aGUgdmFsdWUgYXNzb2NpYXRlZCB3aXRoIHRoZSBrZXkuXG4gKiBJZiB0aGVyZSBhbHJlYWR5IGlzIG9uZSwgcmV0dXJuIHRoYXQuIE90aGVyd2lzZSxcbiAqIGNhbGwgYG1ha2VWYWx1ZShrZXkpYCwgcmVtZW1iZXIgaXQgYXMgdGhlIHZhbHVlIGZvclxuICogdGhhdCBrZXksIGFuZCByZXR1cm4gaXQuXG4gKlxuICogQHRlbXBsYXRlIEssVlxuICogQHBhcmFtIHtXZWFrTWFwU3RvcmU8SyxWPn0gbWFwU3RvcmVcbiAqIEBwYXJhbSB7S30ga2V5XG4gKiBAcGFyYW0geyhrZXk6IEspID0+IFZ9IG1ha2VWYWx1ZVxuICogQHJldHVybnMge1Z9XG4gKi9cbmNvbnN0ICAgICAgICBwcm92aWRlTGF6eT0obWFwU3RvcmUsa2V5LG1ha2VWYWx1ZSk9PntcbmlmKCFtYXBTdG9yZS5oYXMoa2V5KSl7XG5tYXBTdG9yZS5pbml0KGtleSxtYWtlVmFsdWUoa2V5KSk7XG4gfVxucmV0dXJuIG1hcFN0b3JlLmdldChrZXkpO1xuIH07JGjigI1fb25jZS5wcm92aWRlTGF6eShwcm92aWRlTGF6eSk7XG5oYXJkZW4ocHJvdmlkZUxhenkpO1xuXG4vKipcbiAqIEhlbHBlciBmb3IgdXNlIGNhc2VzIGluIHdoaWNoIHRoZSBtYWtlciBmdW5jdGlvbiBpcyBhc3luYy5cbiAqIEZvciB0d28gcHJvdmlkZUxhenkgY2FsbHMgd2l0aCB0aGUgc2FtZSBrZXksIG9uZSBtYXkgYmUgbWFraW5nIHdoZW4gdGhlXG4gKiBvdGhlciBjYWxsIHN0YXJ0cyBhbmQgaXQgd291bGQgbWFrZSBhZ2Fpbi5cbiAqIChUaGVuIHRoZXJlJ2QgYmUgYSBjb2xsaXNpb24gd2hlbiB0aGUgc2Vjb25kIHRyaWVzIHRvIHN0b3JlXG4gKiB0aGUga2V5LikgVGhpcyBwcmV2ZW50cyB0aGF0IHJhY2UgY29uZGl0aW9uIGJ5IGltbWVkaWF0ZWx5IHN0b3JpbmcgYSBQcm9taXNlXG4gKiBmb3IgdGhlIG1ha2VyIGluIGFuIGVwaGVtZXJhbCBzdG9yZS5cbiAqXG4gKiBXaGVuIHRoZSBgc3RvcmVgIGFyZ3VtZW50IGlzIGR1cmFibGUgc3RvcmFnZSwgbm90ZSB0aGF0IGl0J3MgcG9zc2libGUgZm9yXG4gKiB0ZXJtaW5hdGlvbiB0byBoYXBwZW4gYWZ0ZXIgdGhlIG1ha2UgY29tcGxldGVzIGFuZCBiZWZvcmUgaXQgcmVhY2hlcyBkdXJhYmxlXG4gKiBzdG9yYWdlLlxuICpcbiAqIEB0ZW1wbGF0ZSBLXG4gKiBAdGVtcGxhdGUgVlxuICogQHBhcmFtIHtXZWFrTWFwU3RvcmU8SywgVj59IHN0b3JlXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQXRvbWljUHJvdmlkZXI9KHN0b3JlKT0+e1xuLyoqIEB0eXBlIHtNYXA8SywgUHJvbWlzZTxWPj59ICovXG5jb25zdCBwZW5kaW5nPW5ldyBNYXAoKTtcblxuLyoqXG4gKiBDYWxsIGBwcm92aWRlQXN5bmNgIHRvIGdldCBvciBtYWtlIHRoZSB2YWx1ZSBhc3NvY2lhdGVkIHdpdGggdGhlIGtleSxcbiAqIHdoZW4gdGhlIG1ha2VyIGlzIGFzeW5jaHJvbm91cy5cbiAqIElmIHRoZXJlIGFscmVhZHkgaXMgb25lLCByZXR1cm4gdGhhdC4gT3RoZXJ3aXNlLFxuICogY2FsbCBgbWFrZVZhbHVlKGtleSlgLCByZW1lbWJlciBpdCBhcyB0aGUgdmFsdWUgZm9yXG4gKiB0aGF0IGtleSwgYW5kIHJldHVybiBpdC5cbiAqXG4gKiBAcGFyYW0ge0t9IGtleVxuICogQHBhcmFtIHsoa2V5OiBLKSA9PiBQcm9taXNlPFY+fSBtYWtlVmFsdWUgbWFrZSB0aGUgdmFsdWUgZm9yIHRoZSBzdG9yZVxuICogaWYgaXQgaGFzbid0IGJlZW4gbWFkZSB5ZXQgb3IgdGhlIGxhc3QgbWFrZSBmYWlsZWRcbiAqIEBwYXJhbSB7KGtleTogSywgdmFsdWU6IFYpID0+IFByb21pc2U8dm9pZD59IFtmaW5pc2hWYWx1ZV0gcnVucyBleGFjdGx5XG4gKiBvbmNlIGFmdGVyIGEgbmV3IHZhbHVlIGlzIGFkZGVkIHRvIHRoZSBzdG9yZVxuICogQHJldHVybnMge1Byb21pc2U8Vj59XG4gKi9cbmNvbnN0IHByb3ZpZGVBc3luYz0oa2V5LG1ha2VWYWx1ZSxmaW5pc2hWYWx1ZSk9PntcbmlmKHN0b3JlLmhhcyhrZXkpKXtcbnJldHVybiBQcm9taXNlLnJlc29sdmUoc3RvcmUuZ2V0KGtleSkpO1xuIH1cbmlmKCFwZW5kaW5nLmhhcyhrZXkpKXtcbmNvbnN0IHZhbFA9bWFrZVZhbHVlKGtleSkuXG50aGVuKCh2KT0+e1xuc3RvcmUuaW5pdChrZXksdik7XG5yZXR1cm4gdjtcbiB9KS5cbnRoZW4oKHYpPT57XG5pZihmaW5pc2hWYWx1ZSl7XG5yZXR1cm4gZmluaXNoVmFsdWUoa2V5LHYpLnRoZW4oKCk9PnYpO1xuIH1cbnJldHVybiB2O1xuIH0pLlxuZmluYWxseSgoKT0+e1xucGVuZGluZy5kZWxldGUoa2V5KTtcbiB9KTtcbnBlbmRpbmcuc2V0KGtleSx2YWxQKTtcbiB9XG5jb25zdCB2YWxQPXBlbmRpbmcuZ2V0KGtleSk7XG5hc3NlcnQodmFsUCk7XG5yZXR1cm4gdmFsUDtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKHtwcm92aWRlQXN5bmN9KTtcbiB9OyRo4oCNX29uY2UubWFrZUF0b21pY1Byb3ZpZGVyKG1ha2VBdG9taWNQcm92aWRlcik7XG5oYXJkZW4obWFrZUF0b21pY1Byb3ZpZGVyKTtcbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEB0ZW1wbGF0ZSBWXG4gKiBAdHlwZWRlZiB7UmV0dXJuVHlwZTx0eXBlb2YgbWFrZUF0b21pY1Byb3ZpZGVyPEssIFY+Pn0gQXRvbWljUHJvdmlkZXI8SywgVj5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBLLCBWXG4gKiBAcGFyYW0ge01hcFN0b3JlPEssIFZbXT59IG1hcFN0b3JlXG4gKiBAcGFyYW0ge0t9IGtleVxuICogQHBhcmFtIHtWfSBpdGVtXG4gKi9cbmNvbnN0ICAgICAgICBhcHBlbmRUb1N0b3JlZEFycmF5PShtYXBTdG9yZSxrZXksaXRlbSk9PntcbmlmKG1hcFN0b3JlLmhhcyhrZXkpKXtcbmNvbnN0IGV4dGFudD1tYXBTdG9yZS5nZXQoa2V5KTtcbm1hcFN0b3JlLnNldChrZXksaGFyZGVuKFsuLi5leHRhbnQsaXRlbV0pKTtcbiB9ZWxzZXtcbm1hcFN0b3JlLmluaXQoa2V5LGhhcmRlbihbaXRlbV0pKTtcbiB9XG4gfTskaOKAjV9vbmNlLmFwcGVuZFRvU3RvcmVkQXJyYXkoYXBwZW5kVG9TdG9yZWRBcnJheSk7XG5oYXJkZW4oYXBwZW5kVG9TdG9yZWRBcnJheSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNDb3B5U2V0IjpbImlzQ29weVNldCJdLCJpc0NvcHlNYXAiOlsiaXNDb3B5TWFwIl0sIm1ha2VDdXJyZW50S2V5c0tpdCI6WyJtYWtlQ3VycmVudEtleXNLaXQiXSwicHJvdmlkZUxhenkiOlsicHJvdmlkZUxhenkiXSwibWFrZUF0b21pY1Byb3ZpZGVyIjpbIm1ha2VBdG9taWNQcm92aWRlciJdLCJhcHBlbmRUb1N0b3JlZEFycmF5IjpbImFwcGVuZFRvU3RvcmVkQXJyYXkiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAxQCsglgqAABYKgAAJwAAAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuUGFzc1N0eWxlfSBQYXNzU3R5bGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNvcHlUYWdnZWR9IENvcHlUYWdnZWQgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNvcHlSZWNvcmQ8VD59IENvcHlSZWNvcmQgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNvcHlBcnJheTxUPn0gQ29weUFycmF5ICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5DaGVja2VyfSBDaGVja2VyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwvc3JjL3JhbmtPcmRlcicpLlJhbmtDb21wYXJlfSBSYW5rQ29tcGFyZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsL3NyYy9yYW5rT3JkZXInKS5SYW5rQ29tcGFyaXNvbn0gUmFua0NvbXBhcmlzb24gKi9cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuLyogUGxhY2Vob2xkZXIgcmVkdW5kYW50IHR5cGVzLCB0byBiZSBpbXBvcnRlZCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZC4qL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtQYXNzYWJsZX0gS2V5XG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtQYXNzYWJsZX0gUGF0dGVyblxuICogVE9ETyBwbGFjZWhvbGRlci4gRmlndXJlIG91dCBob3cgdG8gaW1wb3J0IGZyb20gYEBlbmRvL3BhdHRlcm5zYCBpbnN0ZWFkXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gW0s9S2V5XVxuICogQHR5cGVkZWYge0NvcHlUYWdnZWQgJiB7XG4gKiAgIFtTeW1ib2wudG9TdHJpbmdUYWddOiAnY29weVNldCcsXG4gKiAgIHBheWxvYWQ6IEFycmF5PEs+LFxuICogfX0gQ29weVNldFxuICogVE9ETyBwbGFjZWhvbGRlci4gRmlndXJlIG91dCBob3cgdG8gaW1wb3J0IGZyb20gYEBlbmRvL3BhdHRlcm5zYCBpbnN0ZWFkXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gW0s9S2V5XVxuICogQHR5cGVkZWYge0NvcHlUYWdnZWQgJiB7XG4gKiAgIFtTeW1ib2wudG9TdHJpbmdUYWddOiAnY29weUJhZycsXG4gKiAgIHBheWxvYWQ6IEFycmF5PFtLLCBiaWdpbnRdPixcbiAqIH19IENvcHlCYWdcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV1cbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFtWPVBhc3NhYmxlXVxuICogQHR5cGVkZWYge0NvcHlUYWdnZWQgJiB7XG4gKiAgIFtTeW1ib2wudG9TdHJpbmdUYWddOiAnY29weU1hcCcsXG4gKiAgIHBheWxvYWQ6IHsga2V5czogQXJyYXk8Sz4sIHZhbHVlczogQXJyYXk8Vj4gfSxcbiAqIH19IENvcHlNYXBcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gR3VhcmRNYWtlcnNcbiAqIEBwcm9wZXJ0eSB7PE0gZXh0ZW5kcyBSZWNvcmQ8YW55LCBhbnk+PihpbnRlcmZhY2VOYW1lOiBzdHJpbmcsXG4gKiAgICAgICAgICAgICBtZXRob2RHdWFyZHM6IE0sXG4gKiAgICAgICAgICAgICBvcHRpb25zPzoge3Nsb3BweT86IGJvb2xlYW59XG4gKiApID0+IEludGVyZmFjZUd1YXJkfSBpbnRlcmZhY2VcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICpcbiAqIEBwcm9wZXJ0eSB7KC4uLmFyZ0d1YXJkczogQXJnR3VhcmRbXSkgPT4gTWV0aG9kR3VhcmRNYWtlcn0gY2FsbCBHdWFyZCBhIHN5bmNocm9ub3VzIGNhbGxcbiAqXG4gKiBAcHJvcGVydHkgeyguLi5hcmdHdWFyZHM6IEFyZ0d1YXJkW10pID0+IE1ldGhvZEd1YXJkTWFrZXJ9IGNhbGxXaGVuIEd1YXJkIGFuIGFzeW5jIGNhbGxcbiAqXG4gKiBAcHJvcGVydHkgeyhhcmdHdWFyZDogQXJnR3VhcmQpID0+IEFyZ0d1YXJkfSBhd2FpdCBHdWFyZCBhbiBhd2FpdFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYgeyguLi5hcmdzOiBhbnlbXSkgPT4gYW55fSBNZXRob2RcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge3tcbiAqIGtsYXNzOiAnSW50ZXJmYWNlJyxcbiAqIGludGVyZmFjZU5hbWU6IHN0cmluZyxcbiAqIG1ldGhvZEd1YXJkczogUmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgTWV0aG9kR3VhcmQ+XG4gKiBzbG9wcHk/OiBib29sZWFuXG4gKiB9fSBJbnRlcmZhY2VHdWFyZFxuICogVE9ETyBwbGFjZWhvbGRlci4gRmlndXJlIG91dCBob3cgdG8gaW1wb3J0IGZyb20gYEBlbmRvL3BhdHRlcm5zYCBpbnN0ZWFkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7YW55fSBNZXRob2RHdWFyZE1ha2VyXG4gKiBUT0RPIHBsYWNlaG9sZGVyLiBGaWd1cmUgb3V0IGhvdyB0byBpbXBvcnQgZnJvbSBgQGVuZG8vcGF0dGVybnNgIGluc3RlYWRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHt7IGtsYXNzOiAnbWV0aG9kR3VhcmQnLCBjYWxsS2luZDogJ3N5bmMnIHwgJ2FzeW5jJywgcmV0dXJuR3VhcmQ6IHVua25vd24gfX0gTWV0aG9kR3VhcmRcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge2FueX0gQXJnR3VhcmRcbiAqIFRPRE8gcGxhY2Vob2xkZXIuIEZpZ3VyZSBvdXQgaG93IHRvIGltcG9ydCBmcm9tIGBAZW5kby9wYXR0ZXJuc2AgaW5zdGVhZFxuICovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yZU9wdGlvbnNcbiAqIE9mIHRoZSBkaW1lbnNpb25zIG9uIHdoaWNoIEtleWVkU3RvcmVzIGNhbiBkaWZmZXIsIHdlIG9ubHkgcmVwcmVzZW50IGEgZmV3XG4gKiBvZiB0aGVtIGFzIHN0YW5kYXJkIG9wdGlvbnMuIEEgZ2l2ZW4gc3RvcmUgbWFrZXIgc2hvdWxkIGRvY3VtZW50IHdoaWNoXG4gKiBvcHRpb25zIGl0IHN1cHBvcnRzLCBhcyB3ZWxsIGFzIGl0cyBwb3NpdGlvbnMgb24gZGltZW5zaW9ucyBmb3Igd2hpY2ggaXRcbiAqIGRvZXMgbm90IHN1cHBvcnQgb3B0aW9ucy5cbiAqIEBwcm9wZXJ0eSB7Ym9vbGVhbn0gW2xvbmdMaXZlZD10cnVlXSBXaGljaCB3YXkgdG8gb3B0aW1pemUgYSB3ZWFrIHN0b3JlLiBUcnVlIG1lYW5zXG4gKiB0aGF0IHdlIGV4cGVjdCB0aGlzIHdlYWsgc3RvcmUgdG8gb3V0bGl2ZSBtb3N0IG9mIGl0cyBrZXlzLCBpbiB3aGljaFxuICogY2FzZSB3ZSBpbnRlcm5hbGx5IG1heSB1c2UgYSBKYXZhU2NyaXB0IGBXZWFrTWFwYC4gT3RoZXJ3aXNlIHdlIGludGVybmFsbHlcbiAqIG1heSB1c2UgYSBKYXZhU2NyaXB0IGBNYXBgLlxuICogRGVmYXVsdHMgdG8gdHJ1ZSwgc28gcGxlYXNlIG1hcmsgc2hvcnQgbGl2ZWQgc3RvcmVzIGV4cGxpY2l0bHkuXG4gKiBAcHJvcGVydHkge2Jvb2xlYW59IFtkdXJhYmxlPWZhbHNlXSAgVGhlIGNvbnRlbnRzIG9mIHRoaXMgc3RvcmUgc3Vydml2ZSB0ZXJtaW5hdGlvblxuICogICBvZiBpdHMgY29udGFpbmluZyBwcm9jZXNzLCBhbGxvd2luZyBmb3IgcmVzdGFydCBvciB1cGdyYWRlIGJ1dCBhdCB0aGUgY29zdFxuICogICBvZiBmb3JiaWRkaW5nIHN0b3JhZ2Ugb2YgcmVmZXJlbmNlcyB0byBlcGhlbWVyYWwgZGF0YS4gIERlZmF1bHRzIHRvIGZhbHNlLlxuICogQHByb3BlcnR5IHtib29sZWFufSBbZmFrZUR1cmFibGU9ZmFsc2VdICBUaGlzIHN0b3JlIHByZXRlbmRzIHRvIGJlIGEgZHVyYWJsZSBzdG9yZVxuICogICBidXQgZG9lcyBub3QgZW5mb3JjZSB0aGF0IHRoZSB0aGluZ3Mgc3RvcmVkIGluIGl0IGFjdHVhbGx5IGJlIHRoZW1zZWx2ZXNcbiAqICAgZHVyYWJsZSAod2hlcmVhcyBhbiBhY3R1YWwgZHVyYWJsZSBzdG9yZSB3b3VsZCBmb3JiaWQgc3RvcmFnZSBvZiBzdWNoXG4gKiAgIGl0ZW1zKS4gIFRoaXMgaXMgaW4gc2VydmljZSBvZiBhbGxvd2luZyBpbmNyZW1lbnRhbCB0cmFuc2l0aW9uIHRvIHVzZSBvZlxuICogICBkdXJhYmxlIHN0b3JlcywgdG8gZW5hYmxlIG5vcm1hbCBvcGVyYXRpb24gYW5kIHRlc3Rpbmcgd2hlbiBzb21lIHN0dWZmXG4gKiAgIGludGVuZGVkIHRvIGV2ZW50dWFsbHkgYmUgZHVyYWJsZSBoYXMgbm90IHlldCBiZWVuIG1hZGUgZHVyYWJsZS4gIEEgc3RvcmVcbiAqICAgbWFya2VkIGFzIGZha2VEdXJhYmxlIHdpbGwgYXBwZWFyIHRvIG9wZXJhdGUgbm9ybWFsbHkgYnV0IGFueSBhdHRlbXB0IHRvXG4gKiAgIHVwZ3JhZGUgaXRzIGNvbnRhaW5pbmcgdmF0IHdpbGwgZmFpbCB3aXRoIGFuIGVycm9yLlxuICogQHByb3BlcnR5IHtQYXR0ZXJufSBba2V5U2hhcGVdXG4gKiBAcHJvcGVydHkge1BhdHRlcm59IFt2YWx1ZVNoYXBlXVxuICovXG5cbi8qKlxuICogTW9zdCBzdG9yZSBtZXRob2RzIGFyZSBpbiBvbmUgb2YgdGhyZWUgY2F0ZWdvcmllc1xuICogICAqIGxvb2t1cCBtZXRob2RzIChgaGFzYCxgZ2V0YClcbiAqICAgKiB1cGRhdGUgbWV0aG9kcyAoYGFkZGAsYGluaXRgLGBzZXRgLGBkZWxldGVgLGBhZGRBbGxgKVxuICogICAqIHF1ZXJ5IG1ldGhvZHMgKGBzbmFwc2hvdGAsYGtleXNgLGB2YWx1ZXNgLGBlbnRyaWVzYCxgZ2V0U2l6ZWApXG4gKiAgICogcXVlcnktdXBkYXRlIG1ldGhvZHMgKGBjbGVhcmApXG4gKlxuICogV2Vha1N0b3JlcyBoYXZlIHRoZSBsb29rdXAgYW5kIHVwZGF0ZSBtZXRob2RzIGJ1dCBub3QgdGhlIHF1ZXJ5XG4gKiBvciBxdWVyeS11cGRhdGUgbWV0aG9kcy5cbiAqIE5vbi13ZWFrIFN0b3JlcyBhcmUgbGlrZSB0aGVpciBjb3JyZXNwb25kaW5nIFdlYWtTdG9yZXMsIGJ1dCB3aXRoIHRoZVxuICogYWRkaXRpb25hbCBxdWVyeSBhbmQgcXVlcnktdXBkYXRlIG1ldGhvZHMuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleSAmIG9iamVjdH0gW0s9S2V5XVxuICogQHR5cGVkZWYge29iamVjdH0gV2Vha1NldFN0b3JlXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IGJvb2xlYW59IGhhc1xuICogQ2hlY2sgaWYgYSBrZXkgZXhpc3RzLiBUaGUga2V5IGNhbiBiZSBhbnkgSmF2YVNjcmlwdCB2YWx1ZSwgdGhvdWdoIHRoZVxuICogYW5zd2VyIHdpbGwgYWx3YXlzIGJlIGZhbHNlIGZvciBrZXlzIHRoYXQgY2Fubm90IGJlIGZvdW5kIGluIHRoaXMgc3RvcmUuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IHZvaWR9IGFkZFxuICogQWRkIHRoZSBrZXkgdG8gdGhlIHNldCBpZiBpdCBpcyBub3QgYWxyZWFkeSB0aGVyZS4gRG8gbm90aGluZyBzaWxlbnRseSBpZlxuICogYWxyZWFkeSB0aGVyZS5cbiAqIFRoZSBrZXkgbXVzdCBiZSBvbmUgYWxsb3dlZCBieSB0aGlzIHN0b3JlLiBGb3IgZXhhbXBsZSBhIHNjYWxhciBzdG9yZSBvbmx5XG4gKiBhbGxvd3MgcHJpbWl0aXZlcyBhbmQgcmVtb3RhYmxlcy5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gdm9pZH0gZGVsZXRlXG4gKiBSZW1vdmUgdGhlIGtleS4gVGhyb3dzIGlmIG5vdCBmb3VuZC5cbiAqIEBwcm9wZXJ0eSB7KGtleXM6IENvcHlTZXQ8Sz4gfCBJdGVyYWJsZTxLPikgPT4gdm9pZH0gYWRkQWxsXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gW0s9S2V5XVxuICogQHR5cGVkZWYge29iamVjdH0gU2V0U3RvcmVcbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gYm9vbGVhbn0gaGFzXG4gKiBDaGVjayBpZiBhIGtleSBleGlzdHMuIFRoZSBrZXkgY2FuIGJlIGFueSBKYXZhU2NyaXB0IHZhbHVlLCB0aG91Z2ggdGhlXG4gKiBhbnN3ZXIgd2lsbCBhbHdheXMgYmUgZmFsc2UgZm9yIGtleXMgdGhhdCBjYW5ub3QgYmUgZm91bmQgaW4gdGhpcyBzdG9yZS5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gdm9pZH0gYWRkXG4gKiBBZGQgdGhlIGtleSB0byB0aGUgc2V0IGlmIGl0IGlzIG5vdCBhbHJlYWR5IHRoZXJlLiBEbyBub3RoaW5nIHNpbGVudGx5IGlmXG4gKiBhbHJlYWR5IHRoZXJlLlxuICogVGhlIGtleSBtdXN0IGJlIG9uZSBhbGxvd2VkIGJ5IHRoaXMgc3RvcmUuIEZvciBleGFtcGxlIGEgc2NhbGFyIHN0b3JlIG9ubHlcbiAqIGFsbG93cyBwcmltaXRpdmVzIGFuZCByZW1vdGFibGVzLlxuICogQHByb3BlcnR5IHsoa2V5OiBLKSA9PiB2b2lkfSBkZWxldGVcbiAqIFJlbW92ZSB0aGUga2V5LiBUaHJvd3MgaWYgbm90IGZvdW5kLlxuICogQHByb3BlcnR5IHsoa2V5czogQ29weVNldDxLPiB8IEl0ZXJhYmxlPEs+KSA9PiB2b2lkfSBhZGRBbGxcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuKSA9PiBJdGVyYWJsZTxLPn0ga2V5c1xuICogQHByb3BlcnR5IHsoa2V5UGF0dD86IFBhdHRlcm4pID0+IEl0ZXJhYmxlPEs+fSB2YWx1ZXNcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuKSA9PiBDb3B5U2V0PEs+fSBzbmFwc2hvdFxuICogQHByb3BlcnR5IHsoa2V5UGF0dD86IFBhdHRlcm4pID0+IG51bWJlcn0gZ2V0U2l6ZVxuICogQHByb3BlcnR5IHsoa2V5UGF0dD86IFBhdHRlcm4pID0+IHZvaWR9IGNsZWFyXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleSAmIG9iamVjdH0gW0s9S2V5XVxuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gW1Y9UGFzc2FibGVdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBXZWFrTWFwU3RvcmVcbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gYm9vbGVhbn0gaGFzXG4gKiBDaGVjayBpZiBhIGtleSBleGlzdHMuIFRoZSBrZXkgY2FuIGJlIGFueSBKYXZhU2NyaXB0IHZhbHVlLCB0aG91Z2ggdGhlXG4gKiBhbnN3ZXIgd2lsbCBhbHdheXMgYmUgZmFsc2UgZm9yIGtleXMgdGhhdCBjYW5ub3QgYmUgZm91bmQgaW4gdGhpcyBzdG9yZS5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gVn0gZ2V0XG4gKiBSZXR1cm4gYSB2YWx1ZSBmb3IgdGhlIGtleS4gVGhyb3dzIGlmIG5vdCBmb3VuZC5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IGluaXRcbiAqIEluaXRpYWxpemUgdGhlIGtleSBvbmx5IGlmIGl0IGRvZXNuJ3QgYWxyZWFkeSBleGlzdC5cbiAqIFRoZSBrZXkgbXVzdCBiZSBvbmUgYWxsb3dlZCBieSB0aGlzIHN0b3JlLiBGb3IgZXhhbXBsZSBhIHNjYWxhciBzdG9yZSBvbmx5XG4gKiBhbGxvd3MgcHJpbWl0aXZlcyBhbmQgcmVtb3RhYmxlcy5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IHNldFxuICogU2V0IHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IHZvaWR9IGRlbGV0ZVxuICogUmVtb3ZlIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhlbnRyaWVzOiBDb3B5TWFwPEssVj4gfCBJdGVyYWJsZTxbSyxWXT4pID0+IHZvaWR9IGFkZEFsbFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV1cbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFtWPVBhc3NhYmxlXVxuICogQHR5cGVkZWYge29iamVjdH0gTWFwU3RvcmVcbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gYm9vbGVhbn0gaGFzXG4gKiBDaGVjayBpZiBhIGtleSBleGlzdHMuIFRoZSBrZXkgY2FuIGJlIGFueSBKYXZhU2NyaXB0IHZhbHVlLCB0aG91Z2ggdGhlXG4gKiBhbnN3ZXIgd2lsbCBhbHdheXMgYmUgZmFsc2UgZm9yIGtleXMgdGhhdCBjYW5ub3QgYmUgZm91bmQgaW4gdGhpcyBtYXBcbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gVn0gZ2V0XG4gKiBSZXR1cm4gYSB2YWx1ZSBmb3IgdGhlIGtleS4gVGhyb3dzIGlmIG5vdCBmb3VuZC5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IGluaXRcbiAqIEluaXRpYWxpemUgdGhlIGtleSBvbmx5IGlmIGl0IGRvZXNuJ3QgYWxyZWFkeSBleGlzdC5cbiAqIFRoZSBrZXkgbXVzdCBiZSBvbmUgYWxsb3dlZCBieSB0aGlzIHN0b3JlLiBGb3IgZXhhbXBsZSBhIHNjYWxhciBzdG9yZSBvbmx5XG4gKiBhbGxvd3MgcHJpbWl0aXZlcyBhbmQgcmVtb3RhYmxlcy5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IHNldFxuICogU2V0IHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IHZvaWR9IGRlbGV0ZVxuICogUmVtb3ZlIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhlbnRyaWVzOiBDb3B5TWFwPEssVj4gfCBJdGVyYWJsZTxbSyxWXT4pID0+IHZvaWR9IGFkZEFsbFxuICogQHByb3BlcnR5IHsoa2V5UGF0dD86IFBhdHRlcm4sIHZhbHVlUGF0dD86IFBhdHRlcm4pID0+IEl0ZXJhYmxlPEs+fSBrZXlzXG4gKiBAcHJvcGVydHkgeyhrZXlQYXR0PzogUGF0dGVybiwgdmFsdWVQYXR0PzogUGF0dGVybikgPT4gSXRlcmFibGU8Vj59IHZhbHVlc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGtleVBhdHQ/OiBQYXR0ZXJuLFxuICogICB2YWx1ZVBhdHQ/OiBQYXR0ZXJuXG4gKiApID0+IEl0ZXJhYmxlPFtLLFZdPn0gZW50cmllc1xuICogQHByb3BlcnR5IHsoa2V5UGF0dD86IFBhdHRlcm4sIHZhbHVlUGF0dD86IFBhdHRlcm4pID0+IENvcHlNYXA8SyxWPn0gc25hcHNob3RcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuLCB2YWx1ZVBhdHQ/OiBQYXR0ZXJuKSA9PiBudW1iZXJ9IGdldFNpemVcbiAqIEBwcm9wZXJ0eSB7KGtleVBhdHQ/OiBQYXR0ZXJuLCB2YWx1ZVBhdHQ/OiBQYXR0ZXJuKSA9PiB2b2lkfSBjbGVhclxuICovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gRGVwcmVjYXRlZCBMZWdhY3kgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgSyxWXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBMZWdhY3lXZWFrTWFwXG4gKiBMZWdhY3lXZWFrTWFwIGlzIGRlcHJlY2F0ZWQuIFVzZSBXZWFrTWFwU3RvcmUgaW5zdGVhZCBpZiBwb3NzaWJsZS5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gYm9vbGVhbn0gaGFzXG4gKiBDaGVjayBpZiBhIGtleSBleGlzdHNcbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gVn0gZ2V0XG4gKiBSZXR1cm4gYSB2YWx1ZSBmb3IgdGhlIGtleS4gVGhyb3dzIGlmIG5vdCBmb3VuZC5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IGluaXRcbiAqIEluaXRpYWxpemUgdGhlIGtleSBvbmx5IGlmIGl0XG4gKiBkb2Vzbid0IGFscmVhZHkgZXhpc3RcbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IHNldFxuICogU2V0IHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IHZvaWR9IGRlbGV0ZVxuICogUmVtb3ZlIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgSyxWXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBMZWdhY3lNYXBcbiAqIExlZ2FjeU1hcCBpcyBkZXByZWNhdGVkLiBVc2UgTWFwU3RvcmUgaW5zdGVhZCBpZiBwb3NzaWJsZS5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gYm9vbGVhbn0gaGFzXG4gKiBDaGVjayBpZiBhIGtleSBleGlzdHNcbiAqIEBwcm9wZXJ0eSB7KGtleTogSykgPT4gVn0gZ2V0XG4gKiBSZXR1cm4gYSB2YWx1ZSBmb3IgdGhlIGtleS4gVGhyb3dzIGlmIG5vdCBmb3VuZC5cbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IGluaXRcbiAqIEluaXRpYWxpemUgdGhlIGtleSBvbmx5IGlmIGl0XG4gKiBkb2Vzbid0IGFscmVhZHkgZXhpc3RcbiAqIEBwcm9wZXJ0eSB7KGtleTogSywgdmFsdWU6IFYpID0+IHZvaWR9IHNldFxuICogU2V0IHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeyhrZXk6IEspID0+IHZvaWR9IGRlbGV0ZVxuICogUmVtb3ZlIHRoZSBrZXkuIFRocm93cyBpZiBub3QgZm91bmQuXG4gKiBAcHJvcGVydHkgeygpID0+IEl0ZXJhYmxlPEs+fSBrZXlzXG4gKiBAcHJvcGVydHkgeygpID0+IEl0ZXJhYmxlPFY+fSB2YWx1ZXNcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gSXRlcmFibGU8W0ssVl0+fSBlbnRyaWVzXG4gKiBAcHJvcGVydHkgeygpID0+IG51bWJlcn0gZ2V0U2l6ZVxuICogQHByb3BlcnR5IHsoKSA9PiB2b2lkfSBjbGVhclxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAJgZO7M0AQAANAEAAC4AAABAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wL2V4cG9ydGVkLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAI5QuynZFQAA2RUAADwAAABAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wL3NyYy92YXRzL25ldHdvcmsvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKipcbiAqIEB0eXBlZGVmIHtzdHJpbmd8QnVmZmVyfEFycmF5QnVmZmVyfSBEYXRhXG4gKiBAdHlwZWRlZiB7c3RyaW5nfSBCeXRlc1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge3N0cmluZ30gRW5kcG9pbnQgQSBsb2NhbCBvciByZW1vdGUgYWRkcmVzc1xuICogU2VlIG11bHRpYWRkci5qcyBmb3IgYW4gb3BpbmlvbmF0ZWQgcm91dGVyIGltcGxlbWVudGF0aW9uXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDbG9zYWJsZSBBIGNsb3NhYmxlIG9iamVjdFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPHZvaWQ+fSBjbG9zZSBUZXJtaW5hdGUgdGhlIG9iamVjdFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUHJvdG9jb2wgVGhlIG5ldHdvcmsgUHJvdG9jb2xcbiAqIEBwcm9wZXJ0eSB7KHByZWZpeDogRW5kcG9pbnQpID0+IFByb21pc2U8UG9ydD59IGJpbmQgQ2xhaW0gYSBwb3J0LCBvciBpZiBlbmRpbmcgaW4gRU5EUE9JTlRfU0VQQVJBVE9SLCBhIGZyZXNoIG5hbWVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFBvcnQgQSBwb3J0IHRoYXQgaGFzIGJlZW4gYm91bmQgdG8gYSBwcm90b2NvbFxuICogQHByb3BlcnR5IHsoKSA9PiBFbmRwb2ludH0gZ2V0TG9jYWxBZGRyZXNzIEdldCB0aGUgbG9jYWxseSBib3VuZCBuYW1lIG9mIHRoaXMgcG9ydFxuICogQHByb3BlcnR5IHsoYWNjZXB0SGFuZGxlcjogTGlzdGVuSGFuZGxlcikgPT4gUHJvbWlzZTx2b2lkPn0gYWRkTGlzdGVuZXIgQmVnaW4gYWNjZXB0aW5nIGluY29taW5nIGNvbm5lY3Rpb25zXG4gKiBAcHJvcGVydHkgeyhyZW1vdGU6IEVuZHBvaW50LCBjb25uZWN0aW9uSGFuZGxlcj86IENvbm5lY3Rpb25IYW5kbGVyKSA9PiBQcm9taXNlPENvbm5lY3Rpb24+fSBjb25uZWN0IE1ha2UgYW4gb3V0Ym91bmQgY29ubmVjdGlvblxuICogQHByb3BlcnR5IHsoYWNjZXB0SGFuZGxlcjogTGlzdGVuSGFuZGxlcikgPT4gUHJvbWlzZTx2b2lkPn0gcmVtb3ZlTGlzdGVuZXIgUmVtb3ZlIHRoZSBjdXJyZW50bHktYm91bmQgbGlzdGVuZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gdm9pZH0gcmV2b2tlIERlYWxsb2NhdGUgdGhlIHBvcnQgZW50aXJlbHksIHJlbW92aW5nIGFsbCBsaXN0ZW5lcnMgYW5kIGNsb3NpbmcgYWxsIGFjdGl2ZSBjb25uZWN0aW9uc1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gTGlzdGVuSGFuZGxlciBBIGhhbmRsZXIgZm9yIGluY29taW5nIGNvbm5lY3Rpb25zXG4gKiBAcHJvcGVydHkgeyhwb3J0OiBQb3J0LCBsOiBMaXN0ZW5IYW5kbGVyKSA9PiBQcm9taXNlPHZvaWQ+fSBbb25MaXN0ZW5dIFRoZSBsaXN0ZW5lciBoYXMgYmVlbiByZWdpc3RlcmVkXG4gKiBAcHJvcGVydHkgeyhwb3J0OiBQb3J0LCBsb2NhbEFkZHI6IEVuZHBvaW50LCByZW1vdGVBZGRyOiBFbmRwb2ludCwgbDogTGlzdGVuSGFuZGxlcikgPT4gUHJvbWlzZTxDb25uZWN0aW9uSGFuZGxlcj59IG9uQWNjZXB0IEEgbmV3IGNvbm5lY3Rpb24gaXMgaW5jb21pbmdcbiAqIEBwcm9wZXJ0eSB7KHBvcnQ6IFBvcnQsIGxvY2FsQWRkcjogRW5kcG9pbnQsIHJlbW90ZUFkZHI6IEVuZHBvaW50LCBsOiBMaXN0ZW5IYW5kbGVyKSA9PiBQcm9taXNlPHZvaWQ+fSBbb25SZWplY3RdIFRoZSBjb25uZWN0aW9uIHdhcyByZWplY3RlZFxuICogQHByb3BlcnR5IHsocG9ydDogUG9ydCwgcmVqOiBhbnksIGw6IExpc3RlbkhhbmRsZXIpID0+IFByb21pc2U8dm9pZD59IFtvbkVycm9yXSBUaGVyZSB3YXMgYW4gZXJyb3Igd2hpbGUgbGlzdGVuaW5nXG4gKiBAcHJvcGVydHkgeyhwb3J0OiBQb3J0LCBsOiBMaXN0ZW5IYW5kbGVyKSA9PiBQcm9taXNlPHZvaWQ+fSBbb25SZW1vdmVdIFRoZSBsaXN0ZW5lciBoYXMgYmVlbiByZW1vdmVkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb25uZWN0aW9uXG4gKiBAcHJvcGVydHkgeyhwYWNrZXRCeXRlczogRGF0YSwgb3B0cz86IFJlY29yZDxzdHJpbmcsIGFueT4pID0+IFByb21pc2U8Qnl0ZXM+fSBzZW5kIFNlbmQgYSBwYWNrZXQgb24gdGhlIGNvbm5lY3Rpb25cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTx2b2lkPn0gY2xvc2UgQ2xvc2UgYm90aCBlbmRzIG9mIHRoZSBjb25uZWN0aW9uXG4gKiBAcHJvcGVydHkgeygpID0+IEVuZHBvaW50fSBnZXRMb2NhbEFkZHJlc3MgR2V0IHRoZSBsb2NhbGx5IGJvdW5kIG5hbWUgb2YgdGhpcyBjb25uZWN0aW9uXG4gKiBAcHJvcGVydHkgeygpID0+IEVuZHBvaW50fSBnZXRSZW1vdGVBZGRyZXNzIEdldCB0aGUgbmFtZSBvZiB0aGUgY291bnRlcnBhcnR5XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb25uZWN0aW9uSGFuZGxlciBBIGhhbmRsZXIgZm9yIGEgZ2l2ZW4gQ29ubmVjdGlvblxuICogQHByb3BlcnR5IHsoY29ubmVjdGlvbjogQ29ubmVjdGlvbiwgbG9jYWxBZGRyOiBFbmRwb2ludCwgcmVtb3RlQWRkcjogRW5kcG9pbnQsIGM6IENvbm5lY3Rpb25IYW5kbGVyKSA9PiB2b2lkfSBbb25PcGVuXSBUaGUgY29ubmVjdGlvbiBoYXMgYmVlbiBvcGVuZWRcbiAqIEBwcm9wZXJ0eSB7KGNvbm5lY3Rpb246IENvbm5lY3Rpb24sIHBhY2tldEJ5dGVzOiBCeXRlcywgYzogQ29ubmVjdGlvbkhhbmRsZXIsIG9wdHM/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+KSA9PiBQcm9taXNlPERhdGE+fSBbb25SZWNlaXZlXSBUaGUgY29ubmVjdGlvbiByZWNlaXZlZCBhIHBhY2tldFxuICogQHByb3BlcnR5IHsoY29ubmVjdGlvbjogQ29ubmVjdGlvbiwgcmVhc29uPzogQ2xvc2VSZWFzb24sIGM/OiBDb25uZWN0aW9uSGFuZGxlcikgPT4gUHJvbWlzZTx2b2lkPn0gW29uQ2xvc2VdIFRoZSBjb25uZWN0aW9uIGhhcyBiZWVuIGNsb3NlZFxuICpcbiAqIEB0eXBlZGVmIHthbnk/fSBDbG9zZVJlYXNvbiBUaGUgcmVhc29uIGEgY29ubmVjdGlvbiB3YXMgY2xvc2VkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBBdHRlbXB0RGVzY3JpcHRpb25cbiAqIEBwcm9wZXJ0eSB7Q29ubmVjdGlvbkhhbmRsZXJ9IGhhbmRsZXJcbiAqIEBwcm9wZXJ0eSB7RW5kcG9pbnR9IFtyZW1vdGVBZGRyZXNzXVxuICogQHByb3BlcnR5IHtFbmRwb2ludH0gW2xvY2FsQWRkcmVzc11cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFByb3RvY29sSGFuZGxlciBBIGhhbmRsZXIgZm9yIHRoaW5ncyB0aGUgcHJvdG9jb2wgaW1wbGVtZW50YXRpb24gd2lsbCBpbnZva2VcbiAqIEBwcm9wZXJ0eSB7KHByb3RvY29sOiBQcm90b2NvbEltcGwsIHA6IFByb3RvY29sSGFuZGxlcikgPT4gUHJvbWlzZTx2b2lkPn0gb25DcmVhdGUgVGhpcyBwcm90b2NvbCBpcyBjcmVhdGVkXG4gKiBAcHJvcGVydHkgeyhsb2NhbEFkZHI6IEVuZHBvaW50LCBwOiBQcm90b2NvbEhhbmRsZXIpID0+IFByb21pc2U8c3RyaW5nPn0gZ2VuZXJhdGVQb3J0SUQgQ3JlYXRlIGEgZnJlc2ggcG9ydCBpZGVudGlmaWVyIGZvciB0aGlzIHByb3RvY29sXG4gKiBAcHJvcGVydHkgeyhwb3J0OiBQb3J0LCBsb2NhbEFkZHI6IEVuZHBvaW50LCBwOiBQcm90b2NvbEhhbmRsZXIpID0+IFByb21pc2U8dm9pZD59IG9uQmluZCBBIHBvcnQgd2lsbCBiZSBib3VuZFxuICogQHByb3BlcnR5IHsocG9ydDogUG9ydCwgbG9jYWxBZGRyOiBFbmRwb2ludCwgbGlzdGVuSGFuZGxlcjogTGlzdGVuSGFuZGxlciwgcDogUHJvdG9jb2xIYW5kbGVyKSA9PiBQcm9taXNlPHZvaWQ+fSBvbkxpc3RlbiBBIHBvcnQgd2FzIGxpc3RlbmluZ1xuICogQHByb3BlcnR5IHsocG9ydDogUG9ydCwgbG9jYWxBZGRyOiBFbmRwb2ludCwgbGlzdGVuSGFuZGxlcjogTGlzdGVuSGFuZGxlciwgcDogUHJvdG9jb2xIYW5kbGVyKSA9PiBQcm9taXNlPHZvaWQ+fSBvbkxpc3RlblJlbW92ZSBBIHBvcnQgbGlzdGVuZXIgaGFzIGJlZW4gcmVzZXRcbiAqIEBwcm9wZXJ0eSB7KHBvcnQ6IFBvcnQsIGxvY2FsQWRkcjogRW5kcG9pbnQsIHJlbW90ZTogRW5kcG9pbnQsIHA6IFByb3RvY29sSGFuZGxlcikgPT4gUHJvbWlzZTxFbmRwb2ludD59IFtvbkluc3RhbnRpYXRlXSBSZXR1cm4gdW5pcXVlIHN1ZmZpeCBmb3JcbiAqIGxvY2FsIGFkZHJlc3NcbiAqIEBwcm9wZXJ0eSB7KHBvcnQ6IFBvcnQsIGxvY2FsQWRkcjogRW5kcG9pbnQsIHJlbW90ZTogRW5kcG9pbnQsIGM6IENvbm5lY3Rpb25IYW5kbGVyLCBwOiBQcm90b2NvbEhhbmRsZXIpID0+IFByb21pc2U8QXR0ZW1wdERlc2NyaXB0aW9uPn0gb25Db25uZWN0IEEgcG9ydCBpbml0aWF0ZXMgYW4gb3V0Ym91bmQgY29ubmVjdGlvblxuICogQHByb3BlcnR5IHsocG9ydDogUG9ydCwgbG9jYWxBZGRyOiBFbmRwb2ludCwgcDogUHJvdG9jb2xIYW5kbGVyKSA9PiBQcm9taXNlPHZvaWQ+fSBvblJldm9rZSBUaGUgcG9ydCBpcyBiZWluZyBjb21wbGV0ZWx5IGRlc3Ryb3llZFxuICpcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEluYm91bmRBdHRlbXB0IEFuIGluYm91bmQgY29ubmVjdGlvbiBhdHRlbXB0XG4gKiBAcHJvcGVydHkgeyhkZXNjOiBBdHRlbXB0RGVzY3JpcHRpb24pID0+IFByb21pc2U8Q29ubmVjdGlvbj59IGFjY2VwdCBFc3RhYmxpc2ggdGhlIGNvbm5lY3Rpb25cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gRW5kcG9pbnR9IGdldExvY2FsQWRkcmVzcyBSZXR1cm4gdGhlIGxvY2FsIGFkZHJlc3MgZm9yIHRoaXMgYXR0ZW1wdFxuICogQHByb3BlcnR5IHsoKSA9PiBFbmRwb2ludH0gZ2V0UmVtb3RlQWRkcmVzcyBSZXR1cm4gdGhlIHJlbW90ZSBhZGRyZXNzIGZvciB0aGlzIGF0dGVtcHRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTx2b2lkPn0gY2xvc2UgQWJvcnQgdGhlIGF0dGVtcHRcbiAqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQcm90b2NvbEltcGwgVGhpbmdzIHRoZSBwcm90b2NvbCBjYW4gZG8gZm9yIHVzXG4gKiBAcHJvcGVydHkgeyhwcmVmaXg6IEVuZHBvaW50KSA9PiBQcm9taXNlPFBvcnQ+fSBiaW5kIENsYWltIGEgcG9ydCwgb3IgaWYgZW5kaW5nIGluIEVORFBPSU5UX1NFUEFSQVRPUiwgYSBmcmVzaCBuYW1lXG4gKiBAcHJvcGVydHkgeyhsaXN0ZW5BZGRyOiBFbmRwb2ludCwgcmVtb3RlQWRkcjogRW5kcG9pbnQpID0+IFByb21pc2U8SW5ib3VuZEF0dGVtcHQ+fSBpbmJvdW5kIE1ha2UgYW4gYXR0ZW1wdCB0byBjb25uZWN0IGludG8gdGhpcyBwcm90b2NvbFxuICogQHByb3BlcnR5IHsocG9ydDogUG9ydCwgcmVtb3RlQWRkcjogRW5kcG9pbnQsIGNvbm5lY3Rpb25IYW5kbGVyOiBDb25uZWN0aW9uSGFuZGxlcikgPT4gUHJvbWlzZTxDb25uZWN0aW9uPn0gb3V0Ym91bmQgQ3JlYXRlIGFuIG91dGJvdW5kIGNvbm5lY3Rpb25cbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAhmCHYvwEAAL8BAAAiAAAAQGFnb3JpYy90aW1lLXYwLjMuMy11MTEuMC9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy90aW1lTWF0aC5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3NyYy90aW1lTWF0aC5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy90aW1lTWF0aC5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZUd1YXJkcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAwEA35qgiAACoIgAAKQAAAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3RpbWVNYXRoLmpzeyJpbXBvcnRzIjpbIi4vdHlwZUd1YXJkcy5qcyIsIkBhZ29yaWMvc3RvcmUiLCJAZW5kby9uYXQiXSwiZXhwb3J0cyI6WyJUaW1lTWF0aCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtdXN0TWF0Y2gsTmF0LFJlbGF0aXZlVGltZVJlY29yZFNoYXBlLFRpbWVzdGFtcFJlY29yZFNoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL25hdFwiLCBbW1wiTmF0XCIsIFskaOKAjV9hID0+IChOYXQgPSAkaOKAjV9hKV1dXV0sW1wiLi90eXBlR3VhcmRzLmpzXCIsIFtbXCJSZWxhdGl2ZVRpbWVSZWNvcmRTaGFwZVwiLCBbJGjigI1fYSA9PiAoUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlRpbWVzdGFtcFJlY29yZFNoYXBlXCIsIFskaOKAjV9hID0+IChUaW1lc3RhbXBSZWNvcmRTaGFwZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzJykuVGltZXJCcmFuZH0gVGltZXJCcmFuZFxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMnKS5UaW1lc3RhbXB9IFRpbWVzdGFtcFxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMnKS5SZWxhdGl2ZVRpbWV9IFJlbGF0aXZlVGltZVxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMnKS5SZWxhdGl2ZVRpbWVWYWx1ZX0gUmVsYXRpdmVUaW1lVmFsdWVcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzJykuVGltZXN0YW1wVmFsdWV9IFRpbWVzdGFtcFZhbHVlXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcycpLlRpbWVNYXRoVHlwZX0gVGltZU1hdGhUeXBlXG4gKlxuICovXG5cbi8qKlxuICogYGFncmVlZFRpbWVyQnJhbmRgIGlzIGludGVybmFsIHRvIHRoaXMgbW9kdWxlLlxuICpcbiAqIEBwYXJhbSB7VGltZXJCcmFuZCB8IHVuZGVmaW5lZH0gbGVmdEJyYW5kXG4gKiBAcGFyYW0ge1RpbWVyQnJhbmQgfCB1bmRlZmluZWR9IHJpZ2h0QnJhbmRcbiAqIEByZXR1cm5zIHtUaW1lckJyYW5kIHwgdW5kZWZpbmVkfVxuICovXG5jb25zdCBhZ3JlZWRUaW1lckJyYW5kPShsZWZ0QnJhbmQscmlnaHRCcmFuZCk9PntcbmlmKGxlZnRCcmFuZD09PXVuZGVmaW5lZCl7XG5pZihyaWdodEJyYW5kPT09dW5kZWZpbmVkKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfWVsc2V7XG5yZXR1cm4gcmlnaHRCcmFuZDtcbiB9XG4gfWVsc2UgaWYocmlnaHRCcmFuZD09PXVuZGVmaW5lZCl7XG5yZXR1cm4gbGVmdEJyYW5kO1xuIH1lbHNle1xubGVmdEJyYW5kPT09cmlnaHRCcmFuZHx8XG5GYWlsIGBUaW1lckJyYW5kcyBtdXN0IG1hdGNoOiAke3EobGVmdEJyYW5kKX0gdnMgJHtxKHJpZ2h0QnJhbmQpfWA7XG5yZXR1cm4gbGVmdEJyYW5kO1xuIH1cbiB9O1xuXG4vKipcbiAqIGBzaGFyZWRUaW1lckJyYW5kYCBpcyBpbnRlcm5hbCB0byB0aGlzIG1vZHVsZSwgYW5kIGltcGxlbWVudHMgdGhlXG4gKiB0cmFuc2l0aW9uYWwgYnJhbmQgY2hlY2tpbmcgYW5kIGNvbnRhaWdpb24gbG9naWMgZXhwbGFpbmVkIGluIHRoZSBgVGltZU1hdGhgXG4gKiBjb21tZW50LiBJdCBpcyB1c2VkIHRvIGRlZmluZSB0aGUgYmluYXJ5IG9wZXJhdG9ycyB0aGF0IHNob3VsZCBmb2xsb3dcbiAqIHRoaXMgbG9naWMuIEl0IGRvZXMgdGhlIGVycm9yIGNoZWNraW5nIGJldHdlZW4gdGhlIG9wZXJhbmRzLCBhbmQgcmV0dXJuc1xuICogdGhlIGJyYW5kLCBpZiBhbnksIHRoYXQgc2hvdWxkIGxhYmVsIHRoZSByZXN1bHRpbmcgdGltZSB2YWx1ZS5cbiAqXG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gbGVmdFxuICogQHBhcmFtIHtUaW1lc3RhbXAgfCBSZWxhdGl2ZVRpbWV9IHJpZ2h0XG4gKiBAcmV0dXJucyB7VGltZXJCcmFuZCB8IHVuZGVmaW5lZH1cbiAqL1xuY29uc3Qgc2hhcmVkVGltZXJCcmFuZD0obGVmdCxyaWdodCk9PntcbmNvbnN0IGxlZnRCcmFuZD10eXBlb2YgbGVmdD09PSdiaWdpbnQnP3VuZGVmaW5lZDpsZWZ0LnRpbWVyQnJhbmQ7XG5jb25zdCByaWdodEJyYW5kPXR5cGVvZiByaWdodD09PSdiaWdpbnQnP3VuZGVmaW5lZDpyaWdodC50aW1lckJyYW5kO1xucmV0dXJuIGFncmVlZFRpbWVyQnJhbmQobGVmdEJyYW5kLHJpZ2h0QnJhbmQpO1xuIH07XG5cbi8qKlxuICogYGFic0xpa2VgIGlzIGludGVybmFsIHRvIHRoaXMgbW9kdWxlLCBhbmQgdXNlZCB0byBpbXBsZW1lbnQgdGhlIGJpbmFyeVxuICogb3BlcmF0b3JzIGluIHRoZSBjYXNlIHdoZXJlIHRoZSByZXR1cm5lZCB0aW1lIHNob3VsZCBiZSBhIGBUaW1lc3RhbXBgXG4gKiByYXRoZXIgdGhhbiBhIGBSZWxhdGl2ZVRpbWVgLlxuICpcbiAqIEBwYXJhbSB7VGltZXN0YW1wIHwgUmVsYXRpdmVUaW1lfSBsZWZ0XG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gcmlnaHRcbiAqIEBwYXJhbSB7VGltZXN0YW1wVmFsdWV9IGFic1ZhbHVlXG4gKiBAcmV0dXJucyB7VGltZXN0YW1wfVxuICovXG5jb25zdCBhYnNMaWtlPShsZWZ0LHJpZ2h0LGFic1ZhbHVlKT0+e1xuTmF0KGFic1ZhbHVlKTtcbmNvbnN0IHRpbWVyQnJhbmQ9c2hhcmVkVGltZXJCcmFuZChsZWZ0LHJpZ2h0KTtcbmlmKHRpbWVyQnJhbmQpe1xucmV0dXJuIGhhcmRlbih7XG50aW1lckJyYW5kLFxuYWJzVmFsdWV9KTtcblxuIH1lbHNle1xucmV0dXJuIGFic1ZhbHVlO1xuIH1cbiB9O1xuXG4vKipcbiAqIGByZWxMaWtlYCBpcyBpbnRlcm5hbCB0byB0aGlzIG1vZHVsZSwgYW5kIHVzZWQgdG8gaW1wbGVtZW50IHRoZSBiaW5hcnlcbiAqIG9wZXJhdG9ycyBpbiB0aGUgY2FzZSB3aGVyZSB0aGUgcmV0dXJuZWQgdGltZSBzaG91bGQgYmUgYSBgUmVsYXRpdmVUaW1lYFxuICogcmF0aGVyIHRoYW4gYSBgVGltZXN0YW1wYC5cbiAqXG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gbGVmdFxuICogQHBhcmFtIHtUaW1lc3RhbXAgfCBSZWxhdGl2ZVRpbWV9IHJpZ2h0XG4gKiBAcGFyYW0ge1JlbGF0aXZlVGltZVZhbHVlfSByZWxWYWx1ZVxuICogQHJldHVybnMge1JlbGF0aXZlVGltZX1cbiAqL1xuY29uc3QgcmVsTGlrZT0obGVmdCxyaWdodCxyZWxWYWx1ZSk9Pntcbk5hdChyZWxWYWx1ZSk7XG5jb25zdCB0aW1lckJyYW5kPXNoYXJlZFRpbWVyQnJhbmQobGVmdCxyaWdodCk7XG5pZih0aW1lckJyYW5kKXtcbnJldHVybiBoYXJkZW4oe1xudGltZXJCcmFuZCxcbnJlbFZhbHVlfSk7XG5cbiB9ZWxzZXtcbnJldHVybiByZWxWYWx1ZTtcbiB9XG4gfTtcblxuLyogRm9yIGFsbCB0aGUgZm9sbG93aW5nIHRpbWUgb3BlcmF0b3JzLCB0aGVpciBkb2N1bWVudGF0aW9uIGlzIGluKi9cbi8qIHRoZSBgVGltZU1hdGhUeXBlYCwgc2luY2UgdGhhdCBpcyB0aGUgZG9jdW1lbnRhdGlvbiB0aGF0IHNob3dzIHVwKi9cbi8qIGluIHRoZSBJREUuIFdlbGwsIGF0IGxlYXN0IHRoZSB2c2NvZGUgSURFLiovXG5cbmNvbnN0IGFic1ZhbHVlPShhYnMpPT57XG5pZih0eXBlb2YgYWJzPT09J2JpZ2ludCcpe1xucmV0dXJuIE5hdChhYnMpO1xuIH1cbm11c3RNYXRjaChhYnMsVGltZXN0YW1wUmVjb3JkU2hhcGUsJ3RpbWVzdGFtcCcpO1xucmV0dXJuIE5hdChhYnMuYWJzVmFsdWUpO1xuIH07XG5cbmNvbnN0IHJlbFZhbHVlPShyZWwpPT57XG5pZih0eXBlb2YgcmVsPT09J2JpZ2ludCcpe1xucmV0dXJuIE5hdChyZWwpO1xuIH1cbm11c3RNYXRjaChyZWwsUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUsJ3JlbGF0aXZlJyk7XG5yZXR1cm4gTmF0KHJlbC5yZWxWYWx1ZSk7XG4gfTtcblxuY29uc3QgbWFrZVRpbWVzdGFtcFJlY29yZD0oYWJzLHRpbWVyQnJhbmQpPT5cbmhhcmRlbih7YWJzVmFsdWU6YWJzLHRpbWVyQnJhbmR9KTtcbmNvbnN0IG1ha2VSZWxhdGl2ZVRpbWVSZWNvcmQ9KHJlbCx0aW1lckJyYW5kKT0+XG5oYXJkZW4oe3JlbFZhbHVlOnJlbCx0aW1lckJyYW5kfSk7XG5cbmNvbnN0IGNvZXJjZVRpbWVzdGFtcFJlY29yZD0odHMsYnJhbmQpPT57XG5icmFuZHx8RmFpbCBgbXVzdCBoYXZlIGEgYnJhbmRgO1xuaWYodHlwZW9mIHRzPT09J251bWJlcicpe1xudHM9TmF0KHRzKTtcbiB9XG5pZih0eXBlb2YgdHM9PT0nYmlnaW50Jyl7XG5yZXR1cm4gbWFrZVRpbWVzdGFtcFJlY29yZCh0cyxicmFuZCk7XG4gfWVsc2V7XG5jb25zdHt0aW1lckJyYW5kfT10cztcbm11c3RNYXRjaCh0cyxUaW1lc3RhbXBSZWNvcmRTaGFwZSwndGltZXN0YW1wJyk7XG5hZ3JlZWRUaW1lckJyYW5kKHRpbWVyQnJhbmQsYnJhbmQpO1xucmV0dXJuIHRzO1xuIH1cbiB9O1xuXG5jb25zdCBjb2VyY2VSZWxhdGl2ZVRpbWVSZWNvcmQ9KHJ0LGJyYW5kKT0+e1xuYnJhbmR8fEZhaWwgYG11c3QgaGF2ZSBhIGJyYW5kYDtcbmlmKHR5cGVvZiBydD09PSdudW1iZXInKXtcbnJ0PU5hdChydCk7XG4gfVxuaWYodHlwZW9mIHJ0PT09J2JpZ2ludCcpe1xucmV0dXJuIG1ha2VSZWxhdGl2ZVRpbWVSZWNvcmQocnQsYnJhbmQpO1xuIH1lbHNle1xuY29uc3R7dGltZXJCcmFuZH09cnQ7XG5tdXN0TWF0Y2gocnQsUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUsJ3JlbGF0aXZlVGltZScpO1xuYWdyZWVkVGltZXJCcmFuZCh0aW1lckJyYW5kLGJyYW5kKTtcbnJldHVybiBydDtcbiB9XG4gfTtcblxuY29uc3QgYWRkQWJzUmVsPShhYnMscmVsKT0+XG5hYnNMaWtlKGFicyxyZWwsYWJzVmFsdWUoYWJzKStyZWxWYWx1ZShyZWwpKTtcblxuY29uc3QgYWRkUmVsUmVsPShyZWwxLHJlbDIpPT5cbnJlbExpa2UocmVsMSxyZWwyLHJlbFZhbHVlKHJlbDEpK3JlbFZhbHVlKHJlbDIpKTtcblxuY29uc3Qgc3VidHJhY3RBYnNBYnM9KGFiczEsYWJzMik9PlxucmVsTGlrZShhYnMxLGFiczIsYWJzVmFsdWUoYWJzMSktYWJzVmFsdWUoYWJzMikpO1xuXG5jb25zdCBjbGFtcGVkU3VidHJhY3RBYnNBYnM9KGFiczEsYWJzMik9PntcbmNvbnN0IHZhbDE9YWJzVmFsdWUoYWJzMSk7XG5jb25zdCB2YWwyPWFic1ZhbHVlKGFiczIpO1xucmV0dXJuIHJlbExpa2UoYWJzMSxhYnMyLHZhbDE+dmFsMj92YWwxLXZhbDI6MG4pO1xuIH07XG5cbmNvbnN0IHN1YnRyYWN0QWJzUmVsPShhYnMscmVsKT0+XG5hYnNMaWtlKGFicyxyZWwsYWJzVmFsdWUoYWJzKS1yZWxWYWx1ZShyZWwpKTtcblxuY29uc3Qgc3VidHJhY3RSZWxSZWw9KHJlbDEscmVsMik9PlxucmVsTGlrZShyZWwxLHJlbDIscmVsVmFsdWUocmVsMSktcmVsVmFsdWUocmVsMikpO1xuXG5jb25zdCBpc1JlbFplcm89KHJlbCk9PnJlbFZhbHVlKHJlbCk9PT0wbjtcblxuY29uc3QgbXVsdGlwbHlSZWxOYXQ9KHJlbCxuYXQpPT5yZWxMaWtlKHJlbCxuYXQscmVsVmFsdWUocmVsKSpuYXQpO1xuXG5jb25zdCBkaXZpZGVSZWxOYXQ9KHJlbCxuYXQpPT5yZWxMaWtlKHJlbCxuYXQscmVsVmFsdWUocmVsKS9uYXQpO1xuXG5jb25zdCBkaXZpZGVSZWxSZWw9KHJlbDEscmVsMik9PntcbnNoYXJlZFRpbWVyQnJhbmQocmVsMSxyZWwyKTsvKiBqdXN0IGVycm9yIGNoZWNrKi9cbnJldHVybiByZWxWYWx1ZShyZWwxKS9yZWxWYWx1ZShyZWwyKTtcbiB9O1xuXG5jb25zdCBtb2RBYnNSZWw9KGFicyxzdGVwKT0+XG5yZWxMaWtlKGFicyxzdGVwLGFic1ZhbHVlKGFicyklcmVsVmFsdWUoc3RlcCkpO1xuXG5jb25zdCBtb2RSZWxSZWw9KHJlbCxzdGVwKT0+XG5yZWxMaWtlKHJlbCxzdGVwLHJlbFZhbHVlKHJlbCklcmVsVmFsdWUoc3RlcCkpO1xuXG4vKipcbiAqIGBjb21wYXJlVmFsdWVzYCBpcyBpbnRlcm5hbCB0byB0aGlzIG1vZHVsZSwgYW5kIHVzZWQgdG8gaW1wbGVtZW50XG4gKiB0aGUgdGltZSBjb21wYXJpc29uIG9wZXJhdG9ycy5cbiAqXG4gKiBAcGFyYW0ge1RpbWVzdGFtcCB8IFJlbGF0aXZlVGltZX0gbGVmdFxuICogQHBhcmFtIHtUaW1lc3RhbXAgfCBSZWxhdGl2ZVRpbWV9IHJpZ2h0XG4gKiBAcGFyYW0ge2JpZ2ludH0gdjFcbiAqIEBwYXJhbSB7YmlnaW50fSB2MlxuICogQHJldHVybnMge1JhbmtDb21wYXJpc29ufVxuICovXG5jb25zdCBjb21wYXJlVmFsdWVzPShsZWZ0LHJpZ2h0LHYxLHYyKT0+e1xuc2hhcmVkVGltZXJCcmFuZChsZWZ0LHJpZ2h0KTtcbmlmKHYxPHYyKXtcbnJldHVybi0xO1xuIH1lbHNlIGlmKHYxPT09djIpe1xucmV0dXJuIDA7XG4gfWVsc2V7XG5hc3NlcnQodjE+djIpO1xucmV0dXJuIDE7XG4gfVxuIH07XG5cbi8qKlxuICogVGhlIGBUaW1lTWF0aGAgb2JqZWN0IHByb3ZpZGVzIGhlbHBlciBtZXRob2RzIHRvIGRvIGFyaXRobWV0aWMgb24gbGFiZWxlZFxuICogdGltZSB2YWx1ZXMsIG11Y2ggbGlrZSBgQW1vdW50TWF0aGAgcHJvdmlkZXMgaGVscGVyIG1ldGhvZHMgdG8gZG8gYXJpdGhtZXRpY1xuICogb24gbGFiZWxlZCBhc3NldC9tb25leSB2YWx1ZXMuIEJvdGggY2hlY2sgZm9yIGNvbnNpc3RlbmN5IG9mIGxhYmVsczogYVxuICogYmluYXJ5IG9wZXJhdGlvbiBvbiB0d28gbGFiZWxlZCBvYmplY3RzIGVuc3VyZXMgdGhhdCB0aGUgYm90aCBjYXJyeVxuICogdGhlIHNhbWUgbGFiZWwuIElmIHRoZXkgcHJvZHVjZSBhbm90aGVyIG9iamVjdCBmcm9tIHRoZSBzYW1lIGRvbWFpbiwgaXRcbiAqIHdpbGwgY2FycnkgdGhlIHNhbWUgbGFiZWwuIElmIHRoZSBvcGVyYW5kcyBoYXZlIGluY29tcGF0aWJsZSBsYWJlbHMsXG4gKiBhbiBlcnJvciBpcyB0aHJvd24uXG4gKlxuICogVW5saWtlIGFtb3VudCBhcml0aG1ldGljLCB0aW1lIGFyaXRobWV0aWMgZGVhbHMgaW4gdHdvIGtpbmRzIG9mIHRpbWUgb2JqZWN0czpcbiAqIFRpbWVzdGFtcHMsIHdoaWNoIHJlcHJlc2VudCBhYnNvbHV0ZSB0aW1lLCBhbmQgUmVsYXRpdmVUaW1lLCB3aGljaCByZXByZXNlbnRzXG4gKiB0aGUgZHVyYXRpb24gYmV0d2VlbiB0d28gYWJzb2x1dGUgdGltZXMuIEJvdGgga2luZHMgb2YgdGltZSBvYmplY3RcbiAqIGFyZSBsYWJlbGVkIGJ5IGEgYFRpbWVyQnJhbmRgLiBGb3IgYSBUaW1lc3RhbXAgb2JqZWN0LCB0aGUgdmFsdWUgaXNcbiAqIGEgYmlnaW50IGluIGFuIGBhYnNWYWx1ZWAgcHJvcGVydHkuIEZvciBhIFJlbGF0aXZlVGltZSBvYmplY3QsIHRoZSB2YWx1ZVxuICogaXMgYSBiaWdpbnQgaW4gYSBgcmVsVmFsdWVgIHByb3BlcnR5LiBUaHVzIHdlIGhhdmUgYSBydW50aW1lIHNhZmV0eSBjaGVja1xuICogdG8gZW5zdXJlIHRoYXQgd2UgZG9uJ3QgY29uZnVzZWQgdGhlIHR3bywgZXZlbiBpZiB3ZSBoYXZlIG1hbmFnZWQgdG8gZm9vbFxuICogdGhlICh1bnNvdW5kKSBzdGF0aWMgdHlwZSBzeXN0ZW0uXG4gKlxuICogQXMgYSB0cmFuc2l0aW9uYWwgbWVhc3VyZSwgY3VycmVudGx5IG1hbnkgVGltZXN0YW1wcyBhbmQgUmVsYXRpdmVUaW1lcyBhcmVcbiAqIHN0aWxsIHJlcHJlc2VudGVkIGJ5IHVubGFiZWxlZCBiaWdpbnRzLiBEdXJpbmcgdGhpcyB0cmFuc2l0aW9uYWwgcGVyaW9kLFxuICogd2UgYWxsb3cgdGhpcywgYm90aCBzdGF0aWNhbGx5IGFuZCBkeW5hbWljYWxseS4gRm9yIGEgbm9ybWFsIGJpbmFyeVxuICogb3BlcmF0aW9uLCBpZiBib3RoIGlucHV0cyBhcmUgbGFiZWxlZCwgdGhlbiB3ZSBkbyB0aGUgZnVsbCBjaGVja2luZyBhc1xuICogZXhwbGFpbmVkIGFib3ZlIGFuZCByZXR1cm4gYSBsYWJlbGVkIHJlc3VsdC4gSWYgYm90aCBpbnB1dHMgYXJlIHVubGFiZWxlZFxuICogYmlnaW50cywgd2UgKmFzc3VtZSogdGhhdCB0aGV5IGluZGljYXRlIGEgdGltZSBvZiB0aGUgcmlnaHQga2luZFxuICogKFRpbWVzdGFtcCB2cyBSZWxhdGl2ZVRpbWUpIGFuZCB0aW1lciBicmFuZC4gU2luY2Ugd2UgZG9uJ3Qga25vdyB3aGF0XG4gKiBicmFuZCB3YXMgaW50ZW5kZWQsIHdlIGNhbiBvbmx5IHJldHVybiB5ZXQgYW5vdGhlciB1bmxhYmVsZWQgYmlnaW50LlxuICpcbiAqIElmIG9uZSBvcGVyYW5kIGlzIGxhYmVsZWQgYW5kIHRoZSBvdGhlciBpcyBub3QsIHdlIGNoZWNrIHRoZSBsYWJlbGVkIG9wZXJhbmQsXG4gKiAqYXNzdW1lKiB0aGUgdW5sYWJlbGVkIGJpZ2ludCByZXByZXNlbnRzIHRoZSB2YWx1ZSBuZWVkZWQgZm9yIHRoZSBvdGhlclxuICogb3BlcmFuZCwgYW5kIHJldHVybiBhIGxhYmVsZWQgdGltZSBvYmplY3Qgd2l0aCB0aGUgYnJhbmQgb2YgdGhlIGxhYmVsZWRcbiAqIG9wZXJhbmQuXG4gKlxuICogQHR5cGUge1RpbWVNYXRoVHlwZX1cbiAqL1xuY29uc3QgICAgICAgIFRpbWVNYXRoPWhhcmRlbih7XG5hYnNWYWx1ZSxcbnJlbFZhbHVlLFxuY29lcmNlVGltZXN0YW1wUmVjb3JkLFxuY29lcmNlUmVsYXRpdmVUaW1lUmVjb3JkLFxuYWRkQWJzUmVsLFxuYWRkUmVsUmVsLFxuc3VidHJhY3RBYnNBYnMsXG5jbGFtcGVkU3VidHJhY3RBYnNBYnMsXG5zdWJ0cmFjdEFic1JlbCxcbnN1YnRyYWN0UmVsUmVsLFxuaXNSZWxaZXJvLFxubXVsdGlwbHlSZWxOYXQsXG5kaXZpZGVSZWxOYXQsXG5kaXZpZGVSZWxSZWwsXG5tb2RBYnNSZWwsXG5tb2RSZWxSZWwsXG5jb21wYXJlQWJzOihhYnMxLGFiczIpPT5cbmNvbXBhcmVWYWx1ZXMoYWJzMSxhYnMyLGFic1ZhbHVlKGFiczEpLGFic1ZhbHVlKGFiczIpKSxcbmNvbXBhcmVSZWw6KHJlbDEscmVsMik9PlxuY29tcGFyZVZhbHVlcyhyZWwxLHJlbDIscmVsVmFsdWUocmVsMSkscmVsVmFsdWUocmVsMikpfSk7JGjigI1fb25jZS5UaW1lTWF0aChUaW1lTWF0aCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGltZU1hdGgiOlsiVGltZU1hdGgiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAbrMeqqcHAACnBwAAKwAAAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbIlJlbGF0aXZlVGltZVJlY29yZFNoYXBlIiwiUmVsYXRpdmVUaW1lU2hhcGUiLCJSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlIiwiVGltZXJCcmFuZFNoYXBlIiwiVGltZXJTZXJ2aWNlU2hhcGUiLCJUaW1lc3RhbXBSZWNvcmRTaGFwZSIsIlRpbWVzdGFtcFNoYXBlIiwiVGltZXN0YW1wVmFsdWVTaGFwZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuY29uc3QgICAgICAgIFRpbWVyQnJhbmRTaGFwZT1NLnJlbW90YWJsZSgnVGltZXJCcmFuZCcpOyRo4oCNX29uY2UuVGltZXJCcmFuZFNoYXBlKFRpbWVyQnJhbmRTaGFwZSk7XG5jb25zdCAgICAgICAgVGltZXN0YW1wVmFsdWVTaGFwZT1NLm5hdCgpOyRo4oCNX29uY2UuVGltZXN0YW1wVmFsdWVTaGFwZShUaW1lc3RhbXBWYWx1ZVNoYXBlKTtcbmNvbnN0ICAgICAgICBSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlPU0ubmF0KCk7LyogU2hvdWxkIHdlIGFsbG93IG5lZ2F0aXZlcz8qLyRo4oCNX29uY2UuUmVsYXRpdmVUaW1lVmFsdWVTaGFwZShSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlKTtcblxuY29uc3QgICAgICAgIFRpbWVzdGFtcFJlY29yZFNoYXBlPWhhcmRlbih7XG50aW1lckJyYW5kOlRpbWVyQnJhbmRTaGFwZSxcbmFic1ZhbHVlOlRpbWVzdGFtcFZhbHVlU2hhcGV9KTskaOKAjV9vbmNlLlRpbWVzdGFtcFJlY29yZFNoYXBlKFRpbWVzdGFtcFJlY29yZFNoYXBlKTtcblxuXG5jb25zdCAgICAgICAgUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGU9aGFyZGVuKHtcbnRpbWVyQnJhbmQ6VGltZXJCcmFuZFNoYXBlLFxucmVsVmFsdWU6UmVsYXRpdmVUaW1lVmFsdWVTaGFwZX0pOyRo4oCNX29uY2UuUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUoUmVsYXRpdmVUaW1lUmVjb3JkU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBUaW1lc3RhbXBTaGFwZT1NLm9yKFRpbWVzdGFtcFJlY29yZFNoYXBlLFRpbWVzdGFtcFZhbHVlU2hhcGUpOyRo4oCNX29uY2UuVGltZXN0YW1wU2hhcGUoVGltZXN0YW1wU2hhcGUpO1xuY29uc3QgICAgICAgIFJlbGF0aXZlVGltZVNoYXBlPU0ub3IoXG5SZWxhdGl2ZVRpbWVSZWNvcmRTaGFwZSxcblJlbGF0aXZlVGltZVZhbHVlU2hhcGUpOyRo4oCNX29uY2UuUmVsYXRpdmVUaW1lU2hhcGUoUmVsYXRpdmVUaW1lU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBUaW1lclNlcnZpY2VTaGFwZT1NLnJlbW90YWJsZSgnVGltZXJTZXJ2aWNlJyk7JGjigI1fb25jZS5UaW1lclNlcnZpY2VTaGFwZShUaW1lclNlcnZpY2VTaGFwZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGltZXJCcmFuZFNoYXBlIjpbIlRpbWVyQnJhbmRTaGFwZSJdLCJUaW1lc3RhbXBWYWx1ZVNoYXBlIjpbIlRpbWVzdGFtcFZhbHVlU2hhcGUiXSwiUmVsYXRpdmVUaW1lVmFsdWVTaGFwZSI6WyJSZWxhdGl2ZVRpbWVWYWx1ZVNoYXBlIl0sIlRpbWVzdGFtcFJlY29yZFNoYXBlIjpbIlRpbWVzdGFtcFJlY29yZFNoYXBlIl0sIlJlbGF0aXZlVGltZVJlY29yZFNoYXBlIjpbIlJlbGF0aXZlVGltZVJlY29yZFNoYXBlIl0sIlRpbWVzdGFtcFNoYXBlIjpbIlRpbWVzdGFtcFNoYXBlIl0sIlJlbGF0aXZlVGltZVNoYXBlIjpbIlJlbGF0aXZlVGltZVNoYXBlIl0sIlRpbWVyU2VydmljZVNoYXBlIjpbIlRpbWVyU2VydmljZVNoYXBlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAL7URGNjKAAAYygAAC4AAABAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMC9zcmMvZXhvLXV0aWxzLmpzeyJpbXBvcnRzIjpbIi4vdmF0LWRhdGEtYmluZGluZ3MuanMiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiZGVmaW5lRHVyYWJsZUV4b0NsYXNzIiwiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0IiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzIiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0IiwiaWdub3JlQ29udGV4dCIsIm1ha2VFeG9VdGlscyIsInByZXBhcmVFeG8iLCJwcmVwYXJlRXhvQ2xhc3MiLCJwcmVwYXJlRXhvQ2xhc3NLaXQiLCJwcmVwYXJlS2luZCIsInByZXBhcmVLaW5kTXVsdGkiLCJwcmVwYXJlU2luZ2xldG9uIiwicHJvdmlkZUtpbmRIYW5kbGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgaW5pdEVtcHR5LHByb3ZpZGUsZ2xvYmFsVmF0RGF0YTskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJpbml0RW1wdHlcIiwgWyRo4oCNX2EgPT4gKGluaXRFbXB0eSA9ICRo4oCNX2EpXV1dXSxbXCIuL3ZhdC1kYXRhLWJpbmRpbmdzLmpzXCIsIFtbXCJwcm92aWRlXCIsIFskaOKAjV9hID0+IChwcm92aWRlID0gJGjigI1fYSldXSxbXCJWYXREYXRhXCIsIFskaOKAjV9hID0+IChnbG9iYWxWYXREYXRhID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuLyoqIEB0ZW1wbGF0ZSBMLFIgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDxMLCBSPn0gUmVtb3RhYmxlQnJhbmQgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vZmFyJykuRVJlZjxUPn0gRVJlZiAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQmFnZ2FnZX0gQmFnZ2FnZSAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRGVmaW5lS2luZE9wdGlvbnM8VD59IERlZmluZUtpbmRPcHRpb25zICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5LaW5kRmFjZXQ8VD59IEtpbmRGYWNldCAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuS2luZEZhY2V0czxUPn0gS2luZEZhY2V0cyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRHVyYWJsZUtpbmRIYW5kbGV9IER1cmFibGVLaW5kSGFuZGxlICovXG5cbi8qKlxuICogTWFrZSBhIHZlcnNpb24gb2YgdGhlIGFyZ3VtZW50IGZ1bmN0aW9uIHRoYXQgdGFrZXMgYSBraW5kIGNvbnRleHQgYnV0XG4gKiBpZ25vcmVzIGl0LlxuICpcbiAqIEB0eXBlIHs8VCBleHRlbmRzIEZ1bmN0aW9uPihmbjogVCkgPT4gWGltcG9ydCgnLi90eXBlcy5qcycpLlBsdXNDb250ZXh0PG5ldmVyLCBUPn1cbiAqL1xuY29uc3QgICAgICAgIGlnbm9yZUNvbnRleHQ9XG4oZm4pPT5cbihfY29udGV4dCwuLi5hcmdzKT0+XG5mbiguLi5hcmdzKTskaOKAjV9vbmNlLmlnbm9yZUNvbnRleHQoaWdub3JlQ29udGV4dCk7XG5oYXJkZW4oaWdub3JlQ29udGV4dCk7XG5cbi8qIFRPRE86IEZpbmQgYSBnb29kIGhvbWUgZm9yIHRoaXMgZnVuY3Rpb24gdXNlZCBieSBAYWdvcmljL3ZhdC1kYXRhIGFuZCB0ZXN0aW5nIGNvZGUqL1xuY29uc3QgICAgICAgIG1ha2VFeG9VdGlscz0oVmF0RGF0YSk9PntcbmNvbnN0e1xuZGVmaW5lS2luZCxcbmRlZmluZUtpbmRNdWx0aSxcbmRlZmluZUR1cmFibGVLaW5kLFxuZGVmaW5lRHVyYWJsZUtpbmRNdWx0aSxcbm1ha2VLaW5kSGFuZGxlfT1cblZhdERhdGE7XG5cbi8qKlxuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2luZE5hbWVcbiAqIEByZXR1cm5zIHtEdXJhYmxlS2luZEhhbmRsZX1cbiAqL1xuY29uc3QgcHJvdmlkZUtpbmRIYW5kbGU9KGJhZ2dhZ2Usa2luZE5hbWUpPT5cbnByb3ZpZGUoYmFnZ2FnZSwgYCR7a2luZE5hbWV9X2tpbmRIYW5kbGVgLCgpPT5tYWtlS2luZEhhbmRsZShraW5kTmFtZSkpO1xuaGFyZGVuKHByb3ZpZGVLaW5kSGFuZGxlKTtcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2UgcHJlcGFyZUV4b0NsYXNzIGluc3RlYWRcbiAqIEB0eXBlIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUHJlcGFyZUtpbmR9XG4gKi9cbmNvbnN0IHByZXBhcmVLaW5kPShcbmJhZ2dhZ2UsXG5raW5kTmFtZSxcbmluaXQsXG5iZWhhdmlvcixcbm9wdGlvbnM9dW5kZWZpbmVkKT0+XG5cbmRlZmluZUR1cmFibGVLaW5kKFxucHJvdmlkZUtpbmRIYW5kbGUoYmFnZ2FnZSxraW5kTmFtZSksXG5pbml0LFxuYmVoYXZpb3IsXG5vcHRpb25zKTtcblxuaGFyZGVuKHByZXBhcmVLaW5kKTtcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2UgcHJlcGFyZUV4b0NsYXNzS2l0IGluc3RlYWRcbiAqIEB0eXBlIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUHJlcGFyZUtpbmRNdWx0aX1cbiAqL1xuY29uc3QgcHJlcGFyZUtpbmRNdWx0aT0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbml0LFxuYmVoYXZpb3IsXG5vcHRpb25zPXVuZGVmaW5lZCk9PlxuXG5kZWZpbmVEdXJhYmxlS2luZE11bHRpKFxucHJvdmlkZUtpbmRIYW5kbGUoYmFnZ2FnZSxraW5kTmFtZSksXG5pbml0LFxuYmVoYXZpb3IsXG5vcHRpb25zKTtcblxuaGFyZGVuKHByZXBhcmVLaW5kTXVsdGkpO1xuXG4vKiBUT0RPIGludGVyZmFjZUd1YXJkIHR5cGUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy82MjA2Ki9cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55KSA9PiBhbnl9IEkgaW5pdCBzdGF0ZSBmdW5jdGlvblxuICogQHRlbXBsYXRlIFQgYmVoYXZpb3JcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZFxuICogQHBhcmFtIHtJfSBpbml0XG4gKiBAcGFyYW0ge1QgJiBUaGlzVHlwZTx7IHNlbGY6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+IH0+fSBtZXRob2RzXG4gKiBAcGFyYW0ge0RlZmluZUtpbmRPcHRpb25zPHsgc2VsZjogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IGRlZmluZVZpcnR1YWxFeG9DbGFzcz0odGFnLGludGVyZmFjZUd1YXJkLGluaXQsbWV0aG9kcyxvcHRpb25zKT0+XG5kZWZpbmVLaW5kKHRhZyxpbml0LG1ldGhvZHMse1xuLi4ub3B0aW9ucyxcbnRoaXNmdWxNZXRob2RzOnRydWUsXG5pbnRlcmZhY2VHdWFyZH0pO1xuXG5oYXJkZW4oZGVmaW5lVmlydHVhbEV4b0NsYXNzKTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueSkgPT4gYW55fSBJIGluaXQgc3RhdGUgZnVuY3Rpb25cbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZywgUmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj4+fSBUIGZhY2V0c1xuICogQHBhcmFtIHtzdHJpbmd9IHRhZ1xuICogQHBhcmFtIHthbnl9IGludGVyZmFjZUd1YXJkS2l0XG4gKiBAcGFyYW0ge0l9IGluaXRcbiAqIEBwYXJhbSB7VCAmIFRoaXNUeXBlPHsgZmFjZXRzOiBULCBzdGF0ZTogUmV0dXJuVHlwZTxJPiB9PiB9IGZhY2V0c1xuICogQHBhcmFtIHtEZWZpbmVLaW5kT3B0aW9uczx7IGZhY2V0czogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IGRlZmluZVZpcnR1YWxFeG9DbGFzc0tpdD0oXG50YWcsXG5pbnRlcmZhY2VHdWFyZEtpdCxcbmluaXQsXG5mYWNldHMsXG5vcHRpb25zKT0+XG5cbmRlZmluZUtpbmRNdWx0aSh0YWcsaW5pdCxmYWNldHMse1xuLi4ub3B0aW9ucyxcbnRoaXNmdWxNZXRob2RzOnRydWUsXG5pbnRlcmZhY2VHdWFyZDppbnRlcmZhY2VHdWFyZEtpdH0pO1xuXG5oYXJkZW4oZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0KTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueSkgPT4gYW55fSBJIGluaXQgc3RhdGUgZnVuY3Rpb25cbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IFQgbWV0aG9kc1xuICogQHBhcmFtIHtEdXJhYmxlS2luZEhhbmRsZX0ga2luZEhhbmRsZVxuICogQHBhcmFtIHthbnl9IGludGVyZmFjZUd1YXJkXG4gKiBAcGFyYW0ge0l9IGluaXRcbiAqIEBwYXJhbSB7VCAmIFRoaXNUeXBlPHsgc2VsZjogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IG1ldGhvZHNcbiAqIEBwYXJhbSB7RGVmaW5lS2luZE9wdGlvbnM8eyBzZWxmOiBULCBzdGF0ZTogUmV0dXJuVHlwZTxJPiB9Pn0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7KC4uLmFyZ3M6IFBhcmFtZXRlcnM8ST4pID0+IChUICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+KX1cbiAqL1xuY29uc3QgZGVmaW5lRHVyYWJsZUV4b0NsYXNzPShcbmtpbmRIYW5kbGUsXG5pbnRlcmZhY2VHdWFyZCxcbmluaXQsXG5tZXRob2RzLFxub3B0aW9ucyk9PlxuXG5kZWZpbmVEdXJhYmxlS2luZChraW5kSGFuZGxlLGluaXQsbWV0aG9kcyx7XG4uLi5vcHRpb25zLFxudGhpc2Z1bE1ldGhvZHM6dHJ1ZSxcbmludGVyZmFjZUd1YXJkfSk7XG5cbmhhcmRlbihkZWZpbmVEdXJhYmxlRXhvQ2xhc3MpO1xuXG4vKiBUT0RPIGludGVyZmFjZUd1YXJkIHR5cGUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy82MjA2Ki9cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55KSA9PiBhbnl9IEkgaW5pdCBzdGF0ZSBmdW5jdGlvblxuICogQHRlbXBsYXRlIHtSZWNvcmQ8c3RyaW5nLCBSZWNvcmQ8c3RyaW5nIHwgc3ltYm9sLCBDYWxsYWJsZUZ1bmN0aW9uPj59IFQgZmFjZXRzXG4gKiBAcGFyYW0ge0R1cmFibGVLaW5kSGFuZGxlfSBraW5kSGFuZGxlXG4gKiBAcGFyYW0ge2FueX0gaW50ZXJmYWNlR3VhcmRLaXRcbiAqIEBwYXJhbSB7SX0gaW5pdFxuICogQHBhcmFtIHtUICYgVGhpc1R5cGU8eyBmYWNldHM6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+fT4gfSBmYWNldHNcbiAqIEBwYXJhbSB7RGVmaW5lS2luZE9wdGlvbnM8eyBmYWNldHM6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+fT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IGRlZmluZUR1cmFibGVFeG9DbGFzc0tpdD0oXG5raW5kSGFuZGxlLFxuaW50ZXJmYWNlR3VhcmRLaXQsXG5pbml0LFxuZmFjZXRzLFxub3B0aW9ucyk9PlxuXG5kZWZpbmVEdXJhYmxlS2luZE11bHRpKGtpbmRIYW5kbGUsaW5pdCxmYWNldHMse1xuLi4ub3B0aW9ucyxcbnRoaXNmdWxNZXRob2RzOnRydWUsXG5pbnRlcmZhY2VHdWFyZDppbnRlcmZhY2VHdWFyZEtpdH0pO1xuXG5oYXJkZW4oZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0KTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7KC4uLmFyZ3M6IGFueSkgPT4gYW55fSBJIGluaXQgc3RhdGUgZnVuY3Rpb25cbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IFQgbWV0aG9kc1xuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2luZE5hbWVcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZFxuICogQHBhcmFtIHtJfSBpbml0XG4gKiBAcGFyYW0ge1QgJiBUaGlzVHlwZTx7IHNlbGY6IFQsIHN0YXRlOiBSZXR1cm5UeXBlPEk+IH0+fSBtZXRob2RzXG4gKiBAcGFyYW0ge0RlZmluZUtpbmRPcHRpb25zPHsgc2VsZjogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IHByZXBhcmVFeG9DbGFzcz0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZCxcbmluaXQsXG5tZXRob2RzLFxub3B0aW9ucz11bmRlZmluZWQpPT5cblxuZGVmaW5lRHVyYWJsZUV4b0NsYXNzKFxucHJvdmlkZUtpbmRIYW5kbGUoYmFnZ2FnZSxraW5kTmFtZSksXG5pbnRlcmZhY2VHdWFyZCxcbmluaXQsXG5tZXRob2RzLFxub3B0aW9ucyk7XG5cbmhhcmRlbihwcmVwYXJlRXhvQ2xhc3MpO1xuXG4vKiBUT0RPIGludGVyZmFjZUd1YXJkIHR5cGUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy82MjA2Ki9cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55KSA9PiBhbnl9IEkgaW5pdCBzdGF0ZSBmdW5jdGlvblxuICogQHRlbXBsYXRlIHtSZWNvcmQ8c3RyaW5nLCBSZWNvcmQ8c3RyaW5nIHwgc3ltYm9sLCBDYWxsYWJsZUZ1bmN0aW9uPj59IFQgZmFjZXRzXG4gKiBAcGFyYW0ge0JhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBraW5kTmFtZVxuICogQHBhcmFtIHthbnl9IGludGVyZmFjZUd1YXJkS2l0XG4gKiBAcGFyYW0ge0l9IGluaXRcbiAqIEBwYXJhbSB7VCAmIFRoaXNUeXBlPHsgZmFjZXRzOiBULCBzdGF0ZTogUmV0dXJuVHlwZTxJPiB9PiB9IGZhY2V0c1xuICogQHBhcmFtIHtEZWZpbmVLaW5kT3B0aW9uczx7IGZhY2V0czogVCwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoVCAmIFJlbW90YWJsZUJyYW5kPHt9LCBUPil9XG4gKi9cbmNvbnN0IHByZXBhcmVFeG9DbGFzc0tpdD0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZEtpdCxcbmluaXQsXG5mYWNldHMsXG5vcHRpb25zPXVuZGVmaW5lZCk9PlxuXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3NLaXQoXG5wcm92aWRlS2luZEhhbmRsZShiYWdnYWdlLGtpbmROYW1lKSxcbmludGVyZmFjZUd1YXJkS2l0LFxuaW5pdCxcbmZhY2V0cyxcbm9wdGlvbnMpO1xuXG5oYXJkZW4ocHJlcGFyZUV4b0NsYXNzS2l0KTtcblxuLyogVE9ETyBpbnRlcmZhY2VHdWFyZCB0eXBlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNjIwNiovXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IE0gbWV0aG9kc1xuICogQHBhcmFtIHtCYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30ga2luZE5hbWVcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZFxuICogQHBhcmFtIHtNfSBtZXRob2RzXG4gKiBAcGFyYW0ge0RlZmluZUtpbmRPcHRpb25zPHsgc2VsZjogTSB9Pn0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7TSAmIFJlbW90YWJsZUJyYW5kPHt9LCBNPn1cbiAqL1xuY29uc3QgcHJlcGFyZUV4bz0oXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZCxcbm1ldGhvZHMsXG5vcHRpb25zPXVuZGVmaW5lZCk9Plxue1xuY29uc3QgbWFrZVNpbmdsZXRvbj1wcmVwYXJlRXhvQ2xhc3MoXG5iYWdnYWdlLFxua2luZE5hbWUsXG5pbnRlcmZhY2VHdWFyZCxcbmluaXRFbXB0eSxcbm1ldGhvZHMsXG5vcHRpb25zKTtcblxuXG5yZXR1cm4gcHJvdmlkZShiYWdnYWdlLCBgJHtraW5kTmFtZX1fc2luZ2xldG9uYCwoKT0+bWFrZVNpbmdsZXRvbigpKTtcbiB9O1xuaGFyZGVuKHByZXBhcmVFeG8pO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IE0gbWV0aG9kc1xuICogQGRlcHJlY2F0ZWQgVXNlIHByZXBhcmVFeG8gaW5zdGVhZC5cbiAqIEBwYXJhbSB7QmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtzdHJpbmd9IGtpbmROYW1lXG4gKiBAcGFyYW0ge019IG1ldGhvZHNcbiAqIEBwYXJhbSB7RGVmaW5lS2luZE9wdGlvbnM8eyBzZWxmOiBNIH0+fSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHtNICYgUmVtb3RhYmxlQnJhbmQ8e30sIE0+fVxuICovXG5jb25zdCBwcmVwYXJlU2luZ2xldG9uPShiYWdnYWdlLGtpbmROYW1lLG1ldGhvZHMsb3B0aW9ucz11bmRlZmluZWQpPT5cbnByZXBhcmVFeG8oYmFnZ2FnZSxraW5kTmFtZSx1bmRlZmluZWQsbWV0aG9kcyxvcHRpb25zKTtcbmhhcmRlbihwcmVwYXJlU2luZ2xldG9uKTtcblxucmV0dXJuIGhhcmRlbih7XG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3MsXG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3MsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvQ2xhc3MsXG5wcmVwYXJlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvLFxucHJlcGFyZVNpbmdsZXRvbixcblxucHJvdmlkZUtpbmRIYW5kbGUsXG5wcmVwYXJlS2luZCxcbnByZXBhcmVLaW5kTXVsdGl9KTtcblxuIH07JGjigI1fb25jZS5tYWtlRXhvVXRpbHMobWFrZUV4b1V0aWxzKTtcblxuY29uc3QgZ2xvYmFsRXhvVXRpbHM9bWFrZUV4b1V0aWxzKGdsb2JhbFZhdERhdGEpO1xuXG5jb25zdCAgICAgICB7XG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3MsXG5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3MsXG5kZWZpbmVEdXJhYmxlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvQ2xhc3MsXG5wcmVwYXJlRXhvQ2xhc3NLaXQsXG5wcmVwYXJlRXhvLFxucHJlcGFyZVNpbmdsZXRvbn09XG5nbG9iYWxFeG9VdGlscztcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2UgRXhvcy9FeG9DbGFzc2VzIGluc3RlYWQgb2YgS2luZHNcbiAqLyRo4oCNX29uY2UuZGVmaW5lVmlydHVhbEV4b0NsYXNzKGRlZmluZVZpcnR1YWxFeG9DbGFzcyk7JGjigI1fb25jZS5kZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQoZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0KTskaOKAjV9vbmNlLmRlZmluZUR1cmFibGVFeG9DbGFzcyhkZWZpbmVEdXJhYmxlRXhvQ2xhc3MpOyRo4oCNX29uY2UuZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0KGRlZmluZUR1cmFibGVFeG9DbGFzc0tpdCk7JGjigI1fb25jZS5wcmVwYXJlRXhvQ2xhc3MocHJlcGFyZUV4b0NsYXNzKTskaOKAjV9vbmNlLnByZXBhcmVFeG9DbGFzc0tpdChwcmVwYXJlRXhvQ2xhc3NLaXQpOyRo4oCNX29uY2UucHJlcGFyZUV4byhwcmVwYXJlRXhvKTskaOKAjV9vbmNlLnByZXBhcmVTaW5nbGV0b24ocHJlcGFyZVNpbmdsZXRvbik7XG5jb25zdCAgICAgICB7cHJvdmlkZUtpbmRIYW5kbGUscHJlcGFyZUtpbmQscHJlcGFyZUtpbmRNdWx0aX09XG5nbG9iYWxFeG9VdGlsczskaOKAjV9vbmNlLnByb3ZpZGVLaW5kSGFuZGxlKHByb3ZpZGVLaW5kSGFuZGxlKTskaOKAjV9vbmNlLnByZXBhcmVLaW5kKHByZXBhcmVLaW5kKTskaOKAjV9vbmNlLnByZXBhcmVLaW5kTXVsdGkocHJlcGFyZUtpbmRNdWx0aSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaWdub3JlQ29udGV4dCI6WyJpZ25vcmVDb250ZXh0Il0sIm1ha2VFeG9VdGlscyI6WyJtYWtlRXhvVXRpbHMiXSwiZGVmaW5lVmlydHVhbEV4b0NsYXNzIjpbImRlZmluZVZpcnR1YWxFeG9DbGFzcyJdLCJkZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQiOlsiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0Il0sImRlZmluZUR1cmFibGVFeG9DbGFzcyI6WyJkZWZpbmVEdXJhYmxlRXhvQ2xhc3MiXSwiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0IjpbImRlZmluZUR1cmFibGVFeG9DbGFzc0tpdCJdLCJwcmVwYXJlRXhvQ2xhc3MiOlsicHJlcGFyZUV4b0NsYXNzIl0sInByZXBhcmVFeG9DbGFzc0tpdCI6WyJwcmVwYXJlRXhvQ2xhc3NLaXQiXSwicHJlcGFyZUV4byI6WyJwcmVwYXJlRXhvIl0sInByZXBhcmVTaW5nbGV0b24iOlsicHJlcGFyZVNpbmdsZXRvbiJdLCJwcm92aWRlS2luZEhhbmRsZSI6WyJwcm92aWRlS2luZEhhbmRsZSJdLCJwcmVwYXJlS2luZCI6WyJwcmVwYXJlS2luZCJdLCJwcmVwYXJlS2luZE11bHRpIjpbInByZXBhcmVLaW5kTXVsdGkiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAO+M9iJIIAACSCAAAKgAAAEBhZ29yaWMvdmF0LWRhdGEtdjAuNS4zLXUxMS4wL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6WyIuL2V4by11dGlscy5qcyIsIi4vdmF0LWRhdGEtYmluZGluZ3MuanMiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0IiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzS2l0IiwibWFrZVNjYWxhck1hcFN0b3JlIiwibWFrZVNjYWxhck1hcFN0b3JlIiwicHJvdmlkZVByb21pc2VXYXRjaGVyIiwicHJvdmlkZVByb21pc2VXYXRjaGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbXV0sW1wiLi92YXQtZGF0YS1iaW5kaW5ncy5qc1wiLCBbXV0sW1wiLi9leG8tdXRpbHMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiQGFnb3JpYy9zdG9yZSI6W1siTSIsIk0iXSxbIm1ha2VTY2FsYXJNYXBTdG9yZSIsIm1ha2VTY2FsYXJNYXBTdG9yZSJdLFsibWFrZVNjYWxhcldlYWtNYXBTdG9yZSIsIm1ha2VTY2FsYXJXZWFrTWFwU3RvcmUiXSxbIm1ha2VTY2FsYXJTZXRTdG9yZSIsIm1ha2VTY2FsYXJTZXRTdG9yZSJdLFsibWFrZVNjYWxhcldlYWtTZXRTdG9yZSIsIm1ha2VTY2FsYXJXZWFrU2V0U3RvcmUiXV0sIi4vdmF0LWRhdGEtYmluZGluZ3MuanMiOltbIm1ha2VLaW5kSGFuZGxlIiwibWFrZUtpbmRIYW5kbGUiXSxbInByb3ZpZGVQcm9taXNlV2F0Y2hlciIsInByb3ZpZGVQcm9taXNlV2F0Y2hlciJdLFsid2F0Y2hQcm9taXNlIiwid2F0Y2hQcm9taXNlIl0sWyJtYWtlU2NhbGFyQmlnTWFwU3RvcmUiLCJtYWtlU2NhbGFyQmlnTWFwU3RvcmUiXSxbIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUiLCJtYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlIl0sWyJtYWtlU2NhbGFyQmlnU2V0U3RvcmUiLCJtYWtlU2NhbGFyQmlnU2V0U3RvcmUiXSxbIm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmUiLCJtYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlIl0sWyJjYW5CZUR1cmFibGUiLCJjYW5CZUR1cmFibGUiXSxbInBpY2tGYWNldCIsInBpY2tGYWNldCJdLFsicGFydGlhbEFzc2lnbiIsInBhcnRpYWxBc3NpZ24iXSxbInByb3ZpZGUiLCJwcm92aWRlIl0sWyJwcm92aWRlRHVyYWJsZU1hcFN0b3JlIiwicHJvdmlkZUR1cmFibGVNYXBTdG9yZSJdLFsicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiLCJwcm92aWRlRHVyYWJsZVdlYWtNYXBTdG9yZSJdLFsicHJvdmlkZUR1cmFibGVTZXRTdG9yZSIsInByb3ZpZGVEdXJhYmxlU2V0U3RvcmUiXSxbInByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlIiwicHJvdmlkZUR1cmFibGVXZWFrU2V0U3RvcmUiXSxbImRlZmluZUtpbmQiLCJkZWZpbmVLaW5kIl0sWyJkZWZpbmVLaW5kTXVsdGkiLCJkZWZpbmVLaW5kTXVsdGkiXSxbImRlZmluZUR1cmFibGVLaW5kIiwiZGVmaW5lRHVyYWJsZUtpbmQiXSxbImRlZmluZUR1cmFibGVLaW5kTXVsdGkiLCJkZWZpbmVEdXJhYmxlS2luZE11bHRpIl1dLCIuL2V4by11dGlscy5qcyI6W1siZGVmaW5lVmlydHVhbEV4b0NsYXNzIiwiZGVmaW5lVmlydHVhbEV4b0NsYXNzIl0sWyJkZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQiLCJkZWZpbmVWaXJ0dWFsRXhvQ2xhc3NLaXQiXSxbImRlZmluZUR1cmFibGVFeG9DbGFzcyIsImRlZmluZUR1cmFibGVFeG9DbGFzcyJdLFsiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0IiwiZGVmaW5lRHVyYWJsZUV4b0NsYXNzS2l0Il0sWyJwcmVwYXJlRXhvQ2xhc3MiLCJwcmVwYXJlRXhvQ2xhc3MiXSxbInByZXBhcmVFeG9DbGFzc0tpdCIsInByZXBhcmVFeG9DbGFzc0tpdCJdLFsicHJlcGFyZUV4byIsInByZXBhcmVFeG8iXSxbInByZXBhcmVTaW5nbGV0b24iLCJwcmVwYXJlU2luZ2xldG9uIl0sWyJpZ25vcmVDb250ZXh0IiwiaWdub3JlQ29udGV4dCJdLFsicHJvdmlkZUtpbmRIYW5kbGUiLCJwcm92aWRlS2luZEhhbmRsZSJdLFsicHJlcGFyZUtpbmQiLCJwcmVwYXJlS2luZCJdLFsicHJlcGFyZUtpbmRNdWx0aSIsInByZXBhcmVLaW5kTXVsdGkiXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAN70jyBTKAAAUygAADYAAABAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMC9zcmMvdmF0LWRhdGEtYmluZGluZ3MuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9hc3NlcnQiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiVmF0RGF0YSIsImNhbkJlRHVyYWJsZSIsImRlZmluZUR1cmFibGVLaW5kIiwiZGVmaW5lRHVyYWJsZUtpbmRNdWx0aSIsImRlZmluZUtpbmQiLCJkZWZpbmVLaW5kTXVsdGkiLCJtYWtlS2luZEhhbmRsZSIsIm1ha2VTY2FsYXJCaWdNYXBTdG9yZSIsIm1ha2VTY2FsYXJCaWdTZXRTdG9yZSIsIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUiLCJtYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlIiwibWFrZVN0b3JlVXRpbHMiLCJwYXJ0aWFsQXNzaWduIiwicGlja0ZhY2V0IiwicHJvdmlkZSIsInByb3ZpZGVEdXJhYmxlTWFwU3RvcmUiLCJwcm92aWRlRHVyYWJsZVNldFN0b3JlIiwicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiLCJwcm92aWRlRHVyYWJsZVdlYWtTZXRTdG9yZSIsInByb3ZpZGVQcm9taXNlV2F0Y2hlciIsIndhdGNoUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYWlsLHByb3ZpZGVMYXp5OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJGYWlsXCIsIFskaOKAjV9hID0+IChGYWlsID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcInByb3ZpZGVMYXp5XCIsIFskaOKAjV9hID0+IChwcm92aWRlTGF6eSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG4vKiogQHR5cGUge1hpbXBvcnQoJy4vdHlwZXMnKS5WYXREYXRhfSAqL1xubGV0IFZhdERhdGFHbG9iYWw7XG5pZignVmF0RGF0YSdpbiBnbG9iYWxUaGlzKXtcbmdsb2JhbFRoaXMuVmF0RGF0YXx8RmFpbCBgVmF0RGF0YSBkZWZpbmVkIGluIGdsb2JhbCBhcyBudWxsIG9yIHVuZGVmaW5lZGA7XG5WYXREYXRhR2xvYmFsPWdsb2JhbFRoaXMuVmF0RGF0YTtcbiB9ZWxzZXtcbi8qIFhYWCB0aGlzIG1vZHVsZSBoYXMgYmVlbiBrbm93biB0byBnZXQgaW1wb3J0ZWQgKHRyYW5zaXRpdmVseSkgaW4gY2FzZXMgdGhhdCovXG4vKiBuZXZlciB1c2UgaXQgc28gd2UgbWFrZSBhIHZlcnNpb24gdGhhdCB3aWxsIHNhdGlzZnkgbW9kdWxlIHJlc29sdXRpb24gYnV0Ki9cbi8qIGZhaWwgYXQgcnVudGltZS4qL1xuY29uc3QgdW52YWlsYWJsZT0oKT0+RmFpbCBgVmF0RGF0YSB1bmF2YWlsYWJsZWA7XG5WYXREYXRhR2xvYmFsPXtcbmRlZmluZUtpbmQ6dW52YWlsYWJsZSxcbmRlZmluZUtpbmRNdWx0aTp1bnZhaWxhYmxlLFxuZGVmaW5lRHVyYWJsZUtpbmQ6dW52YWlsYWJsZSxcbmRlZmluZUR1cmFibGVLaW5kTXVsdGk6dW52YWlsYWJsZSxcbm1ha2VLaW5kSGFuZGxlOnVudmFpbGFibGUsXG5wcm92aWRlUHJvbWlzZVdhdGNoZXI6dW52YWlsYWJsZSxcbndhdGNoUHJvbWlzZTp1bnZhaWxhYmxlLFxubWFrZVNjYWxhckJpZ01hcFN0b3JlOnVudmFpbGFibGUsXG5tYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlOnVudmFpbGFibGUsXG5tYWtlU2NhbGFyQmlnU2V0U3RvcmU6dW52YWlsYWJsZSxcbm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmU6dW52YWlsYWJsZSxcbmNhbkJlRHVyYWJsZTp1bnZhaWxhYmxlfTtcblxuIH1cblxuY29uc3QgVmF0RGF0YUV4cG9ydD1WYXREYXRhR2xvYmFsOyRo4oCNX29uY2UuVmF0RGF0YUV4cG9ydChWYXREYXRhRXhwb3J0KTtcblxuXG4vKipcbiAqIEBkZXByZWNhdGVkIFVzZSBFeG9zL0V4b0NsYXNzZXMgaW5zdGVhZCBvZiBLaW5kc1xuICovXG5jb25zdCAgICAgICB7XG5kZWZpbmVLaW5kLFxuZGVmaW5lS2luZE11bHRpLFxuZGVmaW5lRHVyYWJsZUtpbmQsXG5kZWZpbmVEdXJhYmxlS2luZE11bHRpfT1cblZhdERhdGFHbG9iYWw7JGjigI1fb25jZS5kZWZpbmVLaW5kKGRlZmluZUtpbmQpOyRo4oCNX29uY2UuZGVmaW5lS2luZE11bHRpKGRlZmluZUtpbmRNdWx0aSk7JGjigI1fb25jZS5kZWZpbmVEdXJhYmxlS2luZChkZWZpbmVEdXJhYmxlS2luZCk7JGjigI1fb25jZS5kZWZpbmVEdXJhYmxlS2luZE11bHRpKGRlZmluZUR1cmFibGVLaW5kTXVsdGkpO1xuXG5jb25zdCAgICAgICB7XG5tYWtlS2luZEhhbmRsZSxcbnByb3ZpZGVQcm9taXNlV2F0Y2hlcixcbndhdGNoUHJvbWlzZSxcbm1ha2VTY2FsYXJCaWdNYXBTdG9yZSxcbm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUsXG5tYWtlU2NhbGFyQmlnU2V0U3RvcmUsXG5tYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlLFxuY2FuQmVEdXJhYmxlfT1cblZhdERhdGFHbG9iYWw7XG5cbi8qKlxuICogV2hlbiBtYWtpbmcgYSBtdWx0aS1mYWNldCBraW5kLCBpdCdzIGNvbW1vbiB0byBwaWNrIG9uZSBmYWNldCB0byBleHBvc2UuIEUuZy4sXG4gKlxuICogICAgIGNvbnN0IG1ha2VGb28gPSAoYSwgYiwgYywgZCkgPT4gbWFrZUZvb0Jhc2UoYSwgYiwgYywgZCkuc2VsZjtcbiAqXG4gKiBUaGlzIGhlbHBlciByZWR1Y2VzIHRoZSBkdXBsaWNhdGlvbjpcbiAqXG4gKiAgICAgY29uc3QgbWFrZUZvbyA9IHBpY2tGYWNldChtYWtlRm9vQmFzZSwgJ3NlbGYnKTtcbiAqXG4gKiBAdHlwZSB7WGltcG9ydCgnLi90eXBlcycpLlBpY2tGYWNldH1cbiAqLyRo4oCNX29uY2UubWFrZUtpbmRIYW5kbGUobWFrZUtpbmRIYW5kbGUpOyRo4oCNX29uY2UucHJvdmlkZVByb21pc2VXYXRjaGVyKHByb3ZpZGVQcm9taXNlV2F0Y2hlcik7JGjigI1fb25jZS53YXRjaFByb21pc2Uod2F0Y2hQcm9taXNlKTskaOKAjV9vbmNlLm1ha2VTY2FsYXJCaWdNYXBTdG9yZShtYWtlU2NhbGFyQmlnTWFwU3RvcmUpOyRo4oCNX29uY2UubWFrZVNjYWxhckJpZ1dlYWtNYXBTdG9yZShtYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlKTskaOKAjV9vbmNlLm1ha2VTY2FsYXJCaWdTZXRTdG9yZShtYWtlU2NhbGFyQmlnU2V0U3RvcmUpOyRo4oCNX29uY2UubWFrZVNjYWxhckJpZ1dlYWtTZXRTdG9yZShtYWtlU2NhbGFyQmlnV2Vha1NldFN0b3JlKTskaOKAjV9vbmNlLmNhbkJlRHVyYWJsZShjYW5CZUR1cmFibGUpO1xuY29uc3QgICAgICAgIHBpY2tGYWNldD1cbihtYWtlcixmYWNldE5hbWUpPT5cbiguLi5hcmdzKT0+XG5tYWtlciguLi5hcmdzKVtmYWNldE5hbWVdOyRo4oCNX29uY2UucGlja0ZhY2V0KHBpY2tGYWNldCk7XG5oYXJkZW4ocGlja0ZhY2V0KTtcblxuLyoqXG4gKiBBc3NpZ24gdGhlIHZhbHVlcyBvZiBhbGwgb2YgdGhlIGVudW1lcmFibGUgb3duIHByb3BlcnRpZXMgZnJvbSB0aGUgc291cmNlXG4gKiBvYmplY3QgdG8gdGhlaXIga2V5cyBpbiB0aGUgdGFyZ2V0IG9iamVjdC5cbiAqXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge1R9IHRhcmdldFxuICogQHBhcmFtIHtQYXJ0aWFsPFQ+fSBzb3VyY2VcbiAqL1xuY29uc3QgICAgICAgIHBhcnRpYWxBc3NpZ249KHRhcmdldCxzb3VyY2UpPT57XG5PYmplY3QuYXNzaWduKHRhcmdldCxzb3VyY2UpO1xuIH07JGjigI1fb25jZS5wYXJ0aWFsQXNzaWduKHBhcnRpYWxBc3NpZ24pO1xuaGFyZGVuKHBhcnRpYWxBc3NpZ24pO1xuXG4vKiBYWFggY29waWVkIGZyb20gQGFnb3JpYy9zdG9yZSB0eXBlcyovXG4vKiBVTlRJTCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQ1NjAqL1xuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdG9yZU9wdGlvbnNcbiAqIE9mIHRoZSBkaW1lbnNpb25zIG9uIHdoaWNoIEtleWVkU3RvcmVzIGNhbiBkaWZmZXIsIHdlIG9ubHkgcmVwcmVzZW50IGEgZmV3XG4gKiBvZiB0aGVtIGFzIHN0YW5kYXJkIG9wdGlvbnMuIEEgZ2l2ZW4gc3RvcmUgbWFrZXIgc2hvdWxkIGRvY3VtZW50IHdoaWNoXG4gKiBvcHRpb25zIGl0IHN1cHBvcnRzLCBhcyB3ZWxsIGFzIGl0cyBwb3NpdGlvbnMgb24gZGltZW5zaW9ucyBmb3Igd2hpY2ggaXRcbiAqIGRvZXMgbm90IHN1cHBvcnQgb3B0aW9ucy5cbiAqIEBwcm9wZXJ0eSB7Ym9vbGVhbn0gW2xvbmdMaXZlZD10cnVlXSBXaGljaCB3YXkgdG8gb3B0aW1pemUgYSB3ZWFrIHN0b3JlLiBUcnVlIG1lYW5zXG4gKiB0aGF0IHdlIGV4cGVjdCB0aGlzIHdlYWsgc3RvcmUgdG8gb3V0bGl2ZSBtb3N0IG9mIGl0cyBrZXlzLCBpbiB3aGljaFxuICogY2FzZSB3ZSBpbnRlcm5hbGx5IG1heSB1c2UgYSBKYXZhU2NyaXB0IGBXZWFrTWFwYC4gT3RoZXJ3aXNlIHdlIGludGVybmFsbHlcbiAqIG1heSB1c2UgYSBKYXZhU2NyaXB0IGBNYXBgLlxuICogRGVmYXVsdHMgdG8gdHJ1ZSwgc28gcGxlYXNlIG1hcmsgc2hvcnQgbGl2ZWQgc3RvcmVzIGV4cGxpY2l0bHkuXG4gKiBAcHJvcGVydHkge2Jvb2xlYW59IFtkdXJhYmxlPWZhbHNlXSAgVGhlIGNvbnRlbnRzIG9mIHRoaXMgc3RvcmUgc3Vydml2ZSB0ZXJtaW5hdGlvblxuICogICBvZiBpdHMgY29udGFpbmluZyBwcm9jZXNzLCBhbGxvd2luZyBmb3IgcmVzdGFydCBvciB1cGdyYWRlIGJ1dCBhdCB0aGUgY29zdFxuICogICBvZiBmb3JiaWRkaW5nIHN0b3JhZ2Ugb2YgcmVmZXJlbmNlcyB0byBlcGhlbWVyYWwgZGF0YS4gIERlZmF1bHRzIHRvIGZhbHNlLlxuICogQHByb3BlcnR5IHtib29sZWFufSBbZmFrZUR1cmFibGU9ZmFsc2VdICBUaGlzIHN0b3JlIHByZXRlbmRzIHRvIGJlIGEgZHVyYWJsZSBzdG9yZVxuICogICBidXQgZG9lcyBub3QgZW5mb3JjZSB0aGF0IHRoZSB0aGluZ3Mgc3RvcmVkIGluIGl0IGFjdHVhbGx5IGJlIHRoZW1zZWx2ZXNcbiAqICAgZHVyYWJsZSAod2hlcmVhcyBhbiBhY3R1YWwgZHVyYWJsZSBzdG9yZSB3b3VsZCBmb3JiaWQgc3RvcmFnZSBvZiBzdWNoXG4gKiAgIGl0ZW1zKS4gIFRoaXMgaXMgaW4gc2VydmljZSBvZiBhbGxvd2luZyBpbmNyZW1lbnRhbCB0cmFuc2l0aW9uIHRvIHVzZSBvZlxuICogICBkdXJhYmxlIHN0b3JlcywgdG8gZW5hYmxlIG5vcm1hbCBvcGVyYXRpb24gYW5kIHRlc3Rpbmcgd2hlbiBzb21lIHN0dWZmXG4gKiAgIGludGVuZGVkIHRvIGV2ZW50dWFsbHkgYmUgZHVyYWJsZSBoYXMgbm90IHlldCBiZWVuIG1hZGUgZHVyYWJsZS4gIEEgc3RvcmVcbiAqICAgbWFya2VkIGFzIGZha2VEdXJhYmxlIHdpbGwgYXBwZWFyIHRvIG9wZXJhdGUgbm9ybWFsbHkgYnV0IGFueSBhdHRlbXB0IHRvXG4gKiAgIHVwZ3JhZGUgaXRzIGNvbnRhaW5pbmcgdmF0IHdpbGwgZmFpbCB3aXRoIGFuIGVycm9yLlxuICogQHByb3BlcnR5IHtYaW1wb3J0KCcuL3R5cGVzJykuUGF0dGVybn0gW2tleVNoYXBlXVxuICogQHByb3BlcnR5IHtYaW1wb3J0KCcuL3R5cGVzJykuUGF0dGVybn0gW3ZhbHVlU2hhcGVdXG4gKi9cbi8qKlxuICogVW5saWtlIGBwcm92aWRlTGF6eWAsIGBwcm92aWRlYCBzaG91bGQgYmUgY2FsbGVkIGF0IG1vc3Qgb25jZVxuICogd2l0aGluIGFueSB2YXQgaW5jYXJuYXRpb24gd2l0aCBhIGdpdmVuIGBiYWdnYWdlYCxga2V5YCBwYWlyLlxuICpcbiAqIGBwcm92aWRlYCBzaG91bGQgb25seSB0byBiZSB1c2VkIHRvIHBvcHVsYXRlIGJhZ2dhZ2UsXG4gKiB3aGVyZSB0aGUgdG90YWwgbnVtYmVyIG9mIGNhbGxzIHRvIGBwcm92aWRlYCBtdXN0IGJlXG4gKiBsb3cgY2FyZGluYWxpdHksIHNpbmNlIHdlIGtlZXAgdGhlIGJvb2trZWVwaW5nIHRvIGRldGVjdCBjb2xsaXNpb25zXG4gKiBpbiBub3JtYWwgbGFuZ3VhZ2UtaGVhcCBtZW1vcnkuIEFsbCB0aGUgb3RoZXIgYmFnZ2FnZS1vcmllbnRlZFxuICogYHByb3ZpZGUqYCBhbmQgYHByZXBhcmUqYCBmdW5jdGlvbnMgY2FsbCBgcHJvdmlkZWAsXG4gKiBhbmQgc28gaW1wb3NlIHRoZSBzYW1lIGNvbnN0cmFpbnRzLiBUaGlzIGlzIGNvbnNpc3RlbnQgd2l0aFxuICogb3VyIGV4cGVjdGVkIGR1cmFiaWxpdHkgcGF0dGVybnM6IFdoYXQgd2Ugc3RvcmUgaW4gYmFnZ2FnZSBhcmVcbiAqICAgICoga2luZEhhbmRsZXMsIHdoaWNoIGFyZSBwZXIga2luZCwgd2hpY2ggbXVzdCBiZSBsb3cgY2FyZGluYWxpdHlcbiAqICAgICogZGF0YSBcInZhcmlhYmxlc1wiIGZvciByZWVzdGFibGlzaGluZyB0aGUgbGV4aWNhbCBzY29wZSwgZXNwZWNpYWxseVxuICogICAgICBvZiBzaW5nbGV0b25zXG4gKiAgICAqIG5hbWVkIG5vbi1iYWdnYWdlIGNvbGxlY3Rpb25zIGF0IHRoZSBsZWF2ZXMgb2YgdGhlIGJhZ2dhZ2UgdHJlZS5cbiAqXG4gKiBXaGF0IGlzIGV4cGVjdGVkIHRvIGJlIGhpZ2ggY2FyZGluYWxpdHkgYXJlIHRoZSBpbnN0YW5jZXMgb2YgdGhlIGtpbmRzLFxuICogYW5kIHRoZSBtZW1iZXJzIG9mIHRoZSBub24tYmFnZ2dhZ2UgY29sbGVjdGlvbnMuXG4gKlxuICogVE9ETyBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvcHVsbC81ODc1IDpcbiAqIEltcGxlbWVudCBkZXZlbG9wbWVudC10aW1lIGluc3RydW1lbnRhdGlvbiB0byBkZXRlY3Qgd2hlblxuICogYHByb3ZpZGVgIHZpb2xhdGVzIHRoZSBhYm92ZSBwcmVzY3JpcHRpb24sIGFuZCBpcyBjYWxsZWQgbW9yZVxuICogdGhhbiBvbmNlIGluIHRoZSBzYW1lIHZhdCBpbmNhcm5hdGlvbiB3aXRoIHRoZSBzYW1lXG4gKiBiYWdnYWdlLGtleSBwYWlyLlxuICovXG5cbmNvbnN0ICAgICAgICBwcm92aWRlPVxuLyogWFhYIGNhc3QgYmVjYXVzZSBwcm92aWRlTGF6eSBpcyBgYW55YCBkdWUgdG8gYnJva2VuIHR5cGUgaW1wb3J0Ki9cbi8qKiBAdHlwZSB7PEssIFY+KGJhZ2dhZ2U6IFhpbXBvcnQoJy4vdHlwZXMuanMnKS5CYWdnYWdlLCBrZXk6IEssIG1ha2VWYWx1ZTogKGtleTogSykgPT4gVikgPT4gVn0gKi9cbnByb3ZpZGVMYXp5O1xuXG5cbi8qIFRPRE86IEZpbmQgYSBnb29kIGhvbWUgZm9yIHRoaXMgZnVuY3Rpb24gdXNlZCBieSBAYWdvcmljL3ZhdC1kYXRhIGFuZCB0ZXN0aW5nIGNvZGUqL1xuLyoqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YS9zcmMvdHlwZXMnKS5WYXREYXRhfSBWYXREYXRhICovJGjigI1fb25jZS5wcm92aWRlKHByb3ZpZGUpO1xuY29uc3QgICAgICAgIG1ha2VTdG9yZVV0aWxzPShWYXREYXRhKT0+e1xuY29uc3R7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIHRoZXNlIGxpdGVyYWxseSBkbyBzaGFkb3cgdGhlIGdsb2JhbHMqL1xubWFrZVNjYWxhckJpZ01hcFN0b3JlLFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXNoYWRvdyAtLSB0aGVzZSBsaXRlcmFsbHkgZG8gc2hhZG93IHRoZSBnbG9iYWxzKi9cbm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUsXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIHRoZXNlIGxpdGVyYWxseSBkbyBzaGFkb3cgdGhlIGdsb2JhbHMqL1xubWFrZVNjYWxhckJpZ1NldFN0b3JlLFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXNoYWRvdyAtLSB0aGVzZSBsaXRlcmFsbHkgZG8gc2hhZG93IHRoZSBnbG9iYWxzKi9cbm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmV9PVxuVmF0RGF0YTtcblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtPbWl0PFN0b3JlT3B0aW9ucywgJ2R1cmFibGUnPn0gb3B0aW9uc1xuICovXG5jb25zdCBwcm92aWRlRHVyYWJsZU1hcFN0b3JlPShiYWdnYWdlLG5hbWUsb3B0aW9ucz17fSk9PlxucHJvdmlkZShiYWdnYWdlLG5hbWUsKCk9PlxubWFrZVNjYWxhckJpZ01hcFN0b3JlKG5hbWUse2R1cmFibGU6dHJ1ZSwuLi5vcHRpb25zfSkpO1xuXG5oYXJkZW4ocHJvdmlkZUR1cmFibGVNYXBTdG9yZSk7XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzJykuQmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtzdHJpbmd9IG5hbWVcbiAqIEBwYXJhbSB7T21pdDxTdG9yZU9wdGlvbnMsICdkdXJhYmxlJz59IG9wdGlvbnNcbiAqL1xuY29uc3QgcHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmU9KGJhZ2dhZ2UsbmFtZSxvcHRpb25zPXt9KT0+XG5wcm92aWRlKGJhZ2dhZ2UsbmFtZSwoKT0+XG5tYWtlU2NhbGFyQmlnV2Vha01hcFN0b3JlKG5hbWUse2R1cmFibGU6dHJ1ZSwuLi5vcHRpb25zfSkpO1xuXG5oYXJkZW4ocHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUpO1xuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcycpLkJhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBuYW1lXG4gKiBAcGFyYW0ge09taXQ8U3RvcmVPcHRpb25zLCAnZHVyYWJsZSc+fSBvcHRpb25zXG4gKi9cbmNvbnN0IHByb3ZpZGVEdXJhYmxlU2V0U3RvcmU9KGJhZ2dhZ2UsbmFtZSxvcHRpb25zPXt9KT0+XG5wcm92aWRlKGJhZ2dhZ2UsbmFtZSwoKT0+XG5tYWtlU2NhbGFyQmlnU2V0U3RvcmUobmFtZSx7ZHVyYWJsZTp0cnVlLC4uLm9wdGlvbnN9KSk7XG5cbmhhcmRlbihwcm92aWRlRHVyYWJsZVNldFN0b3JlKTtcblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHBhcmFtIHtPbWl0PFN0b3JlT3B0aW9ucywgJ2R1cmFibGUnPn0gb3B0aW9uc1xuICovXG5jb25zdCBwcm92aWRlRHVyYWJsZVdlYWtTZXRTdG9yZT0oYmFnZ2FnZSxuYW1lLG9wdGlvbnM9e30pPT5cbnByb3ZpZGUoYmFnZ2FnZSxuYW1lLCgpPT5cbm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmUobmFtZSx7ZHVyYWJsZTp0cnVlLC4uLm9wdGlvbnN9KSk7XG5cbmhhcmRlbihwcm92aWRlRHVyYWJsZVdlYWtTZXRTdG9yZSk7XG5cbnJldHVybiBoYXJkZW4oe1xucHJvdmlkZUR1cmFibGVNYXBTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlLFxucHJvdmlkZUR1cmFibGVTZXRTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZVN0b3JlVXRpbHMobWFrZVN0b3JlVXRpbHMpO1xuXG5jb25zdCBnbG9iYWxTdG9yZVV0aWxzPW1ha2VTdG9yZVV0aWxzKFZhdERhdGFHbG9iYWwpO1xuY29uc3QgICAgICAge1xucHJvdmlkZUR1cmFibGVNYXBTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha01hcFN0b3JlLFxucHJvdmlkZUR1cmFibGVTZXRTdG9yZSxcbnByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlfT1cbmdsb2JhbFN0b3JlVXRpbHM7JGjigI1fb25jZS5wcm92aWRlRHVyYWJsZU1hcFN0b3JlKHByb3ZpZGVEdXJhYmxlTWFwU3RvcmUpOyRo4oCNX29uY2UucHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUocHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUpOyRo4oCNX29uY2UucHJvdmlkZUR1cmFibGVTZXRTdG9yZShwcm92aWRlRHVyYWJsZVNldFN0b3JlKTskaOKAjV9vbmNlLnByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlKHByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJWYXREYXRhIjpbIlZhdERhdGFFeHBvcnQiXSwiZGVmaW5lS2luZCI6WyJkZWZpbmVLaW5kIl0sImRlZmluZUtpbmRNdWx0aSI6WyJkZWZpbmVLaW5kTXVsdGkiXSwiZGVmaW5lRHVyYWJsZUtpbmQiOlsiZGVmaW5lRHVyYWJsZUtpbmQiXSwiZGVmaW5lRHVyYWJsZUtpbmRNdWx0aSI6WyJkZWZpbmVEdXJhYmxlS2luZE11bHRpIl0sIm1ha2VLaW5kSGFuZGxlIjpbIm1ha2VLaW5kSGFuZGxlIl0sInByb3ZpZGVQcm9taXNlV2F0Y2hlciI6WyJwcm92aWRlUHJvbWlzZVdhdGNoZXIiXSwid2F0Y2hQcm9taXNlIjpbIndhdGNoUHJvbWlzZSJdLCJtYWtlU2NhbGFyQmlnTWFwU3RvcmUiOlsibWFrZVNjYWxhckJpZ01hcFN0b3JlIl0sIm1ha2VTY2FsYXJCaWdXZWFrTWFwU3RvcmUiOlsibWFrZVNjYWxhckJpZ1dlYWtNYXBTdG9yZSJdLCJtYWtlU2NhbGFyQmlnU2V0U3RvcmUiOlsibWFrZVNjYWxhckJpZ1NldFN0b3JlIl0sIm1ha2VTY2FsYXJCaWdXZWFrU2V0U3RvcmUiOlsibWFrZVNjYWxhckJpZ1dlYWtTZXRTdG9yZSJdLCJjYW5CZUR1cmFibGUiOlsiY2FuQmVEdXJhYmxlIl0sInBpY2tGYWNldCI6WyJwaWNrRmFjZXQiXSwicGFydGlhbEFzc2lnbiI6WyJwYXJ0aWFsQXNzaWduIl0sInByb3ZpZGUiOlsicHJvdmlkZSJdLCJtYWtlU3RvcmVVdGlscyI6WyJtYWtlU3RvcmVVdGlscyJdLCJwcm92aWRlRHVyYWJsZU1hcFN0b3JlIjpbInByb3ZpZGVEdXJhYmxlTWFwU3RvcmUiXSwicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiOlsicHJvdmlkZUR1cmFibGVXZWFrTWFwU3RvcmUiXSwicHJvdmlkZUR1cmFibGVTZXRTdG9yZSI6WyJwcm92aWRlRHVyYWJsZVNldFN0b3JlIl0sInByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlIjpbInByb3ZpZGVEdXJhYmxlV2Vha1NldFN0b3JlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAACivt2jAAwAAwAMAACUAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL2V4cG9ydGVkLmpzeyJpbXBvcnRzIjpbIi4vc3JjL2NvbnRyYWN0RmFjZXQvdHlwZXMuanMiLCIuL3NyYy9jb250cmFjdFN1cHBvcnQvdHlwZXMuanMiLCIuL3NyYy9jb250cmFjdHMvZXhwb3J0ZWQuanMiLCIuL3NyYy90eXBlcy5qcyIsIi4vc3JjL3pvZVNlcnZpY2UvdHlwZXMuanMiLCIuL3Rvb2xzL3R5cGVzLWFtYmllbnQuanMiLCJAYWdvcmljL2VydHAvZXhwb3J0ZWQuanMiLCJAYWdvcmljL25vdGlmaWVyL2V4cG9ydGVkLmpzIiwiQGFnb3JpYy9zdG9yZS9leHBvcnRlZC5qcyIsIkBhZ29yaWMvc3dpbmdzZXQtdmF0L2V4cG9ydGVkLmpzIl0sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vc3JjL2NvbnRyYWN0RmFjZXQvdHlwZXMuanNcIiwgW11dLFtcIi4vc3JjL3pvZVNlcnZpY2UvdHlwZXMuanNcIiwgW11dLFtcIi4vc3JjL2NvbnRyYWN0U3VwcG9ydC90eXBlcy5qc1wiLCBbXV0sW1wiLi9zcmMvY29udHJhY3RzL2V4cG9ydGVkLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV0sW1wiLi90b29scy90eXBlcy1hbWJpZW50LmpzXCIsIFtdXSxbXCJAYWdvcmljL25vdGlmaWVyL2V4cG9ydGVkLmpzXCIsIFtdXSxbXCJAYWdvcmljL2VydHAvZXhwb3J0ZWQuanNcIiwgW11dLFtcIkBhZ29yaWMvc3RvcmUvZXhwb3J0ZWQuanNcIiwgW11dLFtcIkBhZ29yaWMvc3dpbmdzZXQtdmF0L2V4cG9ydGVkLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABxjbziQBwAAEAcAAAuAAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY2xlYW5Qcm9wb3NhbC5qc3siaW1wb3J0cyI6WyIuL2ludGVybmFsLXR5cGVzLmpzIiwiLi9vYmpBcnJheUNvbnZlcnNpb24uanMiLCIuL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL2Fzc2VydCIsIkBhZ29yaWMvZXJ0cCIsIkBhZ29yaWMvc3RvcmUiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiTUFYX0tFWVdPUkRfTEVOR1RIIiwiYXNzZXJ0S2V5d29yZE5hbWUiLCJjbGVhbktleXdvcmRzIiwiY2xlYW5Qcm9wb3NhbCIsImNvZXJjZUFtb3VudEtleXdvcmRSZWNvcmQiLCJjb2VyY2VBbW91bnRQYXR0ZXJuS2V5d29yZFJlY29yZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnQscSxGYWlsLEFtb3VudE1hdGgsZ2V0QXNzZXRLaW5kLGFzc2VydFJlY29yZCxhc3NlcnRLZXksYXNzZXJ0UGF0dGVybixtdXN0TWF0Y2gsaXNLZXksRnVsbFByb3Bvc2FsU2hhcGUsYXJyYXlUb09iajskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2Fzc2VydFwiLCBbW1wiYXNzZXJ0XCIsIFskaOKAjV9hID0+IChhc3NlcnQgPSAkaOKAjV9hKV1dLFtcInFcIiwgWyRo4oCNX2EgPT4gKHEgPSAkaOKAjV9hKV1dLFtcIkZhaWxcIiwgWyRo4oCNX2EgPT4gKEZhaWwgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBbW91bnRNYXRoXCIsIFskaOKAjV9hID0+IChBbW91bnRNYXRoID0gJGjigI1fYSldXSxbXCJnZXRBc3NldEtpbmRcIiwgWyRo4oCNX2EgPT4gKGdldEFzc2V0S2luZCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRSZWNvcmRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlY29yZCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJhc3NlcnRLZXlcIiwgWyRo4oCNX2EgPT4gKGFzc2VydEtleSA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UGF0dGVyblwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGF0dGVybiA9ICRo4oCNX2EpXV0sW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dLFtcImlzS2V5XCIsIFskaOKAjV9hID0+IChpc0tleSA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVHdWFyZHMuanNcIiwgW1tcIkZ1bGxQcm9wb3NhbFNoYXBlXCIsIFskaOKAjV9hID0+IChGdWxsUHJvcG9zYWxTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCIuL29iakFycmF5Q29udmVyc2lvbi5qc1wiLCBbW1wiYXJyYXlUb09ialwiLCBbJGjigI1fYSA9PiAoYXJyYXlUb09iaiA9ICRo4oCNX2EpXV1dXSxbXCIuL2ludGVybmFsLXR5cGVzLmpzXCIsIFtdXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbmNvbnN0ICAgICAgICBNQVhfS0VZV09SRF9MRU5HVEg9MTAwOyRo4oCNX29uY2UuTUFYX0tFWVdPUkRfTEVOR1RIKE1BWF9LRVlXT1JEX0xFTkdUSCk7XG5cbmNvbnN0IGZpcnN0Q2FwQVNDSUk9L15bQS1aXVthLXpBLVowLTlfJF0qJC87XG5cbi8qIFdlIGFkb3B0IHNpbXBsZSByZXF1aXJlbWVudHMgb24ga2V5d29yZHMgc28gdGhhdCB0aGV5IGRvIG5vdCBhY2NpZGVudGFsbHkqL1xuLyogY29uZmxpY3Qgd2l0aCBleGlzdGluZyBwcm9wZXJ0eSBuYW1lcy4qL1xuLyogV2UgcmVxdWlyZSBrZXl3b3JkcyB0byBiZSBzdHJpbmdzLCBhc2NpaSBpZGVudGlmaWVycyBiZWdpbm5pbmcgd2l0aCBhbiovXG4vKiB1cHBlciBjYXNlIGxldHRlciwgYW5kIGRpc3RpbmN0IGZyb20gdGhlIHN0cmluZ2lmaWVkIGZvcm0gb2YgYW55IG51bWJlci4qL1xuLyoqL1xuLyogT2YgbnVtYmVycywgb25seSBOYU4gYW5kIEluZmluaXR5LCB3aGVuIHN0cmluZ2lmaWVkIHRvIGEgcHJvcGVydHkgbmFtZSwqL1xuLyogcHJvZHVjZSBhbiBhc2NpaSBpZGVudGlmaWVyIGJlZ2lubmluZyB3aXRoIGFuIHVwcGVyIGNhc2UgbGV0dGVyLiovXG4vKiBXaXRoIHRoaXMgcnVsZSwgYSBjb21wdXRlZCBpbmRleGluZyBleHByZXNzaW9uIGxpa2UgYGFbK2ldYCBjYW5ub3QqL1xuLyogbG9va3VwIGEga2V5d29yZC1uYW1lZCBwcm9wZXJ0eSBubyBtYXR0ZXIgd2hhdCBgaWAgaXMuKi9cbmNvbnN0ICAgICAgICBhc3NlcnRLZXl3b3JkTmFtZT0oa2V5d29yZCk9PntcbmFzc2VydC50eXBlb2Yoa2V5d29yZCwnc3RyaW5nJyk7XG5rZXl3b3JkLmxlbmd0aDw9TUFYX0tFWVdPUkRfTEVOR1RIfHxcbkZhaWwgYGtleXdvcmQgJHtxKGtleXdvcmQpfSBleGNlZWRlZCBtYXhpbXVtIGxlbmd0aCAke3EoXG5NQVhfS0VZV09SRF9MRU5HVEgpXG4gfSBjaGFyYWN0ZXJzOyBnb3QgJHtrZXl3b3JkLmxlbmd0aH1gO1xuZmlyc3RDYXBBU0NJSS50ZXN0KGtleXdvcmQpfHxcbkZhaWwgYGtleXdvcmQgJHtxKFxua2V5d29yZClcbiB9IG11c3QgYmUgYW4gYXNjaWkgaWRlbnRpZmllciBzdGFydGluZyB3aXRoIHVwcGVyIGNhc2UuYDtcbmtleXdvcmQhPT0nTmFOJyYma2V5d29yZCE9PSdJbmZpbml0eSd8fFxuRmFpbCBga2V5d29yZCAke3Eoa2V5d29yZCl9IG11c3Qgbm90IGJlIGEgbnVtYmVyJ3MgbmFtZWA7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3tbbmFtZTogc3RyaW5nXTogYW55fX0gdW5jbGVhbktleXdvcmRSZWNvcmRcbiAqIEByZXR1cm5zIHtzdHJpbmdbXX1cbiAqLyRo4oCNX29uY2UuYXNzZXJ0S2V5d29yZE5hbWUoYXNzZXJ0S2V5d29yZE5hbWUpO1xuY29uc3QgICAgICAgIGNsZWFuS2V5d29yZHM9KHVuY2xlYW5LZXl3b3JkUmVjb3JkKT0+e1xuaGFyZGVuKHVuY2xlYW5LZXl3b3JkUmVjb3JkKTtcbmFzc2VydFJlY29yZCh1bmNsZWFuS2V5d29yZFJlY29yZCwna2V5d29yZFJlY29yZCcpO1xuY29uc3Qga2V5d29yZHM9b3duS2V5cyh1bmNsZWFuS2V5d29yZFJlY29yZCk7XG5cbi8qIEFzc2VydCBhbGwgbmFtZXMgYXJlIGFzY2lpIGlkZW50aWZpZXJzIHN0YXJ0aW5nIHdpdGgqL1xuLyogYW4gdXBwZXIgY2FzZSBsZXR0ZXIuKi9cbmtleXdvcmRzLmZvckVhY2goYXNzZXJ0S2V5d29yZE5hbWUpO1xuXG5yZXR1cm4gKC8qKiBAdHlwZSB7c3RyaW5nW119ICova2V5d29yZHMpO1xuIH07JGjigI1fb25jZS5jbGVhbktleXdvcmRzKGNsZWFuS2V5d29yZHMpO1xuXG5jb25zdCAgICAgICAgY29lcmNlQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmQ9KFxuYWxsZWdlZEFtb3VudEtleXdvcmRSZWNvcmQsXG5nZXRBc3NldEtpbmRCeUJyYW5kKT0+XG57XG5jb25zdCBrZXl3b3Jkcz1jbGVhbktleXdvcmRzKGFsbGVnZWRBbW91bnRLZXl3b3JkUmVjb3JkKTtcblxuY29uc3QgYW1vdW50cz1PYmplY3QudmFsdWVzKGFsbGVnZWRBbW91bnRLZXl3b3JkUmVjb3JkKTtcbi8qIENoZWNrIHRoYXQgZWFjaCB2YWx1ZSBjYW4gYmUgY29lcmNlZCB1c2luZyB0aGUgQW1vdW50TWF0aCovXG4vKiBpbmRpY2F0ZWQgYnkgYnJhbmQuIGBBbW91bnRNYXRoLmNvZXJjZWAgdGhyb3dzIGlmIGNvZXJjaW9uIGZhaWxzLiovXG5jb25zdCBjb2VyY2VkQW1vdW50cz1hbW91bnRzLm1hcCgoYW1vdW50KT0+e1xuaWYoaXNLZXkoYW1vdW50KSl7XG5jb25zdCBicmFuZEFzc2V0S2luZD1nZXRBc3NldEtpbmRCeUJyYW5kKGFtb3VudC5icmFuZCk7XG5jb25zdCBhc3NldEtpbmQ9Z2V0QXNzZXRLaW5kKGFtb3VudCk7XG4vKiBUT0RPOiByZXBsYWNlIHRoaXMgYXNzZXJ0aW9uIHdpdGggYSBjaGVjayBvZiB0aGUgYXNzZXRLaW5kKi9cbi8qIHByb3BlcnR5IG9uIHRoZSBicmFuZCwgd2hlbiB0aGF0IGV4aXN0cy4qL1xuYXNzZXRLaW5kPT09YnJhbmRBc3NldEtpbmR8fFxuRmFpbCBgVGhlIGFtb3VudCAke2Ftb3VudH0gZGlkIG5vdCBoYXZlIHRoZSBhc3NldEtpbmQgb2YgdGhlIGJyYW5kICR7YnJhbmRBc3NldEtpbmR9YDtcbnJldHVybiBBbW91bnRNYXRoLmNvZXJjZShhbW91bnQuYnJhbmQsYW1vdW50KTtcbiB9ZWxzZXtcbmFzc2VydFBhdHRlcm4oYW1vdW50KTtcbnJldHVybiBhbW91bnQ7XG4gfVxuIH0pO1xuXG4vKiBSZWNyZWF0ZSB0aGUgYW1vdW50S2V5d29yZFJlY29yZCB3aXRoIGNvZXJjZWRBbW91bnRzLiovXG5yZXR1cm4gaGFyZGVuKGFycmF5VG9PYmooY29lcmNlZEFtb3VudHMsa2V5d29yZHMpKTtcbiB9OyRo4oCNX29uY2UuY29lcmNlQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmQoY29lcmNlQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmQpO1xuXG5jb25zdCAgICAgICAgY29lcmNlQW1vdW50S2V5d29yZFJlY29yZD0oXG5hbGxlZ2VkQW1vdW50S2V5d29yZFJlY29yZCxcbmdldEFzc2V0S2luZEJ5QnJhbmQpPT5cbntcbmNvbnN0IHJlc3VsdD1jb2VyY2VBbW91bnRQYXR0ZXJuS2V5d29yZFJlY29yZChcbmFsbGVnZWRBbW91bnRLZXl3b3JkUmVjb3JkLFxuZ2V0QXNzZXRLaW5kQnlCcmFuZCk7XG5cbmFzc2VydEtleShyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEp1c3QgY2hlY2tzIHJlc2lkdWFsIGlzc3VlcyBhZnRlciBtYXRjaGluZyBQcm9wb3NhbFNoYXBlLlxuICogT25seSBrbm93biByZXNpZHVhbCBpc3N1ZSBpcyB2ZXJpZnlpbmcgdGhhdCBpdCBvbmx5IGhhcyBvbmUgb2YgdGhlXG4gKiBvcHRpb25hbCBwcm9wZXJ0aWVzLlxuICpcbiAqIEBwYXJhbSB7RXhpdFJ1bGV9IGV4aXRcbiAqLyRo4oCNX29uY2UuY29lcmNlQW1vdW50S2V5d29yZFJlY29yZChjb2VyY2VBbW91bnRLZXl3b3JkUmVjb3JkKTtcbmNvbnN0IGFzc2VydEV4aXQ9KGV4aXQpPT5cbm93bktleXMoZXhpdCkubGVuZ3RoPT09MXx8RmFpbCBgZXhpdCAke2V4aXR9IHNob3VsZCBvbmx5IGhhdmUgb25lIGtleWA7XG5cbi8qKlxuICogY2hlY2sgdGhhdCBrZXl3b3JkIGlzIG5vdCBpbiBib3RoICd3YW50JyBhbmQgJ2dpdmUnLlxuICpcbiAqIEBwYXJhbSB7UHJvcG9zYWxSZWNvcmRbXCJ3YW50XCJdfSB3YW50XG4gKiBAcGFyYW0ge1Byb3Bvc2FsUmVjb3JkW1wiZ2l2ZVwiXX0gZ2l2ZVxuICovXG5jb25zdCBhc3NlcnRLZXl3b3JkTm90SW5Cb3RoPSh3YW50LGdpdmUpPT57XG5jb25zdCB3YW50S2V5d29yZFNldD1uZXcgU2V0KG93bktleXMod2FudCkpO1xuY29uc3QgZ2l2ZUtleXdvcmRzPW93bktleXMoZ2l2ZSk7XG5cbmdpdmVLZXl3b3Jkcy5mb3JFYWNoKChrZXl3b3JkKT0+e1xuIXdhbnRLZXl3b3JkU2V0LmhhcyhrZXl3b3JkKXx8XG5GYWlsIGBhIGtleXdvcmQgY2Fubm90IGJlIGluIGJvdGggJ3dhbnQnIGFuZCAnZ2l2ZSdgO1xuIH0pO1xuIH07XG5cbi8qKlxuICogY2xlYW5Qcm9wb3NhbCBjaGVja3MgdGhlIGtleXMgYW5kIHZhbHVlcyBvZiB0aGUgcHJvcG9zYWwsIGluY2x1ZGluZ1xuICogdGhlIGtleXMgYW5kIHZhbHVlcyBvZiB0aGUgaW50ZXJuYWwgb2JqZWN0cy4gVGhlIHByb3Bvc2FsIG1heSBoYXZlXG4gKiB0aGUgZm9sbG93aW5nIGtleXM6IGBnaXZlYCwgYHdhbnRgLCBhbmQgYGV4aXRgLiBUaGVzZSBrZXlzIG1heSBiZVxuICogb21pdHRlZCBpbiB0aGUgYHByb3Bvc2FsYCBhcmd1bWVudCBwYXNzZWQgdG8gY2xlYW5Qcm9wb3NhbCwgYnV0XG4gKiBhbnl0aGluZyBvdGhlciB0aGFuIHRoZXNlIGtleXMgaXMgbm90IGFsbG93ZWQuIFRoZSB2YWx1ZXMgb2YgYGdpdmVgXG4gKiBhbmQgYHdhbnRgIG11c3QgYmUgXCJhbW91bnRLZXl3b3JkUmVjb3Jkc1wiLCBtZWFuaW5nIHRoYXQgdGhlIGtleXNcbiAqIG11c3QgYmUga2V5d29yZHMgYW5kIHRoZSB2YWx1ZXMgbXVzdCBiZSBhbW91bnRzLiBUaGUgdmFsdWUgb2ZcbiAqIGBleGl0YCwgaWYgcHJlc2VudCwgbXVzdCBiZSBhIHJlY29yZCBvZiBvbmUgb2YgdGhlIGZvbGxvd2luZyBmb3JtczpcbiAqIGB7IHdhaXZlZDogbnVsbCB9YCBgeyBvbkRlbWFuZDogbnVsbCB9YCBgeyBhZnRlckRlYWRsaW5lOiB7IHRpbWVyXG4gKiA6VGltZXIsIGRlYWRsaW5lIDpiaWdpbnQgfSB9XG4gKlxuICogQHBhcmFtIHtQcm9wb3NhbH0gcHJvcG9zYWxcbiAqIEBwYXJhbSB7R2V0QXNzZXRLaW5kQnlCcmFuZH0gZ2V0QXNzZXRLaW5kQnlCcmFuZFxuICogQHJldHVybnMge1Byb3Bvc2FsUmVjb3JkfVxuICovXG5jb25zdCAgICAgICAgY2xlYW5Qcm9wb3NhbD0ocHJvcG9zYWwsZ2V0QXNzZXRLaW5kQnlCcmFuZCk9PntcbmFzc2VydFJlY29yZChwcm9wb3NhbCwncHJvcG9zYWwnKTtcbi8qIFdlIGZpbGwgaW4gdGhlIGRlZmF1bHQgdmFsdWVzIGlmIHRoZSBrZXlzIGFyZSBhYnNlbnQgb3IgdW5kZWZpbmVkLiovXG5jb25zdHtcbndhbnQ9aGFyZGVuKHt9KSxcbmdpdmU9aGFyZGVuKHt9KSxcbmV4aXQ9aGFyZGVuKHtvbkRlbWFuZDpudWxsfSksXG4uLi5yZXN0fT1cbnByb3Bvc2FsO1xub3duS2V5cyhyZXN0KS5sZW5ndGg9PT0wfHxcbkZhaWwgYCR7cHJvcG9zYWx9IC0gTXVzdCBvbmx5IGhhdmUgd2FudDosIGdpdmU6LCBleGl0OiBwcm9wZXJ0aWVzOiAke3Jlc3R9YDtcblxuY29uc3QgY2xlYW5lZFdhbnQ9Y29lcmNlQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmQoXG53YW50LFxuZ2V0QXNzZXRLaW5kQnlCcmFuZCk7XG5cbmNvbnN0IGNsZWFuZWRHaXZlPWNvZXJjZUFtb3VudEtleXdvcmRSZWNvcmQoZ2l2ZSxnZXRBc3NldEtpbmRCeUJyYW5kKTtcblxuY29uc3QgY2xlYW5lZFByb3Bvc2FsPWhhcmRlbih7XG53YW50OmNsZWFuZWRXYW50LFxuZ2l2ZTpjbGVhbmVkR2l2ZSxcbmV4aXR9KTtcblxubXVzdE1hdGNoKGNsZWFuZWRQcm9wb3NhbCxGdWxsUHJvcG9zYWxTaGFwZSwncHJvcG9zYWwnKTtcbmFzc2VydEV4aXQoZXhpdCk7XG5hc3NlcnRLZXl3b3JkTm90SW5Cb3RoKGNsZWFuZWRXYW50LGNsZWFuZWRHaXZlKTtcbnJldHVybiBjbGVhbmVkUHJvcG9zYWw7XG4gfTskaOKAjV9vbmNlLmNsZWFuUHJvcG9zYWwoY2xlYW5Qcm9wb3NhbCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiTUFYX0tFWVdPUkRfTEVOR1RIIjpbIk1BWF9LRVlXT1JEX0xFTkdUSCJdLCJhc3NlcnRLZXl3b3JkTmFtZSI6WyJhc3NlcnRLZXl3b3JkTmFtZSJdLCJjbGVhbktleXdvcmRzIjpbImNsZWFuS2V5d29yZHMiXSwiY29lcmNlQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmQiOlsiY29lcmNlQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmQiXSwiY29lcmNlQW1vdW50S2V5d29yZFJlY29yZCI6WyJjb2VyY2VBbW91bnRLZXl3b3JkUmVjb3JkIl0sImNsZWFuUHJvcG9zYWwiOlsiY2xlYW5Qcm9wb3NhbCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACaqDlCvBAAALwQAAA6AAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RGYWNldC9vZmZlclNhZmV0eS5qc3siaW1wb3J0cyI6WyJAYWdvcmljL2VydHAiXSwiZXhwb3J0cyI6WyJpc09mZmVyU2FmZSIsInNhdGlzZmllc1dhbnQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgQW1vdW50TWF0aDskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2VydHBcIiwgW1tcIkFtb3VudE1hdGhcIiwgWyRo4oCNX2EgPT4gKEFtb3VudE1hdGggPSAkaOKAjV9hKV1dXV1dKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoaXNPZmZlclNhZmUsICduYW1lJywge3ZhbHVlOiBcImlzT2ZmZXJTYWZlXCJ9KTskaOKAjV9vbmNlLmlzT2ZmZXJTYWZlKGlzT2ZmZXJTYWZlKTsgICBcblxuLyoqXG4gKiBIZWxwZXIgdG8gcGVyZm9ybSBzYXRpc2ZpZXNXYW50IGFuZCBzYXRpc2ZpZXNHaXZlLiBJc1xuICogYWxsb2NhdGlvbkFtb3VudCBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gcmVxdWlyZWRBbW91bnQgZm9yIGV2ZXJ5XG4gKiBrZXl3b3JkIG9mIGdpdmVPcldhbnQ/XG4gKlxuICogVG8gcHJlcGFyZSBmb3IgbXVsdGlwbGVzLCBzYXRpc2ZpZXNXYW50IGFuZCBzYXRpc2ZpZXNHaXZlIHJldHVybiAwIG9yIDEuXG4gKiBpc09mZmVyU2FmZSB3aWxsIHN0aWxsIGJlIGJvb2xlYW4uIFdoZW4gd2UgaGF2ZSBNdWx0aXBsZXMsIHNhdGlzZmllc1dhbnQgYW5kXG4gKiBzYXRpc2ZpZXNHaXZlIHdpbGwgdGVsbCBob3cgbWFueSB0aW1lcyB0aGUgb2ZmZXIgd2FzIG1hdGNoZWQuXG4gKlxuICogQHBhcmFtIHtBbW91bnRLZXl3b3JkUmVjb3JkfSBnaXZlT3JXYW50XG4gKiBAcGFyYW0ge0Ftb3VudEtleXdvcmRSZWNvcmR9IGFsbG9jYXRpb25cbiAqIEByZXR1cm5zIHswfDF9XG4gKi9cbmNvbnN0IHNhdGlzZmllc0ludGVybmFsPShnaXZlT3JXYW50PXt9LGFsbG9jYXRpb24pPT57XG5jb25zdCBpc0dURUJ5S2V5d29yZD0oW2tleXdvcmQscmVxdWlyZWRBbW91bnRdKT0+e1xuLyogSWYgdGhlcmUgaXMgbm8gYWxsb2NhdGlvbiBmb3IgYSBrZXl3b3JkLCB3ZSBrbm93IHRoZSBnaXZlT3JXYW50Ki9cbi8qIGlzIG5vdCBzYXRpc2ZpZWQgd2l0aG91dCBjaGVja2luZyBmdXJ0aGVyLiovXG5pZihhbGxvY2F0aW9uW2tleXdvcmRdPT09dW5kZWZpbmVkKXtcbnJldHVybiAwO1xuIH1cbmNvbnN0IGFsbG9jYXRpb25BbW91bnQ9YWxsb2NhdGlvbltrZXl3b3JkXTtcbnJldHVybiBBbW91bnRNYXRoLmlzR1RFKGFsbG9jYXRpb25BbW91bnQscmVxdWlyZWRBbW91bnQpPzE6MDtcbiB9O1xucmV0dXJuIE9iamVjdC5lbnRyaWVzKGdpdmVPcldhbnQpLmV2ZXJ5KGlzR1RFQnlLZXl3b3JkKT8xOjA7XG4gfTtcblxuLyoqXG4gKiBGb3IgdGhpcyBhbGxvY2F0aW9uIHRvIHNhdGlzZnkgd2hhdCB0aGUgdXNlciB3YW50ZWQsIHRoZWlyXG4gKiBhbGxvY2F0ZWQgYW1vdW50cyBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byBwcm9wb3NhbC53YW50LlxuICpcbiAqIEBwYXJhbSB7UHJvcG9zYWxSZWNvcmR9IHByb3Bvc2FsIC0gdGhlIHJ1bGVzIHRoYXQgYWNjb21wYW5pZWQgdGhlXG4gKiBlc2Nyb3cgb2YgcGF5bWVudHMgdGhhdCBkaWN0YXRlIHdoYXQgdGhlIHVzZXIgZXhwZWN0ZWQgdG8gZ2V0IGJhY2tcbiAqIGZyb20gWm9lLiBBIHByb3Bvc2FsIGlzIGEgcmVjb3JkIHdpdGgga2V5cyBgZ2l2ZWAsIGB3YW50YCwgYW5kXG4gKiBgZXhpdGAuIGBnaXZlYCBhbmQgYHdhbnRgIGFyZSByZWNvcmRzIHdpdGgga2V5d29yZHMgYXMga2V5cyBhbmRcbiAqIGFtb3VudHMgYXMgdmFsdWVzLiBUaGUgcHJvcG9zYWwgaXMgYSB1c2VyJ3MgdW5kZXJzdGFuZGluZyBvZiB0aGVcbiAqIGNvbnRyYWN0IHRoYXQgdGhleSBhcmUgZW50ZXJpbmcgd2hlbiB0aGV5IG1ha2UgYW4gb2ZmZXIuXG4gKiBAcGFyYW0ge0Ftb3VudEtleXdvcmRSZWNvcmR9IGFsbG9jYXRpb24gLSBhIHJlY29yZCB3aXRoIGtleXdvcmRzXG4gKiBhcyBrZXlzIGFuZCBhbW91bnRzIGFzIHZhbHVlcy4gVGhlc2UgYW1vdW50cyBhcmUgdGhlIHJlYWxsb2NhdGlvblxuICogdG8gYmUgZ2l2ZW4gdG8gYSB1c2VyLlxuICovXG5jb25zdCBzYXRpc2ZpZXNXYW50PShwcm9wb3NhbCxhbGxvY2F0aW9uKT0+XG5zYXRpc2ZpZXNJbnRlcm5hbChwcm9wb3NhbC53YW50LGFsbG9jYXRpb24pO1xuXG4vKipcbiAqIEZvciB0aGlzIGFsbG9jYXRpb24gdG8gY291bnQgYXMgYSBmdWxsIHJlZnVuZCwgdGhlIGFsbG9jYXRlZFxuICogYW1vdW50cyBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byB3aGF0IHdhcyBvcmlnaW5hbGx5XG4gKiBvZmZlcmVkIChwcm9wb3NhbC5naXZlKS5cbiAqXG4gKiBAcGFyYW0gIHtQcm9wb3NhbFJlY29yZH0gcHJvcG9zYWwgLSB0aGUgcnVsZXMgdGhhdCBhY2NvbXBhbmllZCB0aGVcbiAqIGVzY3JvdyBvZiBwYXltZW50cyB0aGF0IGRpY3RhdGUgd2hhdCB0aGUgdXNlciBleHBlY3RlZCB0byBnZXQgYmFja1xuICogZnJvbSBab2UuIEEgcHJvcG9zYWwgaXMgYSByZWNvcmQgd2l0aCBrZXlzIGBnaXZlYCwgYHdhbnRgLCBhbmRcbiAqIGBleGl0YC4gYGdpdmVgIGFuZCBgd2FudGAgYXJlIHJlY29yZHMgd2l0aCBrZXl3b3JkcyBhcyBrZXlzIGFuZFxuICogYW1vdW50cyBhcyB2YWx1ZXMuIFRoZSBwcm9wb3NhbCBpcyBhIHVzZXIncyB1bmRlcnN0YW5kaW5nIG9mIHRoZVxuICogY29udHJhY3QgdGhhdCB0aGV5IGFyZSBlbnRlcmluZyB3aGVuIHRoZXkgbWFrZSBhbiBvZmZlci5cbiAqIEBwYXJhbSAge0Ftb3VudEtleXdvcmRSZWNvcmR9IGFsbG9jYXRpb24gLSBhIHJlY29yZCB3aXRoIGtleXdvcmRzXG4gKiBhcyBrZXlzIGFuZCBhbW91bnRzIGFzIHZhbHVlcy4gVGhlc2UgYW1vdW50cyBhcmUgdGhlIHJlYWxsb2NhdGlvblxuICogdG8gYmUgZ2l2ZW4gdG8gYSB1c2VyLlxuICovJGjigI1fb25jZS5zYXRpc2ZpZXNXYW50KHNhdGlzZmllc1dhbnQpO1xuY29uc3Qgc2F0aXNmaWVzR2l2ZT0ocHJvcG9zYWwsYWxsb2NhdGlvbik9Plxuc2F0aXNmaWVzSW50ZXJuYWwocHJvcG9zYWwuZ2l2ZSxhbGxvY2F0aW9uKTtcblxuLyoqXG4gKiBgaXNPZmZlclNhZmVgIGNoZWNrcyBvZmZlciBzYWZldHkgZm9yIGEgc2luZ2xlIG9mZmVyLlxuICpcbiAqIE5vdGU6IFRoaXMgaW1wbGVtZW50YXRpb24gY2hlY2tzIHdoZXRoZXIgd2UgZnVsbHkgc2F0aXNmeVxuICogYHByb3Bvc2FsLmdpdmVgIChnaXZpbmcgYSByZWZ1bmQpIG9yIHdoZXRoZXIgd2UgZnVsbHkgc2F0aXNmeVxuICogYHByb3Bvc2FsLndhbnRgLiBCb3RoIGNhbiBiZSBmdWxseSBzYXRpc2ZpZWQuXG4gKlxuICogQHBhcmFtICB7UHJvcG9zYWxSZWNvcmR9IHByb3Bvc2FsIC0gdGhlIHJ1bGVzIHRoYXQgYWNjb21wYW5pZWQgdGhlXG4gKiBlc2Nyb3cgb2YgcGF5bWVudHMgdGhhdCBkaWN0YXRlIHdoYXQgdGhlIHVzZXIgZXhwZWN0ZWQgdG8gZ2V0IGJhY2tcbiAqIGZyb20gWm9lLiBBIHByb3Bvc2FsIGlzIGEgcmVjb3JkIHdpdGgga2V5cyBgZ2l2ZWAsIGB3YW50YCwgYW5kXG4gKiBgZXhpdGAuIGBnaXZlYCBhbmQgYHdhbnRgIGFyZSByZWNvcmRzIHdpdGgga2V5d29yZHMgYXMga2V5cyBhbmRcbiAqIGFtb3VudHMgYXMgdmFsdWVzLiBUaGUgcHJvcG9zYWwgaXMgYSB1c2VyJ3MgdW5kZXJzdGFuZGluZyBvZiB0aGVcbiAqIGNvbnRyYWN0IHRoYXQgdGhleSBhcmUgZW50ZXJpbmcgd2hlbiB0aGV5IG1ha2UgYW4gb2ZmZXIuXG4gKiBAcGFyYW0gIHtBbW91bnRLZXl3b3JkUmVjb3JkfSBhbGxvY2F0aW9uIC0gYSByZWNvcmQgd2l0aCBrZXl3b3Jkc1xuICogYXMga2V5cyBhbmQgYW1vdW50cyBhcyB2YWx1ZXMuIFRoZXNlIGFtb3VudHMgYXJlIHRoZSByZWFsbG9jYXRpb25cbiAqIHRvIGJlIGdpdmVuIHRvIGEgdXNlci5cbiAqL1xuZnVuY3Rpb24gaXNPZmZlclNhZmUocHJvcG9zYWwsYWxsb2NhdGlvbil7XG5yZXR1cm4oXG5zYXRpc2ZpZXNHaXZlKHByb3Bvc2FsLGFsbG9jYXRpb24pPjB8fFxuc2F0aXNmaWVzV2FudChwcm9wb3NhbCxhbGxvY2F0aW9uKT4wKTtcblxuIH1cblxuaGFyZGVuKGlzT2ZmZXJTYWZlKTtcbmhhcmRlbihzYXRpc2ZpZXNXYW50KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJzYXRpc2ZpZXNXYW50IjpbInNhdGlzZmllc1dhbnQiXSwiaXNPZmZlclNhZmUiOlsiaXNPZmZlclNhZmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAKfeSQQ0PAAANDwAAQQAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0RmFjZXQvcmlnaHRzQ29uc2VydmF0aW9uLmpzeyJpbXBvcnRzIjpbIi4uL2ludGVybmFsLXR5cGVzLmpzIiwiQGFnb3JpYy9hc3NlcnQiLCJAYWdvcmljL2VydHAiLCJAYWdvcmljL3N0b3JlIl0sImV4cG9ydHMiOlsiYXNzZXJ0UmlnaHRzQ29uc2VydmVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG1ha2VTY2FsYXJNYXBTdG9yZSxhc3NlcnQsRmFpbCxBbW91bnRNYXRoOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm1ha2VTY2FsYXJNYXBTdG9yZVwiLCBbJGjigI1fYSA9PiAobWFrZVNjYWxhck1hcFN0b3JlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJhc3NlcnRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydCA9ICRo4oCNX2EpXV0sW1wiRmFpbFwiLCBbJGjigI1fYSA9PiAoRmFpbCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL2VydHBcIiwgW1tcIkFtb3VudE1hdGhcIiwgWyRo4oCNX2EgPT4gKEFtb3VudE1hdGggPSAkaOKAjV9hKV1dXV0sW1wiLi4vaW50ZXJuYWwtdHlwZXMuanNcIiwgW11dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KGFzc2VydFJpZ2h0c0NvbnNlcnZlZCwgJ25hbWUnLCB7dmFsdWU6IFwiYXNzZXJ0UmlnaHRzQ29uc2VydmVkXCJ9KTskaOKAjV9vbmNlLmFzc2VydFJpZ2h0c0NvbnNlcnZlZChhc3NlcnRSaWdodHNDb25zZXJ2ZWQpOyAgIFxuXG5cblxuXG5cbi8qKlxuICogSXRlcmF0ZSBvdmVyIHRoZSBhbW91bnRzIGFuZCBzdW0sIHN0b3JpbmcgdGhlIHN1bXMgaW4gYVxuICogbWFwIGJ5IGJyYW5kLlxuICpcbiAqIEBwYXJhbSAge0Ftb3VudFtdfSBhbW91bnRzIC0gYW4gYXJyYXkgb2YgYW1vdW50c1xuICogQHJldHVybnMge01hcFN0b3JlPEJyYW5kLCBBbW91bnQ+fSBzdW1zQnlCcmFuZCAtIGEgbWFwIG9mIEJyYW5kIGtleXMgYW5kXG4gKiBBbW91bnQgdmFsdWVzLiBUaGUgYW1vdW50cyBhcmUgdGhlIHN1bXMuXG4gKi9cbmNvbnN0IHN1bUJ5QnJhbmQ9KGFtb3VudHMpPT57XG4vKiogQHR5cGUge01hcFN0b3JlPEJyYW5kLCBBbW91bnQ+fSAqL1xuY29uc3Qgc3Vtc0J5QnJhbmQ9bWFrZVNjYWxhck1hcFN0b3JlKCdicmFuZCcpO1xuYW1vdW50cy5mb3JFYWNoKChhbW91bnQpPT57XG5jb25zdHticmFuZH09YW1vdW50O1xuaWYoIXN1bXNCeUJyYW5kLmhhcyhicmFuZCkpe1xuc3Vtc0J5QnJhbmQuaW5pdChicmFuZCxhbW91bnQpO1xuIH1lbHNle1xuY29uc3Qgc3VtU29GYXI9c3Vtc0J5QnJhbmQuZ2V0KGJyYW5kKTtcbnN1bXNCeUJyYW5kLnNldChicmFuZCxBbW91bnRNYXRoLmFkZChzdW1Tb0ZhcixhbW91bnQpKTtcbiB9XG4gfSk7XG5yZXR1cm4gc3Vtc0J5QnJhbmQ7XG4gfTtcblxuLyoqXG4gKiBBc3NlcnQgdGhhdCB0aGUgbGVmdCBzdW1zIGJ5IGJyYW5kIGVxdWFsIHRoZSByaWdodCBzdW1zIGJ5IGJyYW5kXG4gKlxuICogQHBhcmFtICB7TWFwU3RvcmU8QnJhbmQsIEFtb3VudD59IGxlZnRTdW1zQnlCcmFuZCAtIGEgbWFwIG9mIGJyYW5kcyB0byBzdW1zXG4gKiBAcGFyYW0gIHtNYXBTdG9yZTxCcmFuZCwgQW1vdW50Pn0gcmlnaHRTdW1zQnlCcmFuZCAtIGEgbWFwIG9mIGJyYW5kcyB0byBzdW1zXG4gKi9cbmNvbnN0IGFzc2VydEVxdWFsUGVyQnJhbmQ9KGxlZnRTdW1zQnlCcmFuZCxyaWdodFN1bXNCeUJyYW5kKT0+e1xuLyogV2UgY2Fubm90IGFzc3VtZSB0aGF0IGFsbCBvZiB0aGUgYnJhbmQga2V5cyBwcmVzZW50IGluKi9cbi8qIGxlZnRTdW1zQnlCcmFuZCBhcmUgYWxzbyBwcmVzZW50IGluIHJpZ2h0U3Vtc0J5QnJhbmQuIEEgZW1wdHkqL1xuLyogYW1vdW50IGNvdWxkIGJlIGludHJvZHVjZWQgb3IgZHJvcHBlZCwgYW5kIHRoaXMgc2hvdWxkIHN0aWxsIGJlKi9cbi8qIGRlZW1lZCBcImVxdWFsXCIgZnJvbSB0aGUgcGVyc3BlY3RpdmUgb2YgcmlnaHRzIGNvbnNlcnZhdGlvbi4qL1xuXG4vKiBUaHVzLCB3ZSBzaG91bGQgYWxsb3cgZm9yIGEgYnJhbmQgdG8gYmUgbWlzc2luZyBmcm9tIGEgbWFwLCBidXQqL1xuLyogb25seSBpZiB0aGUgc3VtIGZvciB0aGUgYnJhbmQgaW4gdGhlIG90aGVyIG1hcCBpcyBlbXB0eS4qL1xuXG4vKipcbiAqIEEgaGVscGVyIHRoYXQgZWl0aGVyIGdldHMgdGhlIHN1bXMgZm9yIHRoZSBzcGVjaWZpZWQgYnJhbmQsIG9yIGlmXG4gKiB0aGUgYnJhbmQgaXMgYWJzZW50IGluIHRoZSBtYXAsIHJldHVybnMgYW4gZW1wdHkgYW1vdW50LlxuICpcbiAqIEBwYXJhbSB7QnJhbmR9IGJyYW5kXG4gKiBAcmV0dXJucyB7eyBsZWZ0U3VtOiBBbW91bnQsIHJpZ2h0U3VtOiBBbW91bnQgfX1cbiAqL1xuY29uc3QgZ2V0U3Vtcz0oYnJhbmQpPT57XG5sZXQgbGVmdFN1bTtcbmxldCByaWdodFN1bTtcbmlmKGxlZnRTdW1zQnlCcmFuZC5oYXMoYnJhbmQpKXtcbmxlZnRTdW09bGVmdFN1bXNCeUJyYW5kLmdldChicmFuZCk7XG4gfVxuaWYocmlnaHRTdW1zQnlCcmFuZC5oYXMoYnJhbmQpKXtcbnJpZ2h0U3VtPXJpZ2h0U3Vtc0J5QnJhbmQuZ2V0KGJyYW5kKTtcbiB9XG5pZihsZWZ0U3VtPT09dW5kZWZpbmVkKXtcbmFzc2VydChyaWdodFN1bSk7XG5sZWZ0U3VtPUFtb3VudE1hdGgubWFrZUVtcHR5RnJvbUFtb3VudChyaWdodFN1bSk7XG4gfVxuaWYocmlnaHRTdW09PT11bmRlZmluZWQpe1xucmlnaHRTdW09QW1vdW50TWF0aC5tYWtlRW1wdHlGcm9tQW1vdW50KGxlZnRTdW0pO1xuIH1cbnJldHVybntsZWZ0U3VtLHJpZ2h0U3VtfTtcbiB9O1xuXG5jb25zdCBhbGxCcmFuZHM9bmV3IFNldChbXG4uLi5sZWZ0U3Vtc0J5QnJhbmQua2V5cygpLFxuLi4ucmlnaHRTdW1zQnlCcmFuZC5rZXlzKCldKTtcblxuXG5hbGxCcmFuZHMuZm9yRWFjaCgoYnJhbmQpPT57XG5jb25zdHtsZWZ0U3VtLHJpZ2h0U3VtfT1nZXRTdW1zKGJyYW5kKTtcbkFtb3VudE1hdGguaXNFcXVhbChsZWZ0U3VtLHJpZ2h0U3VtKXx8XG5GYWlsIGByaWdodHMgd2VyZSBub3QgY29uc2VydmVkIGZvciBicmFuZCAke2JyYW5kfSAke2xlZnRTdW0udmFsdWV9ICE9ICR7cmlnaHRTdW0udmFsdWV9YDtcbiB9KTtcbiB9O1xuXG4vKipcbiAqIGBhc3NlcnRSaWdodHNDb25zZXJ2ZWRgIGNoZWNrcyB0aGF0IHRoZSB0b3RhbCBhbW91bnQgcGVyIGJyYW5kIGlzXG4gKiBlcXVhbCB0byB0aGUgdG90YWwgYW1vdW50IHBlciBicmFuZCBpbiB0aGUgcHJvcG9zZWQgcmVhbGxvY2F0aW9uXG4gKlxuICogQHBhcmFtIHtBbW91bnRbXX0gcHJldmlvdXNBbW91bnRzIC0gYW4gYXJyYXkgb2YgdGhlIGFtb3VudHMgYmVmb3JlIHRoZVxuICogcHJvcG9zZWQgcmVhbGxvY2F0aW9uXG4gKiBAcGFyYW0ge0Ftb3VudFtdfSBuZXdBbW91bnRzIC0gYW4gYXJyYXkgb2YgdGhlIGFtb3VudHMgaW4gdGhlXG4gKiBwcm9wb3NlZCByZWFsbG9jYXRpb25cbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5mdW5jdGlvbiBhc3NlcnRSaWdodHNDb25zZXJ2ZWQocHJldmlvdXNBbW91bnRzLG5ld0Ftb3VudHMpe1xuY29uc3Qgc3Vtc1ByZXZBbW91bnRzPXN1bUJ5QnJhbmQocHJldmlvdXNBbW91bnRzKTtcbmNvbnN0IHN1bXNOZXdBbW91bnRzPXN1bUJ5QnJhbmQobmV3QW1vdW50cyk7XG5hc3NlcnRFcXVhbFBlckJyYW5kKHN1bXNQcmV2QW1vdW50cyxzdW1zTmV3QW1vdW50cyk7XG4gfVxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImFzc2VydFJpZ2h0c0NvbnNlcnZlZCI6WyJhc3NlcnRSaWdodHNDb25zZXJ2ZWQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAZZpDvpIlAACSJQAANAAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0RmFjZXQvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAamVzc2llLWNoZWNrKi9cblxuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL2VydHAnKS5Jc3N1ZXJPcHRpb25zUmVjb3JkfSBJc3N1ZXJPcHRpb25zUmVjb3JkICovXG5cbi8qIFhYWCBjYW4gYmUgdGlnaHRlciB0aGFuICdhbnknKi9cbi8qKlxuICogQHR5cGVkZWYge2FueX0gQ29tcGxldGlvblxuICogQW55IHBhc3NhYmxlIG5vbi10aGVuYWJsZS4gT2Z0ZW4gYW4gZXhwbGFuYXRvcnkgc3RyaW5nLlxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFpDRk1ha2VFbXB0eVNlYXRLaXRcbiAqIEBwYXJhbSB7RXhpdFJ1bGV9IFtleGl0XVxuICogQHJldHVybnMge1pjZlNlYXRLaXR9XG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge29iamVjdH0gW0NUPVJlY29yZDxzdHJpbmcsIHVua25vd24+XSBDb250cmFjdCdzIGN1c3RvbSB0ZXJtc1xuICogQHR5cGVkZWYge29iamVjdH0gWkNGIFpvZSBDb250cmFjdCBGYWNldFxuICpcbiAqIFRoZSBab2UgaW50ZXJmYWNlIHNwZWNpZmljIHRvIGEgY29udHJhY3QgaW5zdGFuY2UuIFRoZSBab2UgQ29udHJhY3RcbiAqIEZhY2V0IGlzIGFuIEFQSSBvYmplY3QgdXNlZCBieSBydW5uaW5nIGNvbnRyYWN0IGluc3RhbmNlcyB0byBhY2Nlc3NcbiAqIHRoZSBab2Ugc3RhdGUgZm9yIHRoYXQgaW5zdGFuY2UuIFRoZSBab2UgQ29udHJhY3QgRmFjZXQgaXMgYWNjZXNzZWRcbiAqIHN5bmNocm9ub3VzbHkgZnJvbSB3aXRoaW4gdGhlIGNvbnRyYWN0LCBhbmQgdXN1YWxseSBpcyByZWZlcnJlZCB0b1xuICogaW4gY29kZSBhcyB6Y2YuXG4gKlxuICogQHByb3BlcnR5IHtSZWFsbG9jYXRlfSByZWFsbG9jYXRlIC0gcmVhbGxvY2F0ZSBhbW91bnRzIGFtb25nIHNlYXRzLlxuICogRGVwcmVjYXRlZDogVXNlIGF0b21pY1JlYXJyYW5nZSBpbnN0ZWFkLlxuICogQHByb3BlcnR5IHsoa2V5d29yZDogS2V5d29yZCkgPT4gdm9pZH0gYXNzZXJ0VW5pcXVlS2V5d29yZCAtIGNoZWNrXG4gKiB3aGV0aGVyIGEga2V5d29yZCBpcyB2YWxpZCBhbmQgdW5pcXVlIGFuZCBjb3VsZCBiZSBhZGRlZCBpblxuICogYHNhdmVJc3N1ZXJgXG4gKiBAcHJvcGVydHkge1NhdmVJc3N1ZXJ9IHNhdmVJc3N1ZXIgLSBzYXZlIGFuIGlzc3VlciB0byBaQ0YgYW5kIFpvZVxuICogYW5kIGdldCB0aGUgQW1vdW50TWF0aCBhbmQgYnJhbmQgc3luY2hyb25vdXNseSBhY2Nlc3NpYmxlIGFmdGVyXG4gKiBzYXZpbmdcbiAqIEBwcm9wZXJ0eSB7TWFrZUludml0YXRpb259IG1ha2VJbnZpdGF0aW9uXG4gKiBAcHJvcGVydHkgeyhjb21wbGV0aW9uOiBDb21wbGV0aW9uKSA9PiB2b2lkfSBzaHV0ZG93blxuICogQHByb3BlcnR5IHtTaHV0ZG93bldpdGhGYWlsdXJlfSBzaHV0ZG93bldpdGhGYWlsdXJlXG4gKiBAcHJvcGVydHkgeygpID0+IEVSZWY8Wm9lU2VydmljZT59IGdldFpvZVNlcnZpY2VcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gSXNzdWVyPCdzZXQnPn0gZ2V0SW52aXRhdGlvbklzc3VlclxuICogQHByb3BlcnR5IHsoKSA9PiBTdGFuZGFyZFRlcm1zICYgQ1R9IGdldFRlcm1zXG4gKiBAcHJvcGVydHkgezxLIGV4dGVuZHMgQXNzZXRLaW5kPihpc3N1ZXI6IElzc3VlcjxLPikgPT4gQnJhbmQ8Sz59IGdldEJyYW5kRm9ySXNzdWVyXG4gKiBAcHJvcGVydHkgezxLIGV4dGVuZHMgQXNzZXRLaW5kPihicmFuZDogQnJhbmQ8Sz4pID0+IElzc3VlcjxLPn0gZ2V0SXNzdWVyRm9yQnJhbmRcbiAqIEBwcm9wZXJ0eSB7R2V0QXNzZXRLaW5kQnlCcmFuZH0gZ2V0QXNzZXRLaW5kXG4gKiBAcHJvcGVydHkgezxLIGV4dGVuZHMgQXNzZXRLaW5kID0gJ25hdCc+KFxuICogICBrZXl3b3JkOiBLZXl3b3JkLFxuICogICBhc3NldEtpbmQ/OiBLLFxuICogICBkaXNwbGF5SW5mbz86IEFkZGl0aW9uYWxEaXNwbGF5SW5mbyxcbiAqICAgb3B0aW9ucz86IElzc3Vlck9wdGlvbnNSZWNvcmRcbiAqICkgPT4gUHJvbWlzZTxaQ0ZNaW50PEs+Pn0gbWFrZVpDRk1pbnRcbiAqIEBwcm9wZXJ0eSB7WkNGUmVnaXN0ZXJGZWVNaW50fSByZWdpc3RlckZlZU1pbnRcbiAqIEBwcm9wZXJ0eSB7WkNGTWFrZUVtcHR5U2VhdEtpdH0gbWFrZUVtcHR5U2VhdEtpdFxuICogQHByb3BlcnR5IHtTZXRUZXN0SmlnfSBzZXRUZXN0SmlnXG4gKiBAcHJvcGVydHkgeygpID0+IFByb21pc2U8dm9pZD59IHN0b3BBY2NlcHRpbmdPZmZlcnNcbiAqIEBwcm9wZXJ0eSB7KHN0cmluZ3M6IEFycmF5PHN0cmluZz4pID0+IFByb21pc2U8dm9pZD59IHNldE9mZmVyRmlsdGVyXG4gKiBAcHJvcGVydHkgeygpID0+IFByb21pc2U8QXJyYXk8c3RyaW5nPj59IGdldE9mZmVyRmlsdGVyXG4gKiBAcHJvcGVydHkgeygpID0+IEluc3RhbmNlfSBnZXRJbnN0YW5jZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYgeyhzZWF0MTogWkNGU2VhdCwgc2VhdDI6IFpDRlNlYXQsIC4uLnNlYXRSZXN0OlxuICogQXJyYXk8WkNGU2VhdD4pID0+IHZvaWR9IFJlYWxsb2NhdGVcbiAqXG4gKiBUaGUgY29udHJhY3QgY2FuIHJlYWxsb2NhdGUgb3ZlciBzZWF0cywgd2hpY2ggY29tbWl0cyB0aGUgc3RhZ2VkXG4gKiBhbGxvY2F0aW9uIGZvciBlYWNoIHNlYXQuIE9uIGNvbW1pdCwgdGhlIHN0YWdlZCBhbGxvY2F0aW9uIGJlY29tZXNcbiAqIHRoZSBjdXJyZW50IGFsbG9jYXRpb24gYW5kIHRoZSBzdGFnZWQgYWxsb2NhdGlvbiBpcyBkZWxldGVkLlxuICpcbiAqIFRoZSByZWFsbG9jYXRpb24gd2lsbCBvbmx5IHN1Y2NlZWQgaWYgdGhlIHJlYWxsb2NhdGlvbiAxKSBjb25zZXJ2ZXNcbiAqIHJpZ2h0cyAodGhlIGFtb3VudHMgc3BlY2lmaWVkIGhhdmUgdGhlIHNhbWUgdG90YWwgdmFsdWUgYXMgdGhlXG4gKiBjdXJyZW50IHRvdGFsIGFtb3VudCksIGFuZCAyKSBpcyAnb2ZmZXItc2FmZScgZm9yIGFsbCBwYXJ0aWVzXG4gKiBpbnZvbHZlZC4gQWxsIHNlYXRzIHRoYXQgaGF2ZSBzdGFnZWQgYWxsb2NhdGlvbnMgbXVzdCBiZSBpbmNsdWRlZFxuICogYXMgYXJndW1lbnRzIHRvIGByZWFsbG9jYXRlYCwgb3IgYW4gZXJyb3IgaXMgdGhyb3duLiBBZGRpdGlvbmFsbHksXG4gKiBhbiBlcnJvciBpcyB0aHJvd24gaWYgYW55IHNlYXRzIGluY2x1ZGVkIGluIGByZWFsbG9jYXRlYCBkbyBub3RcbiAqIGhhdmUgYSBzdGFnZWQgYWxsb2NhdGlvbi5cbiAqXG4gKiBUaGUgcmVhbGxvY2F0aW9uIGlzIHBhcnRpYWwsIG1lYW5pbmcgdGhhdCBpdCBhcHBsaWVzIG9ubHkgdG8gdGhlXG4gKiBzZWF0cyBwYXNzZWQgaW4gYXMgYXJndW1lbnRzLiBCeSBpbmR1Y3Rpb24sIGlmIHJpZ2h0cyBjb25zZXJ2YXRpb25cbiAqIGFuZCBvZmZlciBzYWZldHkgaG9sZCBiZWZvcmUsIHRoZXkgd2lsbCBob2xkIGFmdGVyIGEgc2FmZVxuICogcmVhbGxvY2F0aW9uLCBldmVuIHRob3VnaCB3ZSBvbmx5IHJlLXZhbGlkYXRlIGZvciB0aGUgc2VhdHMgd2hvc2VcbiAqIGFsbG9jYXRpb25zIHdpbGwgY2hhbmdlLiBTaW5jZSByaWdodHMgYXJlIGNvbnNlcnZlZCBmb3IgdGhlIGNoYW5nZSxcbiAqIG92ZXJhbGwgcmlnaHRzIHdpbGwgYmUgdW5jaGFuZ2VkLCBhbmQgYSByZWFsbG9jYXRpb24gY2FuIG9ubHlcbiAqIGVmZmVjdCBvZmZlciBzYWZldHkgZm9yIHNlYXRzIHdob3NlIGFsbG9jYXRpb25zIGNoYW5nZS5cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBTYXZlSXNzdWVyXG4gKlxuICogSW5mb3JtcyBab2UgYWJvdXQgYW4gaXNzdWVyIGFuZCByZXR1cm5zIGEgcHJvbWlzZSBmb3IgYWNrbm93bGVkZ2luZ1xuICogd2hlbiB0aGUgaXNzdWVyIGlzIGFkZGVkIGFuZCByZWFkeS5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8SXNzdWVyPn0gaXNzdWVyUCBQcm9taXNlIGZvciBpc3N1ZXJcbiAqIEBwYXJhbSB7S2V5d29yZH0ga2V5d29yZCBLZXl3b3JkIGZvciBhZGRlZCBpc3N1ZXJcbiAqIEByZXR1cm5zIHtQcm9taXNlPElzc3VlclJlY29yZDwqPj59IElzc3VlciBpcyBhZGRlZCBhbmQgcmVhZHlcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHs8UmVzdWx0PihcbiAqICAgb2ZmZXJIYW5kbGVyOiBPZmZlckhhbmRsZXI8UmVzdWx0PixcbiAqICAgZGVzY3JpcHRpb246IHN0cmluZyxcbiAqICAgY3VzdG9tRGV0YWlscz86IG9iamVjdCxcbiAqICAgcHJvcG9zYWxTaGFwZT86IFBhdHRlcm4sXG4gKiApID0+IFByb21pc2U8SW52aXRhdGlvbjxBd2FpdGVkPFJlc3VsdD4+PlxuICogfSBNYWtlSW52aXRhdGlvblxuICpcbiAqIE1ha2UgYSBjcmVkaWJsZSBab2UgaW52aXRhdGlvbiBmb3IgYSBwYXJ0aWN1bGFyIHNtYXJ0IGNvbnRyYWN0XG4gKiBpbmRpY2F0ZWQgYnkgdGhlIGBpbnN0YW5jZWAgaW4gdGhlIGRldGFpbHMgb2YgdGhlIGludml0YXRpb24uIFpvZVxuICogYWxzbyBwdXRzIHRoZSBgaW5zdGFsbGF0aW9uYCBhbmQgYSB1bmlxdWUgYGhhbmRsZWAgaW4gdGhlIGRldGFpbHNcbiAqIG9mIHRoZSBpbnZpdGF0aW9uLiBUaGUgY29udHJhY3QgbXVzdCBwcm92aWRlIGEgYGRlc2NyaXB0aW9uYCBmb3JcbiAqIHRoZSBpbnZpdGF0aW9uIGFuZCBzaG91bGQgaW5jbHVkZSB3aGF0ZXZlciBpbmZvcm1hdGlvbiBpcyBuZWNlc3NhcnlcbiAqIGZvciBhIHBvdGVudGlhbCBidXllciBvZiB0aGUgaW52aXRhdGlvbiB0byBrbm93IHdoYXQgdGhleSBhcmVcbiAqIGdldHRpbmcgaW4gdGhlIGBjdXN0b21EZXRhaWxzYC4gYGN1c3RvbURldGFpbHNgIHdpbGwgYmVcbiAqIHBsYWNlZCBpbiB0aGUgZGV0YWlscyBvZiB0aGUgaW52aXRhdGlvbi5cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBaQ0ZSZWdpc3RlckZlZU1pbnRcbiAqIEBwYXJhbSB7S2V5d29yZH0ga2V5d29yZFxuICogQHBhcmFtIHtGZWVNaW50QWNjZXNzfSBhbGxlZ2VkRmVlTWludEFjY2VzcyAtIGFuIG9iamVjdCB0aGF0XG4gKiBwdXJwb3J0cyB0byBiZSB0aGUgb2JqZWN0IHRoYXQgZ3JhbnRzIGFjY2VzcyB0byB0aGUgZmVlIG1pbnRcbiAqIEByZXR1cm5zIHtQcm9taXNlPFpDRk1pbnQ8J25hdCc+Pn1cbiAqL1xuXG4vKipcbiAqIFByb3ZpZGUgYSBqaWcgb2JqZWN0IGZvciB0ZXN0aW5nIHB1cnBvc2VzIG9ubHkuXG4gKlxuICogVGhlIGNvbnRyYWN0IGNvZGUgcHJvdmlkZXMgYSBjYWxsYmFjayB3aG9zZSByZXR1cm4gcmVzdWx0IHdpbGxcbiAqIGJlIG1hZGUgYXZhaWxhYmxlIHRvIHRoZSB0ZXN0IHRoYXQgc3RhcnRlZCB0aGlzIGNvbnRyYWN0LiBUaGVcbiAqIHN1cHBsaWVkIGNhbGxiYWNrIHdpbGwgb25seSBiZSBjYWxsZWQgaW4gYSB0ZXN0aW5nIGNvbnRleHQsXG4gKiBuZXZlciBpbiBwcm9kdWN0aW9uOyBpLmUuLCBpdCBpcyBvbmx5IGNhbGxlZCBpZiBgdGVzdEppZ1NldHRlcmBcbiAqIHdhcyBzdXBwbGllZC5cbiAqXG4gKiBJZiBubywgYHRlc3RGbmAgaXMgc3VwcGxpZWQsIHRoZW4gYW4gZW1wdHkgamlnIHdpbGwgYmUgdXNlZC5cbiAqIEFuIGFkZGl0aW9uYWwgYHpjZmAgcHJvcGVydHkgc2V0IHRvIHRoZSBjdXJyZW50IENvbnRyYWN0RmFjZXRcbiAqIHdpbGwgYmUgYXBwZW5kZWQgdG8gdGhlIHJldHVybmVkIGppZyBvYmplY3QgKG92ZXJyaWRpbmcgYW55XG4gKiBwcm92aWRlZCBieSB0aGUgYHRlc3RGbmApLlxuICpcbiAqIEBjYWxsYmFjayBTZXRUZXN0SmlnXG4gKiBAcGFyYW0geygpID0+IFJlY29yZDxzdHJpbmcsIHVua25vd24+fSB0ZXN0Rm5cbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtBc3NldEtpbmR9IFtLPUFzc2V0S2luZF1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IFpDRk1pbnRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gSXNzdWVyUmVjb3JkPEs+fSBnZXRJc3N1ZXJSZWNvcmRcbiAqIEBwcm9wZXJ0eSB7KGdhaW5zOiBBbW91bnRLZXl3b3JkUmVjb3JkLCB6Y2ZTZWF0PzogWkNGU2VhdCkgPT4gWkNGU2VhdH0gbWludEdhaW5zXG4gKiBBbGwgdGhlIGFtb3VudHMgaW4gZ2FpbnMgbXVzdCBiZSBvZiB0aGlzIFpDRk1pbnQncyBicmFuZC5cbiAqIFRoZSBnYWlucycga2V5d29yZHMgYXJlIGluIHRoZSBuYW1lc3BhY2Ugb2YgdGhhdCBzZWF0LlxuICogQWRkIHRoZSBnYWlucyB0byB0aGF0IHNlYXQncyBhbGxvY2F0aW9uLlxuICogVGhlIHJlc3VsdGluZyBzdGF0ZSBtdXN0IGJlIG9mZmVyIHNhZmUuIChDdXJyZW50bHksIGluY3JlYXNpbmcgYXNzZXRzIGNhblxuICogbmV2ZXIgdmlvbGF0ZSBvZmZlciBzYWZldHkgYW55d2F5LilcbiAqXG4gKiBNaW50IHRoYXQgYW1vdW50IG9mIGFzc2V0cyBpbnRvIHRoZSBwb29sZWQgcHVyc2UuXG4gKiBJZiBhIHNlYXQgaXMgcHJvdmlkZWQsIGl0IGlzIHJldHVybmVkLiBPdGhlcndpc2UgYSBuZXcgc2VhdCBpc1xuICogcmV0dXJuZWQuXG4gKlxuICogQHByb3BlcnR5IHsobG9zc2VzOiBBbW91bnRLZXl3b3JkUmVjb3JkLFxuICogICAgICAgICAgICAgemNmU2VhdDogWkNGU2VhdCxcbiAqICAgICAgICAgICAgKSA9PiB2b2lkfSBidXJuTG9zc2VzXG4gKiBBbGwgdGhlIGFtb3VudHMgaW4gbG9zc2VzIG11c3QgYmUgb2YgdGhpcyBaQ0ZNaW50J3MgYnJhbmQuXG4gKiBUaGUgbG9zc2VzJyBrZXl3b3JkcyBhcmUgaW4gdGhlIG5hbWVzcGFjZSBvZiB0aGF0IHNlYXQuXG4gKiBTdWJ0cmFjdCBsb3NzZXMgZnJvbSB0aGF0IHNlYXQncyBhbGxvY2F0aW9uLlxuICogVGhlIHJlc3VsdGluZyBzdGF0ZSBtdXN0IGJlIG9mZmVyIHNhZmUuXG4gKlxuICogQnVybiB0aGF0IGFtb3VudCBvZiBhc3NldHMgZnJvbSB0aGUgcG9vbGVkIHB1cnNlLlxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFpDRlNlYXRGYWlsXG4gKlxuICogZmFpbCBjYWxsZWQgd2l0aCB0aGUgcmVhc29uIGZvciB0aGlzIGZhaWx1cmUsIHdoZXJlIHJlYXNvbiBpc1xuICogbm9ybWFsbHkgYW4gaW5zdGFuY2VvZiBFcnJvci5cbiAqIEBwYXJhbSB7dW5rbm93bn0gcmVhc29uXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgWkNGR2V0QW1vdW50QWxsb2NhdGVkXG4gKiBUaGUgYnJhbmQgaXMgdXNlZCBmb3IgZmlsbGluZyBpbiBhbiBlbXB0eSBhbW91bnQgaWYgdGhlIGBrZXl3b3JkYFxuICogaXMgbm90IHByZXNlbnQgaW4gdGhlIGFsbG9jYXRpb25cbiAqIEBwYXJhbSB7S2V5d29yZH0ga2V5d29yZFxuICogQHBhcmFtIHtCcmFuZH0gW2JyYW5kXVxuICogQHJldHVybnMge0Ftb3VudDxhbnk+fVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gWkNGU2VhdFxuICogQHByb3BlcnR5IHsoY29tcGxldGlvbj86IENvbXBsZXRpb24pID0+IHZvaWR9IGV4aXRcbiAqIEBwcm9wZXJ0eSB7WkNGU2VhdEZhaWx9IGZhaWxcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxTdWJzY3JpYmVyPEFsbG9jYXRpb24+Pn0gZ2V0U3Vic2NyaWJlclxuICogQHByb3BlcnR5IHsoKSA9PiBib29sZWFufSBoYXNFeGl0ZWRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvcG9zYWxSZWNvcmR9IGdldFByb3Bvc2FsXG4gKiBAcHJvcGVydHkge1pDRkdldEFtb3VudEFsbG9jYXRlZH0gZ2V0QW1vdW50QWxsb2NhdGVkXG4gKiBAcHJvcGVydHkgeygpID0+IEFsbG9jYXRpb259IGdldEN1cnJlbnRBbGxvY2F0aW9uXG4gKiBAcHJvcGVydHkgeygpID0+IEFsbG9jYXRpb259IGdldFN0YWdlZEFsbG9jYXRpb25cbiAqIERlcHJlY2F0ZWQ6IFVzZSBhdG9taWNSZWFycmFuZ2UgaW5zdGVhZFxuICogQHByb3BlcnR5IHsoKSA9PiBib29sZWFufSBoYXNTdGFnZWRBbGxvY2F0aW9uXG4gKiBEZXByZWNhdGVkOiBVc2UgYXRvbWljUmVhcnJhbmdlIGluc3RlYWRcbiAqIEBwcm9wZXJ0eSB7KG5ld0FsbG9jYXRpb246IEFsbG9jYXRpb24pID0+IGJvb2xlYW59IGlzT2ZmZXJTYWZlXG4gKiBAcHJvcGVydHkgeyhhbW91bnRLZXl3b3JkUmVjb3JkOiBBbW91bnRLZXl3b3JkUmVjb3JkKSA9PiBBbW91bnRLZXl3b3JkUmVjb3JkfSBpbmNyZW1lbnRCeVxuICogRGVwcmVjYXRlZDogVXNlIGF0b21pY1JlYXJyYW5nZSBpbnN0ZWFkXG4gKiBAcHJvcGVydHkgeyhhbW91bnRLZXl3b3JkUmVjb3JkOiBBbW91bnRLZXl3b3JkUmVjb3JkKSA9PiBBbW91bnRLZXl3b3JkUmVjb3JkfSBkZWNyZW1lbnRCeVxuICogRGVwcmVjYXRlZDogVXNlIGF0b21pY1JlYXJyYW5nZSBpbnN0ZWFkXG4gKiBAcHJvcGVydHkgeygpID0+IHZvaWR9IGNsZWFyXG4gKiBEZXByZWNhdGVkOiBVc2UgYXRvbWljUmVhcnJhbmdlIGluc3RlYWRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHt7IHpjZlNlYXQ6IFpDRlNlYXQsIHVzZXJTZWF0OiBFUmVmPFVzZXJTZWF0Pn19IFpjZlNlYXRLaXRcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7b2JqZWN0fSBPUiBPZmZlciByZXN1bHRzXG4gKiBAdHlwZWRlZiB7KHNlYXQ6IFpDRlNlYXQsIG9mZmVyQXJncz86IG9iamVjdCkgPT4gT1J9IEhhbmRsZU9mZmVyXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge29iamVjdH0gW09SPXVua25vd25dIE9mZmVyIHJlc3VsdHNcbiAqIEB0eXBlZGVmIHtIYW5kbGVPZmZlcjxPUj4gfCB7IGhhbmRsZTogSGFuZGxlT2ZmZXI8T1I+IH19IE9mZmVySGFuZGxlclxuICovXG5cbi8qKlxuICogQVBJIGZvciBhIGNvbnRyYWN0IHN0YXJ0IGZ1bmN0aW9uLlxuICpcbiAqIENBVkVBVDogYXNzdW1lcyBzeW5jaHJvbm91c1xuICpcbiAqIEBkZXByZWNhdGVkIGRlZmluZSBmdW5jdGlvbiBzaWduYXR1cmUgZGlyZWN0bHlcbiAqXG4gKiBAdGVtcGxhdGUge29iamVjdH0gW1BGPWFueV0gUHVibGljIGZhY2V0XG4gKiBAdGVtcGxhdGUge29iamVjdH0gW0NGPWFueV0gQ3JlYXRvciBmYWNldFxuICogQHRlbXBsYXRlIHtvYmplY3R9IFtDVD1hbnldIEN1c3RvbSB0ZXJtc1xuICogQHRlbXBsYXRlIHtvYmplY3R9IFtQQT1hbnldIFByaXZhdGUgYXJnc1xuICogQGNhbGxiYWNrIENvbnRyYWN0U3RhcnRGblxuICogQHBhcmFtIHtaQ0Y8Q1Q+fSB6Y2ZcbiAqIEBwYXJhbSB7UEF9IHByaXZhdGVBcmdzXG4gKiBAcmV0dXJucyB7Q29udHJhY3RTdGFydEZuUmVzdWx0PFBGLCBDRj59XG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgUEYgUHVibGljIGZhY2V0XG4gKiBAdGVtcGxhdGUgQ0YgQ3JlYXRvciBmYWNldFxuICogQHR5cGVkZWYge29iamVjdH0gQ29udHJhY3RTdGFydEZuUmVzdWx0XG4gKiBAcHJvcGVydHkge1BGfSBwdWJsaWNGYWNldFxuICogQHByb3BlcnR5IHtDRn0gY3JlYXRvckZhY2V0XG4gKiBAcHJvcGVydHkge1Byb21pc2U8SW52aXRhdGlvbj59IFtjcmVhdG9ySW52aXRhdGlvbl1cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBTXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vem9lU2VydmljZS91dGlscycpLkNvbnRyYWN0T2Y8Uz59IENvbnRyYWN0T2ZcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi96b2VTZXJ2aWNlL3V0aWxzJykuQWRtaW5GYWNldH0gQWRtaW5GYWNldFxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGC9QzEuHAAALhwAAD8AAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvYXRvbWljVHJhbnNmZXIuanN7ImltcG9ydHMiOlsiLi4vY29udHJhY3RGYWNldC9yaWdodHNDb25zZXJ2YXRpb24uanMiLCIuLi90eXBlR3VhcmRzLmpzIiwiQGFnb3JpYy9zdG9yZSJdLCJleHBvcnRzIjpbIlRyYW5zZmVyUGFydFNoYXBlIiwiYXRvbWljUmVhcnJhbmdlIiwiYXRvbWljVHJhbnNmZXIiLCJmcm9tT25seSIsInRvT25seSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtdXN0TWF0Y2gsTSxhc3NlcnRSaWdodHNDb25zZXJ2ZWQsQW1vdW50S2V5d29yZFJlY29yZFNoYXBlLFNlYXRTaGFwZTskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV1dXSxbXCIuLi9jb250cmFjdEZhY2V0L3JpZ2h0c0NvbnNlcnZhdGlvbi5qc1wiLCBbW1wiYXNzZXJ0UmlnaHRzQ29uc2VydmVkXCIsIFskaOKAjV9hID0+IChhc3NlcnRSaWdodHNDb25zZXJ2ZWQgPSAkaOKAjV9hKV1dXV0sW1wiLi4vdHlwZUd1YXJkcy5qc1wiLCBbW1wiQW1vdW50S2V5d29yZFJlY29yZFNoYXBlXCIsIFskaOKAjV9hID0+IChBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlNlYXRTaGFwZVwiLCBbJGjigI1fYSA9PiAoU2VhdFNoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5jb25zdHtGYWlsLHF1b3RlOnF9PWFzc2VydDtcblxuY29uc3QgICAgICAgIFRyYW5zZmVyUGFydFNoYXBlPU0uc3BsaXRBcnJheShcbmhhcmRlbihbTS5vcHQoU2VhdFNoYXBlKSxNLm9wdChTZWF0U2hhcGUpLE0ub3B0KEFtb3VudEtleXdvcmRSZWNvcmRTaGFwZSldKSxcbmhhcmRlbihbTS5vcHQoQW1vdW50S2V5d29yZFJlY29yZFNoYXBlKV0pKTtcblxuXG4vKipcbiAqIEB0eXBlZGVmIHtbXG4gKiAgIGZyb21TZWF0PzogWkNGU2VhdCxcbiAqICAgdG9TZWF0PzogWkNGU2VhdCxcbiAqICAgZnJvbUFtb3VudHM/OiBBbW91bnRLZXl3b3JkUmVjb3JkLFxuICogICB0b0Ftb3VudHM/OiBBbW91bnRLZXl3b3JkUmVjb3JkXG4gKiBdfSBUcmFuc2ZlclBhcnRcbiAqL1xuXG4vKipcbiAqIEFza3MgWm9lICh2aWEgemNmKSB0byByZWFycmFuZ2UgdGhlIGFsbG9jYXRpb25zIGFtb25nIHRoZSBzZWF0c1xuICogbWVudGlvbmVkLiBUaGlzIGlzIGEgc2V0IG9mIGNoYW5nZXMgdG8gYWxsb2NhdGlvbnMgdGhhdCBtdXN0IHNhdGlzZnlcbiAqIHNldmVyYWwgY29uc3RyYWludHMuIElmIHRoZXNlIGNvbnN0cmFpbnRzIGFyZSBhbGwgbWV0LCB0aGVuIHRoZVxuICogcmVhbGxvY2F0aW9uIGhhcHBlbnMgYXRvbWljYWxseS4gT3RoZXJ3aXNlIGl0IGRvZXMgbm90IGhhcHBlblxuICogYXQgYWxsLlxuICpcbiAqIFRoZSBjb25kaXRpb25zXG4gKiAgICAqIEFsbCB0aGUgbWVudGlvbmVkIHNlYXRzIGFyZSBzdGlsbCBsaXZlIC0tIGVuZm9yY2VkIGJ5IFpDRi5cbiAqICAgICogTm8gb3V0c3RhbmRpbmcgc3RhZ2luZ3MgZm9yIGFueSBvZiB0aGUgbWVudGlvbmVkIHNlYXRzLlxuICogICAgICBTdGFnaW5ncyBub3cgZGVwcmVjYXRlZCBpbiBmYXZvciBvciBhdG9taWNSZWFycmFuZ2UuIFRvXG4gKiAgICAgIHByZXZlbnQgY29uZnVzaW9uLCBmb3IgZWFjaCByZWFsbG9jYXRpb24sIGl0IGNhbiBvbmx5IGJlXG4gKiAgICAgIGV4cHJlc3NlZCBpbiB0aGUgb2xkIHdheSBvciB0aGUgbmV3IHdheSwgYnV0IG5vdCBhIG1peHR1cmUuXG4gKiAgICAqIE9mZmVyIHNhZmV0eSAtLSBlbmZvcmNlZCBieSBaQ0YuXG4gKiAgICAqIE92ZXJhbGwgY29uc2VydmF0aW9uIC0tIGVuZm9yY2VkIGJ5IFpDRi5cbiAqICAgICogVGhlIG92ZXJhbGwgdHJhbnNmZXIgaXMgZXhwcmVzc2VkIGFzIGFuIGFycmF5IG9mIGBUcmFuc2ZlclBhcnRgLlxuICogICAgICBFYWNoIGluZGl2aWR1YWwgYFRyYW5zZmVyUGFydGAgaXMgb25lIG9mXG4gKiAgICAgICAtIEEgdHJhbnNmZXIgZnJvbSBhIGBmcm9tU2VhdGAgdG8gYSBgdG9TZWF0YC5cbiAqICAgICAgICAgVGhpcyBpcyBub3QgbmVlZGVkIGZvciBab2UncyBzYWZldHksIGFzIFpvZSBkb2VzXG4gaXRzIG93biBvdmVyYWxsIGNvbnNlcnZhdGlvbiBjaGVjay4gUmF0aGVyLCBpdCBoZWxwcyBjYXRjaFxuIGFuZCBkaWFnbm9zZSBjb250cmFjdCBidWdzIGVhcmxpZXIuXG4gKiAgICAgICAtIEEgdGFraW5nIGZyb20gYSBgZnJvbVNlYXRgJ3MgYWxsb2NhdGlvbi4gU2VlIHRoZSBgZnJvbU9ubHlgXG4gaGVscGVyLlxuIC0gQSBnaXZpbmcgaW50byBhIGB0b1NlYXRgJ3MgYWxsb2NhdGlvbi4gU2VlIHRoZSBgdG9Pbmx5YFxuIGhlbHBlci5cbiAqXG4gKiBUT0RPKDY2NzkpIFJlZmFjdG9yIGBhdG9taWNSZWFycmFuZ2VgZnJvbSBiZWluZyBhIGhlbHBlciBpbnRvIGJlaW5nXG4gKiB6Y2YncyByZXBsYWNlbWVudCBmb3IgcmVhbGxvY2F0ZS4gSXQgd2FzIG1hZGUgYSBoZWxwZXIgZHVyaW5nXG4gKiB0aGUgdHJhbnNpdGlvbiwgdG8gYXZvaWQgaW50ZXJmZXJlbmNlIHdpdGggcHJvZ3Jlc3Mgb24gWm9lIGR1cmFiaWxpdHkuXG4gKlxuICogU2VlIHRoZSBoZWxwZXJzIGJlbG93LCBgZnJvbU9ubHlgLCBgdG9Pbmx5YCwgYW5kIGBhdG9taWNUcmFuc2ZlcmAsXG4gKiB3aGljaCB3aWxsIHJlbWFpbiBoZWxwZXJzLiBUaGVzZSBoZWxwZXIgYXJlIGZvciBjb252ZW5pZW5jZVxuICogaW4gZXhwcmVzc2luZyBhdG9taWMgcmVhcnJhbmdlbWVudHMgY2xlYXJseS5cbiAqXG4gKiBAcGFyYW0ge1pDRn0gemNmXG4gKiBAcGFyYW0ge1RyYW5zZmVyUGFydFtdfSB0cmFuc2ZlcnNcbiAqLyRo4oCNX29uY2UuVHJhbnNmZXJQYXJ0U2hhcGUoVHJhbnNmZXJQYXJ0U2hhcGUpO1xuY29uc3QgICAgICAgIGF0b21pY1JlYXJyYW5nZT0oemNmLHRyYW5zZmVycyk9Pntcbm11c3RNYXRjaCh0cmFuc2ZlcnMsTS5hcnJheU9mKE0uYXJyYXkoKSksJ3RyYW5zZmVycycpO1xuY29uc3QgdW5pcXVlU2VhdFNldD1uZXcgU2V0KCk7XG5mb3IoY29uc3RbXG5mcm9tU2VhdD11bmRlZmluZWQsXG50b1NlYXQ9dW5kZWZpbmVkLFxuZnJvbUFtb3VudHM9dW5kZWZpbmVkLFxudG9BbW91bnRzPXVuZGVmaW5lZF1vZlxudHJhbnNmZXJzKXtcbmlmKGZyb21TZWF0KXtcbmlmKCFmcm9tQW1vdW50cyl7XG50aHJvdyBGYWlsIGBUcmFuc2ZlciBmcm9tICR7ZnJvbVNlYXR9IG11c3Qgc2F5IGhvdyBtdWNoYDtcbiB9XG51bmlxdWVTZWF0U2V0LmFkZChmcm9tU2VhdCk7XG5pZih0b1NlYXQpe1xuLyogQ29uc2VydmVkIHRyYW5zZmVyIGJldHdlZW4gc2VhdHMqL1xuaWYodG9BbW91bnRzKXtcbi8qIGRpc3RpbmN0IGFtb3VudHMsIHNvIHdlIGNoZWNrIGNvbnNlcnZhdGlvbi4qL1xuYXNzZXJ0UmlnaHRzQ29uc2VydmVkKFxuT2JqZWN0LnZhbHVlcyhmcm9tQW1vdW50cyksXG5PYmplY3QudmFsdWVzKHRvQW1vdW50cykpO1xuXG4gfS8qIGVsc2UgZnJvbUFtb3VudHMgd2lsbCBiZSB1c2VkIGFzIHRvQW1vdW50cyovXG51bmlxdWVTZWF0U2V0LmFkZCh0b1NlYXQpO1xuIH1lbHNle1xuLyogVHJhbnNmZXIgb25seSBmcm9tIGZyb21TZWF0Ki9cbiF0b0Ftb3VudHN8fFxuRmFpbCBgVHJhbnNmZXIgd2l0aG91dCB0b1NlYXQgY2Fubm90IGhhdmUgdG9BbW91bnRzICR7dG9BbW91bnRzfWA7XG4gfVxuIH1lbHNle1xudG9TZWF0fHxGYWlsIGBUcmFuc2ZlciBtdXN0IGhhdmUgYXQgbGVhc3Qgb25lIG9mIGZyb21TZWF0IG9yIHRvU2VhdGA7XG4vKiBUcmFuc2ZlciBvbmx5IHRvIHRvU2VhdCovXG4hZnJvbUFtb3VudHN8fFxuRmFpbCBgVHJhbnNmZXIgd2l0aG91dCBmcm9tU2VhdCBjYW5ub3QgaGF2ZSBmcm9tQW1vdW50cyAke2Zyb21BbW91bnRzfWA7XG50b0Ftb3VudHN8fEZhaWwgYFRyYW5zZmVyIHRvICR7dG9TZWF0fSBtdXN0IHNheSBob3cgbXVjaGA7XG51bmlxdWVTZWF0U2V0LmFkZCh0b1NlYXQpO1xuIH1cbiB9XG5cbmNvbnN0IHVuaXF1ZVNlYXRzPWhhcmRlbihbLi4udW5pcXVlU2VhdFNldC5rZXlzKCldKTtcbmZvcihjb25zdCBzZWF0IG9mIHVuaXF1ZVNlYXRzKXtcbiFzZWF0Lmhhc1N0YWdlZEFsbG9jYXRpb24oKXx8XG5GYWlsIGBDYW5ub3QgbWl4IGF0b21pY1JlYXJyYW5nZSB3aXRoIHNlYXQgc3RhZ2luZ3M6ICR7c2VhdH1gO1xuIH1cblxuLyogQXQgdGhpcyBwb2ludCB0aGUgYmFzaWMgc2hhcGUgaGFzIGJlZW4gdmFsaWRhdGVkKi9cblxudHJ5e1xuZm9yKGNvbnN0W1xuZnJvbVNlYXQ9dW5kZWZpbmVkLFxudG9TZWF0PXVuZGVmaW5lZCxcbmZyb21BbW91bnRzPXVuZGVmaW5lZCxcbnRvQW1vdW50cz10b1NlYXQmJmZyb21BbW91bnRzXW9mXG50cmFuc2ZlcnMpe1xuaWYoZnJvbVNlYXQmJmZyb21BbW91bnRzKXtcbi8qIHRlc3RpbmcgYm90aCBqdXN0IHRvIHNhdGlzZnkgdGhlIHR5cGUgY2hlY2tlciovXG5mcm9tU2VhdC5kZWNyZW1lbnRCeShmcm9tQW1vdW50cyk7XG4gfVxuaWYodG9TZWF0JiZ0b0Ftb3VudHMpe1xuLyogdGVzdGluZyBib3RoIGp1c3QgdG8gc2F0aXNmeSB0aGUgdHlwZSBjaGVja2VyKi9cbnRvU2VhdC5pbmNyZW1lbnRCeSh0b0Ftb3VudHMpO1xuIH1cbiB9XG5cbi8qIFBlcmhhcHMgZGVwcmVjYXRlIHRoaXMgPj0gMiByZXN0cmljdGlvbj8qL1xudW5pcXVlU2VhdHMubGVuZ3RoPj0yfHxcbkZhaWwgYENhbiBvbmx5IGNvbW1pdCBhIHJlYWxsb2NhdGlvbiBhbW9uZyBhdCBsZWFzdCAyIHNlYXRzOiAke3EoXG51bmlxdWVTZWF0cy5sZW5ndGgpXG4gfWA7XG4vKiBUYWtlIGl0IGFwYXJ0IGFuZCBwdXQgaXQgYmFjayB0b2dldGhlciB0byBzYXRpc2Z5IHRoZSB0eXBlIGNoZWNrZXIqL1xuY29uc3Rbc2VhdDAsc2VhdDEsLi4ucmVzdFNlYXRzXT11bmlxdWVTZWF0cztcbnpjZi5yZWFsbG9jYXRlKHNlYXQwLHNlYXQxLC4uLnJlc3RTZWF0cyk7XG4gfWZpbmFsbHl7XG5mb3IoY29uc3Qgc2VhdCBvZiB1bmlxdWVTZWF0cyl7XG5zZWF0LmNsZWFyKCk7XG4gfVxuIH1cbiB9O1xuXG4vKipcbiAqIFNvbWV0aW1lcyBhIFRyYW5zZmVyUGFydCBpbiBhbiBhdG9taWNSZWFycmFuZ2Ugb25seSBleHByZXNzZXMgd2hhdCBhbW91bnRzXG4gKiBzaG91bGQgYmUgdGFrZW4gZnJvbSBhIHNlYXQsIGxlYXZpbmcgaXQgdG8gb3RoZXIgVHJhbnNmZXJQYXJ0IG9mIHRoZVxuICogc2FtZSBhdG9taWNSZWFycmFuZ2UgdG8gYmFsYW5jZSBpdCBvdXQuIEZvciB0aGlzIGNhc2UsIHRoZVxuICogYFtmcm9tU2VhdCwgdW5kZWZpbmVkLCBmcm9tQW1vdW50c11gIGZvcm0gaXMgbW9yZSBjbGVhcmx5IGV4cHJlc3NlZCBhc1xuICogYGZyb21Pbmx5KGZyb21TZWF0LCBmcm9tQW1vdW50cylgLiBVbmxpa2UgVHJhbnNmZXJQYXJ0LCBib3RoIGFyZ3VtZW50cyB0b1xuICogYGZyb21Pbmx5YCBhcmUgbm9uLW9wdGlvbmFsLCBhcyBvdGhlcndpc2UgaXQgZG9lc24ndCBtYWtlIG11Y2ggc2Vuc2UuXG4gKlxuICogQHBhcmFtIHtaQ0ZTZWF0fSBmcm9tU2VhdFxuICogQHBhcmFtIHtBbW91bnRLZXl3b3JkUmVjb3JkfSBmcm9tQW1vdW50c1xuICogQHJldHVybnMge1RyYW5zZmVyUGFydH1cbiAqLyRo4oCNX29uY2UuYXRvbWljUmVhcnJhbmdlKGF0b21pY1JlYXJyYW5nZSk7XG5jb25zdCAgICAgICAgZnJvbU9ubHk9KGZyb21TZWF0LGZyb21BbW91bnRzKT0+XG5oYXJkZW4oW2Zyb21TZWF0LHVuZGVmaW5lZCxmcm9tQW1vdW50c10pO1xuXG4vKipcbiAqIFNvbWV0aW1lcyBhIFRyYW5zZmVyUGFydCBpbiBhbiBhdG9taWNSZWFycmFuZ2Ugb25seSBleHByZXNzZXMgd2hhdCBhbW91bnRzXG4gKiBzaG91bGQgYmUgZ2l2ZW4gdG8gYSBzZWF0LCBsZWF2aW5nIGl0IHRvIG90aGVyIFRyYW5zZmVyUGFydCBvZiB0aGVcbiAqIHNhbWUgYXRvbWljUmVhcnJhbmdlIHRvIGJhbGFuY2UgaXQgb3V0LiBGb3IgdGhpcyBjYXNlLCB0aGVcbiAqIGBbdW5kZWZpbmVkLCB0b1NlYXQsIHVuZGVmaW5lZCwgdG9BbW91bnRzXWAgZm9ybSBpcyBtb3JlIGNsZWFybHkgZXhwcmVzc2VkIGFzXG4gKiBgdG9Pbmx5KHRvU2VhdCwgdG9BbW91bnRzKWAuIFVubGlrZSBUcmFuc2ZlclBhcnQsIGJvdGggYXJndW1lbnRzIHRvXG4gKiBgdG9Pbmx5YCBhcmUgbm9uLW9wdGlvbmFsLCBhcyBvdGhlcndpc2UgaXQgZG9lc24ndCBtYWtlIG11Y2ggc2Vuc2UuXG4gKlxuICogQHBhcmFtIHtaQ0ZTZWF0fSB0b1NlYXRcbiAqIEBwYXJhbSB7QW1vdW50S2V5d29yZFJlY29yZH0gdG9BbW91bnRzXG4gKiBAcmV0dXJucyB7VHJhbnNmZXJQYXJ0fVxuICovJGjigI1fb25jZS5mcm9tT25seShmcm9tT25seSk7XG5jb25zdCAgICAgICAgdG9Pbmx5PSh0b1NlYXQsdG9BbW91bnRzKT0+XG5oYXJkZW4oW3VuZGVmaW5lZCx0b1NlYXQsdW5kZWZpbmVkLHRvQW1vdW50c10pO1xuXG4vKipcbiAqIFNwZWNpYWwgY2FzZSBvZiBhdG9taWNSZWFycmFuZ2UgZm9yIGEgc2luZ2xlIG9uZS13YXkgdHJhbnNmZXJcbiAqXG4gKiBAcGFyYW0ge1pDRn0gemNmXG4gKiBAcGFyYW0ge1pDRlNlYXR9IFtmcm9tU2VhdF1cbiAqIEBwYXJhbSB7WkNGU2VhdH0gW3RvU2VhdF1cbiAqIEBwYXJhbSB7QW1vdW50S2V5d29yZFJlY29yZH0gW2Zyb21BbW91bnRzXVxuICogQHBhcmFtIHtBbW91bnRLZXl3b3JkUmVjb3JkfSBbdG9BbW91bnRzXVxuICovJGjigI1fb25jZS50b09ubHkodG9Pbmx5KTtcbmNvbnN0ICAgICAgICBhdG9taWNUcmFuc2Zlcj0oXG56Y2YsXG5mcm9tU2VhdD11bmRlZmluZWQsXG50b1NlYXQ9dW5kZWZpbmVkLFxuZnJvbUFtb3VudHM9dW5kZWZpbmVkLFxudG9BbW91bnRzPXVuZGVmaW5lZCk9PlxuYXRvbWljUmVhcnJhbmdlKHpjZixoYXJkZW4oW1tmcm9tU2VhdCx0b1NlYXQsZnJvbUFtb3VudHMsdG9BbW91bnRzXV0pKTskaOKAjV9vbmNlLmF0b21pY1RyYW5zZmVyKGF0b21pY1RyYW5zZmVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJUcmFuc2ZlclBhcnRTaGFwZSI6WyJUcmFuc2ZlclBhcnRTaGFwZSJdLCJhdG9taWNSZWFycmFuZ2UiOlsiYXRvbWljUmVhcnJhbmdlIl0sImZyb21Pbmx5IjpbImZyb21Pbmx5Il0sInRvT25seSI6WyJ0b09ubHkiXSwiYXRvbWljVHJhbnNmZXIiOlsiYXRvbWljVHJhbnNmZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAdVQIBb4bAAC+GwAAPgAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9ib25kaW5nQ3VydmVzLmpzeyJpbXBvcnRzIjpbIi4vc2FmZU1hdGguanMiLCJAZW5kby9uYXQiXSwiZXhwb3J0cyI6WyJjYWxjTGlxVmFsdWVUb01pbnQiLCJjYWxjU2Vjb25kYXJ5UmVxdWlyZWQiLCJjYWxjVmFsdWVUb1JlbW92ZSIsImdldElucHV0UHJpY2UiLCJnZXRPdXRwdXRQcmljZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBOYXQsbmF0U2FmZU1hdGg7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRo4oCNX2EgPT4gKE5hdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3NhZmVNYXRoLmpzXCIsIFtbXCJuYXRTYWZlTWF0aFwiLCBbJGjigI1fYSA9PiAobmF0U2FmZU1hdGggPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuY29uc3R7c3VidHJhY3QsYWRkLG11bHRpcGx5LGZsb29yRGl2aWRlfT1uYXRTYWZlTWF0aDtcbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuY29uc3QgQkFTSVNfUE9JTlRTPTEwMDAwbjsvKiBUT0RPIGNoYW5nZSB0byAxMF8wMDBuIG9uY2UgdG9vbGluZyBjb3Blcy4qL1xuXG4vKipcbiAqIENhbGN1bGF0aW9ucyBmb3IgY29uc3RhbnQgcHJvZHVjdCBtYXJrZXRzIGxpa2UgVW5pc3dhcC5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9ydW50aW1ldmVyaWZpY2F0aW9uL3ZlcmlmaWVkLXNtYXJ0LWNvbnRyYWN0cy9ibG9iL3VuaXN3YXAvdW5pc3dhcC94LXktay5wZGZcbiAqL1xuXG4vKipcbiAqIENvbnRhaW5zIHRoZSBsb2dpYyBmb3IgY2FsY3VsYXRpbmcgaG93IG11Y2ggc2hvdWxkIGJlIGdpdmVuXG4gKiBiYWNrIHRvIHRoZSB1c2VyIGluIGV4Y2hhbmdlIGZvciB3aGF0IHRoZXkgc2VudCBpbi4gUmV1c2VkIGluXG4gKiBzZXZlcmFsIGRpZmZlcmVudCBwbGFjZXMsIGluY2x1ZGluZyB0byBjaGVjayB3aGV0aGVyIGFuIG9mZmVyXG4gKiBpcyB2YWxpZCwgZ2V0dGluZyB0aGUgY3VycmVudCBwcmljZSBmb3IgYW4gYXNzZXQgb24gdXNlclxuICogcmVxdWVzdCwgYW5kIHRvIGRvIHRoZSBhY3R1YWwgcmVhbGxvY2F0aW9uIGFmdGVyIGFuIG9mZmVyIGhhc1xuICogYmVlbiBtYWRlLlxuICpcbiAqIEBwYXJhbSB7YW55fSBpbnB1dFZhbHVlIC0gdGhlIHZhbHVlIG9mIHRoZSBhc3NldCBzZW50XG4gKiBpbiB0byBiZSBzd2FwcGVkXG4gKiBAcGFyYW0ge2FueX0gaW5wdXRSZXNlcnZlIC0gdGhlIHZhbHVlIGluIHRoZSBsaXF1aWRpdHlcbiAqIHBvb2wgb2YgdGhlIGtpbmQgb2YgYXNzZXQgc2VudCBpblxuICogQHBhcmFtIHthbnl9IG91dHB1dFJlc2VydmUgLSB0aGUgdmFsdWUgaW4gdGhlIGxpcXVpZGl0eVxuICogcG9vbCBvZiB0aGUga2luZCBvZiBhc3NldCB0byBiZSBzZW50IG91dFxuICogQHBhcmFtIHtiaWdpbnR9IFtmZWVCYXNpc1BvaW50cz0zMG5dIC0gdGhlIGZlZSB0YWtlbiBpblxuICogYmFzaXMgcG9pbnRzLiBUaGUgZGVmYXVsdCBpcyAwLjMlIG9yIDMwIGJhc2lzIHBvaW50cy4gVGhlIGZlZVxuICogaXMgdGFrZW4gZnJvbSBpbnB1dFZhbHVlXG4gKiBAcmV0dXJucyB7TmF0VmFsdWV9IG91dHB1dFZhbHVlIC0gdGhlIGN1cnJlbnQgcHJpY2UsIGluIHZhbHVlIGZvcm1cbiAqL1xuY29uc3QgICAgICAgIGdldElucHV0UHJpY2U9KFxuaW5wdXRWYWx1ZSxcbmlucHV0UmVzZXJ2ZSxcbm91dHB1dFJlc2VydmUsXG5mZWVCYXNpc1BvaW50cz0zMG4pPT5cbntcbmlucHV0VmFsdWU9TmF0KGlucHV0VmFsdWUpO1xuaW5wdXRSZXNlcnZlPU5hdChpbnB1dFJlc2VydmUpO1xub3V0cHV0UmVzZXJ2ZT1OYXQob3V0cHV0UmVzZXJ2ZSk7XG5pbnB1dFZhbHVlPjBufHxGYWlsIGBpbnB1dFZhbHVlICR7aW5wdXRWYWx1ZX0gbXVzdCBiZSBwb3NpdGl2ZWA7XG5pbnB1dFJlc2VydmU+MG58fEZhaWwgYGlucHV0UmVzZXJ2ZSAke2lucHV0UmVzZXJ2ZX0gbXVzdCBiZSBwb3NpdGl2ZWA7XG5vdXRwdXRSZXNlcnZlPjBufHxGYWlsIGBvdXRwdXRSZXNlcnZlICR7b3V0cHV0UmVzZXJ2ZX0gbXVzdCBiZSBwb3NpdGl2ZWA7XG5cbmNvbnN0IG9uZU1pbnVzRmVlU2NhbGVkPXN1YnRyYWN0KEJBU0lTX1BPSU5UUyxmZWVCYXNpc1BvaW50cyk7XG5jb25zdCBpbnB1dFdpdGhGZWU9bXVsdGlwbHkoaW5wdXRWYWx1ZSxvbmVNaW51c0ZlZVNjYWxlZCk7XG5jb25zdCBudW1lcmF0b3I9bXVsdGlwbHkoaW5wdXRXaXRoRmVlLG91dHB1dFJlc2VydmUpO1xuY29uc3QgZGVub21pbmF0b3I9YWRkKG11bHRpcGx5KGlucHV0UmVzZXJ2ZSxCQVNJU19QT0lOVFMpLGlucHV0V2l0aEZlZSk7XG5yZXR1cm4gZmxvb3JEaXZpZGUobnVtZXJhdG9yLGRlbm9taW5hdG9yKTtcbiB9O1xuXG4vKipcbiAqIENvbnRhaW5zIHRoZSBsb2dpYyBmb3IgY2FsY3VsYXRpbmcgaG93IG11Y2ggc2hvdWxkIGJlIHRha2VuXG4gKiBmcm9tIHRoZSB1c2VyIGluIGV4Y2hhbmdlIGZvciB3aGF0IHRoZXkgd2FudCB0byBvYnRhaW4uIFJldXNlZCBpblxuICogc2V2ZXJhbCBkaWZmZXJlbnQgcGxhY2VzLCBpbmNsdWRpbmcgdG8gY2hlY2sgd2hldGhlciBhbiBvZmZlclxuICogaXMgdmFsaWQsIGdldHRpbmcgdGhlIGN1cnJlbnQgcHJpY2UgZm9yIGFuIGFzc2V0IG9uIHVzZXJcbiAqIHJlcXVlc3QsIGFuZCB0byBkbyB0aGUgYWN0dWFsIHJlYWxsb2NhdGlvbiBhZnRlciBhbiBvZmZlciBoYXNcbiAqIGJlZW4gbWFkZS5cbiAqXG4gKiBAcGFyYW0ge2FueX0gb3V0cHV0VmFsdWUgLSB0aGUgdmFsdWUgb2YgdGhlIGFzc2V0IHRoZSB1c2VyIHdhbnRzXG4gKiB0byBnZXRcbiAqIEBwYXJhbSB7YW55fSBpbnB1dFJlc2VydmUgLSB0aGUgdmFsdWUgaW4gdGhlIGxpcXVpZGl0eVxuICogcG9vbCBvZiB0aGUgYXNzZXQgYmVpbmcgc3BlbnRcbiAqIEBwYXJhbSB7YW55fSBvdXRwdXRSZXNlcnZlIC0gdGhlIHZhbHVlIGluIHRoZSBsaXF1aWRpdHlcbiAqIHBvb2wgb2YgdGhlIGtpbmQgb2YgYXNzZXQgdG8gYmUgc2VudCBvdXRcbiAqIEBwYXJhbSB7YmlnaW50fSBbZmVlQmFzaXNQb2ludHM9MzBuXSAtIHRoZSBmZWUgdGFrZW4gaW5cbiAqIGJhc2lzIHBvaW50cy4gVGhlIGRlZmF1bHQgaXMgMC4zJSBvciAzMCBiYXNpcyBwb2ludHMuIFRoZSBmZWUgaXMgdGFrZW4gZnJvbVxuICogb3V0cHV0VmFsdWVcbiAqIEByZXR1cm5zIHtOYXRWYWx1ZX0gaW5wdXRWYWx1ZSAtIHRoZSB2YWx1ZSBvZiBpbnB1dCByZXF1aXJlZCB0byBwdXJjaGFzZSBvdXRwdXRcbiAqLyRo4oCNX29uY2UuZ2V0SW5wdXRQcmljZShnZXRJbnB1dFByaWNlKTtcbmNvbnN0ICAgICAgICBnZXRPdXRwdXRQcmljZT0oXG5vdXRwdXRWYWx1ZSxcbmlucHV0UmVzZXJ2ZSxcbm91dHB1dFJlc2VydmUsXG5mZWVCYXNpc1BvaW50cz0zMG4pPT5cbntcbm91dHB1dFZhbHVlPU5hdChvdXRwdXRWYWx1ZSk7XG5pbnB1dFJlc2VydmU9TmF0KGlucHV0UmVzZXJ2ZSk7XG5vdXRwdXRSZXNlcnZlPU5hdChvdXRwdXRSZXNlcnZlKTtcblxuaW5wdXRSZXNlcnZlPjBufHxGYWlsIGBpbnB1dFJlc2VydmUgJHtpbnB1dFJlc2VydmV9IG11c3QgYmUgcG9zaXRpdmVgO1xub3V0cHV0UmVzZXJ2ZT4wbnx8RmFpbCBgb3V0cHV0UmVzZXJ2ZSAke291dHB1dFJlc2VydmV9IG11c3QgYmUgcG9zaXRpdmVgO1xub3V0cHV0UmVzZXJ2ZT5vdXRwdXRWYWx1ZXx8XG5GYWlsIGBvdXRwdXRSZXNlcnZlICR7b3V0cHV0UmVzZXJ2ZX0gbXVzdCBiZSBncmVhdGVyIHRoYW4gb3V0cHV0VmFsdWUgJHtvdXRwdXRWYWx1ZX1gO1xuXG5jb25zdCBvbmVNaW51c0ZlZVNjYWxlZD1zdWJ0cmFjdChCQVNJU19QT0lOVFMsZmVlQmFzaXNQb2ludHMpO1xuY29uc3QgbnVtZXJhdG9yPW11bHRpcGx5KG11bHRpcGx5KG91dHB1dFZhbHVlLGlucHV0UmVzZXJ2ZSksQkFTSVNfUE9JTlRTKTtcbmNvbnN0IGRlbm9taW5hdG9yPW11bHRpcGx5KFxuc3VidHJhY3Qob3V0cHV0UmVzZXJ2ZSxvdXRwdXRWYWx1ZSksXG5vbmVNaW51c0ZlZVNjYWxlZCk7XG5cbnJldHVybiBhZGQoZmxvb3JEaXZpZGUobnVtZXJhdG9yLGRlbm9taW5hdG9yKSwxbik7XG4gfTtcblxuLyoqXG4gKiBDYWxjdWxhdGUgaG93IG1hbnkgbGlxdWlkaXR5IHRva2VucyB3ZSBzaG91bGQgYmUgbWludGluZyB0byBzZW5kIGJhY2sgdG8gdGhlXG4gKiB1c2VyIHdoZW4gYWRkaW5nIGxpcXVpZGl0eS4gV2UgcHJvdmlkZSBuZXcgbGlxdWlkaXR5IGVxdWFsIHRvIHRoZSBleGlzdGluZ1xuICogbGlxdWlkaXR5IG11bHRpcGxpZWQgYnkgdGhlIHJhdGlvIG9mIG5ldyBjZW50cmFsIHRva2VucyB0byBjZW50cmFsIHRva2Vuc1xuICogYWxyZWFkeSBoZWxkLiBJZiB0aGUgY3VycmVudCBzdXBwbHkgaXMgemVybywgcmV0dXJuIHRoZSBpbnB1dFZhbHVlIGFzIHRoZVxuICogaW5pdGlhbCBsaXF1aWRpdHkgdG8gbWludCBpcyBhcmJpdHJhcnkuXG4gKlxuICogQHBhcmFtIHtiaWdpbnR9IGxpcVRva2VuU3VwcGx5XG4gKiBAcGFyYW0ge2JpZ2ludH0gaW5wdXRWYWx1ZVxuICogQHBhcmFtIHtiaWdpbnR9IGlucHV0UmVzZXJ2ZVxuICogQHJldHVybnMge05hdFZhbHVlfVxuICovJGjigI1fb25jZS5nZXRPdXRwdXRQcmljZShnZXRPdXRwdXRQcmljZSk7XG5jb25zdCAgICAgICAgY2FsY0xpcVZhbHVlVG9NaW50PShcbmxpcVRva2VuU3VwcGx5LFxuaW5wdXRWYWx1ZSxcbmlucHV0UmVzZXJ2ZSk9Plxue1xubGlxVG9rZW5TdXBwbHk9TmF0KGxpcVRva2VuU3VwcGx5KTtcbmlucHV0VmFsdWU9TmF0KGlucHV0VmFsdWUpO1xuaW5wdXRSZXNlcnZlPU5hdChpbnB1dFJlc2VydmUpO1xuXG5pZihsaXFUb2tlblN1cHBseT09PTBuKXtcbnJldHVybiBpbnB1dFZhbHVlO1xuIH1cbnJldHVybiBmbG9vckRpdmlkZShtdWx0aXBseShpbnB1dFZhbHVlLGxpcVRva2VuU3VwcGx5KSxpbnB1dFJlc2VydmUpO1xuIH07XG5cbi8qKlxuICogQ2FsY3VsYXRlIGhvdyBtdWNoIG9mIHRoZSBzZWNvbmRhcnkgdG9rZW4gaXMgcmVxdWlyZWQgZnJvbSB0aGUgdXNlciB3aGVuXG4gKiBhZGRpbmcgbGlxdWlkaXR5LiBXZSByZXF1aXJlIHRoYXQgdGhlIGRlcG9zaXRlZCByYXRpbyBvZiBjZW50cmFsIHRvIHNlY29uZGFyeVxuICogbWF0Y2ggdGhlIGN1cnJlbnQgcmF0aW8gb2YgaG9sZGluZ3MgaW4gdGhlIHBvb2wuXG4gKlxuICogQHBhcmFtIHthbnl9IGNlbnRyYWxJbiAtIFRoZSB2YWx1ZSBvZiBjZW50cmFsIGFzc2V0cyBiZWluZyBkZXBvc2l0ZWRcbiAqIEBwYXJhbSB7YW55fSBjZW50cmFsUG9vbCAtIFRoZSB2YWx1ZSBvZiBjZW50cmFsIGFzc2V0cyBpbiB0aGUgcG9vbFxuICogQHBhcmFtIHthbnl9IHNlY29uZGFyeVBvb2wgLSBUaGUgdmFsdWUgb2Ygc2Vjb25kYXJ5IGFzc2V0cyBpbiB0aGUgcG9vbFxuICogQHBhcmFtIHthbnl9IHNlY29uZGFyeUluIC0gVGhlIHZhbHVlIG9mIHNlY29uZGFyeSBhc3NldHMgcHJvdmlkZWQuIElmXG4gKiB0aGUgcG9vbCBpcyBlbXB0eSwgdGhlIGVudGlyZSBhbW91bnQgd2lsbCBiZSBhY2NlcHRlZFxuICogQHJldHVybnMge05hdFZhbHVlfSAtIHRoZSBhbW91bnQgb2Ygc2Vjb25kYXJ5IHJlcXVpcmVkXG4gKi8kaOKAjV9vbmNlLmNhbGNMaXFWYWx1ZVRvTWludChjYWxjTGlxVmFsdWVUb01pbnQpO1xuY29uc3QgICAgICAgIGNhbGNTZWNvbmRhcnlSZXF1aXJlZD0oXG5jZW50cmFsSW4sXG5jZW50cmFsUG9vbCxcbnNlY29uZGFyeVBvb2wsXG5zZWNvbmRhcnlJbik9Plxue1xuY2VudHJhbEluPU5hdChjZW50cmFsSW4pO1xuY2VudHJhbFBvb2w9TmF0KGNlbnRyYWxQb29sKTtcbnNlY29uZGFyeVBvb2w9TmF0KHNlY29uZGFyeVBvb2wpO1xuc2Vjb25kYXJ5SW49TmF0KHNlY29uZGFyeUluKTtcblxuaWYoY2VudHJhbFBvb2w9PT0wbnx8c2Vjb25kYXJ5UG9vbD09PTBuKXtcbnJldHVybiBzZWNvbmRhcnlJbjtcbiB9XG5cbmNvbnN0IHNjYWxlZFNlY29uZGFyeT1mbG9vckRpdmlkZShcbm11bHRpcGx5KGNlbnRyYWxJbixzZWNvbmRhcnlQb29sKSxcbmNlbnRyYWxQb29sKTtcblxuY29uc3QgZXhhY3Q9XG5tdWx0aXBseShjZW50cmFsSW4sc2Vjb25kYXJ5UG9vbCk9PT1cbm11bHRpcGx5KHNjYWxlZFNlY29uZGFyeSxjZW50cmFsUG9vbCk7XG5cbi8qIGRvZXNuJ3QgbWF0Y2ggdGhlIHgteS1rLnBkZiBwYXBlciwgYnV0IG1vcmUgY29ycmVjdC4gV2hlbiB0aGUgcmF0aW9zIGFyZSovXG4vKiBleGFjdGx5IGVxdWFsLCBsUHJpbWUgaXMgZXhhY3RseSBsICogKDEgKyBhbHBoYSkgYW5kIGFkZGluZyBvbmUgaXMgd3JvbmcqL1xucmV0dXJuIGV4YWN0P3NjYWxlZFNlY29uZGFyeToxbitzY2FsZWRTZWNvbmRhcnk7XG4gfTtcblxuLyogQ2FsY3VsYXRlIGhvdyBtYW55IHVuZGVybHlpbmcgdG9rZW5zIChpbiB0aGUgZm9ybSBvZiBhIHZhbHVlKSBzaG91bGQgYmUqL1xuLyogcmV0dXJuZWQgd2hlbiByZW1vdmluZyBsaXF1aWRpdHkuKi8kaOKAjV9vbmNlLmNhbGNTZWNvbmRhcnlSZXF1aXJlZChjYWxjU2Vjb25kYXJ5UmVxdWlyZWQpO1xuY29uc3QgICAgICAgIGNhbGNWYWx1ZVRvUmVtb3ZlPShcbmxpcVRva2VuU3VwcGx5LFxucG9vbFZhbHVlLFxubGlxdWlkaXR5VmFsdWVJbik9Plxue1xubGlxVG9rZW5TdXBwbHk9TmF0KGxpcVRva2VuU3VwcGx5KTtcbmxpcXVpZGl0eVZhbHVlSW49TmF0KGxpcXVpZGl0eVZhbHVlSW4pO1xucG9vbFZhbHVlPU5hdChwb29sVmFsdWUpO1xuXG5yZXR1cm4gZmxvb3JEaXZpZGUobXVsdGlwbHkobGlxdWlkaXR5VmFsdWVJbixwb29sVmFsdWUpLGxpcVRva2VuU3VwcGx5KTtcbiB9OyRo4oCNX29uY2UuY2FsY1ZhbHVlVG9SZW1vdmUoY2FsY1ZhbHVlVG9SZW1vdmUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImdldElucHV0UHJpY2UiOlsiZ2V0SW5wdXRQcmljZSJdLCJnZXRPdXRwdXRQcmljZSI6WyJnZXRPdXRwdXRQcmljZSJdLCJjYWxjTGlxVmFsdWVUb01pbnQiOlsiY2FsY0xpcVZhbHVlVG9NaW50Il0sImNhbGNTZWNvbmRhcnlSZXF1aXJlZCI6WyJjYWxjU2Vjb25kYXJ5UmVxdWlyZWQiXSwiY2FsY1ZhbHVlVG9SZW1vdmUiOlsiY2FsY1ZhbHVlVG9SZW1vdmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAstPjsa0SAACtEgAAOwAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvaW50ZXJuYWwiLCJAYWdvcmljL3ZhdC1kYXRhIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCJdLCJleHBvcnRzIjpbIm1ha2VFcGhlbWVyYVByb3ZpZGVyIiwicHJvdmlkZUFsbCIsInByb3ZpZGVFbXB0eVNlYXQiLCJwcm92aWRlU2luZ2xldG9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFsbFZhbHVlcyxvYmplY3RNYXAscHJvdmlkZSxFOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvaW50ZXJuYWxcIiwgW1tcImFsbFZhbHVlc1wiLCBbJGjigI1fYSA9PiAoYWxsVmFsdWVzID0gJGjigI1fYSldXSxbXCJvYmplY3RNYXBcIiwgWyRo4oCNX2EgPT4gKG9iamVjdE1hcCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJwcm92aWRlXCIsIFskaOKAjV9hID0+IChwcm92aWRlID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cbi8qKlxuICogU0NBTEU6IE9ubHkgZm9yIGxvdyBjYXJkaW5hbGl0eSBwcm92aXNpb25pbmcuIEV2ZXJ5IHZhbHVlIGZyb20gaW5pdCgpIHdpbGxcbiAqIHJlbWFpbiBpbiB0aGUgbWFwIGZvciB0aGUgbGlmZXRpbWUgb2YgdGhlIGhlYXAuIElmIGEga2V5IG9iamVjdCBpcyBHQ2VkLCBpdHNcbiAqIHJlcHJlc2VudGF0aXZlIGFsc28gcmVtYWlucy5cbiAqXG4gKiBAdGVtcGxhdGUge3t9fSBFIEVwaGVtZXJhbCBzdGF0ZVxuICogQHRlbXBsYXRlIHt7fX0gW0s9YW55XSBrZXkgb24gd2hpY2ggdG8gcHJvdmlzaW9uXG4gKiBAcGFyYW0geyhrZXk6IEspID0+IEV9IGluaXRcbiAqL1xuY29uc3QgICAgICAgIG1ha2VFcGhlbWVyYVByb3ZpZGVyPShpbml0KT0+e1xuLyoqIEB0eXBlIHtXZWFrTWFwPEssIEU+fSAqL1xuY29uc3QgZXh0YW50PW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogUHJvdmlkZSBhbiBvYmplY3QgdG8gaG9sZCBzdGF0ZSB0aGF0IG5lZWQgbm90IChvciBjYW5ub3QpIGJlIGR1cmFibGUuXG4gKlxuICogQHR5cGUgeyhrZXk6IEspID0+IEV9XG4gKi9cbnJldHVybihrZXkpPT57XG5pZihleHRhbnQuaGFzKGtleSkpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBjYXN0Ki9cbnJldHVybiBleHRhbnQuZ2V0KGtleSk7XG4gfVxuY29uc3QgbmV3RXBoPWluaXQoa2V5KTtcbmV4dGFudC5zZXQoa2V5LG5ld0VwaCk7XG5yZXR1cm4gbmV3RXBoO1xuIH07XG4gfTskaOKAjV9vbmNlLm1ha2VFcGhlbWVyYVByb3ZpZGVyKG1ha2VFcGhlbWVyYVByb3ZpZGVyKTtcbmhhcmRlbihtYWtlRXBoZW1lcmFQcm92aWRlcik7XG5cbi8qKlxuICogUHJvdmlkZSBhbiBlbXB0eSBaQ0Ygc2VhdC5cbiAqXG4gKiBAcGFyYW0ge1pDRn0gemNmXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvZXJ0cCcpLkJhZ2dhZ2V9IGJhZ2dhZ2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBuYW1lXG4gKiBAcmV0dXJucyB7WkNGU2VhdH1cbiAqL1xuY29uc3QgICAgICAgIHByb3ZpZGVFbXB0eVNlYXQ9KHpjZixiYWdnYWdlLG5hbWUpPT57XG5yZXR1cm4gcHJvdmlkZShiYWdnYWdlLG5hbWUsKCk9PnpjZi5tYWtlRW1wdHlTZWF0S2l0KCkuemNmU2VhdCk7XG4gfTskaOKAjV9vbmNlLnByb3ZpZGVFbXB0eVNlYXQocHJvdmlkZUVtcHR5U2VhdCk7XG5oYXJkZW4ocHJvdmlkZUVtcHR5U2VhdCk7XG5cbi8qKlxuICogRm9yIHVzZSBpbiBjb250cmFjdCB1cGdyYWRlcyB0byBwcm92aWRlIHZhbHVlcyB0aGF0IGNvbWUgZnJvbSBvdGhlciB2YXRzLlxuICogQWxsIHZhdHMgbXVzdCBiZSBhYmxlIHRvIGZpbmlzaCB0aGVpciB1cGdyYWRlIHdpdGhvdXQgY29udGFjdGluZyBvdGhlciB2YXRzLFxuICogc28gd2hhdGV2ZXIgdmFsdWVzIGFuIGluc3RhbmNlIG5lZWRzIGZyb20gb3RoZXIgdmF0cyBtdXN0IGJlIHNhdmVkIGluIHRoZSBmaXJzdFxuICogaW5jYXJuYXRpb24gYW5kIHJlYWQgZnJvbSBiYWdnYWdlIGluIGVhY2ggc3Vic2VxdWVudC5cbiAqXG4gKiBUaGlzIGFic3RyYWN0cyB0aGF0IGNvbmRpdGlvbiBzbyB0aGF0IHRoZSBjb250cmFjdCBjYW4gY29udmVydCBhIGRpY3Rpb25hcnlcbiAqIG9mIHRodW5rcyBpbnRvIGEgZGljdGlvbmFyeSBvZiB2YWx1ZXMgZHVyaW5nIGl0cyBmaXJzdCBgcHJlcGFyZWAgKHN0YXJ0KS5cbiAqIEVhY2ggc3Vic2VxdWVudCBgcHJlcGFyZWAgY2FsbCB3aWxsIGF1dG9tYXRpY2FsbHkgcmVhZCBmcm9tIHRoZSBiYWdnYWdlIGFuZFxuICogZXNjaGV3IHJlbW90ZSBjYWxscy5cbiAqXG4gKiBUaGUgdmFsdWVzIGFyZSB0aHVua3MgaW5zdGVhZCBvZiBwcm9taXNlcyBzbyB0aGF0IHRoZXkgZG9uJ3Qgc3RhcnQgZXhlY3V0aW5nXG4gKiB1bm5lY2Vzc2FyaWx5IG9yIGluZHVjZSBmYWlsdXJlcy5cbiAqXG4gKiBGb3IgZXhhbXBsZSxcbiAqXG4gKiAgICAgY29uc3QgaW52aXRhdGlvbklzc3VlclAgPSBFKHpvZSkuZ2V0SW52aXRhdGlvbklzc3VlcigpO1xuICogICAgIGNvbnN0IHtcbiAqICAgICAgIGludml0YXRpb25Jc3N1ZXIsXG4gKiAgICAgICBpbnZpdGF0aW9uQnJhbmQsXG4gKiAgICAgfSA9IGF3YWl0IHByb3ZpZGVBbGwoYmFnZ2FnZSwge1xuICogICAgICAgaW52aXRhdGlvbklzc3VlcjogKCkgPT4gaW52aXRhdGlvbklzc3VlclAsXG4gKiAgICAgICBpbnZpdGF0aW9uQnJhbmQ6ICgpID0+IEUoaW52aXRhdGlvbklzc3VlclApLmdldEJyYW5kKCksXG4gKiAgICAgfSk7XG4gKlxuICogQHRlbXBsYXRlIHtSZWNvcmQ8c3RyaW5nLCAoKSA9PiBFUmVmPGFueT4+fSBUIGRpY3Qgb2YgdGh1bmtzIChwcm9taXNlIG1ha2VycylcbiAqIEBwYXJhbSB7TWFwU3RvcmU8c3RyaW5nLCBhbnk+fSBiYWdnYWdlXG4gKiBAcGFyYW0ge1R9IHRodW5rc1xuICogQHJldHVybnMge1Byb21pc2U8eyBbSyBpbiBrZXlvZiBUXTogQXdhaXRlZDxSZXR1cm5UeXBlPFRbS10+PiB9Pn1cbiAqL1xuY29uc3QgICAgICAgIHByb3ZpZGVBbGw9KGJhZ2dhZ2UsdGh1bmtzKT0+e1xuY29uc3Qga2V5cz1PYmplY3Qua2V5cyh0aHVua3MpO1xuLyogYXNzdW1lIGlmIGFueSBrZXlzIGFyZSBkZWZpbmVkIHRoZXkgYWxsIGFyZSovXG5jb25zdCBpbkJhZ2dhZ2U9YmFnZ2FnZS5oYXMoa2V5c1swXSk7XG5pZihpbkJhZ2dhZ2Upe1xuY29uc3Qgb2JqPW9iamVjdE1hcChcbnRodW5rcyxcbi8qKiBAdHlwZSB7KHZhbHVlOiBhbnksIGtleTogc3RyaW5nKSA9PiBhbnl9ICovXG4oXyxrKT0+YmFnZ2FnZS5nZXQoaykpO1xuXG5yZXR1cm4gUHJvbWlzZS5yZXNvbHZlKGhhcmRlbihvYmopKTtcbiB9XG5cbmNvbnN0IGtleWVkUHJvbWlzZXM9b2JqZWN0TWFwKHRodW5rcywoZm4pPT5mbigpKTtcblxucmV0dXJuIGFsbFZhbHVlcyhrZXllZFByb21pc2VzKS50aGVuKChrZXllZFZhbHMpPT57XG5mb3IoY29uc3Rbayx2XW9mIE9iamVjdC5lbnRyaWVzKGtleWVkVmFscykpe1xuYmFnZ2FnZS5pbml0KGssdik7XG4gfVxucmV0dXJuIGtleWVkVmFscztcbiB9KTtcbiB9OyRo4oCNX29uY2UucHJvdmlkZUFsbChwcm92aWRlQWxsKTtcbmhhcmRlbihwcm92aWRlQWxsKTtcblxuLyoqXG4gKiBMaWtlIHByb3ZpZGVBc3luYyBpbiBBdG9taWNQcm92aWRlciBidXQgYXNzdW1lcyBvbmx5IG9uZSBjYWxsIHNvIHRoZXJlIGFyZSBubyByYWNlIGNvbmRpdGlvbnMuXG4gKiBBZGRpdGlvbmFsbHkgb2ZmZXJzIGEgYHdpdGhWYWx1ZWAgaGVscGVyIHVzZWZ1bCBmb3IgdHJpZ2dlcmluZyBwcm9jZXNlc3Mgb24gYSBwcm92aWRlZCBvYmplY3QuXG4gKlxuICogQHNlZSB7bWFrZUF0b21pY1Byb3ZpZGVyfVxuICogQHNlZSB7QXRvbWljUHJvdmlkZXJ9XG4gKiBAdGVtcGxhdGUgeygpID0+IEVSZWY8YW55Pn0gVFxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gbWFwU3RvcmVcbiAqIEBwYXJhbSB7c3RyaW5nfSBrZXlcbiAqIEBwYXJhbSB7VH0gbWFrZVZhbHVlXG4gKiBAcGFyYW0geyh2YWx1ZTogQXdhaXRlZDxSZXR1cm5UeXBlPFQ+PikgPT4gdm9pZH0gW3dpdGhWYWx1ZV1cbiAqIEByZXR1cm5zIHtQcm9taXNlPEF3YWl0ZWQ8UmV0dXJuVHlwZTxUPj4+fVxuICovXG5jb25zdCAgICAgICAgcHJvdmlkZVNpbmdsZXRvbj0obWFwU3RvcmUsa2V5LG1ha2VWYWx1ZSx3aXRoVmFsdWUpPT57XG5jb25zdCBzdG9yZWQ9XG5tYXBTdG9yZS5oYXMoa2V5KXx8XG5FLndoZW4obWFrZVZhbHVlKCksKHYpPT5tYXBTdG9yZS5pbml0KGtleSxoYXJkZW4odikpKTtcblxucmV0dXJuIEUud2hlbihzdG9yZWQsKCk9PntcbmNvbnN0IHZhbHVlPW1hcFN0b3JlLmdldChrZXkpO1xuaWYod2l0aFZhbHVlKXtcbndpdGhWYWx1ZSh2YWx1ZSk7XG4gfVxucmV0dXJuIHZhbHVlO1xuIH0pO1xuIH07JGjigI1fb25jZS5wcm92aWRlU2luZ2xldG9uKHByb3ZpZGVTaW5nbGV0b24pO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VFcGhlbWVyYVByb3ZpZGVyIjpbIm1ha2VFcGhlbWVyYVByb3ZpZGVyIl0sInByb3ZpZGVFbXB0eVNlYXQiOlsicHJvdmlkZUVtcHR5U2VhdCJdLCJwcm92aWRlQWxsIjpbInByb3ZpZGVBbGwiXSwicHJvdmlkZVNpbmdsZXRvbiI6WyJwcm92aWRlU2luZ2xldG9uIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAFVcfJ7fCQAA3wkAADYAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvaW5kZXguanN7ImltcG9ydHMiOlsiLi9hdG9taWNUcmFuc2Zlci5qcyIsIi4vYm9uZGluZ0N1cnZlcy5qcyIsIi4vZHVyYWJpbGl0eS5qcyIsIi4vcHJpY2VBdXRob3JpdHkuanMiLCIuL3ByaWNlUXVvdGUuanMiLCIuL3JhdGlvLmpzIiwiLi9yZWNvcmRlci5qcyIsIi4vc2FmZU1hdGguanMiLCIuL3N0YXRlTWFjaGluZS5qcyIsIi4vc3RhdGlzdGljcy5qcyIsIi4vdG9waWNzLmpzIiwiLi96b2VIZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiYXRvbWljVHJhbnNmZXIiLCJhdG9taWNUcmFuc2ZlciIsImdldE91dHB1dFByaWNlIiwiZ2V0T3V0cHV0UHJpY2UiLCJtYWtlUmF0aW9Gcm9tQW1vdW50cyIsIm1ha2VSYXRpb0Zyb21BbW91bnRzIiwic3dhcCIsInN3YXAiLG51bGwsbnVsbF0sInJlZXhwb3J0cyI6WyIuL2R1cmFiaWxpdHkuanMiLCIuL3ByaWNlQXV0aG9yaXR5LmpzIiwiLi9wcmljZVF1b3RlLmpzIiwiLi9yZWNvcmRlci5qcyIsIi4vc3RhdGlzdGljcy5qcyIsIi4vdG9waWNzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9ib25kaW5nQ3VydmVzLmpzXCIsIFtdXSxbXCIuL3NhZmVNYXRoLmpzXCIsIFtdXSxbXCIuL3N0YXRlTWFjaGluZS5qc1wiLCBbXV0sW1wiLi9hdG9taWNUcmFuc2Zlci5qc1wiLCBbXV0sW1wiLi96b2VIZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3JhdGlvLmpzXCIsIFtdXSxbXCIuL2R1cmFiaWxpdHkuanNcIiwgW11dLFtcIi4vcHJpY2VBdXRob3JpdHkuanNcIiwgW11dLFtcIi4vcHJpY2VRdW90ZS5qc1wiLCBbXV0sW1wiLi9zdGF0aXN0aWNzLmpzXCIsIFtdXSxbXCIuL3JlY29yZGVyLmpzXCIsIFtdXSxbXCIuL3RvcGljcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL2JvbmRpbmdDdXJ2ZXMuanMiOltbImdldElucHV0UHJpY2UiLCJnZXRJbnB1dFByaWNlIl0sWyJnZXRPdXRwdXRQcmljZSIsImdldE91dHB1dFByaWNlIl0sWyJjYWxjTGlxVmFsdWVUb01pbnQiLCJjYWxjTGlxVmFsdWVUb01pbnQiXSxbImNhbGNWYWx1ZVRvUmVtb3ZlIiwiY2FsY1ZhbHVlVG9SZW1vdmUiXSxbImNhbGNTZWNvbmRhcnlSZXF1aXJlZCIsImNhbGNTZWNvbmRhcnlSZXF1aXJlZCJdXSwiLi9zYWZlTWF0aC5qcyI6W1sibmF0U2FmZU1hdGgiLCJuYXRTYWZlTWF0aCJdXSwiLi9zdGF0ZU1hY2hpbmUuanMiOltbIm1ha2VTdGF0ZU1hY2hpbmUiLCJtYWtlU3RhdGVNYWNoaW5lIl1dLCIuL2F0b21pY1RyYW5zZmVyLmpzIjpbWyJhdG9taWNSZWFycmFuZ2UiLCJhdG9taWNSZWFycmFuZ2UiXSxbImF0b21pY1RyYW5zZmVyIiwiYXRvbWljVHJhbnNmZXIiXSxbImZyb21Pbmx5IiwiZnJvbU9ubHkiXSxbInRvT25seSIsInRvT25seSJdXSwiLi96b2VIZWxwZXJzLmpzIjpbWyJkZWZhdWx0QWNjZXB0YW5jZU1zZyIsImRlZmF1bHRBY2NlcHRhbmNlTXNnIl0sWyJzd2FwIiwic3dhcCJdLFsiZml0UHJvcG9zYWxTaGFwZSIsImZpdFByb3Bvc2FsU2hhcGUiXSxbImFzc2VydFByb3Bvc2FsU2hhcGUiLCJhc3NlcnRQcm9wb3NhbFNoYXBlIl0sWyJhc3NlcnRJc3N1ZXJLZXl3b3JkcyIsImFzc2VydElzc3VlcktleXdvcmRzIl0sWyJzYXRpc2ZpZXMiLCJzYXRpc2ZpZXMiXSxbImFzc2VydE5hdEFzc2V0S2luZCIsImFzc2VydE5hdEFzc2V0S2luZCJdLFsic3dhcEV4YWN0Iiwic3dhcEV4YWN0Il0sWyJkZXBvc2l0VG9TZWF0IiwiZGVwb3NpdFRvU2VhdCJdLFsid2l0aGRyYXdGcm9tU2VhdCIsIndpdGhkcmF3RnJvbVNlYXQiXSxbInNhdmVBbGxJc3N1ZXJzIiwic2F2ZUFsbElzc3VlcnMiXSxbIm9mZmVyVG8iLCJvZmZlclRvIl1dLCIuL3JhdGlvLmpzIjpbWyJtYWtlUmF0aW8iLCJtYWtlUmF0aW8iXSxbIm1ha2VSYXRpb0Zyb21BbW91bnRzIiwibWFrZVJhdGlvRnJvbUFtb3VudHMiXSxbImZsb29yTXVsdGlwbHlCeSIsImZsb29yTXVsdGlwbHlCeSJdLFsiZmxvb3JEaXZpZGVCeSIsImZsb29yRGl2aWRlQnkiXSxbImNlaWxNdWx0aXBseUJ5IiwiY2VpbE11bHRpcGx5QnkiXSxbImNlaWxEaXZpZGVCeSIsImNlaWxEaXZpZGVCeSJdLFsiYXNzZXJ0SXNSYXRpbyIsImFzc2VydElzUmF0aW8iXSxbImludmVydFJhdGlvIiwiaW52ZXJ0UmF0aW8iXSxbIm9uZU1pbnVzIiwib25lTWludXMiXSxbImFkZFJhdGlvcyIsImFkZFJhdGlvcyJdLFsibXVsdGlwbHlSYXRpb3MiLCJtdWx0aXBseVJhdGlvcyJdLFsicmF0aW9zU2FtZSIsInJhdGlvc1NhbWUiXSxbInF1YW50aXplIiwicXVhbnRpemUiXSxbInJhdGlvR1RFIiwicmF0aW9HVEUiXSxbInN1YnRyYWN0UmF0aW9zIiwic3VidHJhY3RSYXRpb3MiXSxbInJhdGlvVG9OdW1iZXIiLCJyYXRpb1RvTnVtYmVyIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA6/4CpqCsAAKgrAAA/AAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L3ByaWNlQXV0aG9yaXR5LmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvYXNzZXJ0IiwiQGFnb3JpYy9lcnRwIiwiQGFnb3JpYy9pbnRlcm5hbCIsIkBhZ29yaWMvbm90aWZpZXIiLCJAYWdvcmljL3N0b3JlIiwiQGFnb3JpYy90aW1lIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL21hcnNoYWwiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbIlByaWNlQXV0aG9yaXR5SSIsIm1ha2VPbmV3YXlQcmljZUF1dGhvcml0eUtpdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixhc3NlcnQscSxGYWlsLG1ha2VQcm9taXNlS2l0LEFtb3VudE1hdGgsQW1vdW50U2hhcGUsQnJhbmRTaGFwZSxtYWtlTm90aWZpZXIsbWFrZVRyYWNlcixUaW1lc3RhbXBTaGFwZSxNOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vbWFyc2hhbFwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9hc3NlcnRcIiwgW1tcImFzc2VydFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0ID0gJGjigI1fYSldXSxbXCJxXCIsIFskaOKAjV9hID0+IChxID0gJGjigI1fYSldXSxbXCJGYWlsXCIsIFskaOKAjV9hID0+IChGYWlsID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJtYWtlUHJvbWlzZUtpdFwiLCBbJGjigI1fYSA9PiAobWFrZVByb21pc2VLaXQgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBbW91bnRNYXRoXCIsIFskaOKAjV9hID0+IChBbW91bnRNYXRoID0gJGjigI1fYSldXSxbXCJBbW91bnRTaGFwZVwiLCBbJGjigI1fYSA9PiAoQW1vdW50U2hhcGUgPSAkaOKAjV9hKV1dLFtcIkJyYW5kU2hhcGVcIiwgWyRo4oCNX2EgPT4gKEJyYW5kU2hhcGUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9ub3RpZmllclwiLCBbW1wibWFrZU5vdGlmaWVyXCIsIFskaOKAjV9hID0+IChtYWtlTm90aWZpZXIgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9pbnRlcm5hbFwiLCBbW1wibWFrZVRyYWNlclwiLCBbJGjigI1fYSA9PiAobWFrZVRyYWNlciA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3RpbWVcIiwgW1tcIlRpbWVzdGFtcFNoYXBlXCIsIFskaOKAjV9hID0+IChUaW1lc3RhbXBTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXV1dXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KG1ha2VPbmV3YXlQcmljZUF1dGhvcml0eUtpdCwgJ25hbWUnLCB7dmFsdWU6IFwibWFrZU9uZXdheVByaWNlQXV0aG9yaXR5S2l0XCJ9KTskaOKAjV9vbmNlLm1ha2VPbmV3YXlQcmljZUF1dGhvcml0eUtpdChtYWtlT25ld2F5UHJpY2VBdXRob3JpdHlLaXQpOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0IHRyYWNlPW1ha2VUcmFjZXIoJ1BBJyxmYWxzZSk7XG5cbi8qKlxuICogQGNhbGxiYWNrIENvbXBhcmVBbW91bnRcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnRcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnRMaW1pdFxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cblxuLyoqIEB0eXBlIHtDb21wYXJlQW1vdW50fSAqL1xuY29uc3QgaXNMVD0oYW1vdW50LGFtb3VudExpbWl0KT0+IUFtb3VudE1hdGguaXNHVEUoYW1vdW50LGFtb3VudExpbWl0KTtcblxuLyoqIEB0eXBlIHtDb21wYXJlQW1vdW50fSAqL1xuY29uc3QgaXNMVEU9KGFtb3VudCxhbW91bnRMaW1pdCk9PkFtb3VudE1hdGguaXNHVEUoYW1vdW50TGltaXQsYW1vdW50KTtcblxuLyoqIEB0eXBlIHtDb21wYXJlQW1vdW50fSAqL1xuY29uc3QgaXNHVEU9KGFtb3VudCxhbW91bnRMaW1pdCk9PkFtb3VudE1hdGguaXNHVEUoYW1vdW50LGFtb3VudExpbWl0KTtcblxuLyoqIEB0eXBlIHtDb21wYXJlQW1vdW50fSAqL1xuY29uc3QgaXNHVD0oYW1vdW50LGFtb3VudExpbWl0KT0+IUFtb3VudE1hdGguaXNHVEUoYW1vdW50TGltaXQsYW1vdW50KTtcblxuLyoqXG4gKiBAY2FsbGJhY2sgVHJpZ2dlclxuICogQHBhcmFtIHtQcmljZVF1b3RlQ3JlYXRlfSBjcmVhdGVJbnN0YW50UXVvdGVcbiAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fVxuICovXG5cbmNvbnN0IEd1YXJkQ2FsbEFtb3VudFR1cGxlPU0uY2FsbChBbW91bnRTaGFwZSxBbW91bnRTaGFwZSkucmV0dXJucyhcbk0ucHJvbWlzZSgpKTtcblxuY29uc3QgICAgICAgIFByaWNlQXV0aG9yaXR5ST1NLmludGVyZmFjZSgnUHJpY2VBdXRob3JpdHknLHtcbmdldFF1b3RlSXNzdWVyOk0uY2FsbChCcmFuZFNoYXBlLEJyYW5kU2hhcGUpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuZ2V0VGltZXJTZXJ2aWNlOk0uY2FsbChCcmFuZFNoYXBlLEJyYW5kU2hhcGUpLnJldHVybnMoTS5wcm9taXNlKCkpLFxucXVvdGVHaXZlbjpNLmNhbGwoQW1vdW50U2hhcGUsQnJhbmRTaGFwZSkucmV0dXJucyhNLnByb21pc2UoKSksXG5xdW90ZVdhbnRlZDpNLmNhbGwoQnJhbmRTaGFwZSxBbW91bnRTaGFwZSkucmV0dXJucyhNLnByb21pc2UoKSksXG5tYWtlUXVvdGVOb3RpZmllcjpNLmNhbGwoQW1vdW50U2hhcGUsQnJhbmRTaGFwZSkucmV0dXJucyhNLnByb21pc2UoKSksXG5xdW90ZUF0VGltZTpNLmNhbGwoVGltZXN0YW1wU2hhcGUsQW1vdW50U2hhcGUsQnJhbmRTaGFwZSkucmV0dXJucyhcbk0ucHJvbWlzZSgpKSxcblxucXVvdGVXaGVuTFQ6R3VhcmRDYWxsQW1vdW50VHVwbGUsXG5xdW90ZVdoZW5MVEU6R3VhcmRDYWxsQW1vdW50VHVwbGUsXG5xdW90ZVdoZW5HVEU6R3VhcmRDYWxsQW1vdW50VHVwbGUsXG5xdW90ZVdoZW5HVDpHdWFyZENhbGxBbW91bnRUdXBsZSxcbm11dGFibGVRdW90ZVdoZW5MVDpHdWFyZENhbGxBbW91bnRUdXBsZSxcbm11dGFibGVRdW90ZVdoZW5MVEU6R3VhcmRDYWxsQW1vdW50VHVwbGUsXG5tdXRhYmxlUXVvdGVXaGVuR1RFOkd1YXJkQ2FsbEFtb3VudFR1cGxlLFxubXV0YWJsZVF1b3RlV2hlbkdUOkd1YXJkQ2FsbEFtb3VudFR1cGxlfSk7XG5cblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdH0gb3B0c1xuICogQHBhcmFtIHtJc3N1ZXI8J3NldCc+fSBvcHRzLnF1b3RlSXNzdWVyXG4gKiBAcGFyYW0ge0VSZWY8Tm90aWZpZXI8dW5rbm93bj4+fSBvcHRzLm5vdGlmaWVyXG4gKiBAcGFyYW0ge0VSZWY8WGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVyU2VydmljZT59IG9wdHMudGltZXJcbiAqIEBwYXJhbSB7UHJpY2VRdW90ZUNyZWF0ZX0gb3B0cy5jcmVhdGVRdW90ZVxuICogQHBhcmFtIHtCcmFuZDwnbmF0Jz59IG9wdHMuYWN0dWFsQnJhbmRJblxuICogQHBhcmFtIHtCcmFuZDwnbmF0Jz59IG9wdHMuYWN0dWFsQnJhbmRPdXRcbiAqIEByZXR1cm5zIHtQcmljZUF1dGhvcml0eUtpdH1cbiAqLyRo4oCNX29uY2UuUHJpY2VBdXRob3JpdHlJKFByaWNlQXV0aG9yaXR5SSk7XG5mdW5jdGlvbiAgICAgICAgbWFrZU9uZXdheVByaWNlQXV0aG9yaXR5S2l0KG9wdHMpe1xuY29uc3R7XG50aW1lcixcbmNyZWF0ZVF1b3RlLFxuYWN0dWFsQnJhbmRJbixcbmFjdHVhbEJyYW5kT3V0LFxucXVvdGVJc3N1ZXIsXG5ub3RpZmllcn09XG5vcHRzO1xuXG5sZXQgaGF2ZUZpcnN0UXVvdGU9ZmFsc2U7XG5cbkUobm90aWZpZXIpLlxuZ2V0VXBkYXRlU2luY2UoKS5cbnRoZW4oKF8pPT5oYXZlRmlyc3RRdW90ZT10cnVlKTtcblxuLyoqIEB0eXBlIHtTZXQ8VHJpZ2dlcj59ICovXG5jb25zdCB0cmlnZ2Vycz1uZXcgU2V0KCk7XG5jb25zdCBtdXRhYmxlVHJpZ2dlcnM9bmV3IE1hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UHJpY2VRdW90ZUNyZWF0ZX0gdHJpZ2dlckNyZWF0ZVF1b3RlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn1cbiAqL1xuY29uc3QgZmlyZVRyaWdnZXJzPWFzeW5jKHRyaWdnZXJDcmVhdGVRdW90ZSk9PntcbmlmKCFoYXZlRmlyc3RRdW90ZSl7XG5yZXR1cm47XG4gfVxuYXdhaXQgUHJvbWlzZS5hbGwoXG5bLi4udHJpZ2dlcnMsLi4uQXJyYXkuZnJvbShtdXRhYmxlVHJpZ2dlcnMudmFsdWVzKCkpXS5tYXAoKHRyaWdnZXIpPT5cbnRyaWdnZXIodHJpZ2dlckNyZWF0ZVF1b3RlKSkpO1xuXG5cbiB9O1xuXG4vKipcbiAqIENyZWF0ZSBhIHF1b3RlV2hlbiogZnVuY3Rpb24uXG4gKlxuICogQHBhcmFtIHtDb21wYXJlQW1vdW50fSBjb21wYXJlQW1vdW50c0ZuXG4gKi9cbmNvbnN0IG1ha2VRdW90ZVdoZW5PdXQ9KGNvbXBhcmVBbW91bnRzRm4pPT5cbi8qKlxuICogUmV0dXJuIGEgcXVvdGUgd2hlbiB0cmlnZ2VyV2hlbiBpcyB0cnVlIG9mIHRoZSBhcmd1bWVudHMuXG4gKlxuICogQHBhcmFtIHtBbW91bnQ8J25hdCc+fSBhbW91bnRJbiB0aGUgaW5wdXQgdmFsdWUgdG8gdGhlIGNhbGNBbW91bnRUcmlnZ2VyXG4gKiBAcGFyYW0ge0Ftb3VudH0gYW1vdW50T3V0TGltaXQgdGhlIHZhbHVlIHRvIGNvbXBhcmUgd2l0aCB0aGUgb3V0cHV0XG4gKiBvZiBjYWxjQW1vdW50VHJpZ2dlclxuICovXG5hc3luYyBmdW5jdGlvbiBxdW90ZVdoZW5PdXRUcmlnZ2VyKGFtb3VudEluLGFtb3VudE91dExpbWl0KXtcbmFtb3VudEluPUFtb3VudE1hdGguY29lcmNlKGFjdHVhbEJyYW5kSW4sYW1vdW50SW4pO1xuYW1vdW50T3V0TGltaXQ9QW1vdW50TWF0aC5jb2VyY2UoYWN0dWFsQnJhbmRPdXQsYW1vdW50T3V0TGltaXQpO1xuXG4vKiogQHR5cGUge1Byb21pc2VSZWNvcmQ8UHJpY2VRdW90ZT59ICovXG5jb25zdCB0cmlnZ2VyUEs9bWFrZVByb21pc2VLaXQoKTtcblxuLyoqIEB0eXBlIHtQcmljZVF1b3RlVHJpZ2dlcn0gKi9cbmNvbnN0IHRyaWdnZXI9YXN5bmMoY3JlYXRlSW5zdGFudFF1b3RlKT0+e1xudHJ5e1xuY29uc3QgcXVvdGVQPWNyZWF0ZUluc3RhbnRRdW90ZSgoY2FsY0Ftb3VudE91dCk9PntcbmlmKCF0cmlnZ2Vycy5oYXModHJpZ2dlcikpe1xuLyogQWxyZWFkeSBmaXJlZC4qL1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG5jb25zdCBhbW91bnRPdXQ9Y2FsY0Ftb3VudE91dChhbW91bnRJbik7XG5cbmlmKCFjb21wYXJlQW1vdW50c0ZuKGFtb3VudE91dCxhbW91bnRPdXRMaW1pdCkpe1xuLyogRG9uJ3QgZmlyZSB0aGUgdHJpZ2dlciB5ZXQuKi9cbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuXG4vKiBHZW5lcmF0ZSB0aGUgcXVvdGUuKi9cbnJldHVybnthbW91bnRJbixhbW91bnRPdXR9O1xuIH0pO1xuXG5pZighcXVvdGVQKXtcbi8qIFdlIHNob3VsZG4ndCByZXNvbHZlIHlldC4qL1xucmV0dXJuO1xuIH1cblxudHJpZ2dlcnMuZGVsZXRlKHRyaWdnZXIpO1xudHJpZ2dlclBLLnJlc29sdmUocXVvdGVQKTtcbiB9Y2F0Y2goZSl7XG4vKiBUcmlnZ2VyIGZhaWxlZCwgc28gcmVqZWN0IGFuZCBkcm9wLiovXG50cmlnZ2VyUEsucmVqZWN0KGUpO1xudHJpZ2dlcnMuZGVsZXRlKHRyaWdnZXIpO1xuIH1cbiB9O1xuXG50cmlnZ2Vycy5hZGQodHJpZ2dlcik7XG5cbi8qIEZpcmUgbm93LCBqdXN0IGluIGNhc2UuKi9cbmF3YWl0IHRyaWdnZXIoY3JlYXRlUXVvdGUpO1xuXG5yZXR1cm4gdHJpZ2dlclBLLnByb21pc2U7XG4gfTtcblxuLyoqXG4gKiBDcmVhdGUgYSBtdXRhYmxlUXVvdGVXaGVuKiBmdW5jdGlvbi5cbiAqXG4gKiBAcGFyYW0ge0NvbXBhcmVBbW91bnR9IGNvbXBhcmVBbW91bnRzRm5cbiAqL1xuY29uc3QgbWFrZU11dGFibGVRdW90ZT0oY29tcGFyZUFtb3VudHNGbik9PlxuLyoqXG4gKiBAcGFyYW0ge0Ftb3VudDwnbmF0Jz59IGFtb3VudEluXG4gKiBAcGFyYW0ge0Ftb3VudDwnbmF0Jz59IGFtb3VudE91dExpbWl0XG4gKi9cbmFzeW5jIGZ1bmN0aW9uIG11dGFibGVRdW90ZVdoZW5PdXRUcmlnZ2VyKGFtb3VudEluLGFtb3VudE91dExpbWl0KXtcbkFtb3VudE1hdGguY29lcmNlKGFjdHVhbEJyYW5kSW4sYW1vdW50SW4pO1xuQW1vdW50TWF0aC5jb2VyY2UoYWN0dWFsQnJhbmRPdXQsYW1vdW50T3V0TGltaXQpO1xuXG4vKiogQHR5cGUge1Byb21pc2VSZWNvcmQ8UHJpY2VRdW90ZT59ICovXG5jb25zdCB0cmlnZ2VyUEs9bWFrZVByb21pc2VLaXQoKTtcblxuLyoqIEB0eXBlIHtNdXRhYmxlUXVvdGV9ICovXG5jb25zdCBtdXRhYmxlUXVvdGU9RmFyKCdNdXRhYmxlUXVvdGUnLHtcbmNhbmNlbDooZSk9PnRyaWdnZXJQSy5yZWplY3QoZSksXG51cGRhdGVMZXZlbDoobmV3QW1vdW50SW4sbmV3QW1vdW50T3V0TGltaXQpPT57XG5jb25zdCBjb2VyY2VkQW1vdW50SW49QW1vdW50TWF0aC5jb2VyY2UoYWN0dWFsQnJhbmRJbixuZXdBbW91bnRJbik7XG5jb25zdCBjb2VyY2VkQW1vdW50T3V0TGltaXQ9QW1vdW50TWF0aC5jb2VyY2UoXG5hY3R1YWxCcmFuZE91dCxcbm5ld0Ftb3VudE91dExpbWl0KTtcblxuYW1vdW50SW49Y29lcmNlZEFtb3VudEluO1xuYW1vdW50T3V0TGltaXQ9Y29lcmNlZEFtb3VudE91dExpbWl0O1xuZmlyZVRyaWdnZXJzKGNyZWF0ZVF1b3RlKTtcbiB9LFxuZ2V0UHJvbWlzZTooKT0+dHJpZ2dlclBLLnByb21pc2V9KTtcblxuXG4vKiogQHR5cGUge1ByaWNlUXVvdGVUcmlnZ2VyfSAqL1xuY29uc3QgbXV0YWJsZVRyaWdnZXI9YXN5bmMoY3JlYXRlSW5zdGFudFF1b3RlKT0+e1xudHJ5e1xuY29uc3QgcXVvdGVQPWNyZWF0ZUluc3RhbnRRdW90ZSgoY2FsY0Ftb3VudE91dCk9PntcbmlmKCFtdXRhYmxlVHJpZ2dlcnMuaGFzKG11dGFibGVRdW90ZSkpe1xuLyogQWxyZWFkeSBmaXJlZC4qL1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG5jb25zdCBhbW91bnRPdXQ9Y2FsY0Ftb3VudE91dChhbW91bnRJbik7XG5cbmlmKCFjb21wYXJlQW1vdW50c0ZuKGFtb3VudE91dCxhbW91bnRPdXRMaW1pdCkpe1xuLyogRG9uJ3QgZmlyZSB0aGUgbXV0YWJsZVRyaWdnZXIgeWV0LiovXG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cblxuLyogR2VuZXJhdGUgdGhlIHF1b3RlLiovXG5yZXR1cm57YW1vdW50SW4sYW1vdW50T3V0fTtcbiB9KTtcblxuaWYoIXF1b3RlUCl7XG4vKiBXZSBzaG91bGRuJ3QgcmVzb2x2ZSB5ZXQuKi9cbnJldHVybjtcbiB9XG5cbm11dGFibGVUcmlnZ2Vycy5kZWxldGUobXV0YWJsZVF1b3RlKTtcbnRyaWdnZXJQSy5yZXNvbHZlKHF1b3RlUCk7XG4gfWNhdGNoKGUpe1xuLyogVHJpZ2dlciBmYWlsZWQsIHNvIHJlamVjdCBhbmQgZHJvcC4qL1xudHJpZ2dlclBLLnJlamVjdChlKTtcbm11dGFibGVUcmlnZ2Vycy5kZWxldGUobXV0YWJsZVF1b3RlKTtcbiB9XG4gfTtcblxubXV0YWJsZVRyaWdnZXJzLnNldChtdXRhYmxlUXVvdGUsbXV0YWJsZVRyaWdnZXIpO1xuXG4vKiBGaXJlIG5vdywganVzdCBpbiBjYXNlLiovXG5hd2FpdCBtdXRhYmxlVHJpZ2dlcihjcmVhdGVRdW90ZSk7XG5cbnJldHVybiBtdXRhYmxlUXVvdGU7XG4gfTtcblxuLyoqXG4gKiBFbnN1cmUgdGhhdCB0aGUgYnJhbmRJbi9icmFuZE91dCBwYWlyIGlzIHN1cHBvcnRlZC5cbiAqXG4gKiBAcGFyYW0ge0JyYW5kfSBicmFuZEluXG4gKiBAcGFyYW0ge0JyYW5kfSBicmFuZE91dFxuICovXG5jb25zdCBhc3NlcnRCcmFuZHM9KGJyYW5kSW4sYnJhbmRPdXQpPT57XG5icmFuZEluPT09YWN0dWFsQnJhbmRJbnx8XG5GYWlsIGBEZXNpcmVkIGJyYW5kSW4gJHtxKGJyYW5kSW4pfSBtdXN0IG1hdGNoICR7cShhY3R1YWxCcmFuZEluKX1gO1xuYnJhbmRPdXQ9PT1hY3R1YWxCcmFuZE91dHx8XG5GYWlsIGBEZXNpcmVkIGJyYW5kT3V0ICR7cShicmFuZE91dCl9IG11c3QgbWF0Y2ggJHtxKGFjdHVhbEJyYW5kT3V0KX1gO1xuIH07XG5cbi8qKiBAdHlwZSB7UHJpY2VBdXRob3JpdHl9ICovXG5jb25zdCBwcmljZUF1dGhvcml0eT1GYXIoJ1ByaWNlQXV0aG9yaXR5Jyx7XG5nZXRRdW90ZUlzc3VlcihicmFuZEluLGJyYW5kT3V0KXtcbmFzc2VydEJyYW5kcyhicmFuZEluLGJyYW5kT3V0KTtcbnJldHVybiBxdW90ZUlzc3VlcjtcbiB9LFxuZ2V0VGltZXJTZXJ2aWNlKGJyYW5kSW4sYnJhbmRPdXQpe1xuYXNzZXJ0QnJhbmRzKGJyYW5kSW4sYnJhbmRPdXQpO1xucmV0dXJuIHRpbWVyO1xuIH0sXG5tYWtlUXVvdGVOb3RpZmllcihhbW91bnRJbixicmFuZE91dCl7XG5BbW91bnRNYXRoLmNvZXJjZShhY3R1YWxCcmFuZEluLGFtb3VudEluKTtcbmFzc2VydEJyYW5kcyhhbW91bnRJbi5icmFuZCxicmFuZE91dCk7XG5cbi8qIFdyYXAgb3VyIHVuZGVybHlpbmcgbm90aWZpZXIgd2l0aCBzcGVjaWZpYyBxdW90ZXMuKi9cbmNvbnN0IHNwZWNpZmljQmFzZU5vdGlmaWVyPWhhcmRlbih7XG4gICAgICBhc3luYyBnZXRVcGRhdGVTaW5jZSh1cGRhdGVDb3VudD11bmRlZmluZWQpe1xuLyogV2UgdXNlIHRoZSBzYW1lIHVwZGF0ZUNvdW50IGFzIG91ciB1bmRlcmx5aW5nIG5vdGlmaWVyLiovXG5jb25zdCByZWNvcmQ9YXdhaXQgRShub3RpZmllcikuZ2V0VXBkYXRlU2luY2UodXBkYXRlQ291bnQpO1xuXG4vKiBXZSBjcmVhdGUgYSBxdW90ZSBpbmxpbmUuKi9cbmNvbnN0IHF1b3RlPWNyZWF0ZVF1b3RlKChjYWxjQW1vdW50T3V0KT0+KHtcbmFtb3VudEluLFxuYW1vdW50T3V0OmNhbGNBbW91bnRPdXQoYW1vdW50SW4pfSkpO1xuXG5pZighcXVvdGUpe1xudGhyb3cgRmFpbCBgY3JlYXRlUXVvdGUgcmV0dXJuZWQgZmFsc2V5YDtcbiB9XG5cbmNvbnN0IHZhbHVlPWF3YWl0IHF1b3RlO1xucmV0dXJuIGhhcmRlbih7XG52YWx1ZSxcbnVwZGF0ZUNvdW50OnJlY29yZC51cGRhdGVDb3VudH0pO1xuXG4gfX0pO1xuXG5cbi8qKiBAdHlwZSB7Tm90aWZpZXI8UHJpY2VRdW90ZT59ICovXG5jb25zdCBzcGVjaWZpY05vdGlmaWVyPUZhcignUXVvdGVOb3RpZmllcicse1xuLi4ubWFrZU5vdGlmaWVyKHNwZWNpZmljQmFzZU5vdGlmaWVyKSxcbi8qIFRPRE8gc3RvcCBleHBvc2luZyBiYXNlTm90aWZpZXIgbWV0aG9kcyBkaXJlY3RseS4qL1xuLi4uc3BlY2lmaWNCYXNlTm90aWZpZXJ9KTtcblxucmV0dXJuIHNwZWNpZmljTm90aWZpZXI7XG4gfSxcbiAgICAgIGFzeW5jIHF1b3RlR2l2ZW4oYW1vdW50SW4sYnJhbmRPdXQpe1xudHJhY2UoJ3F1b3RlR2l2ZW4nLGFtb3VudEluLGJyYW5kT3V0KTtcbkFtb3VudE1hdGguY29lcmNlKGFjdHVhbEJyYW5kSW4sYW1vdW50SW4pO1xuYXNzZXJ0QnJhbmRzKGFtb3VudEluLmJyYW5kLGJyYW5kT3V0KTtcblxuYXdhaXQgRShub3RpZmllcikuZ2V0VXBkYXRlU2luY2UoKTtcbmNvbnN0IHF1b3RlPWNyZWF0ZVF1b3RlKChjYWxjQW1vdW50T3V0KT0+KHtcbmFtb3VudEluLFxuYW1vdW50T3V0OmNhbGNBbW91bnRPdXQoYW1vdW50SW4pfSkpO1xuXG5hc3NlcnQocXVvdGUpO1xucmV0dXJuIHF1b3RlO1xuIH0sXG4gICAgICBhc3luYyBxdW90ZVdhbnRlZChicmFuZEluLGFtb3VudE91dCl7XG5BbW91bnRNYXRoLmNvZXJjZShhY3R1YWxCcmFuZE91dCxhbW91bnRPdXQpO1xuYXNzZXJ0QnJhbmRzKGJyYW5kSW4sYW1vdW50T3V0LmJyYW5kKTtcblxuYXdhaXQgRShub3RpZmllcikuZ2V0VXBkYXRlU2luY2UoKTtcbmNvbnN0IHF1b3RlPWNyZWF0ZVF1b3RlKChjYWxjQW1vdW50T3V0LGNhbGNBbW91bnRJbik9Pntcbi8qIFdlIG5lZWQgdG8gZGV0ZXJtaW5lIGFuIGFtb3VudEluIHRoYXQgZ3VhcmFudGVlcyBhdCBsZWFzdCB0aGUgYW1vdW50T3V0LiovXG5jb25zdCBhbW91bnRJbj1jYWxjQW1vdW50SW4oYW1vdW50T3V0KTtcbmNvbnN0IGFjdHVhbEFtb3VudE91dD1jYWxjQW1vdW50T3V0KGFtb3VudEluKTtcbkFtb3VudE1hdGguaXNHVEUoYWN0dWFsQW1vdW50T3V0LGFtb3VudE91dCl8fFxuRmFpbCBgQ2FsY3VsYXRpb24gb2YgJHthY3R1YWxBbW91bnRPdXR9IGRpZG4ndCBjb3ZlciBleHBlY3RlZCAke2Ftb3VudE91dH1gO1xucmV0dXJue2Ftb3VudEluLGFtb3VudE91dH07XG4gfSk7XG5hc3NlcnQocXVvdGUpO1xucmV0dXJuIHF1b3RlO1xuIH0sXG4gICAgICBhc3luYyBxdW90ZUF0VGltZShkZWFkbGluZSxhbW91bnRJbixicmFuZE91dCl7XG5BbW91bnRNYXRoLmNvZXJjZShhY3R1YWxCcmFuZEluLGFtb3VudEluKTtcbmFzc2VydEJyYW5kcyhhbW91bnRJbi5icmFuZCxicmFuZE91dCk7XG5cbmF3YWl0IEUobm90aWZpZXIpLmdldFVwZGF0ZVNpbmNlKCk7XG5jb25zdCBxdW90ZVBLPW1ha2VQcm9taXNlS2l0KCk7XG5hd2FpdCBFKHRpbWVyKS5zZXRXYWtldXAoXG5kZWFkbGluZSxcbkZhcignd2FrZU9iaicse1xuICAgICAgYXN5bmMgd2FrZSh0aW1lc3RhbXApe1xudHJ5e1xuY29uc3QgcXVvdGVQPWNyZWF0ZVF1b3RlKChjYWxjQW1vdW50T3V0KT0+KHtcbmFtb3VudEluLFxuYW1vdW50T3V0OmNhbGNBbW91bnRPdXQoYW1vdW50SW4pLFxudGltZXN0YW1wfSkpO1xuXG5cbi8qIFdlIGRvbid0IHdhaXQgZm9yIHRoZSBxdW90ZSB0byBiZSBhdXRoZW50aWNhdGVkOyByZXNvbHZlKi9cbi8qIGltbWVkaWF0ZWx5LiovXG5xdW90ZVBLLnJlc29sdmUocXVvdGVQKTtcbmF3YWl0IHF1b3RlUEsucHJvbWlzZTtcbiB9Y2F0Y2goZSl7XG5xdW90ZVBLLnJlamVjdChlKTtcbiB9XG4gfX0pKTtcblxuXG5cbi8qIFdhaXQgdW50aWwgdGhlIHdha2V1cCBwYXNzZXMuKi9cbnJldHVybiBxdW90ZVBLLnByb21pc2U7XG4gfSxcbnF1b3RlV2hlbkxUOm1ha2VRdW90ZVdoZW5PdXQoaXNMVCksXG5xdW90ZVdoZW5MVEU6bWFrZVF1b3RlV2hlbk91dChpc0xURSksXG5xdW90ZVdoZW5HVEU6bWFrZVF1b3RlV2hlbk91dChpc0dURSksXG5xdW90ZVdoZW5HVDptYWtlUXVvdGVXaGVuT3V0KGlzR1QpLFxubXV0YWJsZVF1b3RlV2hlbkxUOm1ha2VNdXRhYmxlUXVvdGUoaXNMVCksXG5tdXRhYmxlUXVvdGVXaGVuTFRFOm1ha2VNdXRhYmxlUXVvdGUoaXNMVEUpLFxubXV0YWJsZVF1b3RlV2hlbkdUOm1ha2VNdXRhYmxlUXVvdGUoaXNHVCksXG5tdXRhYmxlUXVvdGVXaGVuR1RFOm1ha2VNdXRhYmxlUXVvdGUoaXNHVEUpfSk7XG5cblxucmV0dXJue3ByaWNlQXV0aG9yaXR5LGFkbWluRmFjZXQ6e2ZpcmVUcmlnZ2Vyc319O1xuIH1cbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJQcmljZUF1dGhvcml0eUkiOlsiUHJpY2VBdXRob3JpdHlJIl0sIm1ha2VPbmV3YXlQcmljZUF1dGhvcml0eUtpdCI6WyJtYWtlT25ld2F5UHJpY2VBdXRob3JpdHlLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAiB7sqfQIAAD0CAAAOwAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9wcmljZVF1b3RlLmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvZXJ0cCIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9uYXQiXSwiZXhwb3J0cyI6WyJnZXRBbW91bnRJbiIsImdldEFtb3VudE91dCIsImdldFByaWNlRGVzY3JpcHRpb24iLCJnZXRUaW1lc3RhbXAiLCJ1bml0QW1vdW50Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEFtb3VudE1hdGgsTmF0LEU7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBbW91bnRNYXRoXCIsIFskaOKAjV9hID0+IChBbW91bnRNYXRoID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL25hdFwiLCBbW1wiTmF0XCIsIFskaOKAjV9hID0+IChOYXQgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cbmNvbnN0e0ZhaWx9PWFzc2VydDtcblxuLyogUHJpY2VBdXRob3JpdGllcyByZXR1cm4gcXVvdGVzIGFzIGEgcGFpciBvZiBhbiBhbW91bnQgYW5kIGEgcGF5bWVudCwgYm90aCovXG4vKiB3aXRoIHRoZSBzYW1lIHZhbHVlLiBUaGUgdW5kZXJseWluZyBhbW91bnQgd3JhcHMgYW1vdW50SW4sIGFtb3VudE91dCwgdGltZXIqL1xuLyogYW5kIHRpbWVzdGFtcC4gVGhlIHBheW1lbnQgaXMgaXNzdWVkIGJ5IHRoZSBxdW90ZUlzc3VlciB0byBzdXBwb3J0IHZlcmFjaXR5Ki9cbi8qIGNoZWNraW5nLiBUaGVzZSBoZWxwZXJzIG1ha2UgaXQgZWFzaWVyIHRvIGV4dHJhY3QgdGhlIGNvbXBvbmVudHMgb2YgdGhlIFF1b3RlKi9cblxuLyoqXG4gKiBAcGFyYW0ge1ByaWNlUXVvdGV9IHF1b3RlXG4gKiBAcmV0dXJucyB7UHJpY2VEZXNjcmlwdGlvbn1cbiAqL1xuY29uc3QgICAgICAgIGdldFByaWNlRGVzY3JpcHRpb249KHF1b3RlKT0+e1xucXVvdGUucXVvdGVBbW91bnQudmFsdWUubGVuZ3RoPT09MXx8XG5GYWlsIGBxdW90ZUFtb3VudCBzZXQgbXVzdCBoYXZlIG9uZSBtZW1iZXJgO1xucmV0dXJuIHF1b3RlLnF1b3RlQW1vdW50LnZhbHVlWzBdO1xuIH07XG5cbi8qKiBAcGFyYW0ge1ByaWNlUXVvdGV9IHF1b3RlICovJGjigI1fb25jZS5nZXRQcmljZURlc2NyaXB0aW9uKGdldFByaWNlRGVzY3JpcHRpb24pO1xuY29uc3QgICAgICAgIGdldEFtb3VudEluPShxdW90ZSk9PmdldFByaWNlRGVzY3JpcHRpb24ocXVvdGUpLmFtb3VudEluO1xuLyoqIEBwYXJhbSB7UHJpY2VRdW90ZX0gcXVvdGUgKi8kaOKAjV9vbmNlLmdldEFtb3VudEluKGdldEFtb3VudEluKTtcbmNvbnN0ICAgICAgICBnZXRBbW91bnRPdXQ9KHF1b3RlKT0+Z2V0UHJpY2VEZXNjcmlwdGlvbihxdW90ZSkuYW1vdW50T3V0O1xuLyoqIEB0eXBlIHsocXVvdGU6IFByaWNlUXVvdGUpID0+IFhpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lc3RhbXB9ICovJGjigI1fb25jZS5nZXRBbW91bnRPdXQoZ2V0QW1vdW50T3V0KTtcbmNvbnN0ICAgICAgICBnZXRUaW1lc3RhbXA9KHF1b3RlKT0+Z2V0UHJpY2VEZXNjcmlwdGlvbihxdW90ZSkudGltZXN0YW1wO1xuXG4vKiogQHBhcmFtIHtCcmFuZDwnbmF0Jz59IGJyYW5kICovJGjigI1fb25jZS5nZXRUaW1lc3RhbXAoZ2V0VGltZXN0YW1wKTtcbmNvbnN0ICAgICAgICB1bml0QW1vdW50PWFzeW5jKGJyYW5kKT0+e1xuLyogQnJhbmQgbWV0aG9kcyBhcmUgcmVtb3RlKi9cbmNvbnN0IGRpc3BsYXlJbmZvPWF3YWl0IEUoYnJhbmQpLmdldERpc3BsYXlJbmZvKCk7XG5jb25zdCBkZWNpbWFsUGxhY2VzPWRpc3BsYXlJbmZvLmRlY2ltYWxQbGFjZXM/PzA7XG5yZXR1cm4gQW1vdW50TWF0aC5tYWtlKGJyYW5kLDEwbioqTmF0KGRlY2ltYWxQbGFjZXMpKTtcbiB9OyRo4oCNX29uY2UudW5pdEFtb3VudCh1bml0QW1vdW50KTtcbmhhcmRlbih1bml0QW1vdW50KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRQcmljZURlc2NyaXB0aW9uIjpbImdldFByaWNlRGVzY3JpcHRpb24iXSwiZ2V0QW1vdW50SW4iOlsiZ2V0QW1vdW50SW4iXSwiZ2V0QW1vdW50T3V0IjpbImdldEFtb3VudE91dCJdLCJnZXRUaW1lc3RhbXAiOlsiZ2V0VGltZXN0YW1wIl0sInVuaXRBbW91bnQiOlsidW5pdEFtb3VudCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACtxV1LvDYAALw2AAA2AAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L3JhdGlvLmpzeyJpbXBvcnRzIjpbIi4vc2FmZU1hdGguanMiLCIuL3R5cGVzLmpzIiwiQGFnb3JpYy9hc3NlcnQiLCJAYWdvcmljL2VydHAiLCJAZW5kby9tYXJzaGFsIiwiQGVuZG8vbmF0Il0sImV4cG9ydHMiOlsiYWRkUmF0aW9zIiwiYXNzZXJ0SXNSYXRpbyIsImFzc2VydFBhcnNhYmxlTnVtYmVyIiwiY2VpbERpdmlkZUJ5IiwiY2VpbE11bHRpcGx5QnkiLCJkaXZpZGVCeSIsImZsb29yRGl2aWRlQnkiLCJmbG9vck11bHRpcGx5QnkiLCJpbnZlcnRSYXRpbyIsIm1ha2VSYXRpbyIsIm1ha2VSYXRpb0Zyb21BbW91bnRzIiwibXVsdGlwbHlCeSIsIm11bHRpcGx5UmF0aW9zIiwib25lTWludXMiLCJwYXJzZVJhdGlvIiwicXVhbnRpemUiLCJyYXRpb0dURSIsInJhdGlvVG9OdW1iZXIiLCJyYXRpb3NTYW1lIiwic3VidHJhY3RSYXRpb3MiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcSxGYWlsLEFtb3VudE1hdGgsYXNzZXJ0UmVjb3JkLGlzTmF0LG5hdFNhZmVNYXRoOyRo4oCNX2ltcG9ydHMoW1tcIi4vdHlwZXMuanNcIiwgW11dLFtcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJxXCIsIFskaOKAjV9hID0+IChxID0gJGjigI1fYSldXSxbXCJGYWlsXCIsIFskaOKAjV9hID0+IChGYWlsID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvZXJ0cFwiLCBbW1wiQW1vdW50TWF0aFwiLCBbJGjigI1fYSA9PiAoQW1vdW50TWF0aCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRSZWNvcmRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlY29yZCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9uYXRcIiwgW1tcImlzTmF0XCIsIFskaOKAjV9hID0+IChpc05hdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3NhZmVNYXRoLmpzXCIsIFtbXCJuYXRTYWZlTWF0aFwiLCBbJGjigI1fYSA9PiAobmF0U2FmZU1hdGggPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuY29uc3R7bXVsdGlwbHksZmxvb3JEaXZpZGUsY2VpbERpdmlkZSxiYW5rZXJzRGl2aWRlLGFkZCxzdWJ0cmFjdH09XG5uYXRTYWZlTWF0aDtcblxuLyogbWFrZSBhIFJhdGlvLCB3aGljaCByZXByZXNlbnRzIGEgZnJhY3Rpb24uIEl0IGlzIGEgcGFzcy1ieS1jb3B5IHJlY29yZC4qL1xuLyoqL1xuLyogVGhlIG5hdHVyYWwgc3ludGF4IGZvciB0aGUgbW9zdCBjb21tb24gb3BlcmF0aW9ucyB3ZSB3YW50IHRvIHN1cHBvcnQqL1xuLyogYXJlIEFtb3VudCAqIFJhdGlvIGFuZCBBbW91bnQgLyBSYXRpby4gU2luY2UgdGhlIG9wZXJhdGlvbnMgd2FudCB0byBhZGhlcmUgdG8qL1xuLyogdGhlIHJhdGlvIHJhdGhlciB0aGFuIHRoZSBhbW91bnQsIHdlIHNldHRsZWQgb24gYSBjYWxsaW5nIGNvbnZlbnRpb24gb2YqL1xuLyogW2NlaWx8Zmxvb3JdTXVsdGlwbHlCeShBbW91bnQsIFJhdGlvKSBhbmQgW2NlaWx8Zmxvb3JdRGl2aWRlQnkoQW1vdW50LCBSYXRpbykqL1xuLyoqL1xuLyogVGhlIG1vc3QgY29tbW9uIGtpbmQgb2YgUmF0aW8gY2FuIGJlIGFwcGxpZWQgdG8gQW1vdW50cyBvZiBhIHBhcnRpY3VsYXIqL1xuLyogYnJhbmQsIGFuZCBwcm9kdWNlcyByZXN1bHRzIG9mIHRoZSBzYW1lIGJyYW5kLiBUaGlzIHJlcHJlc2VudHMgYSBtdWx0aXBsaWVyKi9cbi8qIHRoYXQgaXMgb25seSBhcHBsaWNhYmxlIHRvIHRoYXQgYnJhbmQuIFRoZSBsZXNzIGNvbW1vbiBraW5kIG9mIFJhdGlvIGNhbiBiZSovXG4vKiBhcHBsaWVkIHRvIG9uZSBwYXJ0aWN1bGFyIGJyYW5kIG9mIGFtb3VudHMsIGFuZCBwcm9kdWNlcyByZXN1bHRzIG9mIGFub3RoZXIqL1xuLyogcGFydGljdWxhciBicmFuZC4gVGhpcyByZXByZXNlbnRzIHNvbWUga2luZCBvZiBleGNoYW5nZSByYXRlLiBUaGUqL1xuLyogYnJhbmQtY2hlY2tpbmcgaGVscHMgdXMgZW5zdXJlIHRoYXQgbm9ybWFsIFJhdGlvcyBhcmVuJ3QgYXBwbGllZCB0byBhbW91bnRzKi9cbi8qIG9mIHRoZSB3cm9uZyBicmFuZCwgYW5kIHRoYXQgZXhjaGFuZ2UgcmF0ZXMgYXJlIG9ubHkgdXNlZCBpbiB0aGUgYXBwcm9wcmlhdGUqL1xuLyogZGlyZWN0aW9uLiovXG4vKiovXG4vKiBTaW5jZSB0aGUgcmF0aW9zIGFyZSByZXByZXNlbnRlZCBieSBhIG51bWVyYXRvciBhbmQgYSBkZW5vbWluYXRvciwgZXZlcnkqL1xuLyogbXVsdGlwbGljYXRpb24gb3IgZGl2aXNpb24gb3BlcmF0aW9uIHRoYXQgcHJvZHVjZXMgYW4gYW1vdW50IGVuZHMgd2l0aCBhKi9cbi8qIGRpdmlzaW9uIG9mIHRoZSB1bmRlcmx5aW5nIGJpZ2ludHMsIGFuZCBpbnRlZ2VyIGRpdmlzaW9uIHJlcXVpcmVzIGEgbW9kZSovXG4vKiBvZiBbcm91bmRpbmcgdG8gaW50ZWdlcl0oaHR0cHM6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvUm91bmRpbmcjUm91bmRpbmdfdG9faW50ZWdlcikuKi9cbi8qIEJlY2F1c2UgYFJhdGlvYCBvbmx5IHdvcmsgd2l0aCBOYXR1cmFsIG51bWJlcnMsIGp1c3QgdGhyZWUgbW9kZXMgc3VmZmljZToqL1xuLyogLSBmbG9vciByb3VuZHMgZG93biovXG4vKiAtIGNlaWwgcm91bmRzIHVwKi9cbi8qIC0gZGVmYXVsdCAod2l0aG91dCBwcmVmaXgpIG1pbmltaXplcyBiaWFzIGJ5IHJvdW5kaW5nIGhhbGYgdG8gZXZlbiovXG5cbmNvbnN0IFBFUkNFTlQ9MTAwbjtcblxuY29uc3QgcmF0aW9Qcm9wZXJ0eU5hbWVzPVsnbnVtZXJhdG9yJywnZGVub21pbmF0b3InXTtcblxuY29uc3QgICAgICAgIGFzc2VydElzUmF0aW89KHJhdGlvKT0+e1xuYXNzZXJ0UmVjb3JkKHJhdGlvLCdyYXRpbycpO1xuY29uc3Qga2V5cz1PYmplY3Qua2V5cyhyYXRpbyk7XG5rZXlzLmxlbmd0aD09PTJ8fEZhaWwgYFJhdGlvICR7cmF0aW99IG11c3QgYmUgYSByZWNvcmQgd2l0aCAyIGZpZWxkcy5gO1xuZm9yKGNvbnN0IG5hbWUgb2Yga2V5cyl7XG5yYXRpb1Byb3BlcnR5TmFtZXMuaW5jbHVkZXMobmFtZSl8fFxuRmFpbCBgUGFyYW1ldGVyIG11c3QgYmUgYSBSYXRpbyByZWNvcmQsIGJ1dCAke3JhdGlvfSBoYXMgJHtxKG5hbWUpfWA7XG4gfVxuY29uc3QgbnVtZXJhdG9yVmFsdWU9cmF0aW8ubnVtZXJhdG9yLnZhbHVlO1xuY29uc3QgZGVub21pbmF0b3JWYWx1ZT1yYXRpby5kZW5vbWluYXRvci52YWx1ZTtcbmlzTmF0KG51bWVyYXRvclZhbHVlKXx8XG5GYWlsIGBUaGUgbnVtZXJhdG9yIHZhbHVlIG11c3QgYmUgYSBOYXRWYWx1ZSwgbm90ICR7bnVtZXJhdG9yVmFsdWV9YDtcbmlzTmF0KGRlbm9taW5hdG9yVmFsdWUpfHxcbkZhaWwgYFRoZSBkZW5vbWluYXRvciB2YWx1ZSBtdXN0IGJlIGEgTmF0VmFsdWUsIG5vdCAke2Rlbm9taW5hdG9yVmFsdWV9YDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7YmlnaW50fSBudW1lcmF0b3JcbiAqIEBwYXJhbSB7QnJhbmR9IG51bWVyYXRvckJyYW5kXG4gKiBAcGFyYW0ge2JpZ2ludH0gW2Rlbm9taW5hdG9yXSBUaGUgZGVmYXVsdCBkZW5vbWluYXRvciBpcyAxMDBcbiAqIEBwYXJhbSB7QnJhbmR9IFtkZW5vbWluYXRvckJyYW5kXSBUaGUgZGVmYXVsdCBpcyB0byByZXVzZSB0aGUgbnVtZXJhdG9yQnJhbmRcbiAqIEByZXR1cm5zIHtSYXRpb31cbiAqLyRo4oCNX29uY2UuYXNzZXJ0SXNSYXRpbyhhc3NlcnRJc1JhdGlvKTtcbmNvbnN0ICAgICAgICBtYWtlUmF0aW89KFxubnVtZXJhdG9yLFxubnVtZXJhdG9yQnJhbmQsXG5kZW5vbWluYXRvcj1QRVJDRU5ULFxuZGVub21pbmF0b3JCcmFuZD1udW1lcmF0b3JCcmFuZCk9Plxue1xuZGVub21pbmF0b3I+MG58fFxuRmFpbCBgTm8gaW5maW5pdGUgcmF0aW9zISBEZW5vbWluYXRvciB3YXMgMCAke3EoZGVub21pbmF0b3JCcmFuZCl9YDtcblxuLyogQHRzLWV4cGVjdC1lcnJvciBjYXN0IHRvIHJldHVybiB0eXBlIGJlY2F1c2UgbWFrZSgpIGVuc3VyZXMqL1xucmV0dXJuIGhhcmRlbih7XG5udW1lcmF0b3I6QW1vdW50TWF0aC5tYWtlKG51bWVyYXRvckJyYW5kLG51bWVyYXRvciksXG5kZW5vbWluYXRvcjpBbW91bnRNYXRoLm1ha2UoZGVub21pbmF0b3JCcmFuZCxkZW5vbWluYXRvcil9KTtcblxuIH07XG5cbi8qKlxuICogQHBhcmFtIHtBbW91bnR9IG51bWVyYXRvckFtb3VudFxuICogQHBhcmFtIHtBbW91bnR9IGRlbm9taW5hdG9yQW1vdW50XG4gKiBAcmV0dXJucyB7UmF0aW99XG4gKi8kaOKAjV9vbmNlLm1ha2VSYXRpbyhtYWtlUmF0aW8pO1xuY29uc3QgICAgICAgIG1ha2VSYXRpb0Zyb21BbW91bnRzPShudW1lcmF0b3JBbW91bnQsZGVub21pbmF0b3JBbW91bnQpPT57XG5BbW91bnRNYXRoLmNvZXJjZShudW1lcmF0b3JBbW91bnQuYnJhbmQsbnVtZXJhdG9yQW1vdW50KTtcbkFtb3VudE1hdGguY29lcmNlKGRlbm9taW5hdG9yQW1vdW50LmJyYW5kLGRlbm9taW5hdG9yQW1vdW50KTtcbnJldHVybiBtYWtlUmF0aW8oXG4vKiBAdHMtZXhwZWN0LWVycm9yIHZhbHVlIGNhbiBiZSBhbnkgQW1vdW50VmFsdWUgYnV0IG1ha2VSYXRpbygpIHN1cHBvcnRzIG9ubHkgYmlnaW50Ki9cbm51bWVyYXRvckFtb3VudC52YWx1ZSxcbm51bWVyYXRvckFtb3VudC5icmFuZCxcbmRlbm9taW5hdG9yQW1vdW50LnZhbHVlLFxuZGVub21pbmF0b3JBbW91bnQuYnJhbmQpO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge0Ftb3VudDwnbmF0Jz59IGFtb3VudFxuICogQHBhcmFtIHtSYXRpb30gcmF0aW9cbiAqIEBwYXJhbSB7Kn0gZGl2aWRlT3BcbiAqLyRo4oCNX29uY2UubWFrZVJhdGlvRnJvbUFtb3VudHMobWFrZVJhdGlvRnJvbUFtb3VudHMpO1xuY29uc3QgbXVsdGlwbHlIZWxwZXI9KGFtb3VudCxyYXRpbyxkaXZpZGVPcCk9PntcbkFtb3VudE1hdGguY29lcmNlKGFtb3VudC5icmFuZCxhbW91bnQpO1xuYXNzZXJ0SXNSYXRpbyhyYXRpbyk7XG5hbW91bnQuYnJhbmQ9PT1yYXRpby5kZW5vbWluYXRvci5icmFuZHx8XG5GYWlsIGBhbW91bnQncyBicmFuZCAke3EoYW1vdW50LmJyYW5kKX0gbXVzdCBtYXRjaCByYXRpbydzIGRlbm9taW5hdG9yICR7cShcbnJhdGlvLmRlbm9taW5hdG9yLmJyYW5kKVxuIH1gO1xuXG5yZXR1cm4gQW1vdW50TWF0aC5tYWtlKFxucmF0aW8ubnVtZXJhdG9yLmJyYW5kLFxuZGl2aWRlT3AoXG5tdWx0aXBseShhbW91bnQudmFsdWUscmF0aW8ubnVtZXJhdG9yLnZhbHVlKSxcbnJhdGlvLmRlbm9taW5hdG9yLnZhbHVlKSk7XG5cblxuIH07XG5cbi8qKiBAdHlwZSB7U2NhbGVBbW91bnR9ICovXG5jb25zdCAgICAgICAgZmxvb3JNdWx0aXBseUJ5PShhbW91bnQscmF0aW8pPT57XG5yZXR1cm4gbXVsdGlwbHlIZWxwZXIoYW1vdW50LHJhdGlvLGZsb29yRGl2aWRlKTtcbiB9O1xuXG4vKiogQHR5cGUge1NjYWxlQW1vdW50fSAqLyRo4oCNX29uY2UuZmxvb3JNdWx0aXBseUJ5KGZsb29yTXVsdGlwbHlCeSk7XG5jb25zdCAgICAgICAgY2VpbE11bHRpcGx5Qnk9KGFtb3VudCxyYXRpbyk9PntcbnJldHVybiBtdWx0aXBseUhlbHBlcihhbW91bnQscmF0aW8sY2VpbERpdmlkZSk7XG4gfTtcblxuLyoqIEB0eXBlIHtTY2FsZUFtb3VudH0gKi8kaOKAjV9vbmNlLmNlaWxNdWx0aXBseUJ5KGNlaWxNdWx0aXBseUJ5KTtcbmNvbnN0ICAgICAgICBtdWx0aXBseUJ5PShhbW91bnQscmF0aW8pPT57XG5yZXR1cm4gbXVsdGlwbHlIZWxwZXIoYW1vdW50LHJhdGlvLGJhbmtlcnNEaXZpZGUpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtBbW91bnQ8J25hdCc+fSBhbW91bnRcbiAqIEBwYXJhbSB7UmF0aW99IHJhdGlvXG4gKiBAcGFyYW0geyp9IGRpdmlkZU9wXG4gKi8kaOKAjV9vbmNlLm11bHRpcGx5QnkobXVsdGlwbHlCeSk7XG5jb25zdCBkaXZpZGVIZWxwZXI9KGFtb3VudCxyYXRpbyxkaXZpZGVPcCk9PntcbkFtb3VudE1hdGguY29lcmNlKGFtb3VudC5icmFuZCxhbW91bnQpO1xuYXNzZXJ0SXNSYXRpbyhyYXRpbyk7XG5hbW91bnQuYnJhbmQ9PT1yYXRpby5udW1lcmF0b3IuYnJhbmR8fFxuRmFpbCBgYW1vdW50J3MgYnJhbmQgJHtxKGFtb3VudC5icmFuZCl9IG11c3QgbWF0Y2ggcmF0aW8ncyBudW1lcmF0b3IgJHtxKFxucmF0aW8ubnVtZXJhdG9yLmJyYW5kKVxuIH1gO1xuXG5yZXR1cm4gQW1vdW50TWF0aC5tYWtlKFxucmF0aW8uZGVub21pbmF0b3IuYnJhbmQsXG5kaXZpZGVPcChcbm11bHRpcGx5KGFtb3VudC52YWx1ZSxyYXRpby5kZW5vbWluYXRvci52YWx1ZSksXG5yYXRpby5udW1lcmF0b3IudmFsdWUpKTtcblxuXG4gfTtcblxuLyoqIEB0eXBlIHtTY2FsZUFtb3VudH0gKi9cbmNvbnN0ICAgICAgICBmbG9vckRpdmlkZUJ5PShhbW91bnQscmF0aW8pPT57XG5yZXR1cm4gZGl2aWRlSGVscGVyKGFtb3VudCxyYXRpbyxmbG9vckRpdmlkZSk7XG4gfTtcblxuLyoqIEB0eXBlIHtTY2FsZUFtb3VudH0gKi8kaOKAjV9vbmNlLmZsb29yRGl2aWRlQnkoZmxvb3JEaXZpZGVCeSk7XG5jb25zdCAgICAgICAgY2VpbERpdmlkZUJ5PShhbW91bnQscmF0aW8pPT57XG5yZXR1cm4gZGl2aWRlSGVscGVyKGFtb3VudCxyYXRpbyxjZWlsRGl2aWRlKTtcbiB9O1xuXG4vKiogQHR5cGUge1NjYWxlQW1vdW50fSAqLyRo4oCNX29uY2UuY2VpbERpdmlkZUJ5KGNlaWxEaXZpZGVCeSk7XG5jb25zdCAgICAgICAgZGl2aWRlQnk9KGFtb3VudCxyYXRpbyk9PntcbnJldHVybiBkaXZpZGVIZWxwZXIoYW1vdW50LHJhdGlvLGJhbmtlcnNEaXZpZGUpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtSYXRpb30gcmF0aW9cbiAqIEByZXR1cm5zIHtSYXRpb31cbiAqLyRo4oCNX29uY2UuZGl2aWRlQnkoZGl2aWRlQnkpO1xuY29uc3QgICAgICAgIGludmVydFJhdGlvPShyYXRpbyk9PntcbmFzc2VydElzUmF0aW8ocmF0aW8pO1xuXG5yZXR1cm4gbWFrZVJhdGlvKFxuLyoqIEB0eXBlIHtOYXRWYWx1ZX0gKi9yYXRpby5kZW5vbWluYXRvci52YWx1ZSxcbnJhdGlvLmRlbm9taW5hdG9yLmJyYW5kLFxuLyoqIEB0eXBlIHtOYXRWYWx1ZX0gKi9yYXRpby5udW1lcmF0b3IudmFsdWUsXG5yYXRpby5udW1lcmF0b3IuYnJhbmQpO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhdGlvfSBsZWZ0XG4gKiBAcGFyYW0ge1JhdGlvfSByaWdodFxuICogQHJldHVybnMge1JhdGlvfVxuICovJGjigI1fb25jZS5pbnZlcnRSYXRpbyhpbnZlcnRSYXRpbyk7XG5jb25zdCAgICAgICAgYWRkUmF0aW9zPShsZWZ0LHJpZ2h0KT0+e1xuYXNzZXJ0SXNSYXRpbyhyaWdodCk7XG5hc3NlcnRJc1JhdGlvKGxlZnQpO1xubGVmdC5udW1lcmF0b3IuYnJhbmQ9PT1yaWdodC5udW1lcmF0b3IuYnJhbmR8fFxuRmFpbCBgbnVtZXJhdG9yIGJyYW5kcyBtdXN0IG1hdGNoOiAke3EobGVmdCl9ICR7cShyaWdodCl9YDtcbmxlZnQuZGVub21pbmF0b3IuYnJhbmQ9PT1yaWdodC5kZW5vbWluYXRvci5icmFuZHx8XG5GYWlsIGBkZW5vbWluYXRvciBicmFuZHMgbXVzdCBtYXRjaDogJHtxKGxlZnQpfSAke3EocmlnaHQpfWA7XG5cbi8qIFNpbXBsaWZ5aW5nIHRoZSBleHByZXNzaW9uOiovXG4vKiAoYW5kICsgYm5kKSAvIHkgZCoqMiovXG4vKiAoYSArIGIpIG5kIC8geSBkKioyKi9cbi8qICgoYSArIGIpIG4gLyB5IGQpICogKGQgLyBkKSovXG4vKiAoYSArIGIpIG4gLyB5ZCovXG5yZXR1cm4gbWFrZVJhdGlvKFxuYWRkKFxubXVsdGlwbHkobGVmdC5udW1lcmF0b3IudmFsdWUscmlnaHQuZGVub21pbmF0b3IudmFsdWUpLC8qIGEgbmQqL1xubXVsdGlwbHkobGVmdC5kZW5vbWluYXRvci52YWx1ZSxyaWdodC5udW1lcmF0b3IudmFsdWUpLyogYiBuZCovKSxcbi8qIChhICsgYikgbmQqL1xubGVmdC5udW1lcmF0b3IuYnJhbmQsXG5tdWx0aXBseShsZWZ0LmRlbm9taW5hdG9yLnZhbHVlLHJpZ2h0LmRlbm9taW5hdG9yLnZhbHVlKSwvKiB5IGQqKjIqL1xubGVmdC5kZW5vbWluYXRvci5icmFuZCk7XG5cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UmF0aW99IGxlZnRcbiAqIEBwYXJhbSB7UmF0aW99IHJpZ2h0XG4gKiBAcmV0dXJucyB7UmF0aW99XG4gKi8kaOKAjV9vbmNlLmFkZFJhdGlvcyhhZGRSYXRpb3MpO1xuY29uc3QgICAgICAgIHN1YnRyYWN0UmF0aW9zPShsZWZ0LHJpZ2h0KT0+e1xuYXNzZXJ0SXNSYXRpbyhyaWdodCk7XG5hc3NlcnRJc1JhdGlvKGxlZnQpO1xubGVmdC5udW1lcmF0b3IuYnJhbmQ9PT1yaWdodC5udW1lcmF0b3IuYnJhbmR8fFxuRmFpbCBgbnVtZXJhdG9yIGJyYW5kcyBtdXN0IG1hdGNoOiAke3EobGVmdCl9ICR7cShyaWdodCl9YDtcbmxlZnQuZGVub21pbmF0b3IuYnJhbmQ9PT1yaWdodC5kZW5vbWluYXRvci5icmFuZHx8XG5GYWlsIGBkZW5vbWluYXRvciBicmFuZHMgbXVzdCBtYXRjaDogJHtxKGxlZnQpfSAke3EocmlnaHQpfWA7XG5cbnJldHVybiBtYWtlUmF0aW8oXG5zdWJ0cmFjdChcbm11bHRpcGx5KGxlZnQubnVtZXJhdG9yLnZhbHVlLHJpZ2h0LmRlbm9taW5hdG9yLnZhbHVlKSwvKiBhIG5kKi9cbm11bHRpcGx5KGxlZnQuZGVub21pbmF0b3IudmFsdWUscmlnaHQubnVtZXJhdG9yLnZhbHVlKS8qIGIgbmQqLyksXG4vKiAoYSAtIGIpIG5kKi9cbmxlZnQubnVtZXJhdG9yLmJyYW5kLFxubXVsdGlwbHkobGVmdC5kZW5vbWluYXRvci52YWx1ZSxyaWdodC5kZW5vbWluYXRvci52YWx1ZSksLyogeSBkKioyKi9cbmxlZnQuZGVub21pbmF0b3IuYnJhbmQpO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhdGlvfSBsZWZ0XG4gKiBAcGFyYW0ge1JhdGlvfSByaWdodFxuICogQHJldHVybnMge1JhdGlvfVxuICovJGjigI1fb25jZS5zdWJ0cmFjdFJhdGlvcyhzdWJ0cmFjdFJhdGlvcyk7XG5jb25zdCAgICAgICAgbXVsdGlwbHlSYXRpb3M9KGxlZnQscmlnaHQpPT57XG5hc3NlcnRJc1JhdGlvKHJpZ2h0KTtcbmFzc2VydElzUmF0aW8obGVmdCk7XG5cbmNvbnN0IGdldFJlbWFpbmluZ0JyYW5kcz0oKT0+e1xuLyogUHJlZmVyIHJlc3VsdHMgdGhhdCBoYXZlIHRoZSBzYW1lIGJyYW5kIGFzIHRoZSBsZWZ0IG9wZXJhbmQuKi9cbmlmKHJpZ2h0Lm51bWVyYXRvci5icmFuZD09PXJpZ2h0LmRlbm9taW5hdG9yLmJyYW5kKXtcbnJldHVybltsZWZ0Lm51bWVyYXRvci5icmFuZCxsZWZ0LmRlbm9taW5hdG9yLmJyYW5kXTtcbiB9XG5pZihyaWdodC5udW1lcmF0b3IuYnJhbmQ9PT1sZWZ0LmRlbm9taW5hdG9yLmJyYW5kKXtcbnJldHVybltsZWZ0Lm51bWVyYXRvci5icmFuZCxyaWdodC5kZW5vbWluYXRvci5icmFuZF07XG4gfVxuaWYobGVmdC5udW1lcmF0b3IuYnJhbmQ9PT1yaWdodC5kZW5vbWluYXRvci5icmFuZCl7XG5yZXR1cm5bcmlnaHQubnVtZXJhdG9yLmJyYW5kLGxlZnQuZGVub21pbmF0b3IuYnJhbmRdO1xuIH1cbmlmKGxlZnQubnVtZXJhdG9yLmJyYW5kPT09bGVmdC5kZW5vbWluYXRvci5icmFuZCl7XG5yZXR1cm5bcmlnaHQubnVtZXJhdG9yLmJyYW5kLHJpZ2h0LmRlbm9taW5hdG9yLmJyYW5kXTtcbiB9XG50aHJvdyBGYWlsIGBhdCBsZWFzdCBvbmUgYnJhbmQgbXVzdCBjYW5jZWwgb3V0OiAke3EobGVmdCl9ICR7cShyaWdodCl9YDtcbiB9O1xuXG5jb25zdFtudW1lcmF0b3JCcmFuZCxkZW5vbWluYXRvckJyYW5kXT1nZXRSZW1haW5pbmdCcmFuZHMoKTtcbnJldHVybiBtYWtlUmF0aW8oXG5tdWx0aXBseShsZWZ0Lm51bWVyYXRvci52YWx1ZSxyaWdodC5udW1lcmF0b3IudmFsdWUpLFxubnVtZXJhdG9yQnJhbmQsXG5tdWx0aXBseShsZWZ0LmRlbm9taW5hdG9yLnZhbHVlLHJpZ2h0LmRlbm9taW5hdG9yLnZhbHVlKSxcbmRlbm9taW5hdG9yQnJhbmQpO1xuXG4gfTtcblxuLyoqXG4gKiBJZiByYXRpbyBpcyBiZXR3ZWVuIDAgYW5kIDEsIHN1YnRyYWN0IGZyb20gMS5cbiAqXG4gKiBAcGFyYW0ge1JhdGlvfSByYXRpb1xuICogQHJldHVybnMge1JhdGlvfVxuICovJGjigI1fb25jZS5tdWx0aXBseVJhdGlvcyhtdWx0aXBseVJhdGlvcyk7XG5jb25zdCAgICAgICAgb25lTWludXM9KHJhdGlvKT0+e1xuYXNzZXJ0SXNSYXRpbyhyYXRpbyk7XG5yYXRpby5udW1lcmF0b3IuYnJhbmQ9PT1yYXRpby5kZW5vbWluYXRvci5icmFuZHx8XG5GYWlsIGBvbmVNaW51cyBvbmx5IHN1cHBvcnRzIHJhdGlvcyB3aXRoIGEgc2luZ2xlIGJyYW5kLCBidXQgJHtyYXRpby5udW1lcmF0b3IuYnJhbmR9IGRvZXNuJ3QgbWF0Y2ggJHtyYXRpby5kZW5vbWluYXRvci5icmFuZH1gO1xucmF0aW8ubnVtZXJhdG9yLnZhbHVlPD1yYXRpby5kZW5vbWluYXRvci52YWx1ZXx8XG5GYWlsIGBQYXJhbWV0ZXIgbXVzdCBiZSBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gMTogJHtyYXRpby5udW1lcmF0b3IudmFsdWV9LyR7cmF0aW8uZGVub21pbmF0b3IudmFsdWV9YDtcbnJldHVybiBtYWtlUmF0aW8oXG5zdWJ0cmFjdChyYXRpby5kZW5vbWluYXRvci52YWx1ZSxyYXRpby5udW1lcmF0b3IudmFsdWUpLFxucmF0aW8ubnVtZXJhdG9yLmJyYW5kLFxucmF0aW8uZGVub21pbmF0b3IudmFsdWUsXG5yYXRpby5udW1lcmF0b3IuYnJhbmQpO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhdGlvfSBsZWZ0XG4gKiBAcGFyYW0ge1JhdGlvfSByaWdodFxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi8kaOKAjV9vbmNlLm9uZU1pbnVzKG9uZU1pbnVzKTtcbmNvbnN0ICAgICAgICByYXRpb0dURT0obGVmdCxyaWdodCk9PntcbmlmKGxlZnQubnVtZXJhdG9yLmJyYW5kPT09cmlnaHQubnVtZXJhdG9yLmJyYW5kKXtcbmxlZnQuZGVub21pbmF0b3IuYnJhbmQ9PT1yaWdodC5kZW5vbWluYXRvci5icmFuZHx8XG5GYWlsIGBudW1lcmF0b3IgYnJhbmRzIG1hdGNoLCBidXQgZGVub21pbmF0b3IgYnJhbmRzIGRvbid0OiAke3EobGVmdCl9ICR7cShcbnJpZ2h0KVxuIH1gO1xuIH1lbHNlIGlmKGxlZnQubnVtZXJhdG9yLmJyYW5kPT09bGVmdC5kZW5vbWluYXRvci5icmFuZCl7XG5yaWdodC5udW1lcmF0b3IuYnJhbmQ9PT1yaWdodC5kZW5vbWluYXRvci5icmFuZHx8XG5GYWlsIGBsZWZ0aGFuZCBicmFuZHMgbWF0Y2gsIGJ1dCByaWdodGhhbmQgYnJhbmRzIGRvbid0OiAke3EobGVmdCl9ICR7cShcbnJpZ2h0KVxuIH1gO1xuIH1cbnJldHVybiBuYXRTYWZlTWF0aC5pc0dURShcbm11bHRpcGx5KGxlZnQubnVtZXJhdG9yLnZhbHVlLHJpZ2h0LmRlbm9taW5hdG9yLnZhbHVlKSxcbm11bHRpcGx5KHJpZ2h0Lm51bWVyYXRvci52YWx1ZSxsZWZ0LmRlbm9taW5hdG9yLnZhbHVlKSk7XG5cbiB9O1xuXG4vKipcbiAqIFRydWUgaWZmIHRoZSByYXRpb3MgYXJlIHRoZSBzYW1lIHZhbHVlcyAoZXF1YWwgb3IgZXF1aXZhbGFudCBtYXkgcmV0dXJuIGZhbHNlKVxuICpcbiAqIEBwYXJhbSB7UmF0aW99IGxlZnRcbiAqIEBwYXJhbSB7UmF0aW99IHJpZ2h0XG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqLyRo4oCNX29uY2UucmF0aW9HVEUocmF0aW9HVEUpO1xuY29uc3QgICAgICAgIHJhdGlvc1NhbWU9KGxlZnQscmlnaHQpPT57XG5yZXR1cm4oXG5BbW91bnRNYXRoLmlzRXF1YWwobGVmdC5udW1lcmF0b3IscmlnaHQubnVtZXJhdG9yKSYmXG5BbW91bnRNYXRoLmlzRXF1YWwobGVmdC5kZW5vbWluYXRvcixyaWdodC5kZW5vbWluYXRvcikpO1xuXG4gfTtcblxuLyoqXG4gKiBNYWtlIGFuIGVxdWl2YWxhbnQgcmF0aW8gd2l0aCBhIG5ldyBkZW5vbWluYXRvclxuICpcbiAqIEBwYXJhbSB7UmF0aW99IHJhdGlvXG4gKiBAcGFyYW0ge2JpZ2ludH0gbmV3RGVuXG4gKiBAcmV0dXJucyB7UmF0aW99XG4gKi8kaOKAjV9vbmNlLnJhdGlvc1NhbWUocmF0aW9zU2FtZSk7XG5jb25zdCAgICAgICAgcXVhbnRpemU9KHJhdGlvLG5ld0Rlbik9PntcbmNvbnN0IG9sZERlbj1yYXRpby5kZW5vbWluYXRvci52YWx1ZTtcbmNvbnN0IG9sZE51bT1yYXRpby5udW1lcmF0b3IudmFsdWU7XG5jb25zdCBuZXdOdW09XG5uZXdEZW49PT1vbGREZW4/b2xkTnVtOmJhbmtlcnNEaXZpZGUob2xkTnVtKm5ld0RlbixvbGREZW4pO1xucmV0dXJuIG1ha2VSYXRpbyhcbm5ld051bSxcbnJhdGlvLm51bWVyYXRvci5icmFuZCxcbm5ld0RlbixcbnJhdGlvLmRlbm9taW5hdG9yLmJyYW5kKTtcblxuIH07JGjigI1fb25jZS5xdWFudGl6ZShxdWFudGl6ZSk7XG5cbmNvbnN0IE5VTUVSSUNfUkU9L14oXFxkXFxkKikoPzpcXC4oXFxkKikpPyQvO1xuLyoqIEB0eXBlZGVmIHtiaWdpbnQgfCBudW1iZXIgfCBzdHJpbmd9IFBhcnNhYmxlTnVtYmVyICovXG5cbi8qKlxuICogQ3JlYXRlIGEgcmF0aW8gZnJvbSBhIGdpdmVuIG51bWVyaWMgdmFsdWUuXG4gKlxuICogQHBhcmFtIHtQYXJzYWJsZU51bWJlcn0gbnVtZXJpY1xuICogQHBhcmFtIHtCcmFuZH0gbnVtZXJhdG9yQnJhbmRcbiAqIEBwYXJhbSB7QnJhbmR9IFtkZW5vbWluYXRvckJyYW5kXVxuICogQHJldHVybnMge1JhdGlvfVxuICovXG5jb25zdCAgICAgICAgcGFyc2VSYXRpbz0oXG5udW1lcmljLFxubnVtZXJhdG9yQnJhbmQsXG5kZW5vbWluYXRvckJyYW5kPW51bWVyYXRvckJyYW5kKT0+XG57XG5jb25zdCBtYXRjaD0gYCR7bnVtZXJpY31gLm1hdGNoKE5VTUVSSUNfUkUpO1xuaWYoIW1hdGNoKXtcbnRocm93IEZhaWwgYEludmFsaWQgbnVtZXJpYyBkYXRhOiAke251bWVyaWN9YDtcbiB9XG5cbmNvbnN0W18sd2hvbGUscGFydD0nJ109bWF0Y2g7XG5yZXR1cm4gbWFrZVJhdGlvKFxuQmlnSW50KCBgJHt3aG9sZX0ke3BhcnR9YCksXG5udW1lcmF0b3JCcmFuZCxcbjEwbioqQmlnSW50KHBhcnQubGVuZ3RoKSxcbmRlbm9taW5hdG9yQnJhbmQpO1xuXG4gfTtcblxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIGpzZG9jL3JlcXVpcmUtcmV0dXJucy1jaGVjayovXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gc3BlY2ltZW5cbiAqIEByZXR1cm5zIHthc3NlcnRzIHNwZWNpbWVuIGlzIFBhcnNhYmxlTnVtYmVyfVxuICovJGjigI1fb25jZS5wYXJzZVJhdGlvKHBhcnNlUmF0aW8pO1xuY29uc3QgICAgICAgIGFzc2VydFBhcnNhYmxlTnVtYmVyPShzcGVjaW1lbik9PntcbmNvbnN0IG1hdGNoPSBgJHtzcGVjaW1lbn1gLm1hdGNoKE5VTUVSSUNfUkUpO1xubWF0Y2h8fEZhaWwgYEludmFsaWQgbnVtZXJpYyBkYXRhOiAke3NwZWNpbWVufWA7XG4gfTtcblxuLyoqXG4gKiBSYXRpb3MgbWlnaHQgYmUgZ3JlYXRlciBvciBsZXNzIHRoYW4gb25lLlxuICpcbiAqIEBwYXJhbSB7UmF0aW99IHJhdGlvXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovJGjigI1fb25jZS5hc3NlcnRQYXJzYWJsZU51bWJlcihhc3NlcnRQYXJzYWJsZU51bWJlcik7XG5jb25zdCAgICAgICAgcmF0aW9Ub051bWJlcj0ocmF0aW8pPT57XG5jb25zdCBuPU51bWJlcihyYXRpby5udW1lcmF0b3IudmFsdWUpO1xuY29uc3QgZD1OdW1iZXIocmF0aW8uZGVub21pbmF0b3IudmFsdWUpO1xucmV0dXJuIG4vZDtcbiB9OyRo4oCNX29uY2UucmF0aW9Ub051bWJlcihyYXRpb1RvTnVtYmVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnRJc1JhdGlvIjpbImFzc2VydElzUmF0aW8iXSwibWFrZVJhdGlvIjpbIm1ha2VSYXRpbyJdLCJtYWtlUmF0aW9Gcm9tQW1vdW50cyI6WyJtYWtlUmF0aW9Gcm9tQW1vdW50cyJdLCJmbG9vck11bHRpcGx5QnkiOlsiZmxvb3JNdWx0aXBseUJ5Il0sImNlaWxNdWx0aXBseUJ5IjpbImNlaWxNdWx0aXBseUJ5Il0sIm11bHRpcGx5QnkiOlsibXVsdGlwbHlCeSJdLCJmbG9vckRpdmlkZUJ5IjpbImZsb29yRGl2aWRlQnkiXSwiY2VpbERpdmlkZUJ5IjpbImNlaWxEaXZpZGVCeSJdLCJkaXZpZGVCeSI6WyJkaXZpZGVCeSJdLCJpbnZlcnRSYXRpbyI6WyJpbnZlcnRSYXRpbyJdLCJhZGRSYXRpb3MiOlsiYWRkUmF0aW9zIl0sInN1YnRyYWN0UmF0aW9zIjpbInN1YnRyYWN0UmF0aW9zIl0sIm11bHRpcGx5UmF0aW9zIjpbIm11bHRpcGx5UmF0aW9zIl0sIm9uZU1pbnVzIjpbIm9uZU1pbnVzIl0sInJhdGlvR1RFIjpbInJhdGlvR1RFIl0sInJhdGlvc1NhbWUiOlsicmF0aW9zU2FtZSJdLCJxdWFudGl6ZSI6WyJxdWFudGl6ZSJdLCJwYXJzZVJhdGlvIjpbInBhcnNlUmF0aW8iXSwiYXNzZXJ0UGFyc2FibGVOdW1iZXIiOlsiYXNzZXJ0UGFyc2FibGVOdW1iZXIiXSwicmF0aW9Ub051bWJlciI6WyJyYXRpb1RvTnVtYmVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAPM8Lm46JgAAOiYAADkAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvcmVjb3JkZXIuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9hc3NlcnQiLCJAYWdvcmljL2ludGVybmFsIiwiQGFnb3JpYy9ub3RpZmllciIsIkBhZ29yaWMvbm90aWZpZXIvdG9vbHMvdGVzdFN1cHBvcnRzLmpzIiwiQGFnb3JpYy9zdG9yZSIsIkBhZ29yaWMvdmF0LWRhdGEiLCJAZW5kby9ldmVudHVhbC1zZW5kIl0sImV4cG9ydHMiOlsiZGVmaW5lRVJlY29yZGVyS2l0IiwiZGVmaW5lUmVjb3JkZXJLaXQiLCJwcmVwYXJlTW9ja1JlY29yZGVyS2l0TWFrZXJzIiwicHJlcGFyZVJlY29yZGVyIiwicHJlcGFyZVJlY29yZGVyS2l0IiwicHJlcGFyZVJlY29yZGVyS2l0TWFrZXJzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhaWwsU3RvcmFnZU5vZGVTaGFwZSxwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQsbWFrZUZha2VNYXJzaGFsbGVyLG1ha2VGYWtlU3RvcmFnZSxtdXN0TWF0Y2gsTSxtYWtlU2NhbGFyQmlnTWFwU3RvcmUscHJlcGFyZUV4b0NsYXNzLEU7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9hc3NlcnRcIiwgW1tcIkZhaWxcIiwgWyRo4oCNX2EgPT4gKEZhaWwgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9pbnRlcm5hbFwiLCBbW1wiU3RvcmFnZU5vZGVTaGFwZVwiLCBbJGjigI1fYSA9PiAoU3RvcmFnZU5vZGVTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL25vdGlmaWVyXCIsIFtbXCJwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVEdXJhYmxlUHVibGlzaEtpdCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL25vdGlmaWVyL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qc1wiLCBbW1wibWFrZUZha2VNYXJzaGFsbGVyXCIsIFskaOKAjV9hID0+IChtYWtlRmFrZU1hcnNoYWxsZXIgPSAkaOKAjV9hKV1dLFtcIm1ha2VGYWtlU3RvcmFnZVwiLCBbJGjigI1fYSA9PiAobWFrZUZha2VTdG9yYWdlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dLFtcIm1ha2VTY2FsYXJCaWdNYXBTdG9yZVwiLCBbJGjigI1fYSA9PiAobWFrZVNjYWxhckJpZ01hcFN0b3JlID0gJGjigI1fYSldXSxbXCJwcmVwYXJlRXhvQ2xhc3NcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzcyA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKlxuICogUmVjb3JkZXJzIHN1cHBvcnQgcHVibGlzaGluZyBkYXRhIHRvIHZzdG9yYWdlLlxuICpcbiAqIGBSZWNvcmRlcmAgaXMgc2ltaWxhciB0byBgUHVibGlzaGVyYCAoaW4gdGhhdCB0aGV5IHNlbmQgb3V0IGRhdGEpIGJ1dCBoYXMgZGlmZmVyZW50IHNpZ25hdHVyZXM6XG4gKiAtIG1ldGhvZHMgYXJlIGFzeW5jIGJlY2F1c2UgdGhleSBhd2FpdCByZW1vdGUgY2FsbHMgdG8gTWFyc2hhbGxlciBhbmQgU3RvcmFnZU5vZGVcbiAqIC0gbWV0aG9kIG5hbWVzIGNvbnZleSB0aGUgZHVyYWJpbGl0eVxuICogLSBvbWl0cyBmYWlsKClcbiAqIC0gYWRkcyBnZXRTdG9yYWdlTm9kZSgpIGZyb20gaXRzIGR1cmFibGUgc3RhdGVcbiAqXG4gKiBPdGhlciBuYW1lcyBzdWNoIGFzIFN0b3JlZFB1Ymxpc2hlciBvciBDaGFpblN0b3JhZ2VQdWJsaXNoZXIgd2VyZSBjb25zaWRlcmVkLCBidXQgZm91bmQgdG8gYmUgc29tZXRpbWVzIGNvbmZ1c2VkIHdpdGggKmR1cmFiaWxpdHkqLCBhbm90aGVyIHRyYWl0IG9mIHRoaXMgY2xhc3MuXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3sgZ2V0U3RvcmFnZU5vZGUoKTogU3RvcmFnZU5vZGUsIGdldFN0b3JhZ2VQYXRoKCk6IFByb21pc2U8c3RyaW5nPiwgd3JpdGUodmFsdWU6IFQpOiBQcm9taXNlPHZvaWQ+LCB3cml0ZUZpbmFsKHZhbHVlOiBUKTogUHJvbWlzZTx2b2lkPiB9fSBSZWNvcmRlclxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtQaWNrPFB1Ymxpc2hLaXQ8VD4sICdzdWJzY3JpYmVyJz4gJiB7IHJlY29yZGVyOiBSZWNvcmRlcjxUPiB9fSBSZWNvcmRlcktpdFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtQaWNrPFB1Ymxpc2hLaXQ8VD4sICdzdWJzY3JpYmVyJz4gJiB7IHJlY29yZGVyUDogRVJlZjxSZWNvcmRlcjxUPj4gfX0gRXZlbnR1YWxSZWNvcmRlcktpdFxuICovXG5cbi8qKlxuICogV3JhcCBhIFB1Ymxpc2hlciB0byByZWNvcmQgYWxsIHRoZSB2YWx1ZXMgdG8gY2hhaW4gc3RvcmFnZS5cbiAqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9lJykuQmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtFUmVmPE1hcnNoYWxsZXI+fSBtYXJzaGFsbGVyXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlUmVjb3JkZXI9KGJhZ2dhZ2UsbWFyc2hhbGxlcik9PntcbmNvbnN0IG1ha2VSZWNvcmRlcj1wcmVwYXJlRXhvQ2xhc3MoXG5iYWdnYWdlLFxuJ1JlY29yZGVyJyxcbk0uaW50ZXJmYWNlKCdSZWNvcmRlcicse1xuZ2V0U3RvcmFnZU5vZGU6TS5jYWxsKCkucmV0dXJucyhTdG9yYWdlTm9kZVNoYXBlKSxcbmdldFN0b3JhZ2VQYXRoOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxud3JpdGU6TS5jYWxsKE0uYW55KCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxud3JpdGVGaW5hbDpNLmNhbGwoTS5hbnkoKSkucmV0dXJucyhNLnByb21pc2UoKSl9KSxcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtQdWJsaXNoS2l0PFQ+WydwdWJsaXNoZXInXX0gcHVibGlzaGVyXG4gKiBAcGFyYW0ge1N0b3JhZ2VOb2RlfSBzdG9yYWdlTm9kZVxuICogQHBhcmFtIHtUeXBlZE1hdGNoZXI8VD59IFt2YWx1ZVNoYXBlXVxuICovXG4oXG5wdWJsaXNoZXIsXG5zdG9yYWdlTm9kZSxcbnZhbHVlU2hhcGU9LyoqIEB0eXBlIHtUeXBlZE1hdGNoZXI8YW55Pn0gKi9NLmFueSgpKT0+XG57XG5yZXR1cm57XG5jbG9zZWQ6ZmFsc2UsXG5wdWJsaXNoZXIsXG5zdG9yYWdlTm9kZSxcbnN0b3JhZ2VQYXRoOi8qKiBAdHlwZSB7c3RyaW5nIHwgdW5kZWZpbmVkfSAqL3VuZGVmaW5lZCxcbnZhbHVlU2hhcGV9O1xuXG4gfSxcbntcbmdldFN0b3JhZ2VOb2RlKCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5zdG9yYWdlTm9kZTtcbiB9LFxuLyoqXG4gKiBNZW1vaXplcyB0aGUgcmVtb3RlIGNhbGwgdG8gdGhlIHN0b3JhZ2Ugbm9kZVxuICpcbiAqIEByZXR1cm5zIHtQcm9taXNlPHN0cmluZz59XG4gKi9cbiAgICAgIGFzeW5jIGdldFN0b3JhZ2VQYXRoKCl7XG5jb25zdHtzdG9yYWdlUGF0aDpoZWxkUGF0aH09dGhpcy5zdGF0ZTtcbi8qIGVuZCBzeW5jaHJvbm91cyBwcmVsdWRlKi9cbmF3YWl0IG51bGw7XG5pZihoZWxkUGF0aCE9PXVuZGVmaW5lZCl7XG5yZXR1cm4gaGVsZFBhdGg7XG4gfVxuY29uc3QgcGF0aD1hd2FpdCBFKHRoaXMuc3RhdGUuc3RvcmFnZU5vZGUpLmdldFBhdGgoKTtcbnRoaXMuc3RhdGUuc3RvcmFnZVBhdGg9cGF0aDtcbnJldHVybiBwYXRoO1xuIH0sXG4vKipcbiAqIE1hcnNoYWxscyBiZWZvcmUgd3JpdGluZyB0byBzdG9yYWdlIG9yIHB1Ymxpc2hlciB0byBoZWxwIGVuc3VyZSB0aGUgdHdvIHN0cmVhbXMgbWF0Y2guXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSB2YWx1ZVxuICogQHJldHVybnMge1Byb21pc2U8dm9pZD59XG4gKi9cbiAgICAgIGFzeW5jIHdyaXRlKHZhbHVlKXtcbmNvbnN0e2Nsb3NlZCxwdWJsaXNoZXIsc3RvcmFnZU5vZGUsdmFsdWVTaGFwZX09dGhpcy5zdGF0ZTtcbiFjbG9zZWR8fEZhaWwgYGNhbm5vdCB3cml0ZSB0byBjbG9zZWQgcmVjb3JkZXJgO1xubXVzdE1hdGNoKHZhbHVlLHZhbHVlU2hhcGUpO1xuY29uc3QgZW5jb2RlZD1hd2FpdCBFKG1hcnNoYWxsZXIpLnRvQ2FwRGF0YSh2YWx1ZSk7XG5jb25zdCBzZXJpYWxpemVkPUpTT04uc3RyaW5naWZ5KGVuY29kZWQpO1xuYXdhaXQgRShzdG9yYWdlTm9kZSkuc2V0VmFsdWUoc2VyaWFsaXplZCk7XG5cbi8qIGJlbG93IGhlcmUgZGlmZmVycyBmcm9tIHdyaXRlRmluYWwoKSovXG5yZXR1cm4gcHVibGlzaGVyLnB1Ymxpc2godmFsdWUpO1xuIH0sXG4vKipcbiAqIExpa2UgYHdyaXRlYCBidXQgcHJldmVudHMgZnV0dXJlIHdyaXRlcyBhbmQgdGVybWluYXRlcyB0aGUgcHVibGlzaGVyLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gdmFsdWVcbiAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fVxuICovXG4gICAgICBhc3luYyB3cml0ZUZpbmFsKHZhbHVlKXtcbmNvbnN0e2Nsb3NlZCxwdWJsaXNoZXIsc3RvcmFnZU5vZGUsdmFsdWVTaGFwZX09dGhpcy5zdGF0ZTtcbiFjbG9zZWR8fEZhaWwgYGNhbm5vdCB3cml0ZSB0byBjbG9zZWQgcmVjb3JkZXJgO1xubXVzdE1hdGNoKHZhbHVlLHZhbHVlU2hhcGUpO1xuY29uc3QgZW5jb2RlZD1hd2FpdCBFKG1hcnNoYWxsZXIpLnRvQ2FwRGF0YSh2YWx1ZSk7XG5jb25zdCBzZXJpYWxpemVkPUpTT04uc3RyaW5naWZ5KGVuY29kZWQpO1xuYXdhaXQgRShzdG9yYWdlTm9kZSkuc2V0VmFsdWUoc2VyaWFsaXplZCk7XG5cbi8qIGJlbG93IGhlcmUgZGlmZmVycyBmcm9tIHdyaXRlRmluYWwoKSovXG50aGlzLnN0YXRlLmNsb3NlZD10cnVlO1xucmV0dXJuIHB1Ymxpc2hlci5maW5pc2godmFsdWUpO1xuIH19KTtcblxuXG5cbnJldHVybiBtYWtlUmVjb3JkZXI7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVSZWNvcmRlcihwcmVwYXJlUmVjb3JkZXIpO1xuaGFyZGVuKHByZXBhcmVSZWNvcmRlcik7XG4vKiogQHR5cGVkZWYge1JldHVyblR5cGU8dHlwZW9mIHByZXBhcmVSZWNvcmRlcj59IE1ha2VSZWNvcmRlciAqL1xuXG4vKipcbiAqIGBtYWtlUmVjb3JkZXJLaXRgIGlzIHN1aXRhYmxlIGZvciBtYWtpbmcgYSBkdXJhYmxlIGBSZWNvcmRlcktpdGAgd2hpY2ggY2FuIGJlIGhlbGQgaW4gRXhvIHN0YXRlLlxuICpcbiAqIEBzZWUge2RlZmluZUVSZWNvcmRlcktpdH1cbiAqXG4gKiBAcGFyYW0ge3ttYWtlUmVjb3JkZXI6IE1ha2VSZWNvcmRlciwgbWFrZUR1cmFibGVQdWJsaXNoS2l0OiBSZXR1cm5UeXBlPHR5cGVvZiBwcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQ+fX0gbWFrZXJzXG4gKi9cbmNvbnN0ICAgICAgICBkZWZpbmVSZWNvcmRlcktpdD0oe21ha2VSZWNvcmRlcixtYWtlRHVyYWJsZVB1Ymxpc2hLaXR9KT0+e1xuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtTdG9yYWdlTm9kZX0gc3RvcmFnZU5vZGVcbiAqIEBwYXJhbSB7VHlwZWRNYXRjaGVyPFQ+fSBbdmFsdWVTaGFwZV1cbiAqIEByZXR1cm5zIHtSZWNvcmRlcktpdDxUPn1cbiAqL1xuY29uc3QgbWFrZVJlY29yZGVyS2l0PShzdG9yYWdlTm9kZSx2YWx1ZVNoYXBlKT0+e1xuY29uc3R7c3Vic2NyaWJlcixwdWJsaXNoZXJ9PW1ha2VEdXJhYmxlUHVibGlzaEtpdCgpO1xuY29uc3QgcmVjb3JkZXI9bWFrZVJlY29yZGVyKHB1Ymxpc2hlcixzdG9yYWdlTm9kZSx2YWx1ZVNoYXBlKTtcbnJldHVybiBoYXJkZW4oe3N1YnNjcmliZXIscmVjb3JkZXJ9KTtcbiB9O1xucmV0dXJuIG1ha2VSZWNvcmRlcktpdDtcbiB9O1xuLyoqIEB0eXBlZGVmIHtSZXR1cm5UeXBlPHR5cGVvZiBkZWZpbmVSZWNvcmRlcktpdD59IE1ha2VSZWNvcmRlcktpdCAqL1xuXG4vKipcbiAqIGBtYWtlRVJlY29yZGVyS2l0YCBpcyBmb3IgY2xvc3VyZXMgdGhhdCBtdXN0IHJldHVybiBhIGBzdWJzY3JpYmVyYCBzeW5jaHJvbm91c2x5IGJ1dCBjYW4gZGVmZXIgdGhlIGByZWNvcmRlcmAuXG4gKlxuICogQHNlZSB7ZGVmaW5lUmVjb3JkZXJLaXR9XG4gKlxuICogQHBhcmFtIHt7bWFrZVJlY29yZGVyOiBNYWtlUmVjb3JkZXIsIG1ha2VEdXJhYmxlUHVibGlzaEtpdDogUmV0dXJuVHlwZTx0eXBlb2YgcHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0Pn19IG1ha2Vyc1xuICovJGjigI1fb25jZS5kZWZpbmVSZWNvcmRlcktpdChkZWZpbmVSZWNvcmRlcktpdCk7XG5jb25zdCAgICAgICAgZGVmaW5lRVJlY29yZGVyS2l0PSh7bWFrZVJlY29yZGVyLG1ha2VEdXJhYmxlUHVibGlzaEtpdH0pPT57XG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0VSZWY8U3RvcmFnZU5vZGU+fSBzdG9yYWdlTm9kZVBcbiAqIEBwYXJhbSB7VHlwZWRNYXRjaGVyPFQ+fSBbdmFsdWVTaGFwZV1cbiAqIEByZXR1cm5zIHtFdmVudHVhbFJlY29yZGVyS2l0PFQ+fVxuICovXG5jb25zdCBtYWtlRVJlY29yZGVyS2l0PShzdG9yYWdlTm9kZVAsdmFsdWVTaGFwZSk9PntcbmNvbnN0e3B1Ymxpc2hlcixzdWJzY3JpYmVyfT1tYWtlRHVyYWJsZVB1Ymxpc2hLaXQoKTtcbmNvbnN0IHJlY29yZGVyUD1FLndoZW4oc3RvcmFnZU5vZGVQLChzdG9yYWdlTm9kZSk9PlxubWFrZVJlY29yZGVyKHB1Ymxpc2hlcixzdG9yYWdlTm9kZSx2YWx1ZVNoYXBlKSk7XG5cbnJldHVybntzdWJzY3JpYmVyLHJlY29yZGVyUH07XG4gfTtcbnJldHVybiBtYWtlRVJlY29yZGVyS2l0O1xuIH07JGjigI1fb25jZS5kZWZpbmVFUmVjb3JkZXJLaXQoZGVmaW5lRVJlY29yZGVyS2l0KTtcbmhhcmRlbihkZWZpbmVFUmVjb3JkZXJLaXQpO1xuLyoqIEB0eXBlZGVmIHtSZXR1cm5UeXBlPHR5cGVvZiBkZWZpbmVFUmVjb3JkZXJLaXQ+fSBNYWtlRVJlY29yZGVyS2l0ICovXG5cbi8qKlxuICogQ29udmVuaWVuY2Ugd3JhcHBlciB0byBwcmVwYXJlIHRoZSBEdXJhYmxlUHVibGlzaEtpdCBhbmQgUmVjb3JkZXIga2luZHMuXG4gKiBOb3RlIHRoYXQgYmVjYXVzZSBwcmVwYXJlUmVjb3JkZXIoKSBjYW4gb25seSBiZSBjYWxsZWQgb25jZSBwZXIgYmFnZ2FnZSxcbiAqIHRoaXMgc2hvdWxkIG9ubHkgYmUgdXNlZCB3aGVuIHRoZXJlIGlzIG5vIG5lZWQgZm9yIGFuIEV2ZW50dWFsUmVjb3JkZXJLaXQuXG4gKiBXaGVuIHRoZXJlIGlzLCBwcmVwYXJlIHRoZSBraW5kcyBzZXBhcmF0ZWx5IGFuZCBwYXNzIHRvIHRoZSBraXQgZGVmaW5lcnMuXG4gKlxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtFUmVmPE1hcnNoYWxsZXI+fSBtYXJzaGFsbGVyXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlUmVjb3JkZXJLaXQ9KGJhZ2dhZ2UsbWFyc2hhbGxlcik9PntcbmNvbnN0IG1ha2VEdXJhYmxlUHVibGlzaEtpdD1wcmVwYXJlRHVyYWJsZVB1Ymxpc2hLaXQoXG5iYWdnYWdlLFxuJ0R1cmFibGUgUHVibGlzaCBLaXQnKTtcblxuY29uc3QgbWFrZVJlY29yZGVyPXByZXBhcmVSZWNvcmRlcihiYWdnYWdlLG1hcnNoYWxsZXIpO1xucmV0dXJuIGRlZmluZVJlY29yZGVyS2l0KHttYWtlRHVyYWJsZVB1Ymxpc2hLaXQsbWFrZVJlY29yZGVyfSk7XG4gfTtcblxuLyoqXG4gKiBDb252ZW5pZW5jZSB3cmFwcGVyIGZvciBEdXJhYmxlUHVibGlzaEtpdCBhbmQgUmVjb3JkZXIga2luZHMuXG4gKlxuICogTkI6IHRoaXMgZGVmaW5lcyB0d28gZHVyYWJsZSBraW5kcy4gTXVzdCBiZSBjYWxsZWQgYXQgbW9zdCBvbmNlIHBlciBiYWdnYWdlLlxuICpcbiAqIGBtYWtlUmVjb3JkZXJLaXRgIGlzIHN1aXRhYmxlIGZvciBtYWtpbmcgYSBkdXJhYmxlIGBSZWNvcmRlcktpdGAgd2hpY2ggY2FuIGJlIGhlbGQgaW4gRXhvIHN0YXRlLlxuICogYG1ha2VFUmVjb3JkZXJLaXRgIGlzIGZvciBjbG9zdXJlcyB0aGF0IG11c3QgcmV0dXJuIGEgYHN1YnNjcmliZXJgIHN5bmNocm9ub3VzbHkgYnV0IGNhbiBkZWZlciB0aGUgYHJlY29yZGVyYC5cbiAqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge0VSZWY8TWFyc2hhbGxlcj59IG1hcnNoYWxsZXJcbiAqLyRo4oCNX29uY2UucHJlcGFyZVJlY29yZGVyS2l0KHByZXBhcmVSZWNvcmRlcktpdCk7XG5jb25zdCAgICAgICAgcHJlcGFyZVJlY29yZGVyS2l0TWFrZXJzPShiYWdnYWdlLG1hcnNoYWxsZXIpPT57XG5jb25zdCBtYWtlRHVyYWJsZVB1Ymxpc2hLaXQ9cHJlcGFyZUR1cmFibGVQdWJsaXNoS2l0KFxuYmFnZ2FnZSxcbidEdXJhYmxlIFB1Ymxpc2ggS2l0Jyk7XG5cbmNvbnN0IG1ha2VSZWNvcmRlcj1wcmVwYXJlUmVjb3JkZXIoYmFnZ2FnZSxtYXJzaGFsbGVyKTtcblxuY29uc3QgbWFrZVJlY29yZGVyS2l0PWRlZmluZVJlY29yZGVyS2l0KHtcbm1ha2VSZWNvcmRlcixcbm1ha2VEdXJhYmxlUHVibGlzaEtpdH0pO1xuXG5jb25zdCBtYWtlRVJlY29yZGVyS2l0PWRlZmluZUVSZWNvcmRlcktpdCh7XG5tYWtlUmVjb3JkZXIsXG5tYWtlRHVyYWJsZVB1Ymxpc2hLaXR9KTtcblxuXG5yZXR1cm57XG5tYWtlRHVyYWJsZVB1Ymxpc2hLaXQsXG5tYWtlUmVjb3JkZXIsXG5tYWtlUmVjb3JkZXJLaXQsXG5tYWtlRVJlY29yZGVyS2l0fTtcblxuIH07XG5cbi8qKlxuICogRm9yIHVzZSBpbiB0ZXN0c1xuICovJGjigI1fb25jZS5wcmVwYXJlUmVjb3JkZXJLaXRNYWtlcnMocHJlcGFyZVJlY29yZGVyS2l0TWFrZXJzKTtcbmNvbnN0ICAgICAgICBwcmVwYXJlTW9ja1JlY29yZGVyS2l0TWFrZXJzPSgpPT57XG5jb25zdCBiYWdnYWdlPW1ha2VTY2FsYXJCaWdNYXBTdG9yZSgnbW9jayByZWNvcmRlciBiYWdnYWdlJyk7XG5jb25zdCBtYXJzaGFsbGVyPW1ha2VGYWtlTWFyc2hhbGxlcigpO1xucmV0dXJue1xuLi4ucHJlcGFyZVJlY29yZGVyS2l0TWFrZXJzKGJhZ2dhZ2UsbWFyc2hhbGxlciksXG5zdG9yYWdlTm9kZTptYWtlRmFrZVN0b3JhZ2UoJ21vY2sgcmVjb3JkZXIgc3RvcmFnZScpfTtcblxuIH07XG5cbi8qKlxuICogU3RvcC1nYXAgdW50aWwgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy82MTYwXG4gKiBleHBsaWN0bHkgc3BlY2lmeSB0aGUgdHlwZSB0aGF0IHRoZSBQYXR0ZXJuIHdpbGwgdmVyaWZ5IHRocm91Z2ggYSBtYXRjaC5cbiAqXG4gKiBUaGlzIGlzIGEgUGF0dGVybiBidXQgc2luY2UgdGhhdCdzIGBhbnlgLCBpbmNsdWRpbmcgaW4gdGhlIHR5cGVkZWYgdHVybnMgdGhlXG4gKiB3aG9sZSB0aGluZyB0byBgYW55YC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3sgdmFsaWRhdGVkVHlwZT86IFQgfX0gVHlwZWRNYXRjaGVyXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge1R5cGVkTWF0Y2hlcjxhbnk+fSBUTVxuICogQHR5cGVkZWYge1RNIGV4dGVuZHMgVHlwZWRNYXRjaGVyPGluZmVyIFQ+ID8gVCA6IG5ldmVyfSBNYXRjaGVkVHlwZVxuICovJGjigI1fb25jZS5wcmVwYXJlTW9ja1JlY29yZGVyS2l0TWFrZXJzKHByZXBhcmVNb2NrUmVjb3JkZXJLaXRNYWtlcnMpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVSZWNvcmRlciI6WyJwcmVwYXJlUmVjb3JkZXIiXSwiZGVmaW5lUmVjb3JkZXJLaXQiOlsiZGVmaW5lUmVjb3JkZXJLaXQiXSwiZGVmaW5lRVJlY29yZGVyS2l0IjpbImRlZmluZUVSZWNvcmRlcktpdCJdLCJwcmVwYXJlUmVjb3JkZXJLaXQiOlsicHJlcGFyZVJlY29yZGVyS2l0Il0sInByZXBhcmVSZWNvcmRlcktpdE1ha2VycyI6WyJwcmVwYXJlUmVjb3JkZXJLaXRNYWtlcnMiXSwicHJlcGFyZU1vY2tSZWNvcmRlcktpdE1ha2VycyI6WyJwcmVwYXJlTW9ja1JlY29yZGVyS2l0TWFrZXJzIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAOhpH7e2BgAAtgYAADkAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvc2FmZU1hdGguanN7ImltcG9ydHMiOlsiQGVuZG8vbmF0Il0sImV4cG9ydHMiOlsibmF0U2FmZU1hdGgiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgTmF0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL25hdFwiLCBbW1wiTmF0XCIsIFskaOKAjV9hID0+IChOYXQgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuLyoqIEB0eXBlZGVmIHsoeDogbnVtYmVyIHwgYmlnaW50LCB5OiBudW1iZXIgfCBiaWdpbnQpID0+IE5hdFZhbHVlfSBOYXRPcCAqL1xuXG4vKipcbiAqIFRoZXNlIG9wZXJhdGlvbnMgc2hvdWxkIGJlIHVzZWQgZm9yIGNhbGN1bGF0aW9ucyB3aXRoIHRoZSB2YWx1ZXMgb2ZcbiAqIGJhc2ljIGZ1bmdpYmxlIHRva2Vucy5cbiAqXG4gKiBuYXRTYWZlTWF0aCBpcyBkZXNpZ25lZCB0byBiZSB1c2VkIGRpcmVjdGx5LCBhbmQgc28gaXQgbmVlZHMgdG9cbiAqIHZhbGlkYXRlIHRoZSBpbnB1dHMsIGFzIHdlbGwgYXMgdGhlIG91dHB1dHMgd2hlbiBuZWNlc3NhcnkuXG4gKi9cbmNvbnN0ICAgICAgICBuYXRTYWZlTWF0aD1oYXJkZW4oe1xuLyoqIEB0eXBlIHtOYXRPcH0gKi9cbi8qIEJpZ0ludHMgZG9uJ3Qgb2JzZXJ2YWJseSBvdmVyZmxvdyovXG5hZGQ6KHgseSk9Pk5hdCh4KStOYXQoeSksXG4vKiogQHR5cGUge05hdE9wfSAqL1xuc3VidHJhY3Q6KHgseSk9Pk5hdChOYXQoeCktTmF0KHkpKSxcbi8qKiBAdHlwZSB7TmF0T3B9ICovXG5tdWx0aXBseTooeCx5KT0+TmF0KHgpKk5hdCh5KSxcbi8qKiBAdHlwZSB7TmF0T3B9ICovXG5mbG9vckRpdmlkZTooeCx5KT0+TmF0KHgpL05hdCh5KSxcbi8qKiBAdHlwZSB7TmF0T3B9ICovXG5jZWlsRGl2aWRlOih4LHkpPT57XG55PU5hdCh5KTtcbnJldHVybiBOYXQoTmF0KHgpK3ktMW4pL3k7XG4gfSxcbi8qKlxuICogRGl2aWRlIHVzaW5nIGhhbGYtdG8tZXZlbiAoYWthIEJhbmtlcidzIFJvdW5kaW5nKSBhcyBpbiBJRUVFIDc3NCBkZWZhdWx0IHJvdW5kaW5nXG4gKlxuICogQHR5cGUge05hdE9wfVxuICovXG5iYW5rZXJzRGl2aWRlOihhLGIpPT57XG5hPU5hdChhKTtcbmI9TmF0KGIpO1xuXG5jb25zdCBkaXY9YS9iO1xuY29uc3QgcmVtPWElYjtcbi8qIGlmIHJlbWFpbmRlciA+IGhhbGYgZGl2aXNvciwgc2hvdWxkIGhhdmUgcm91bmRlZCB1cCBpbnN0ZWFkIG9mIGRvd24sIHNvIGFkZCAxKi9cbmlmKHJlbSoybj5iKXtcbnJldHVybiBkaXYrMW47XG4gfWVsc2UgaWYocmVtKjJuPT09Yil7XG4vKiBBZGQgMSBpZiByZXN1bHQgaXMgb2RkIHRvIGdldCBhbiBldmVuIHJldHVybiB2YWx1ZSovXG5pZihkaXYlMm49PT0xbilyZXR1cm4gZGl2KzFuO1xuIH1cbnJldHVybiBkaXY7XG4gfSxcbi8qKiBAdHlwZSB7KHg6IG51bWJlciB8IGJpZ2ludCwgeTogbnVtYmVyIHwgYmlnaW50KSA9PiBib29sZWFufSAqL1xuaXNHVEU6KHgseSk9Pk5hdCh4KT49TmF0KHkpfSk7JGjigI1fb25jZS5uYXRTYWZlTWF0aChuYXRTYWZlTWF0aCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibmF0U2FmZU1hdGgiOlsibmF0U2FmZU1hdGgiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAa4MaC5oEAACaBAAAPQAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9zdGF0ZU1hY2hpbmUuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9hc3NlcnQiXSwiZXhwb3J0cyI6WyJtYWtlU3RhdGVNYWNoaW5lIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydDskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2Fzc2VydFwiLCBbW1wiYXNzZXJ0XCIsIFskaOKAjV9hID0+IChhc3NlcnQgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuLyogYWxsb3dlZFRyYW5zaXRpb25zIGlzIGFuIGFycmF5IG9mIGFycmF5cyB3aGljaCBnZXRzIHR1cm5lZCBpbnRvIGFcbiAqIG1hcC4gVGhlIG1hcCBtYXBzIHN0cmluZyBzdGF0ZXMgdG8gYW4gYXJyYXkgb2YgcG90ZW50aWFsIG5leHRcbiAqIHN0YXRlcy4gRm9yIGV4YW1wbGUsXG4gKiBjb25zdCBhbGxvd2VkVHJhbnNpdGlvbnMgPSBbXG4gWydvcGVuJywgWydjbG9zZWQnXV0sXG4gWydjbG9zZWQnLCBbXV0sXG4gKiBdO1xuKi9cbmNvbnN0IG1ha2VTdGF0ZU1hY2hpbmU9KGluaXRpYWxTdGF0ZSxhbGxvd2VkVHJhbnNpdGlvbnNBcnJheSk9PntcbmxldCBzdGF0ZT1pbml0aWFsU3RhdGU7XG5jb25zdCBhbGxvd2VkVHJhbnNpdGlvbnM9bmV3IE1hcChhbGxvd2VkVHJhbnNpdGlvbnNBcnJheSk7XG5yZXR1cm4gaGFyZGVuKHtcbmNhblRyYW5zaXRpb25UbzoobmV4dFN0YXRlKT0+XG5hbGxvd2VkVHJhbnNpdGlvbnMuZ2V0KHN0YXRlKS5pbmNsdWRlcyhuZXh0U3RhdGUpLFxudHJhbnNpdGlvblRvOihuZXh0U3RhdGUpPT57XG5hc3NlcnQoYWxsb3dlZFRyYW5zaXRpb25zLmdldChzdGF0ZSkuaW5jbHVkZXMobmV4dFN0YXRlKSk7XG5zdGF0ZT1uZXh0U3RhdGU7XG4gfSxcbmdldFN0YXR1czooXyk9PnN0YXRlfSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZVN0YXRlTWFjaGluZShtYWtlU3RhdGVNYWNoaW5lKTtcbmhhcmRlbihtYWtlU3RhdGVNYWNoaW5lKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlU3RhdGVNYWNoaW5lIjpbIm1ha2VTdGF0ZU1hY2hpbmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAfm1pbX8FAAB/BQAAOwAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9zdGF0aXN0aWNzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJjYWxjdWxhdGVNZWRpYW4iXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBUeXBlZE1hdGhcbiAqIEBwcm9wZXJ0eSB7KGE6IFQsIGI6IFQpID0+IFR9IGFkZFxuICogQHByb3BlcnR5IHsoYTogVCwgYjogYmlnaW50KSA9PiBUfSBkaXZpZGVcbiAqIEBwcm9wZXJ0eSB7KGE6IFQsIGI6IFQpID0+IGJvb2xlYW59IGlzR1RFXG4gKi9cblxuLyoqXG4gKiBDYWxjdWxhdGUgdGhlIG1lZGlhbiBvZiBhIHNldCBvZiBzYW1wbGVzXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7QXJyYXk8VD59IHNhbXBsZXMgdGhlIGlucHV0IG1lYXN1cmVtZW50c1xuICogQHBhcmFtIHtUeXBlZE1hdGg8VD59IG1hdGhcbiAqIEByZXR1cm5zIHtUIHwgdW5kZWZpbmVkfSB0aGUgbWVkaWFuICh1bmRlZmluZWQgaWYgbm8gc2FtcGxlcylcbiAqL1xuY29uc3QgICAgICAgIGNhbGN1bGF0ZU1lZGlhbj0oc2FtcGxlcyxtYXRoKT0+e1xuY29uc3Qgc29ydGVkPXNhbXBsZXMuc29ydCgoYSxiKT0+e1xuaWYoIW1hdGguaXNHVEUoYSxiKSl7XG5yZXR1cm4tMTtcbiB9ZWxzZSBpZighbWF0aC5pc0dURShiLGEpKXtcbnJldHVybiAxO1xuIH1cbnJldHVybiAwO1xuIH0pO1xuXG5pZihzb3J0ZWQubGVuZ3RoPT09MCl7XG4vKiBObyB2YWxpZCBzYW1wbGVzLCBkb24ndCByZXBvcnQgYW55dGhpbmcuKi9cbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuXG5pZihzb3J0ZWQubGVuZ3RoJTIhPT0wKXtcbi8qIE9kZCBsZW5ndGgsIGp1c3QgcGljayB0aGUgbWlkZGxlIGVsZW1lbnQuKi9cbnJldHVybiBzb3J0ZWRbKHNvcnRlZC5sZW5ndGgtMSkvMl07XG4gfVxuXG4vKiBFdmVuIGxlbmd0aCwgdGFrZSB0aGUgbWVhbiBvZiB0aGUgdHdvIG1pZGRsZSB2YWx1ZXMuKi9cbmNvbnN0IHNlY29uZEluZGV4PXNvcnRlZC5sZW5ndGgvMjtcbmNvbnN0IHN1bT1tYXRoLmFkZChzb3J0ZWRbc2Vjb25kSW5kZXgtMV0sc29ydGVkW3NlY29uZEluZGV4XSk7XG5yZXR1cm4gbWF0aC5kaXZpZGUoc3VtLDJuKTtcbiB9OyRo4oCNX29uY2UuY2FsY3VsYXRlTWVkaWFuKGNhbGN1bGF0ZU1lZGlhbik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiY2FsY3VsYXRlTWVkaWFuIjpbImNhbGN1bGF0ZU1lZGlhbiJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA+y33fnQcAAJ0HAAA3AAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L3RvcGljcy5qc3siaW1wb3J0cyI6WyJAYWdvcmljL25vdGlmaWVyIiwiQGFnb3JpYy9zdG9yZSIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbIlB1YmxpY1RvcGljU2hhcGUiLCJTdWJzY3JpYmVyU2hhcGUiLCJUb3BpY3NSZWNvcmRTaGFwZSIsIm1ha2VSZWNvcmRlclRvcGljIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IFN1YnNjcmliZXJTaGFwZSxNLEU7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9ub3RpZmllclwiLCBbW1wiU3Vic2NyaWJlclNoYXBlXCIsIFskaOKAjV9hID0+IChTdWJzY3JpYmVyU2hhcGUgPSAkaOKAjV9hKSwkaOKAjV9saXZlW1wiU3Vic2NyaWJlclNoYXBlXCJdXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL2ZhclwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cbmNvbnN0ICAgICAgICBQdWJsaWNUb3BpY1NoYXBlPU0uc3BsaXRSZWNvcmQoXG57XG5zdWJzY3JpYmVyOlN1YnNjcmliZXJTaGFwZSxcbnN0b3JhZ2VQYXRoOk0ucHJvbWlzZSgpfSxcblxue2Rlc2NyaXB0aW9uOk0uc3RyaW5nKCl9KTtcblxuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7b2JqZWN0fSBUIHRvcGljIHZhbHVlXG4gKiBAdHlwZWRlZiB7e1xuICogICBkZXNjcmlwdGlvbj86IHN0cmluZyxcbiAqICAgc3Vic2NyaWJlcjogU3Vic2NyaWJlcjxUPixcbiAqICAgc3RvcmFnZVBhdGg6IEVSZWY8c3RyaW5nPixcbiAqIH19IFB1YmxpY1RvcGljXG4gKi8kaOKAjV9vbmNlLlB1YmxpY1RvcGljU2hhcGUoUHVibGljVG9waWNTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBUb3BpY3NSZWNvcmRTaGFwZT1NLnJlY29yZE9mKE0uc3RyaW5nKCksUHVibGljVG9waWNTaGFwZSk7XG5cbi8qKlxuICogQHR5cGVkZWYge3tcbiAqICAgW3RvcGljTmFtZTogc3RyaW5nXTogUHVibGljVG9waWM8dW5rbm93bj4sXG4gKiB9fSBUb3BpY3NSZWNvcmRcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge3N0cmluZ30gZGVzY3JpcHRpb25cbiAqIEBwYXJhbSB7WGltcG9ydCgnLi9yZWNvcmRlci5qcycpLlJlY29yZGVyS2l0PFQ+IHwgWGltcG9ydCgnLi9yZWNvcmRlci5qcycpLkV2ZW50dWFsUmVjb3JkZXJLaXQ8VD59IHJlY29yZGVyS2l0XG4gKiBAcmV0dXJucyB7UHVibGljVG9waWM8VD59XG4gKi8kaOKAjV9vbmNlLlRvcGljc1JlY29yZFNoYXBlKFRvcGljc1JlY29yZFNoYXBlKTtcbmNvbnN0ICAgICAgICBtYWtlUmVjb3JkZXJUb3BpYz0oZGVzY3JpcHRpb24scmVjb3JkZXJLaXQpPT57XG5jb25zdCByZWNQPVxuJ3JlY29yZGVyJ2luIHJlY29yZGVyS2l0P3JlY29yZGVyS2l0LnJlY29yZGVyOnJlY29yZGVyS2l0LnJlY29yZGVyUDtcbnJldHVybntcbmRlc2NyaXB0aW9uLFxuc3Vic2NyaWJlcjpyZWNvcmRlcktpdC5zdWJzY3JpYmVyLFxuc3RvcmFnZVBhdGg6RShyZWNQKS5nZXRTdG9yYWdlUGF0aCgpfTtcblxuIH07JGjigI1fb25jZS5tYWtlUmVjb3JkZXJUb3BpYyhtYWtlUmVjb3JkZXJUb3BpYyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnsiU3Vic2NyaWJlclNoYXBlIjpbIlN1YnNjcmliZXJTaGFwZSIsZmFsc2VdfSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IlB1YmxpY1RvcGljU2hhcGUiOlsiUHVibGljVG9waWNTaGFwZSJdLCJUb3BpY3NSZWNvcmRTaGFwZSI6WyJUb3BpY3NSZWNvcmRTaGFwZSJdLCJtYWtlUmVjb3JkZXJUb3BpYyI6WyJtYWtlUmVjb3JkZXJUb3BpYyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABlBMIW2gsAANoLAAA2AAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L3R5cGVzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQGplc3NpZS1jaGVjayovXG5cbi8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gU2VhdEdhaW5zTG9zc2VzUmVjb3JkXG4gKiBAcHJvcGVydHkge1pDRlNlYXR9IHNlYXRcbiAqIEBwcm9wZXJ0eSB7QW1vdW50S2V5d29yZFJlY29yZH0gZ2FpbnMgLSB3aGF0IHRoZSBzZWF0IHdpbGxcbiAqIGdhaW4gYXMgYSByZXN1bHQgb2YgdGhpcyB0cmFkZVxuICogQHByb3BlcnR5IHtBbW91bnRLZXl3b3JkUmVjb3JkfSBsb3NzZXMgLSB3aGF0IHRoZSBzZWF0IFt3aWxsXVxuICogZ2l2ZSB1cCBhcyBhIHJlc3VsdCBvZiB0aGlzIHRyYWRlLiBMb3NzZXMgaXMgb3B0aW9uYWwsIGJ1dCBjYW5cbiAqIG9ubHkgYmUgb21pdHRlZCBpZiB0aGUga2V5d29yZHMgZm9yIGJvdGggc2VhdHMgYXJlIHRoZSBzYW1lLlxuICogSWYgbG9zc2VzIGlzIG5vdCBkZWZpbmVkLCB0aGUgZ2FpbnMgb2YgdGhlIG90aGVyIHNlYXQgaXNcbiAqIHN1YnRyYWN0ZWQuXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgU3dhcFxuICogSWYgdHdvIHNlYXRzIGNhbiBzYXRpc2Z5IGVhY2ggb3RoZXIncyB3YW50cywgdHJhZGUgZW5vdWdoIHRvXG4gKiBzYXRpc2Z5IHRoZSB3YW50cyBvZiBib3RoIHNlYXRzIGFuZCBleGl0IGJvdGggc2VhdHMuXG4gKlxuICogVGhlIHN1cnBsdXMgcmVtYWlucyB3aXRoIHRoZSBvcmlnaW5hbCBzZWF0LiBGb3IgZXhhbXBsZSBpZiBzZWF0IEFcbiAqIGdpdmVzIDUgbW9vbGEgYW5kIHNlYXQgQiBvbmx5IHdhbnRzIDMgbW9vbGEsIHNlYXQgQSByZXRhaW5zIDJcbiAqIG1vb2xhLlxuICpcbiAqIElmIHRoZSBzd2FwIGZhaWxzLCBubyBhc3NldHMgYXJlIHRyYW5zZmVycmVkLCBib3RoIHNlYXRzIHdpbGwgZmFpbCxcbiAqIGFuZCB0aGUgZnVuY3Rpb24gdGhyb3dzLlxuICpcbiAqIFRoZSBrZXl3b3JkcyBmb3IgYm90aCBzZWF0cyBtdXN0IG1hdGNoLlxuICpcbiAqIEBwYXJhbSB7WkNGfSB6Y2ZcbiAqIEBwYXJhbSB7WkNGU2VhdH0gbGVmdFNlYXRcbiAqIEBwYXJhbSB7WkNGU2VhdH0gcmlnaHRTZWF0XG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFN3YXBFeGFjdFxuICpcbiAqIFN3YXAgc3VjaCB0aGF0IGJvdGggc2VhdHMgZ2FpbiB3aGF0IHRoZXkgd2FudCBhbmQgbG9zZSBldmVyeXRoaW5nXG4gKiB0aGF0IHRoZXkgZ2F2ZS4gT25seSBnb29kIGZvciBleGFjdCBhbmQgZW50aXJlIHN3YXBzIHdoZXJlIGVhY2hcbiAqIHNlYXQgd2FudHMgZXZlcnl0aGluZyB0aGF0IHRoZSBvdGhlciBzZWF0IGhhcy4gVGhlIGJlbmVmaXQgb2YgdXNpbmdcbiAqIHRoaXMgbWV0aG9kIGlzIHRoYXQgdGhlIGtleXdvcmRzIG9mIGVhY2ggc2VhdCBkbyBub3QgbWF0dGVyLlxuICpcbiAqIElmIHRoZSBzd2FwIGZhaWxzLCBubyBhc3NldHMgYXJlIHRyYW5zZmVycmVkLCBib3RoIHNlYXRzIHdpbGwgZmFpbCxcbiAqIGFuZCB0aGUgZnVuY3Rpb24gdGhyb3dzLlxuICpcbiAqIEBwYXJhbSB7WkNGfSB6Y2ZcbiAqIEBwYXJhbSB7WkNGU2VhdH0gbGVmdFNlYXRcbiAqIEBwYXJhbSB7WkNGU2VhdH0gcmlnaHRTZWF0XG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge1JlY29yZDxLZXl3b3JkLEtleXdvcmQ+fSBLZXl3b3JkS2V5d29yZFJlY29yZFxuICpcbiAqIEEgbWFwcGluZyBvZiBrZXl3b3JkcyB0byBrZXl3b3Jkcy5cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBSZXZlcnNlXG4gKlxuICogR2l2ZW4gYSBtYXBwaW5nIG9mIGtleXdvcmRzIHRvIGtleXdvcmRzLCBpbnZlcnQgdGhlIGtleXMgYW5kXG4gKiB2YWx1ZXMuIFRoaXMgaXMgdXNlZCB0byBtYXAgdGhlIG9mZmVycyBtYWRlIHRvIGFub3RoZXIgY29udHJhY3RcbiAqIGJhY2sgdG8gdGhlIGtleXdvcmRzIHVzZWQgaW4gdGhlIGZpcnN0IGNvbnRyYWN0LlxuICogQHBhcmFtIHtLZXl3b3JkS2V5d29yZFJlY29yZH0gW2tleXdvcmRSZWNvcmRdXG4gKiBAcmV0dXJucyB7S2V5d29yZEtleXdvcmRSZWNvcmQgfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIE1hcEtleXdvcmRzXG4gKlxuICogUmVtYXAgdGhlIGtleXdvcmRzIG9mIGFuIGFtb3VudEtleXdvcmRSZWNvcmQsIGlzc3VlcktleXdvcmRSZWNvcmQsIG9yIGFcbiAqIFBheW1lbnRQS2V5d29yZFJlY29yZCBhY2NvcmRpbmcgdG8gYSBtYXBwaW5nLiBUaGlzIGlzIHVzZWQgdG8gcmVtYXBcbiAqIGZyb20ga2V5d29yZHMgdXNlZCBpbiBjb250cmFjdEEgdG8ga2V5d29yZHMgdXNlZCBpbiBjb250cmFjdEIgYW5kXG4gKiB2aWNlIHZlcnNhIGluIGBvZmZlclRvYFxuICpcbiAqIEBwYXJhbSB7QW1vdW50S2V5d29yZFJlY29yZCB8IFBheW1lbnRQS2V5d29yZFJlY29yZCB8IElzc3VlcktleXdvcmRSZWNvcmQgfCB1bmRlZmluZWQgfSBrZXl3b3JkUmVjb3JkXG4gKiBAcGFyYW0ge0tleXdvcmRLZXl3b3JkUmVjb3JkfSBrZXl3b3JkTWFwcGluZ1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUmF0aW9cbiAqIEBwcm9wZXJ0eSB7QW1vdW50PCduYXQnPn0gbnVtZXJhdG9yXG4gKiBAcHJvcGVydHkge0Ftb3VudDwnbmF0Jz59IGRlbm9taW5hdG9yXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgU2NhbGVBbW91bnRcbiAqIEBwYXJhbSB7QW1vdW50PCduYXQnPn0gYW1vdW50XG4gKiBAcGFyYW0ge1JhdGlvfSByYXRpb1xuICogQHJldHVybnMge0Ftb3VudDwnbmF0Jz59XG4gKi9cbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAANLF3GrQ4AAC0OAAAOwAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC96b2VIZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4uL2NvbnRyYWN0RmFjZXQvb2ZmZXJTYWZldHkuanMiLCIuL2F0b21pY1RyYW5zZmVyLmpzIiwiQGFnb3JpYy9lcnRwIiwiQGFnb3JpYy9pbnRlcm5hbCIsIkBhZ29yaWMvc3RvcmUiLCJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vcHJvbWlzZS1raXQiXSwiZXhwb3J0cyI6WyJhc3NlcnRJc3N1ZXJLZXl3b3JkcyIsImFzc2VydE5hdEFzc2V0S2luZCIsImFzc2VydFByb3Bvc2FsU2hhcGUiLCJkZWZhdWx0QWNjZXB0YW5jZU1zZyIsImRlcG9zaXRUb1NlYXQiLCJkZXBvc2l0VG9TZWF0U3VjY2Vzc01zZyIsImZpdFByb3Bvc2FsU2hhcGUiLCJtYXBLZXl3b3JkcyIsIm9mZmVyVG8iLCJzYXRpc2ZpZXMiLCJzYXZlQWxsSXNzdWVycyIsInN3YXAiLCJzd2FwRXhhY3QiLCJ3aXRoZHJhd0Zyb21TZWF0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG11c3RNYXRjaCxrZXlFUSxFLG1ha2VQcm9taXNlS2l0LEFzc2V0S2luZCxmcm9tVW5pcXVlRW50cmllcyxzYXRpc2ZpZXNXYW50LGF0b21pY1JlYXJyYW5nZSxhdG9taWNUcmFuc2Zlcixmcm9tT25seSx0b09ubHk7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9zdG9yZVwiLCBbW1wibXVzdE1hdGNoXCIsIFskaOKAjV9hID0+IChtdXN0TWF0Y2ggPSAkaOKAjV9hKV1dLFtcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3Byb21pc2Uta2l0XCIsIFtbXCJtYWtlUHJvbWlzZUtpdFwiLCBbJGjigI1fYSA9PiAobWFrZVByb21pc2VLaXQgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBc3NldEtpbmRcIiwgWyRo4oCNX2EgPT4gKEFzc2V0S2luZCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL2ludGVybmFsXCIsIFtbXCJmcm9tVW5pcXVlRW50cmllc1wiLCBbJGjigI1fYSA9PiAoZnJvbVVuaXF1ZUVudHJpZXMgPSAkaOKAjV9hKV1dXV0sW1wiLi4vY29udHJhY3RGYWNldC9vZmZlclNhZmV0eS5qc1wiLCBbW1wic2F0aXNmaWVzV2FudFwiLCBbJGjigI1fYSA9PiAoc2F0aXNmaWVzV2FudCA9ICRo4oCNX2EpXV1dXSxbXCIuL2F0b21pY1RyYW5zZmVyLmpzXCIsIFtbXCJhdG9taWNSZWFycmFuZ2VcIiwgWyRo4oCNX2EgPT4gKGF0b21pY1JlYXJyYW5nZSA9ICRo4oCNX2EpXV0sW1wiYXRvbWljVHJhbnNmZXJcIiwgWyRo4oCNX2EgPT4gKGF0b21pY1RyYW5zZmVyID0gJGjigI1fYSldXSxbXCJmcm9tT25seVwiLCBbJGjigI1fYSA9PiAoZnJvbU9ubHkgPSAkaOKAjV9hKV1dLFtcInRvT25seVwiLCBbJGjigI1fYSA9PiAodG9Pbmx5ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5jb25zdCAgICAgICAgZGVmYXVsdEFjY2VwdGFuY2VNc2c9IGBUaGUgb2ZmZXIgaGFzIGJlZW4gYWNjZXB0ZWQuIE9uY2UgdGhlIGNvbnRyYWN0IGhhcyBiZWVuIGNvbXBsZXRlZCwgcGxlYXNlIGNoZWNrIHlvdXIgcGF5b3V0YDskaOKAjV9vbmNlLmRlZmF1bHRBY2NlcHRhbmNlTXNnKGRlZmF1bHRBY2NlcHRhbmNlTXNnKTtcblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG5jb25zdCBnZXRLZXlzU29ydGVkPShvYmopPT5oYXJkZW4oUmVmbGVjdC5vd25LZXlzKG9ianx8e30pLnNvcnQoKSk7XG5cbmNvbnN0ICAgICAgICBhc3NlcnRJc3N1ZXJLZXl3b3Jkcz0oemNmLGV4cGVjdGVkKT0+e1xuY29uc3R7aXNzdWVyc309emNmLmdldFRlcm1zKCk7XG5jb25zdCBhY3R1YWw9Z2V0S2V5c1NvcnRlZChpc3N1ZXJzKTtcbmV4cGVjdGVkPVsuLi5leHBlY3RlZF07LyogaW4gY2FzZSBoYXJkZW5lZCovXG5leHBlY3RlZC5zb3J0KCk7XG5rZXlFUShhY3R1YWwsaGFyZGVuKGV4cGVjdGVkKSl8fFxuRmFpbCBga2V5d29yZHM6ICR7YWN0dWFsfSB3ZXJlIG5vdCBhcyBleHBlY3RlZDogJHtleHBlY3RlZH1gO1xuIH07XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gWmNmU2VhdFBhcnRpYWxcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvcG9zYWxSZWNvcmR9IGdldFByb3Bvc2FsXG4gKiBAcHJvcGVydHkgeygpID0+IEFsbG9jYXRpb259IGdldEN1cnJlbnRBbGxvY2F0aW9uXG4gKi9cblxuLyoqXG4gKiBDaGVjayB3aGV0aGVyIGFuIHVwZGF0ZSB0byBjdXJyZW50QWxsb2NhdGlvbiBzYXRpc2ZpZXNcbiAqIHByb3Bvc2FsLndhbnQuIE5vdGUgdGhhdCB0aGlzIGlzIGhhbGYgb2YgdGhlIG9mZmVyIHNhZmV0eVxuICogY2hlY2s7IHdoZXRoZXIgdGhlIGFsbG9jYXRpb24gY29uc3RpdHV0ZXMgYSByZWZ1bmQgaXMgbm90XG4gKiBjaGVja2VkLiBUaGUgdXBkYXRlIGlzIG1lcmdlZCB3aXRoIGN1cnJlbnRBbGxvY2F0aW9uXG4gKiAodXBkYXRlJ3MgdmFsdWVzIHByZXZhaWxpbmcgaWYgdGhlIGtleXdvcmRzIGFyZSB0aGUgc2FtZSlcbiAqIHRvIHByb2R1Y2UgdGhlIG5ld0FsbG9jYXRpb24uIFRoZSByZXR1cm4gdmFsdWUgaXMgMCBmb3JcbiAqIGZhbHNlIGFuZCAxIGZvciB0cnVlLiBXaGVuIG11bHRpcGxlcyBhcmUgaW50cm9kdWNlZCwgYW55XG4gKiBwb3NpdGl2ZSByZXR1cm4gdmFsdWUgd2lsbCBtZWFuIHRydWUuXG4gKlxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtaY2ZTZWF0UGFydGlhbH0gc2VhdFxuICogQHBhcmFtIHtBbW91bnRLZXl3b3JkUmVjb3JkfSB1cGRhdGVcbiAqIEByZXR1cm5zIHswfDF9XG4gKi8kaOKAjV9vbmNlLmFzc2VydElzc3VlcktleXdvcmRzKGFzc2VydElzc3VlcktleXdvcmRzKTtcbmNvbnN0ICAgICAgICBzYXRpc2ZpZXM9KHpjZixzZWF0LHVwZGF0ZSk9PntcbmNvbnN0IGN1cnJlbnRBbGxvY2F0aW9uPXNlYXQuZ2V0Q3VycmVudEFsbG9jYXRpb24oKTtcbmNvbnN0IG5ld0FsbG9jYXRpb249ey4uLmN1cnJlbnRBbGxvY2F0aW9uLC4uLnVwZGF0ZX07XG5jb25zdCBwcm9wb3NhbD1zZWF0LmdldFByb3Bvc2FsKCk7XG5yZXR1cm4gc2F0aXNmaWVzV2FudChwcm9wb3NhbCxuZXdBbGxvY2F0aW9uKTtcbiB9O1xuXG4vKiogQHR5cGUge1N3YXB9ICovJGjigI1fb25jZS5zYXRpc2ZpZXMoc2F0aXNmaWVzKTtcbmNvbnN0ICAgICAgICBzd2FwPSh6Y2YsbGVmdFNlYXQscmlnaHRTZWF0KT0+e1xudHJ5e1xuYXRvbWljUmVhcnJhbmdlKFxuemNmLFxuaGFyZGVuKFtcbltyaWdodFNlYXQsbGVmdFNlYXQsbGVmdFNlYXQuZ2V0UHJvcG9zYWwoKS53YW50XSxcbltsZWZ0U2VhdCxyaWdodFNlYXQscmlnaHRTZWF0LmdldFByb3Bvc2FsKCkud2FudF1dKSk7XG5cblxuIH1jYXRjaChlcnIpe1xubGVmdFNlYXQuZmFpbChlcnIpO1xucmlnaHRTZWF0LmZhaWwoZXJyKTtcbnRocm93IGVycjtcbiB9XG5cbmxlZnRTZWF0LmV4aXQoKTtcbnJpZ2h0U2VhdC5leGl0KCk7XG5yZXR1cm4gZGVmYXVsdEFjY2VwdGFuY2VNc2c7XG4gfTtcblxuLyoqIEB0eXBlIHtTd2FwRXhhY3R9ICovJGjigI1fb25jZS5zd2FwKHN3YXApO1xuY29uc3QgICAgICAgIHN3YXBFeGFjdD0oemNmLGxlZnRTZWF0LHJpZ2h0U2VhdCk9PntcbnRyeXtcbmF0b21pY1JlYXJyYW5nZShcbnpjZixcbmhhcmRlbihbXG5mcm9tT25seShyaWdodFNlYXQscmlnaHRTZWF0LmdldFByb3Bvc2FsKCkuZ2l2ZSksXG5mcm9tT25seShsZWZ0U2VhdCxsZWZ0U2VhdC5nZXRQcm9wb3NhbCgpLmdpdmUpLFxuXG50b09ubHkobGVmdFNlYXQsbGVmdFNlYXQuZ2V0UHJvcG9zYWwoKS53YW50KSxcbnRvT25seShyaWdodFNlYXQscmlnaHRTZWF0LmdldFByb3Bvc2FsKCkud2FudCldKSk7XG5cblxuIH1jYXRjaChlcnIpe1xubGVmdFNlYXQuZmFpbChlcnIpO1xucmlnaHRTZWF0LmZhaWwoZXJyKTtcbnRocm93IGVycjtcbiB9XG5cbmxlZnRTZWF0LmV4aXQoKTtcbnJpZ2h0U2VhdC5leGl0KCk7XG5yZXR1cm4gZGVmYXVsdEFjY2VwdGFuY2VNc2c7XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiBFeHBlY3RlZFJlY29yZFxuICogQHByb3BlcnR5IHtSZWNvcmQ8S2V5d29yZCwgbnVsbD59IFt3YW50XVxuICogQHByb3BlcnR5IHtSZWNvcmQ8S2V5d29yZCwgbnVsbD59IFtnaXZlXVxuICogQHByb3BlcnR5IHtQYXJ0aWFsPFJlY29yZDxrZXlvZiBQcm9wb3NhbFJlY29yZFsnZXhpdCddLCBudWxsPj59IFtleGl0XVxuICovXG5cbi8qKlxuICogQ2hlY2sgdGhlIHNlYXQncyBwcm9wb3NhbCBhZ2FpbnN0IGBwcm9wb3NhbFNoYXBlYC5cbiAqIElmIHRoZSBjbGllbnQgc3VibWl0cyBhbiBvZmZlciB3aGljaCBkb2VzIG5vdCBtYXRjaFxuICogdGhlc2UgZXhwZWN0YXRpb25zLCB0aGUgc2VhdCB3aWxsIGJlIGV4aXRlZCAoYW5kIHBheW1lbnRzIHJlZnVuZGVkKS5cbiAqXG4gKiBAcGFyYW0ge1pDRlNlYXR9IHNlYXRcbiAqIEBwYXJhbSB7UGF0dGVybn0gcHJvcG9zYWxTaGFwZVxuICovJGjigI1fb25jZS5zd2FwRXhhY3Qoc3dhcEV4YWN0KTtcbmNvbnN0ICAgICAgICBmaXRQcm9wb3NhbFNoYXBlPShzZWF0LHByb3Bvc2FsU2hhcGUpPT5cbi8qIFRPRE8gcmVtb3ZlIHRoaXMgaGFyZGVuLCBvYmxpZ2F0aW5nIG91ciBjYWxsZXIgdG8gaGFyZGVuLiovXG5tdXN0TWF0Y2goc2VhdC5nZXRQcm9wb3NhbCgpLGhhcmRlbihwcm9wb3NhbFNoYXBlKSwncHJvcG9zYWwnKTtcblxuLyoqXG4gKiBDaGVjayB0aGUgc2VhdCdzIHByb3Bvc2FsIGFnYWluc3QgYW4gYGV4cGVjdGVkYCByZWNvcmQgdGhhdCBzYXlzXG4gKiB3aGF0IFwic2hhcGVcIiBvZiBwcm9wb3NhbCBpcyBhY2NlcHRhYmxlLlxuICpcbiAqIE5vdGUgdGhhdCBieSBvdXIgY3VycmVudCB0ZXJtaW5vbG9neSwgdGhpcyBmdW5jdGlvbiBpcyBtaXNuYW1lZCBiZWNhdXNlXG4gKiB3ZSB1c2VcbiAqIFtcIlNoYXBlXCIgdG8gcmVmZXIgdG8gcGF0dGVybnNdKGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9ibG9iL21hc3Rlci9wYWNrYWdlcy9zdG9yZS9zcmMvdHlwZXMuanMjTDU2LUw3NCksXG4gKiBhbmQgdGhlIGBleHBlY3RlZGAgYXJndW1lbnQgaXMgbm90IHN1Y2ggYSBwYXR0ZXJuLiBSYXRoZXIgaXQgaXMgYW4gYWQtaG9jXG4gKiBwYXR0ZXJuLWxpa2Ugc3BlY2lhbCBjYXNlIHJlY29yZCB0aGF0IGlzIGRpZmZlcmVudCBhbmQgbXVjaCBsZXNzIGV4cHJlc3NpdmUuXG4gKlxuICogVGhpcyBFeHBlY3RlZFJlY29yZCBpcyBsaWtlIGEgUHJvcG9zYWwsIGJ1dCB0aGUgYW1vdW50cyBpbiAnd2FudCdcbiAqIGFuZCAnZ2l2ZScgc2hvdWxkIGJlIG51bGw7IHRoZSBleGl0IGNsYXVzZSBzaG91bGQgc3BlY2lmeSBhIHJ1bGUgd2l0aFxuICogbnVsbCBjb250ZW50cy4gSWYgdGhlIGNsaWVudCBzdWJtaXRzIGFuIG9mZmVyIHdoaWNoIGRvZXMgbm90IG1hdGNoXG4gKiB0aGVzZSBleHBlY3RhdGlvbnMsIHRoZSBzZWF0IHdpbGwgYmUgZXhpdGVkIChhbmQgcGF5bWVudHMgcmVmdW5kZWQpLlxuICpcbiAqIEBkZXByZWNhdGVkIFVzZSBvcHRpb25hbCBgcHJvcG9zYWxTaGFwZWAgYXJndW1lbnQgdG8gYG1ha2VJbnZpdGF0aW9uYCB3aXRoXG4gKiBhIGdlbnVpbmUgcGF0dGVybi5cbiAqIEBwYXJhbSB7WkNGU2VhdH0gc2VhdFxuICogQHBhcmFtIHtFeHBlY3RlZFJlY29yZH0gZXhwZWN0ZWRcbiAqLyRo4oCNX29uY2UuZml0UHJvcG9zYWxTaGFwZShmaXRQcm9wb3NhbFNoYXBlKTtcbmNvbnN0ICAgICAgICBhc3NlcnRQcm9wb3NhbFNoYXBlPShzZWF0LGV4cGVjdGVkKT0+e1xuYXNzZXJ0LnR5cGVvZihleHBlY3RlZCwnb2JqZWN0Jyk7XG4hQXJyYXkuaXNBcnJheShleHBlY3RlZCl8fEZhaWwgYEV4cGVjdGVkIG11c3QgYmUgYW4gbm9uLWFycmF5IG9iamVjdGA7XG5jb25zdCBhc3NlcnRWYWx1ZXNOdWxsPShlKT0+e1xuaWYoZSE9PXVuZGVmaW5lZCl7XG5PYmplY3QudmFsdWVzKGUpLmZvckVhY2goXG4odmFsdWUpPT5cbnZhbHVlPT09bnVsbHx8XG5GYWlsIGBUaGUgdmFsdWUgb2YgdGhlIGV4cGVjdGVkIHJlY29yZCBtdXN0IGJlIG51bGwgYnV0IHdhcyAke3ZhbHVlfWApO1xuXG4gfVxuIH07XG5cbi8qIEFzc2VydCB2YWx1ZXMgb2YgdGhlIGV4cGVjdGVkIHJlY29yZCBhcmUgYWxsIG51bGwuIFdlIGRvIG5vdCovXG4vKiBjaGVjayB0aGUgdmFsdWVzIG9mIHRoZSBhY3R1YWwgcHJvcG9zYWwuKi9cbmFzc2VydFZhbHVlc051bGwoZXhwZWN0ZWQuZ2l2ZSk7XG5hc3NlcnRWYWx1ZXNOdWxsKGV4cGVjdGVkLndhbnQpO1xuYXNzZXJ0VmFsdWVzTnVsbChleHBlY3RlZC5leGl0KTtcblxuY29uc3QgYWN0dWFsPXNlYXQuZ2V0UHJvcG9zYWwoKTtcbmNvbnN0IGFzc2VydEtleXM9KGEsZSk9PntcbmlmKGUhPT11bmRlZmluZWQpe1xua2V5RVEoZ2V0S2V5c1NvcnRlZChhKSxnZXRLZXlzU29ydGVkKGUpKXx8XG5GYWlsIGBhY3R1YWwgJHthfSBkaWQgbm90IG1hdGNoIGV4cGVjdGVkICR7ZX1gO1xuIH1cbiB9O1xuYXNzZXJ0S2V5cyhhY3R1YWwuZ2l2ZSxleHBlY3RlZC5naXZlKTtcbmFzc2VydEtleXMoYWN0dWFsLndhbnQsZXhwZWN0ZWQud2FudCk7XG5hc3NlcnRLZXlzKGFjdHVhbC5leGl0LGV4cGVjdGVkLmV4aXQpO1xuIH07XG5cbi8qIEdpdmVuIGEgYnJhbmQsIGFzc2VydCB0aGF0IGJyYW5kIGlzIEFzc2V0S2luZC5OQVQuICovJGjigI1fb25jZS5hc3NlcnRQcm9wb3NhbFNoYXBlKGFzc2VydFByb3Bvc2FsU2hhcGUpO1xuY29uc3QgICAgICAgIGFzc2VydE5hdEFzc2V0S2luZD0oemNmLGJyYW5kKT0+e1xuemNmLmdldEFzc2V0S2luZChicmFuZCk9PT1Bc3NldEtpbmQuTkFUfHxcbkZhaWwgYGJyYW5kIG11c3QgYmUgQXNzZXRLaW5kLk5BVGA7XG4gfTskaOKAjV9vbmNlLmFzc2VydE5hdEFzc2V0S2luZChhc3NlcnROYXRBc3NldEtpbmQpO1xuXG5jb25zdCAgICAgICAgZGVwb3NpdFRvU2VhdFN1Y2Nlc3NNc2c9IGBEZXBvc2l0IGFuZCByZWFsbG9jYXRpb24gc3VjY2Vzc2Z1bC5gO1xuXG4vKipcbiAqIERlcG9zaXQgcGF5bWVudHMgc3VjaCB0aGF0IHRoZWlyIGFtb3VudHMgYXJlIHJlYWxsb2NhdGVkIHRvIGEgc2VhdC5cbiAqIFRoZSBgYW1vdW50c2AgYW5kIGBwYXltZW50c2AgcmVjb3JkcyBtdXN0IGhhdmUgY29ycmVzcG9uZGluZ1xuICoga2V5d29yZHMuXG4gKlxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtaQ0ZTZWF0fSByZWNpcGllbnRTZWF0XG4gKiBAcGFyYW0ge0Ftb3VudEtleXdvcmRSZWNvcmR9IGFtb3VudHNcbiAqIEBwYXJhbSB7UGF5bWVudFBLZXl3b3JkUmVjb3JkfSBwYXltZW50c1xuICogQHJldHVybnMge1Byb21pc2U8c3RyaW5nPn0gYERlcG9zaXQgYW5kIHJlYWxsb2NhdGlvbiBzdWNjZXNzZnVsLmBcbiAqLyRo4oCNX29uY2UuZGVwb3NpdFRvU2VhdFN1Y2Nlc3NNc2coZGVwb3NpdFRvU2VhdFN1Y2Nlc3NNc2cpO1xuY29uc3QgICAgICAgIGRlcG9zaXRUb1NlYXQ9YXN5bmMoemNmLHJlY2lwaWVudFNlYXQsYW1vdW50cyxwYXltZW50cyk9PntcbiFyZWNpcGllbnRTZWF0Lmhhc0V4aXRlZCgpfHxGYWlsIGBUaGUgcmVjaXBpZW50U2VhdCBjYW5ub3QgaGF2ZSBleGl0ZWQuYDtcblxuLyogV2Ugd2lsbCBjcmVhdGUgYSB0ZW1wb3Jhcnkgb2ZmZXIgdG8gYmUgYWJsZSB0byBlc2Nyb3cgb3VyIHBheW1lbnRzKi9cbi8qIHdpdGggWm9lLiovXG5jb25zdCByZWFsbG9jYXRlQWZ0ZXJEZXBvc2l0PSh0ZW1wU2VhdCk9Pntcbi8qIEFmdGVyIHRoZSBhc3NldHMgYXJlIGRlcG9zaXRlZCwgcmVhbGxvY2F0ZSB0aGVtIG9udG8gdGhlIHJlY2lwaWVudCBzZWF0IGFuZCovXG4vKiBleGl0IHRoZSB0ZW1wb3Jhcnkgc2VhdC4gTm90ZSB0aGF0IHRoZSBvZmZlclJlc3VsdCBpcyB0aGUgcmV0dXJuIHZhbHVlIG9mIHRoaXMqL1xuLyogZnVuY3Rpb24sIHNvIHRoaXMgc3luY2hyb25vdXMgdHJhZGUgbXVzdCBoYXBwZW4gYmVmb3JlIHRoZSovXG4vKiBvZmZlclJlc3VsdCByZXNvbHZlcy4qL1xuYXRvbWljVHJhbnNmZXIoemNmLHRlbXBTZWF0LHJlY2lwaWVudFNlYXQsYW1vdW50cyk7XG50ZW1wU2VhdC5leGl0KCk7XG5yZXR1cm4gZGVwb3NpdFRvU2VhdFN1Y2Nlc3NNc2c7XG4gfTtcbmNvbnN0IGludml0YXRpb249emNmLm1ha2VJbnZpdGF0aW9uKFxucmVhbGxvY2F0ZUFmdGVyRGVwb3NpdCxcbid0ZW1wb3Jhcnkgc2VhdCBmb3IgZGVwb3NpdCcpO1xuXG5jb25zdCBwcm9wb3NhbD1oYXJkZW4oe2dpdmU6YW1vdW50c30pO1xuaGFyZGVuKHBheW1lbnRzKTtcbi8qIFRvIGVzY3JvdyB0aGUgcGF5bWVudCwgd2UgbXVzdCBnZXQgdGhlIFpvZSBTZXJ2aWNlIGZhY2V0IGFuZCovXG4vKiBtYWtlIGFuIG9mZmVyKi9cbmNvbnN0IHpvZT16Y2YuZ2V0Wm9lU2VydmljZSgpO1xuY29uc3QgdGVtcFVzZXJTZWF0PUUoem9lKS5vZmZlcihpbnZpdGF0aW9uLHByb3Bvc2FsLHBheW1lbnRzKTtcbi8qIFRoaXMgd2lsbCBiZSBhIHByb21pc2UgZm9yIHRoZSBzdHJpbmc6IGBEZXBvc2l0IGFuZCByZWFsbG9jYXRpb24qL1xuLyogc3VjY2Vzc2Z1bC5gIEl0IHdpbGwgb25seSBmdWxmaWxsIGFmdGVyIHRoZSBhc3NldHMgaGF2ZSBiZWVuKi9cbi8qIHN1Y2Nlc3NmdWxseSByZWFsbG9jYXRlZCB0byB0aGUgcmVjaXBpZW50IHNlYXQuKi9cbnJldHVybiBFKHRlbXBVc2VyU2VhdCkuZ2V0T2ZmZXJSZXN1bHQoKTtcbiB9O1xuXG4vKipcbiAqIFdpdGhkcmF3IHBheW1lbnRzIGZyb20gYSBzZWF0LiBOb3RlIHRoYXQgd2l0aGRyYXdpbmcgdGhlIGFtb3VudHMgb2ZcbiAqIHRoZSBwYXltZW50cyBtdXN0IG5vdCBhbmQgY2Fubm90IHZpb2xhdGUgb2ZmZXIgc2FmZXR5IGZvciB0aGUgc2VhdC4gVGhlXG4gKiBgYW1vdW50c2AgYW5kIGBwYXltZW50c2AgcmVjb3JkcyBtdXN0IGhhdmUgY29ycmVzcG9uZGluZyBrZXl3b3Jkcy5cbiAqXG4gKiBAcGFyYW0ge1pDRn0gemNmXG4gKiBAcGFyYW0ge1pDRlNlYXR9IHNlYXRcbiAqIEBwYXJhbSB7QW1vdW50S2V5d29yZFJlY29yZH0gYW1vdW50c1xuICogQHJldHVybnMge1Byb21pc2U8UGF5bWVudFBLZXl3b3JkUmVjb3JkPn1cbiAqLyRo4oCNX29uY2UuZGVwb3NpdFRvU2VhdChkZXBvc2l0VG9TZWF0KTtcbmNvbnN0ICAgICAgICB3aXRoZHJhd0Zyb21TZWF0PWFzeW5jKHpjZixzZWF0LGFtb3VudHMpPT57XG4hc2VhdC5oYXNFeGl0ZWQoKXx8RmFpbCBgVGhlIHNlYXQgY2Fubm90IGhhdmUgZXhpdGVkLmA7XG5jb25zdHt6Y2ZTZWF0OnRlbXBTZWF0LHVzZXJTZWF0OnRlbXBVc2VyU2VhdFB9PXpjZi5tYWtlRW1wdHlTZWF0S2l0KCk7XG5hdG9taWNUcmFuc2Zlcih6Y2Ysc2VhdCx0ZW1wU2VhdCxhbW91bnRzKTtcbnRlbXBTZWF0LmV4aXQoKTtcbnJldHVybiBFKHRlbXBVc2VyU2VhdFApLmdldFBheW91dHMoKTtcbiB9O1xuXG4vKipcbiAqIFNhdmUgYWxsIG9mIHRoZSBpc3N1ZXJzIGluIGFuIGlzc3VlcnNLZXl3b3JkUmVjb3JkIHRvIFpDRiwgdXNpbmdcbiAqIHRoZSBtZXRob2QgYHpjZi5zYXZlSXNzdWVyYC4gVGhpcyBkb2VzIG5vdCBlcnJvciBpZiBhbnkgb2YgdGhlIGtleXdvcmRzXG4gKiBhbHJlYWR5IGV4aXN0LiBJZiB0aGUga2V5d29yZCBpcyBhbHJlYWR5IHByZXNlbnQsIGl0IGlzIGlnbm9yZWQuXG4gKlxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtJc3N1ZXJLZXl3b3JkUmVjb3JkfSBpc3N1ZXJLZXl3b3JkUmVjb3JkIElzc3VlcnMgdG8gc2F2ZSB0b1xuICogWkNGXG4gKi8kaOKAjV9vbmNlLndpdGhkcmF3RnJvbVNlYXQod2l0aGRyYXdGcm9tU2VhdCk7XG5jb25zdCAgICAgICAgc2F2ZUFsbElzc3VlcnM9YXN5bmMoemNmLGlzc3VlcktleXdvcmRSZWNvcmQ9aGFyZGVuKHt9KSk9PntcbmNvbnN0e2lzc3VlcnN9PXpjZi5nZXRUZXJtcygpO1xuY29uc3QgaXNzdWVyc1BTYXZlZD1PYmplY3QuZW50cmllcyhpc3N1ZXJLZXl3b3JkUmVjb3JkKS5tYXAoXG4oW2tleXdvcmQsaXNzdWVyXSk9Pntcbi8qIElmIHRoZSBrZXl3b3JkIGRvZXMgbm90IHlldCBleGlzdCwgYWRkIGl0IGFuZCB0aGUqL1xuLyogYXNzb2NpYXRlZCBpc3N1ZXIuKi9cbmlmKGlzc3VlcnNba2V5d29yZF09PT11bmRlZmluZWQpe1xucmV0dXJuIHpjZi5zYXZlSXNzdWVyKGlzc3VlcixrZXl3b3JkKTtcbiB9XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH0pO1xuXG5yZXR1cm4gUHJvbWlzZS5hbGwoaXNzdWVyc1BTYXZlZCk7XG4gfTtcblxuLyoqIEB0eXBlIHtNYXBLZXl3b3Jkc30gKi8kaOKAjV9vbmNlLnNhdmVBbGxJc3N1ZXJzKHNhdmVBbGxJc3N1ZXJzKTtcbmNvbnN0ICAgICAgICBtYXBLZXl3b3Jkcz0oa2V5d29yZFJlY29yZD17fSxrZXl3b3JkTWFwcGluZyk9PntcbnJldHVybiBoYXJkZW4oXG5mcm9tVW5pcXVlRW50cmllcyhcbk9iamVjdC5lbnRyaWVzKGtleXdvcmRSZWNvcmQpLm1hcCgoW2tleXdvcmQsdmFsdWVdKT0+e1xuaWYoa2V5d29yZE1hcHBpbmdba2V5d29yZF09PT11bmRlZmluZWQpe1xucmV0dXJuW2tleXdvcmQsdmFsdWVdO1xuIH1cbnJldHVybltrZXl3b3JkTWFwcGluZ1trZXl3b3JkXSx2YWx1ZV07XG4gfSkpKTtcblxuXG4gfTtcbi8qKiBAdHlwZSB7UmV2ZXJzZX0gKi8kaOKAjV9vbmNlLm1hcEtleXdvcmRzKG1hcEtleXdvcmRzKTtcbmNvbnN0IHJldmVyc2U9KGtleXdvcmRSZWNvcmQ9e30pPT57XG5yZXR1cm4gaGFyZGVuKFxuZnJvbVVuaXF1ZUVudHJpZXMoXG5PYmplY3QuZW50cmllcyhrZXl3b3JkUmVjb3JkKS5tYXAoKFtrZXksdmFsdWVdKT0+W3ZhbHVlLGtleV0pKSk7XG5cblxuIH07XG5cbi8qKlxuICogTWFrZSBhbiBvZmZlciB0byBhbm90aGVyIGNvbnRyYWN0IGluc3RhbmNlIChsYWJlbGVkIGNvbnRyYWN0QiBiZWxvdyksXG4gKiB3aXRoZHJhd2luZyB0aGUgcGF5bWVudHMgZm9yIHRoZSBvZmZlciBmcm9tIGEgc2VhdCBpbiB0aGUgY3VycmVudFxuICogY29udHJhY3QgaW5zdGFuY2UgKGNvbnRyYWN0QSkgYW5kIGRlcG9zaXRpbmcgdGhlIHBheW91dHMgaW4gYW5vdGhlclxuICogc2VhdCBpbiB0aGUgY3VycmVudCBjb250cmFjdCBpbnN0YW5jZSAoY29udHJhY3RBKS5cbiAqXG4gKiBAcGFyYW0ge1pDRn0gemNmXG4gKiAgIFpvZSBDb250cmFjdCBGYWNldCBmb3IgY29udHJhY3RBXG4gKlxuICogQHBhcmFtIHtFUmVmPEludml0YXRpb248UmVzdWx0LCBBcmdzPj59IGludml0YXRpb25cbiAqICAgSW52aXRhdGlvbiB0byBjb250cmFjdEJcbiAqXG4gKiBAcGFyYW0ge0tleXdvcmRLZXl3b3JkUmVjb3JkIHwgdW5kZWZpbmVkfSBrZXl3b3JkTWFwcGluZ1xuICogICBNYXBwaW5nIG9mIGtleXdvcmRzIHVzZWQgaW4gY29udHJhY3RBIHRvIGtleXdvcmRzIHRvIGJlIHVzZWQgaW5cbiAqICAgY29udHJhY3RCLiBOb3RlIHRoYXQgdGhlIHBhdGh3YXkgdG8gZGVwb3NpdCB0aGUgcGF5b3V0IGJhY2sgdG9cbiAqICAgY29udHJhY3RBIHJldmVyc2VzIHRoaXMgbWFwcGluZy5cbiAqXG4gKiBAcGFyYW0ge1Byb3Bvc2FsfSBwcm9wb3NhbFxuICogICBUaGUgcHJvcG9zYWwgZm9yIHRoZSBvZmZlciB0byBiZSBtYWRlIHRvIGNvbnRyYWN0QlxuICpcbiAqIEBwYXJhbSB7WkNGU2VhdH0gZnJvbVNlYXRcbiAqICAgVGhlIHNlYXQgaW4gY29udHJhY3RBIHRvIHRha2UgdGhlIG9mZmVyIHBheW1lbnRzIGZyb20uXG4gKlxuICogQHBhcmFtIHtaQ0ZTZWF0fSBbdG9TZWF0PWZyb21TZWF0XVxuICogICBUaGUgc2VhdCBpbiBjb250cmFjdEEgdG8gZGVwb3NpdCB0aGUgcGF5b3V0IG9mIHRoZSBvZmZlciB0by5cbiAqICAgSWYgYHRvU2VhdGAgaXMgbm90IHByb3ZpZGVkLCB0aGlzIGRlZmF1bHRzIHRvIHRoZSBgZnJvbVNlYXRgLlxuICpcbiAqIEBwYXJhbSB7QXJnc30gW29mZmVyQXJnc11cbiAqICAgQWRkaXRpb25hbCBjb250cmFjdC1zcGVjaWZpYyBvcHRpb25hbCBhcmd1bWVudHMgaW4gYSByZWNvcmQuXG4gKlxuICogQHJldHVybnMge1Byb21pc2U8e3VzZXJTZWF0UHJvbWlzZTogUHJvbWlzZTxVc2VyU2VhdDxSZXN1bHQ+PiwgZGVwb3NpdGVkOiBQcm9taXNlPEFtb3VudEtleXdvcmRSZWNvcmQ+fT59XG4gKiAgIEEgcHJvbWlzZSBmb3IgdGhlIHVzZXJTZWF0IGZvciB0aGUgb2ZmZXIgdG8gdGhlIG90aGVyIGNvbnRyYWN0LCBhbmQgYVxuICogICBwcm9taXNlIChgZGVwb3NpdGVkYCkgd2hpY2ggcmVzb2x2ZXMgd2hlbiB0aGUgcGF5b3V0IGZvciB0aGUgb2ZmZXIgaGFzIGJlZW5cbiAqICAgZGVwb3NpdGVkIHRvIHRoZSBgdG9TZWF0YC5cbiAqICAgQW55IGZhaWx1cmVzIG9mIHRoZSBpbnZpdGF0aW9uIHdpbGwgYmUgcmV0dXJuZWQgYnkgYHVzZXJTZWF0UHJvbWlzZS5nZXRPZmZlclJlc3VsdCgpYC5cbiAqXG4gKiBAdGVtcGxhdGUge29iamVjdH0gQXJncyBPZmZlciBhcmdzXG4gKiBAdGVtcGxhdGUge29iamVjdH0gUmVzdWx0IE9mZmVyIHJlc3VsdFxuICovXG5jb25zdCAgICAgICAgb2ZmZXJUbz1hc3luYyhcbnpjZixcbmludml0YXRpb24sXG5rZXl3b3JkTWFwcGluZyxcbnByb3Bvc2FsLFxuZnJvbVNlYXQsXG50b1NlYXQsXG5vZmZlckFyZ3MpPT5cbntcbmlmKGtleXdvcmRNYXBwaW5nPT09dW5kZWZpbmVkKXtcbmtleXdvcmRNYXBwaW5nPWhhcmRlbih7fSk7XG4gfVxuXG5jb25zdCBkZWZpbmVkVG9TZWF0PXRvU2VhdCE9PXVuZGVmaW5lZD90b1NlYXQ6ZnJvbVNlYXQ7XG5cbmNvbnN0IHpvZT16Y2YuZ2V0Wm9lU2VydmljZSgpO1xuY29uc3QgbWFwcGluZ1JldmVyc2VkPXJldmVyc2Uoa2V5d29yZE1hcHBpbmcpO1xuXG5jb25zdCBuZXdLZXl3b3Jkcz1cbnByb3Bvc2FsIT09dW5kZWZpbmVkP1xubWFwS2V5d29yZHMocHJvcG9zYWwuZ2l2ZSxtYXBwaW5nUmV2ZXJzZWQpOlxuaGFyZGVuKHt9KTtcblxuLyogdGhlIHByb3Bvc2FsIGlzIGluIHRoZSBvdGhlciBjb250cmFjdCdzIGtleXdvcmRzLCBidXQgd2Ugd2FudCB0byovXG4vKiB1c2UgYHByb3Bvc2FsLmdpdmVgIHRvIHdpdGhkcmF3Ki9cbmNvbnN0IHBheW1lbnRzPWF3YWl0IHdpdGhkcmF3RnJvbVNlYXQoemNmLGZyb21TZWF0LG5ld0tleXdvcmRzKTtcblxuLyogTWFwIHRvIHRoZSBvdGhlciBjb250cmFjdCdzIGtleXdvcmRzKi9cbmNvbnN0IHBheW1lbnRzRm9yT3RoZXJDb250cmFjdD1tYXBLZXl3b3JkcyhwYXltZW50cyxrZXl3b3JkTWFwcGluZyk7XG5cbmNvbnN0IHVzZXJTZWF0UHJvbWlzZT1FKHpvZSkub2ZmZXIoXG5pbnZpdGF0aW9uLFxucHJvcG9zYWwsXG5wYXltZW50c0Zvck90aGVyQ29udHJhY3QsXG5vZmZlckFyZ3MpO1xuXG5cbmNvbnN0IGRlcG9zaXRlZFByb21pc2VLaXQ9bWFrZVByb21pc2VLaXQoKTtcblxuY29uc3QgZG9EZXBvc2l0PWFzeW5jKHBheW91dFBheW1lbnRzKT0+e1xuLyogYWZ0ZXIgZ2V0UGF5b3V0cygpLCBnZXRGaW5hbEFsbG9jYXRpb24oKSByZXNvbHZlcyBwcm9tcHRseS4qL1xuY29uc3QgYW1vdW50cz1hd2FpdCBFKHVzZXJTZWF0UHJvbWlzZSkuZ2V0RmluYWxBbGxvY2F0aW9uKCk7XG5cbi8qIE1hcCBiYWNrIHRvIHRoZSBvcmlnaW5hbCBjb250cmFjdCdzIGtleXdvcmRzKi9cbmNvbnN0IG1hcHBlZEFtb3VudHM9bWFwS2V5d29yZHMoYW1vdW50cyxtYXBwaW5nUmV2ZXJzZWQpO1xuY29uc3QgbWFwcGVkUGF5bWVudHM9bWFwS2V5d29yZHMocGF5b3V0UGF5bWVudHMsbWFwcGluZ1JldmVyc2VkKTtcbmF3YWl0IGRlcG9zaXRUb1NlYXQoemNmLGRlZmluZWRUb1NlYXQsbWFwcGVkQW1vdW50cyxtYXBwZWRQYXltZW50cyk7XG5kZXBvc2l0ZWRQcm9taXNlS2l0LnJlc29sdmUobWFwcGVkQW1vdW50cyk7XG4gfTtcblxuRSh1c2VyU2VhdFByb21pc2UpLmdldFBheW91dHMoKS50aGVuKGRvRGVwb3NpdCk7XG5cbi8qIFRPRE8gcmVuYW1lIHJldHVybiBrZXk7IHVzZXJTZWF0UHJvbWlzZSBpcyBhIHJlbW90ZSBVc2VyU2VhdCovXG5yZXR1cm4gaGFyZGVuKHt1c2VyU2VhdFByb21pc2UsZGVwb3NpdGVkOmRlcG9zaXRlZFByb21pc2VLaXQucHJvbWlzZX0pO1xuIH07JGjigI1fb25jZS5vZmZlclRvKG9mZmVyVG8pO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHRBY2NlcHRhbmNlTXNnIjpbImRlZmF1bHRBY2NlcHRhbmNlTXNnIl0sImFzc2VydElzc3VlcktleXdvcmRzIjpbImFzc2VydElzc3VlcktleXdvcmRzIl0sInNhdGlzZmllcyI6WyJzYXRpc2ZpZXMiXSwic3dhcCI6WyJzd2FwIl0sInN3YXBFeGFjdCI6WyJzd2FwRXhhY3QiXSwiZml0UHJvcG9zYWxTaGFwZSI6WyJmaXRQcm9wb3NhbFNoYXBlIl0sImFzc2VydFByb3Bvc2FsU2hhcGUiOlsiYXNzZXJ0UHJvcG9zYWxTaGFwZSJdLCJhc3NlcnROYXRBc3NldEtpbmQiOlsiYXNzZXJ0TmF0QXNzZXRLaW5kIl0sImRlcG9zaXRUb1NlYXRTdWNjZXNzTXNnIjpbImRlcG9zaXRUb1NlYXRTdWNjZXNzTXNnIl0sImRlcG9zaXRUb1NlYXQiOlsiZGVwb3NpdFRvU2VhdCJdLCJ3aXRoZHJhd0Zyb21TZWF0IjpbIndpdGhkcmF3RnJvbVNlYXQiXSwic2F2ZUFsbElzc3VlcnMiOlsic2F2ZUFsbElzc3VlcnMiXSwibWFwS2V5d29yZHMiOlsibWFwS2V5d29yZHMiXSwib2ZmZXJUbyI6WyJvZmZlclRvIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAPIwdINXBwAAVwcAADsAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdHMvY2FsbFNwcmVhZC90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qKlxuICogQHR5cGVkZWYgeydsb25nJyB8ICdzaG9ydCd9IFBvc2l0aW9uS2luZFxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIE1ha2VPcHRpb25JbnZpdGF0aW9uXG4gKiBAcGFyYW0ge1Bvc2l0aW9uS2luZH0gcG9zaXRpb25LaW5kXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxJbnZpdGF0aW9uPn1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFBheW9mZkhhbmRsZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gdm9pZH0gc2NoZWR1bGVQYXlvZmZzXG4gKiBAcHJvcGVydHkgIHtNYWtlT3B0aW9uSW52aXRhdGlvbn0gbWFrZU9wdGlvbkludml0YXRpb25cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IENhbGN1bGF0ZVNoYXJlc1JldHVyblxuICogUmV0dXJuIHZhbHVlIGZyb20gY2FsY3VsYXRlU2hhcmVzLCB3aGljaCByZXByZXNlbnRzIHRoZSBwb3J0aW9ucyBhc3NpZ25lZCB0b1xuICogdGhlIGxvbmcgYW5kIHNob3J0IHNpZGUgb2YgYSB0cmFuc2FjdGlvbi4gVGhlc2Ugd2lsbCBiZSB0d28gbm9uLW5lZ2F0aXZlXG4gKiBpbnRlZ2VycyB0aGF0IHN1bSB0byAxMDAuXG4gKiBAcHJvcGVydHkge1JhdGlvfSBsb25nU2hhcmVcbiAqIEBwcm9wZXJ0eSB7UmF0aW99IHNob3J0U2hhcmVcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBDYWxjdWxhdGVTaGFyZXNcbiAqIGNhbGN1bGF0ZSB0aGUgcG9ydGlvbiAoYXMgYSBwZXJjZW50YWdlKSBvZiB0aGUgY29sbGF0ZXJhbCB0aGF0IHNob3VsZCBiZVxuICogYWxsb2NhdGVkIHRvIHRoZSBsb25nIHNpZGUgb2YgYSBjYWxsIHNwcmVhZCBjb250cmFjdC4gcHJpY2UgZ2l2ZXMgdGhlIHZhbHVlXG4gKiBvZiB0aGUgdW5kZXJseWluZyBhc3NldCBhdCBjbG9zaW5nIHRoYXQgZGV0ZXJtaW5lcyB0aGUgcGF5b3V0cyB0byB0aGUgcGFydGllc1xuICpcbiAqIGlmIHByaWNlIDw9IHN0cmlrZVByaWNlMSwgcmV0dXJuIFJhdGlvIHJlcHJlc2VudGluZyAwXG4gKiBpZiBwcmljZSA+PSBzdHJpa2VQcmljZTIsIHJldHVybiBSYXRpbyByZXByZXNlbnRpbmcgMS5cbiAqIE90aGVyd2lzZSByZXR1cm4gbG9uZ1NoYXJlIGFuZCBzaG9ydFNoYXJlIHJlcHJlc2VudGluZyByYXRpb3MgYmV0d2VlbiAwJSBhbmRcbiAqIDEwMCUgcmVmbGVjdGluZyB0aGUgcG9zaXRpb24gb2YgdGhlIHByaWNlIGluIHRoZSByYW5nZSBmcm9tIHN0cmlrZVByaWNlMSB0b1xuICogc3RyaWtlUHJpY2UyLlxuICogQHBhcmFtIHtCcmFuZH0gY29sbGF0ZXJhbEJyYW5kXG4gKiBAcGFyYW0ge0Ftb3VudDwnbmF0Jz59IHByaWNlXG4gKiBAcGFyYW0ge0Ftb3VudDwnbmF0Jz59IHN0cmlrZVByaWNlMVxuICogQHBhcmFtIHtBbW91bnQ8J25hdCc+fSBzdHJpa2VQcmljZTJcbiAqIEByZXR1cm5zIHtDYWxjdWxhdGVTaGFyZXNSZXR1cm59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgTWFrZTEwMFBlcmNlbnRcbiAqIEBwYXJhbSB7QnJhbmR9IGJyYW5kXG4gKiBAcmV0dXJucyB7UmF0aW99XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgTWFrZTBQZXJjZW50XG4gKiBAcGFyYW0ge0JyYW5kfSBicmFuZFxuICogQHJldHVybnMge1JhdGlvfVxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAACkLpMm4AQAAuAEAADMAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdHMvZXhwb3J0ZWQuanN7ImltcG9ydHMiOlsiLi9jYWxsU3ByZWFkL3R5cGVzLmpzIiwiLi9sb2FuL3R5cGVzLmpzIiwiLi90eXBlcy5qcyJdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3R5cGVzLmpzXCIsIFtdXSxbXCIuL2xvYW4vdHlwZXMuanNcIiwgW11dLFtcIi4vY2FsbFNwcmVhZC90eXBlcy5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA6dHsNaMaAACjGgAANQAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0cy9sb2FuL3R5cGVzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyoqXG4gKiBAdHlwZWRlZiB7Tm90aWZpZXI8WGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVzdGFtcFJlY29yZD59IFBlcmlvZE5vdGlmaWVyXG4gKlxuICogIFRoZSBOb3RpZmllciB0aGF0IHByb3ZpZGVzIG5vdGlmaWNhdGlvbnMgdGhhdCBwZXJpb2RzIGhhdmUgcGFzc2VkLlxuICogIFNpbmNlIG5vdGlmaWVycyBjYW4ndCBiZSByZWxpZWQgb24gdG8gcHJvZHVjZSBhbiBvdXRwdXQgZXZlcnkgdGltZVxuICogIHRoZXkgc2hvdWxkLCB3ZSdsbCB0cmFjayB0aGUgdGltZSBvZiBsYXN0IHBheW1lbnQsIGFuZCBjYXRjaCB1cCBpZlxuICogIGFueSB0aW1lcyBoYXZlIGJlZW4gbWlzc2VkLiBDb21wb3VuZCBpbnRlcmVzdCB3aWxsIGJlIGNhbGN1bGF0ZWRcbiAqICB1c2luZyB0aGUgaW50ZXJlc3RSYXRlLlxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge0luc3RhbmNlfSBBdXRvc3dhcEluc3RhbmNlXG4gKiAgIFRoZSBydW5uaW5nIGNvbnRyYWN0IGluc3RhbmNlIGZvciBhbiBBdXRvc3dhcCBpbnN0YWxsYXRpb24uICBUaGVcbiAqICAgcHVibGljRmFjZXQgZnJvbSB0aGUgQXV0b3N3YXBcbiAqICAgaW5zdGFuY2UgaXMgdXNlZCBmb3IgcHJvZHVjaW5nIGFuIGludml0YXRpb24gdG8gc2VsbCB0aGVcbiAqICAgY29sbGF0ZXJhbCBvbiBsaXF1aWRhdGlvbi5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIExvYW5UZXJtc1xuICpcbiAqIEBwcm9wZXJ0eSB7UmF0aW99IG1tciAtIE1haW50ZW5hbmNlIE1hcmdpbiBSZXF1aXJlbWVudCwgYSBSYXRpbyByZWNvcmQuXG4gKiBEZWZhdWx0IGlzIDE1MCVcbiAqXG4gKiBAcHJvcGVydHkge0F1dG9zd2FwSW5zdGFuY2V9IGF1dG9zd2FwSW5zdGFuY2VcbiAqXG4gKiBAcHJvcGVydHkge1ByaWNlQXV0aG9yaXR5fSBwcmljZUF1dGhvcml0eVxuICpcbiAqICAgVXNlZCBmb3IgZ2V0dGluZyB0aGUgY3VycmVudCB2YWx1ZSBvZiBjb2xsYXRlcmFsIGFuZCBzZXR0aW5nXG4gKiAgIGxpcXVpZGF0aW9uIHRyaWdnZXJzLlxuICpcbiAqIEBwcm9wZXJ0eSB7UGVyaW9kTm90aWZpZXJ9IHBlcmlvZE5vdGlmaWVyXG4gKlxuICogQHByb3BlcnR5IHtSYXRpb30gaW50ZXJlc3RSYXRlXG4gKiAgIFRoZSByYXRlIGluIGJhc2lzIHBvaW50cyB0aGF0IHdpbGwgYmUgbXVsdGlwbGllZCB3aXRoIHRoZSBkZWJ0IG9uXG4gKiAgIGV2ZXJ5IHBlcmlvZCB0byBjb21wb3VuZCBpbnRlcmVzdC5cbiAqXG4gKiBAcHJvcGVydHkge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5SZWxhdGl2ZVRpbWV9IGludGVyZXN0UGVyaW9kXG4gKlxuICogQHByb3BlcnR5IHtCcmFuZH0gbG9hbkJyYW5kXG4gKiBAcHJvcGVydHkge0JyYW5kfSBjb2xsYXRlcmFsQnJhbmRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIExlbmRlclNlYXRQcm9wZXJ0eVxuICogQHByb3BlcnR5IHtaQ0ZTZWF0fSBsZW5kZXJTZWF0XG4gKlxuICogICBUaGUgWkNGU2VhdCByZXByZXNlbnRpbmcgdGhlIGxlbmRlcidzIHBvc2l0aW9uIGluIHRoZSBjb250cmFjdC5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtMb2FuVGVybXMgJiBMZW5kZXJTZWF0UHJvcGVydHl9IExvYW5Db25maWdXaXRoTGVuZGVyXG4gKlxuICogVGhlIGxvYW4gbm93IGhhcyBhIGxlbmRlclNlYXQsIHdoaWNoIGlzIGFkZGVkIHRvIHRoZSBjb25maWcuXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiBCb3Jyb3dlckNvbmZpZ1Byb3BlcnRpZXNcbiAqXG4gKiBAcHJvcGVydHkge1pDRlNlYXR9IGNvbGxhdGVyYWxTZWF0XG4gKlxuICogICBUaGUgWkNGU2VhdCBob2xkaW5nIHRoZSBjb2xsYXRlcmFsIGluIGVzY3JvdyBhZnRlciB0aGUgYm9ycm93ZXJcbiAqICAgZXNjcm93cyBpdFxuICpcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gQW1vdW50PCduYXQnPn0gZ2V0RGVidFxuICpcbiAqICAgQSBmdW5jdGlvbiB0byBnZXQgdGhlIGN1cnJlbnQgZGVidFxuICpcbiAqIEBwcm9wZXJ0eSB7UHJvbWlzZVJlY29yZDxQcmljZVF1b3RlPn0gbGlxdWlkYXRpb25Qcm9taXNlS2l0XG4gKlxuICogICBQcm9taXNlS2l0IHRoYXQgaW5jbHVkZXMgYSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgdG8gYSBQcmljZVF1b3RlXG4gKiAgIHdoZW4gbGlxdWlkYXRpb24gaXMgdHJpZ2dlcmVkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiBCb3Jyb3dlckNvbmZpZ1Byb3BlcnRpZXNNaW51c0RlYnRcbiAqXG4gKiBAcHJvcGVydHkge1pDRlNlYXR9IGNvbGxhdGVyYWxTZWF0XG4gKlxuICogICBUaGUgWkNGU2VhdCBob2xkaW5nIHRoZSBjb2xsYXRlcmFsIGluIGVzY3JvdyBhZnRlciB0aGUgYm9ycm93ZXJcbiAqICAgZXNjcm93cyBpdFxuICpcbiAqIEBwcm9wZXJ0eSB7UHJvbWlzZVJlY29yZDxQcmljZVF1b3RlPn0gbGlxdWlkYXRpb25Qcm9taXNlS2l0XG4gKlxuICogICBQcm9taXNlS2l0IHRoYXQgaW5jbHVkZXMgYSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgdG8gYSBQcmljZVF1b3RlXG4gKiAgIHdoZW4gbGlxdWlkYXRpb24gaXMgdHJpZ2dlcmVkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7TG9hbkNvbmZpZ1dpdGhMZW5kZXIgJiBCb3Jyb3dlckNvbmZpZ1Byb3BlcnRpZXMgfSBMb2FuQ29uZmlnV2l0aEJvcnJvd2VyXG4gKlxuICogVGhlIGxvYW4gaGFzIGEgbGVuZGVyLCBhIGJvcnJvd2VyLCBhbmQgY29sbGF0ZXJhbCBlc2Nyb3dlZC5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtMb2FuQ29uZmlnV2l0aExlbmRlciAmIEJvcnJvd2VyQ29uZmlnUHJvcGVydGllc01pbnVzRGVidFxuICogfSBMb2FuQ29uZmlnV2l0aEJvcnJvd2VyTWludXNEZWJ0XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgU2NoZWR1bGVMaXF1aWRhdGlvblxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtMb2FuQ29uZmlnV2l0aEJvcnJvd2VyfSBjb25maWdcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBNYWtlTGVuZEludml0YXRpb25cbiAqIEBwYXJhbSB7WkNGfSB6Y2ZcbiAqIEBwYXJhbSB7TG9hblRlcm1zfSBjb25maWdcbiAqIEByZXR1cm5zIHtQcm9taXNlPEludml0YXRpb24+fSBsZW5kSW52aXRhdGlvblxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIE1ha2VCb3Jyb3dJbnZpdGF0aW9uXG4gKiBAcGFyYW0ge1pDRn0gemNmXG4gKiBAcGFyYW0ge0xvYW5Db25maWdXaXRoTGVuZGVyfSBjb25maWdcbiAqIEByZXR1cm5zIHtQcm9taXNlPEludml0YXRpb24+fSBib3Jyb3dJbnZpdGF0aW9uXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgTWFrZUNsb3NlTG9hbkludml0YXRpb25cbiAqIEBwYXJhbSB7WkNGfSB6Y2ZcbiAqIEBwYXJhbSB7TG9hbkNvbmZpZ1dpdGhCb3Jyb3dlcn0gY29uZmlnXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxJbnZpdGF0aW9uPn0gY2xvc2VMb2FuSW52aXRhdGlvblxuICovXG5cbi8qKlxuICogQWxsb3dzIGhvbGRlciB0byBhZGQgY29sbGF0ZXJhbCB0byB0aGUgY29udHJhY3QuIEV4aXRzIHRoZSBzZWF0XG4gKiBhZnRlciBhZGRpbmcuXG4gKlxuICogQGNhbGxiYWNrIE1ha2VBZGRDb2xsYXRlcmFsSW52aXRhdGlvblxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtMb2FuQ29uZmlnV2l0aEJvcnJvd2VyfSBjb25maWdcbiAqIEByZXR1cm5zIHtQcm9taXNlPEludml0YXRpb24+fSBhZGRDb2xsYXRlcmFsSW52aXRhdGlvblxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIExpcXVpZGF0ZVxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtMb2FuQ29uZmlnV2l0aEJvcnJvd2VyfSBjb25maWdcbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIE1ha2VEZWJ0Q2FsY3VsYXRvclxuICogQHBhcmFtIHtEZWJ0Q2FsY3VsYXRvckNvbmZpZ30gZGVidENhbGN1bGF0b3JDb25maWdcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBDYWxjSW50ZXJlc3RGblxuICogQHBhcmFtIHtBbW91bnQ8J25hdCc+fSBvbGREZWJ0XG4gKiBAcGFyYW0ge1JhdGlvfSBpbnRlcmVzdFJhdGVcbiAqIEByZXR1cm5zIHtBbW91bnQ8J25hdCc+fSBpbnRlcmVzdFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVidENhbGN1bGF0b3JDb25maWdcbiAqIEBwcm9wZXJ0eSB7Q2FsY0ludGVyZXN0Rm59IGNhbGNJbnRlcmVzdEZuXG4gKlxuICogICBBIGZ1bmN0aW9uIHRvIGNhbGN1bGF0ZSB0aGUgaW50ZXJlc3QsIGdpdmVuIHRoZSBkZWJ0IHZhbHVlIGFuZCBhblxuICogICBpbnRlcmVzdCByYXRlIGluIGJhc2lzIHBvaW50cy5cbiAqXG4gKiBAcHJvcGVydHkge0Ftb3VudDwnbmF0Jz59IG9yaWdpbmFsRGVidFxuICpcbiAqICAgVGhlIGRlYnQgYXQgdGhlIHN0YXJ0IG9mIHRoZSBsb2FuLCBpbiBMb2FuIGJyYW5kXG4gKlxuICogQHByb3BlcnR5IHtQZXJpb2ROb3RpZmllcn0gcGVyaW9kTm90aWZpZXJcbiAqXG4gKiAgIFRoZSBBc3luY0l0ZXJhYmxlIHRvIG5vdGlmeSB3aGVuIGEgcGVyaW9kIGhhcyBvY2N1cnJlZFxuICpcbiAqIEBwcm9wZXJ0eSB7UmF0aW99IGludGVyZXN0UmF0ZVxuICogQHByb3BlcnR5IHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuUmVsYXRpdmVUaW1lfSBpbnRlcmVzdFBlcmlvZFxuICpcbiAqICB0aGUgcGVyaW9kIGF0IHdoaWNoIHRoZSBvdXRzdGFuZGluZyBkZWJ0IGluY3JlYXNlcyBieSB0aGUgaW50ZXJlc3RSYXRlXG4gKlxuICogQHByb3BlcnR5IHtaQ0Z9IHpjZlxuICpcbiAqIEBwcm9wZXJ0eSB7TG9hbkNvbmZpZ1dpdGhCb3Jyb3dlck1pbnVzRGVidH0gY29uZmlnTWludXNHZXREZWJ0XG4gKiBAcHJvcGVydHkge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lc3RhbXB9IGJhc2V0aW1lIFRoZSBzdGFydGluZyBwb2ludCBmcm9tIHdoaWNoIHRvIGNhbGN1bGF0ZVxuICogaW50ZXJlc3QuXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb25maWdNaW51c0dldERlYnRcbiAqIEBwcm9wZXJ0eSB7WkNGU2VhdH0gY29sbGF0ZXJhbFNlYXRcbiAqIEBwcm9wZXJ0eSB7UHJvbWlzZVJlY29yZDxhbnk+fSBsaXF1aWRhdGlvblByb21pc2VLaXRcbiAqIEBwcm9wZXJ0eSB7YmlnaW50fSBbbW1yXVxuICogQHByb3BlcnR5IHtIYW5kbGU8J0luc3RhbmNlJz59IGF1dG9zd2FwSW5zdGFuY2VcbiAqIEBwcm9wZXJ0eSB7UHJpY2VBdXRob3JpdHl9IHByaWNlQXV0aG9yaXR5XG4gKiBAcHJvcGVydHkge1BlcmlvZE5vdGlmaWVyfSBwZXJpb2ROb3RpZmllclxuICogQHByb3BlcnR5IHtiaWdpbnR9IGludGVyZXN0UmF0ZVxuICogQHByb3BlcnR5IHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuUmVsYXRpdmVUaW1lfSBpbnRlcmVzdFBlcmlvZFxuICogQHByb3BlcnR5IHtaQ0ZTZWF0fSBsZW5kZXJTZWF0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBCb3Jyb3dGYWNldFxuICpcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxJbnZpdGF0aW9uPn0gbWFrZUNsb3NlTG9hbkludml0YXRpb25cbiAqXG4gKiBNYWtlIGFuIGludml0YXRpb24gdG8gY2xvc2UgdGhlIGxvYW4gYnkgcmVwYXlpbmcgdGhlIGRlYnRcbiAqICAgKGluY2x1ZGluZyBpbnRlcmVzdCkuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEludml0YXRpb24+fSBtYWtlQWRkQ29sbGF0ZXJhbEludml0YXRpb25cbiAqXG4gKiBNYWtlIGFuIGludml0YXRpb24gdG8gYWRkIGNvbGxhdGVyYWwgdG8gcHJvdGVjdCBhZ2FpbnN0IGxpcXVpZGF0aW9uXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPFByaWNlUXVvdGU+fSBnZXRMaXF1aWRhdGlvblByb21pc2VcbiAqXG4gKiBHZXQgYSBwcm9taXNlIGZvciBhIHByaWNlUXVvdGUgdGhhdCB3aWxsIHJlc29sdmUgaWYgbGlxdWlkYXRpb25cbiAqIG9jY3Vycy4gVGhlIHByaWNlUXVvdGUgaXMgZm9yIHRoZSB2YWx1ZSBvZiB0aGUgY29sbGF0ZXJhbCB0aGF0XG4gKiB0cmlnZ2VyZWQgdGhlIGxpcXVpZGF0aW9uLiBUaGlzIG1heSBiZSBsb3dlciB0aGFuIGV4cGVjdGVkIGlmIHRoZVxuICogcHJpY2UgaXMgbW92aW5nIHF1aWNrbHkuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wfSBnZXRMYXN0Q2FsY3VsYXRpb25UaW1lc3RhbXBcbiAqXG4gKiBHZXQgdGhlIHRpbWVzdGFtcCBhdCB3aGljaCB0aGUgZGVidCB3YXMgbW9zdCByZWNlbnRseSByZWNhbGN1bGF0ZWQuXG4gKlxuICogQHByb3BlcnR5IHsoKSA9PiBOb3RpZmllcjxBbW91bnQ+fSBnZXREZWJ0Tm90aWZpZXJcbiAqXG4gKiBHZXQgYSBOb3RpZmllciB0aGF0IHdpbGwgYmUgdXBkYXRlZCB3aGVuIHRoZSBjdXJyZW50IGRlYnQgKGFuIEFtb3VudCB3aXRoIHRoZSBMb2FuXG4gKiBCcmFuZCkgY2hhbmdlcy4gVGhpcyB3aWxsIGluY3JlYXNlIGFzIGludGVyZXN0IGlzIGFkZGVkLlxuICpcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gQW1vdW50fSBnZXRSZWNlbnRDb2xsYXRlcmFsQW1vdW50XG4gKlxuICogR2V0IGEgcmVjZW50IHJlcG9ydCBvZiB0aGUgYW1vdW50IG9mIGNvbGxhdGVyYWwgaW4gdGhlIGxvYW5cbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA4Wbpi0gsAANILAAAwAAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RzL3R5cGVzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTZWxsSXRlbXNQdWJsaWNGYWNldFxuICogQHByb3BlcnR5IHsoKSA9PiBJc3N1ZXJ9IGdldEl0ZW1zSXNzdWVyXG4gKiBAcHJvcGVydHkgeygpID0+IEFtb3VudH0gZ2V0QXZhaWxhYmxlSXRlbXNcbiAqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTZWxsSXRlbXNDcmVhdG9yT25seVxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEludml0YXRpb24+fSBtYWtlQnV5ZXJJbnZpdGF0aW9uXG4gKlxuICogQHR5cGVkZWYge1NlbGxJdGVtc1B1YmxpY0ZhY2V0ICYgU2VsbEl0ZW1zQ3JlYXRvck9ubHl9IFNlbGxJdGVtc0NyZWF0b3JGYWNldFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gU2VsbEl0ZW1zUGFyYW1ldGVyc1xuICogQHByb3BlcnR5IHtSZWNvcmQ8c3RyaW5nLCBhbnk+fSBjdXN0b21WYWx1ZVByb3BlcnRpZXNcbiAqIEBwcm9wZXJ0eSB7bnVtYmVyfSBjb3VudFxuICogQHByb3BlcnR5IHtJc3N1ZXJ9IG1vbmV5SXNzdWVyXG4gKiBAcHJvcGVydHkge0luc3RhbGxhdGlvbn0gc2VsbEl0ZW1zSW5zdGFsbGF0aW9uXG4gKiBAcHJvcGVydHkge0Ftb3VudH0gcHJpY2VQZXJJdGVtXG4gKlxuICogQHR5cGVkZWYge29iamVjdH0gU2VsbEl0ZW1zUmVzdWx0XG4gKiBAcHJvcGVydHkge1VzZXJTZWF0fSBzZWxsSXRlbXNDcmVhdG9yU2VhdFxuICogQHByb3BlcnR5IHtTZWxsSXRlbXNDcmVhdG9yRmFjZXR9IHNlbGxJdGVtc0NyZWF0b3JGYWNldFxuICogQHByb3BlcnR5IHtJbnN0YW5jZX0gc2VsbEl0ZW1zSW5zdGFuY2VcbiAqIEBwcm9wZXJ0eSB7U2VsbEl0ZW1zUHVibGljRmFjZXR9IHNlbGxJdGVtc1B1YmxpY0ZhY2V0XG4gKlxuICogQHR5cGVkZWYge29iamVjdH0gTWludEFuZFNlbGxORlRDcmVhdG9yRmFjZXRcbiAqIEBwcm9wZXJ0eSB7KHNlbGxQYXJhbXM6IFNlbGxJdGVtc1BhcmFtZXRlcnMpID0+IFByb21pc2U8U2VsbEl0ZW1zUmVzdWx0Pn0gc2VsbFRva2Vuc1xuICogQHByb3BlcnR5IHsoKSA9PiBJc3N1ZXJ9IGdldElzc3VlclxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQXV0b21hdGljUmVmdW5kUHVibGljRmFjZXRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gYmlnaW50fSBnZXRPZmZlcnNDb3VudFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEludml0YXRpb24+fSBtYWtlSW52aXRhdGlvblxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQXV0b3N3YXBQdWJsaWNGYWNldFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEludml0YXRpb24+fSBtYWtlU3dhcEludml0YXRpb24gc3lub255bSBmb3JcbiAqIG1ha2VTd2FwSW5JbnZpdGF0aW9uXG4gKiBAcHJvcGVydHkgeygpID0+IFByb21pc2U8SW52aXRhdGlvbj59IG1ha2VTd2FwSW5JbnZpdGF0aW9uIG1ha2UgYW4gaW52aXRhdGlvblxuICogdGhhdCBhbGxvd3Mgb25lIHRvIGRvIGEgc3dhcCBpbiB3aGljaCB0aGUgSW4gYW1vdW50IGlzIHNwZWNpZmllZCBhbmQgdGhlIE91dFxuICogYW1vdW50IGlzIGNhbGN1bGF0ZWRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxJbnZpdGF0aW9uPn0gbWFrZVN3YXBPdXRJbnZpdGF0aW9uIG1ha2UgYW4gaW52aXRhdGlvblxuICogdGhhdCBhbGxvd3Mgb25lIHRvIGRvIGEgc3dhcCBpbiB3aGljaCB0aGUgT3V0IGFtb3VudCBpcyBzcGVjaWZpZWQgYW5kIHRoZSBJblxuICogYW1vdW50IGlzIGNhbGN1bGF0ZWRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxJbnZpdGF0aW9uPn0gbWFrZUFkZExpcXVpZGl0eUludml0YXRpb24gbWFrZSBhblxuICogaW52aXRhdGlvbiB0aGF0IGFsbG93cyBvbmUgdG8gYWRkIGxpcXVpZGl0eSB0byB0aGUgcG9vbC5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxJbnZpdGF0aW9uPn0gbWFrZVJlbW92ZUxpcXVpZGl0eUludml0YXRpb24gbWFrZSBhblxuICogaW52aXRhdGlvbiB0aGF0IGFsbG93cyBvbmUgdG8gcmVtb3ZlIGxpcXVpZGl0eSBmcm9tIHRoZSBwb29sLlxuICogQHByb3BlcnR5IHsoKSA9PiBJc3N1ZXJ9IGdldExpcXVpZGl0eUlzc3VlclxuICogQHByb3BlcnR5IHsoKSA9PiBiaWdpbnR9IGdldExpcXVpZGl0eVN1cHBseSBnZXQgdGhlIGN1cnJlbnQgdmFsdWUgb2ZcbiAqIGxpcXVpZGl0eSBoZWxkIGJ5IGludmVzdG9ycy5cbiAqIEBwcm9wZXJ0eSB7KGFtb3VudEluOiBBbW91bnQsIGJyYW5kT3V0OiBCcmFuZCkgPT4gQW1vdW50fSBnZXRJbnB1dFByaWNlXG4gKiBjYWxjdWxhdGUgdGhlIGFtb3VudCBvZiBicmFuZE91dCB0aGF0IHdpbGwgYmUgcmV0dXJuZWQgaWYgdGhlIGFtb3VudEluIGlzXG4gKiBvZmZlcmVkIHVzaW5nIG1ha2VTd2FwSW5JbnZpdGF0aW9uIGF0IHRoZSBjdXJyZW50IHByaWNlLlxuICogQHByb3BlcnR5IHsoYW1vdW50T3V0OiBBbW91bnQsIGJyYW5kSW46IEJyYW5kKSA9PiBBbW91bnR9IGdldE91dHB1dFByaWNlXG4gKiBjYWxjdWxhdGUgdGhlIGFtb3VudCBvZiBicmFuZEluIHRoYXQgaXMgcmVxdWlyZWQgaW4gb3JkZXIgdG8gZ2V0IGFtb3VudE91dFxuICogdXNpbmcgbWFrZVN3YXBPdXRJbnZpdGF0aW9uIGF0IHRoZSBjdXJyZW50IHByaWNlXG4gKiBAcHJvcGVydHkgeygpID0+IFJlY29yZDxzdHJpbmcsIEFtb3VudD59IGdldFBvb2xBbGxvY2F0aW9uIGdldCBhblxuICogQW1vdW50S2V5d29yZFJlY29yZCBzaG93aW5nIHRoZSBjdXJyZW50IGJhbGFuY2VzIGluIHRoZSBwb29sLlxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAG0xO1m5JwAAuScAAC8AAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9pbnRlcm5hbC10eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qIEBqZXNzaWUtY2hlY2sqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFNlYXREYXRhXG4gKiBAcHJvcGVydHkge1Byb3Bvc2FsUmVjb3JkfSBwcm9wb3NhbFxuICogQHByb3BlcnR5IHtBbGxvY2F0aW9ufSBpbml0aWFsQWxsb2NhdGlvblxuICogQHByb3BlcnR5IHtTZWF0SGFuZGxlfSBzZWF0SGFuZGxlXG4gKiBAcHJvcGVydHkge29iamVjdH0gW29mZmVyQXJnc11cbiAqL1xuXG4vKipcbiAqIEdpdmVuIGFuIGFsbG9jYXRpb24sIHdpdGhkcmF3IHBheW1lbnRzIHRvIGNyZWF0ZSBhIHBheW91dFxuICpcbiAqIEBjYWxsYmFjayBXaXRoZHJhd1BheW1lbnRzXG4gKiBAcGFyYW0ge0FsbG9jYXRpb259IGFsbG9jYXRpb25cbiAqIEByZXR1cm5zIHtQYXltZW50UEtleXdvcmRSZWNvcmR9XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiBXaXRoZHJhd0ZhY2V0XG4gKiBAcHJvcGVydHkgeyhhbGxvY2F0aW9uOkFsbG9jYXRpb24pID0+IFBheW1lbnRQS2V5d29yZFJlY29yZH0gd2l0aGRyYXdQYXltZW50c1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gSW5zdGFuY2VBZG1pbkhlbHBlclxuICogQHByb3BlcnR5IHsoem9lU2VhdEFkbWluOiBab2VTZWF0QWRtaW4pID0+IHZvaWR9IGV4aXRab2VTZWF0QWRtaW5cbiAqIEBwcm9wZXJ0eSB7KHpvZVNlYXRBZG1pbjogWm9lU2VhdEFkbWluKSA9PiBib29sZWFufSBoYXNFeGl0ZWRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFpvZVNlYXRBZG1pbktpdFxuICogQHByb3BlcnR5IHtVc2VyU2VhdH0gdXNlclNlYXRcbiAqIEBwcm9wZXJ0eSB7Wm9lU2VhdEFkbWlufSB6b2VTZWF0QWRtaW5cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBNYWtlWm9lU2VhdEFkbWluS2l0XG4gKiBNYWtlIHRoZSBab2Ugc2VhdCBhZG1pbiwgdXNlciBzZWF0IGFuZCBhIG5vdGlmaWVyXG4gKiBAcGFyYW0ge0FsbG9jYXRpb259IGluaXRpYWxBbGxvY2F0aW9uXG4gKiBAcGFyYW0ge0luc3RhbmNlQWRtaW5IZWxwZXJ9IGluc3RhbmNlQWRtaW5IZWxwZXJcbiAqIEBwYXJhbSB7UHJvcG9zYWxSZWNvcmR9IHByb3Bvc2FsXG4gKiBAcGFyYW0ge1dpdGhkcmF3RmFjZXR9IHdpdGhkcmF3RmFjZXRcbiAqIEBwYXJhbSB7RVJlZjxFeGl0T2JqPn0gZXhpdE9ialxuICogQHBhcmFtIHtFUmVmPHVua25vd24+fSBbb2ZmZXJSZXN1bHRdXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcmV0dXJucyB7Wm9lU2VhdEFkbWluS2l0fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFpvZVNlYXRBZG1pbkV4aXRcbiAqIEBwYXJhbSB7Q29tcGxldGlvbn0gW2NvbXBsZXRpb25dXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFpvZVNlYXRBZG1pblxuICogQHByb3BlcnR5IHsoYWxsb2NhdGlvbjogQWxsb2NhdGlvbikgPT4gdm9pZH0gcmVwbGFjZUFsbG9jYXRpb25cbiAqIEBwcm9wZXJ0eSB7Wm9lU2VhdEFkbWluRXhpdH0gZXhpdFxuICogQHByb3BlcnR5IHtTaHV0ZG93bldpdGhGYWlsdXJlfSBmYWlsIGNhbGxlZCB3aXRoIHRoZSByZWFzb25cbiAqIGZvciBjYWxsaW5nIGZhaWwgb24gdGhpcyBzZWF0LCB3aGVyZSByZWFzb24gaXMgbm9ybWFsbHkgYW4gaW5zdGFuY2VvZiBFcnJvci5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gU3Vic2NyaWJlcjxBbW91bnRLZXl3b3JkUmVjb3JkPn0gZ2V0RXhpdFN1YnNjcmliZXJcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayB7KGJyYW5kOiBCcmFuZCkgPT4gQXNzZXRLaW5kfSBHZXRBc3NldEtpbmRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEhhbmRsZU9mZmVyUmVzdWx0XG4gKiBAcHJvcGVydHkge1Byb21pc2U8dW5rbm93bj59IG9mZmVyUmVzdWx0UHJvbWlzZVxuICogQHByb3BlcnR5IHtFeGl0T2JqfSBleGl0T2JqXG4gKi9cblxuLyoqXG4gKiBUaGUgc2VhdEhhbmRsZSBtYXkgYmUgY3JlYXRlZCBpbiBlaXRoZXIgdGhlIFpvZSBvciBaQ0YgdmF0LFxuICogZGVwZW5kaW5nIG9uIHdoZXRoZXIgdGhlIHNlYXQgY29tZXMgZnJvbSBhIG5vcm1hbCBvZmZlciBvciBhXG4gKiByZXF1ZXN0IGJ5IHRoZSBjb250cmFjdCBmb3IgYW4gXCJlbXB0eVwiIHNlYXQuXG4gKlxuICogQHR5cGVkZWYge29iamVjdH0gSW5zdGFuY2VBZG1pblxuICogQHByb3BlcnR5IHsoKSA9PiB2b2lkfSBhc3NlcnRBY2NlcHRpbmdPZmZlcnNcbiAqIEBwcm9wZXJ0eSB7KGludml0YXRpb25IYW5kbGU6IEludml0YXRpb25IYW5kbGUsXG4gKiAgICAgaW5pdGlhbEFsbG9jYXRpb246IEFsbG9jYXRpb24sXG4gKiAgICAgcHJvcG9zYWw6IFByb3Bvc2FsUmVjb3JkLFxuICogICAgIG9mZmVyQXJncz86IG9iamVjdCxcbiAqICkgPT4gVXNlclNlYXQgfSBtYWtlVXNlclNlYXRcbiAqIEBwcm9wZXJ0eSB7TWFrZU5vRXNjcm93U2VhdH0gbWFrZU5vRXNjcm93U2VhdFxuICogQHByb3BlcnR5IHsoKSA9PiBJbnN0YW5jZX0gZ2V0SW5zdGFuY2VcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gb2JqZWN0fSBnZXRQdWJsaWNGYWNldFxuICogQHByb3BlcnR5IHsoKSA9PiBJc3N1ZXJLZXl3b3JkUmVjb3JkfSBnZXRJc3N1ZXJzXG4gKiBAcHJvcGVydHkgeygpID0+IEJyYW5kS2V5d29yZFJlY29yZH0gZ2V0QnJhbmRzXG4gKiBAcHJvcGVydHkgeygpID0+IG9iamVjdH0gZ2V0VGVybXNcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gc3RyaW5nW119IGdldE9mZmVyRmlsdGVyXG4gKiBAcHJvcGVydHkgeygpID0+IEluc3RhbGxhdGlvbn0gZ2V0SW5zdGFsbGF0aW9uXG4gKiBAcHJvcGVydHkgeyhjb21wbGV0aW9uOiBDb21wbGV0aW9uKSA9PiB2b2lkfSBleGl0QWxsU2VhdHNcbiAqIEBwcm9wZXJ0eSB7U2h1dGRvd25XaXRoRmFpbHVyZX0gZmFpbEFsbFNlYXRzXG4gKiBAcHJvcGVydHkgeygpID0+IHZvaWR9IHN0b3BBY2NlcHRpbmdPZmZlcnNcbiAqIEBwcm9wZXJ0eSB7KHN0cmluZzogc3RyaW5nKSA9PiBib29sZWFufSBpc0Jsb2NrZWRcbiAqIEBwcm9wZXJ0eSB7KGhhbmRsZU9mZmVyT2JqOiBIYW5kbGVPZmZlck9iaiwgcHVibGljRmFjZXQ6IHVua25vd24pID0+IHZvaWR9IGluaXREZWxheWVkU3RhdGVcbiAqIEBwcm9wZXJ0eSB7KHN0cmluZ3M6IHN0cmluZ1tdKSA9PiB2b2lkfSBzZXRPZmZlckZpbHRlclxuICovXG5cbi8qKlxuICogVGhlIHNlYXRIYW5kbGUgbWF5IGJlIGNyZWF0ZWQgaW4gZWl0aGVyIHRoZSBab2Ugb3IgWkNGIHZhdCxcbiAqIGRlcGVuZGluZyBvbiB3aGV0aGVyIHRoZSBzZWF0IGNvbWVzIGZyb20gYSBub3JtYWwgb2ZmZXIgb3IgYVxuICogcmVxdWVzdCBieSB0aGUgY29udHJhY3QgZm9yIGFuIFwiZW1wdHlcIiBzZWF0LlxuICpcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEhhbmRsZU9mZmVyT2JqXG4gKiBAcHJvcGVydHkgeyhpbnZpdGF0aW9uSGFuZGxlOiBJbnZpdGF0aW9uSGFuZGxlLFxuICogICAgICAgICAgICAgc2VhdERhdGE6IFNlYXREYXRhLFxuICogICAgICAgICAgICApID0+IEhhbmRsZU9mZmVyUmVzdWx0fSBoYW5kbGVPZmZlclxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFpvZUluc3RhbmNlQWRtaW5NYWtlSW52aXRhdGlvblxuICogQHBhcmFtIHtJbnZpdGF0aW9uSGFuZGxlfSBpbnZpdGF0aW9uSGFuZGxlXG4gKiBAcGFyYW0ge3N0cmluZ30gZGVzY3JpcHRpb25cbiAqIEBwYXJhbSB7UmVjb3JkPHN0cmluZywgYW55Pn0gW2N1c3RvbURldGFpbHNdXG4gKiBAcGFyYW0ge1BhdHRlcm59IFtwcm9wb3NhbFNoYXBlXVxuICogQHJldHVybnMge0ludml0YXRpb259XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBab2VJbnN0YW5jZUFkbWluXG4gKiBAcHJvcGVydHkge1pvZUluc3RhbmNlQWRtaW5NYWtlSW52aXRhdGlvbn0gbWFrZUludml0YXRpb25cbiAqIEBwcm9wZXJ0eSB7KGlzc3VlclA6IEVSZWY8SXNzdWVyPixcbiAqICAgICAgICAgICAgIGtleXdvcmQ6IEtleXdvcmRcbiAqICAgICAgICAgICAgKSA9PiBQcm9taXNlPElzc3VlclJlY29yZD59IHNhdmVJc3N1ZXJcbiAqIEBwcm9wZXJ0eSB7TWFrZVpvZU1pbnR9IG1ha2Vab2VNaW50XG4gKiBAcHJvcGVydHkge1JlZ2lzdGVyRmVlTWludH0gcmVnaXN0ZXJGZWVNaW50XG4gKiBAcHJvcGVydHkge01ha2VOb0VzY3Jvd1NlYXR9IG1ha2VOb0VzY3Jvd1NlYXRcbiAqIEBwcm9wZXJ0eSB7UmVwbGFjZUFsbG9jYXRpb25zfSByZXBsYWNlQWxsb2NhdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KGNvbXBsZXRpb246IENvbXBsZXRpb24pID0+IHZvaWR9IGV4aXRBbGxTZWF0c1xuICogQHByb3BlcnR5IHtTaHV0ZG93bldpdGhGYWlsdXJlfSBmYWlsQWxsU2VhdHNcbiAqIEBwcm9wZXJ0eSB7KHNlYXRIYW5kbGU6IFNlYXRIYW5kbGUsIGNvbXBsZXRpb246IENvbXBsZXRpb24pID0+IHZvaWR9IGV4aXRTZWF0XG4gKiBAcHJvcGVydHkgeyhzZWF0SGFuZGxlOiBTZWF0SGFuZGxlLCByZWFzb246IEVycm9yKSA9PiB2b2lkfSBmYWlsU2VhdFxuICogQHByb3BlcnR5IHsoKSA9PiB2b2lkfSBzdG9wQWNjZXB0aW5nT2ZmZXJzXG4gKiBAcHJvcGVydHkgeyhzdHJpbmdzOiBBcnJheTxzdHJpbmc+KSA9PiB2b2lkfSBzZXRPZmZlckZpbHRlclxuICogQHByb3BlcnR5IHsoKSA9PiBBcnJheTxzdHJpbmc+fSBnZXRPZmZlckZpbHRlclxuICogQHByb3BlcnR5IHsoc2VhdEhhbmRsZTogU2VhdEhhbmRsZSkgPT4gU3Vic2NyaWJlcjxBbW91bnRLZXl3b3JkUmVjb3JkPn0gZ2V0RXhpdFN1YnNjcmliZXJcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBSZWdpc3RlckZlZU1pbnRcbiAqIEBwYXJhbSB7S2V5d29yZH0ga2V5d29yZCAtIHRoZSBrZXl3b3JkIHRvIHVzZSBmb3IgdGhlIGlzc3VlclxuICogQHBhcmFtIHtGZWVNaW50QWNjZXNzfSBhbGxlZ2VkRmVlTWludEFjY2VzcyAtIGFuIG9iamVjdCB0aGF0XG4gKiBwdXJwb3J0cyB0byBiZSB0aGUgb2JqZWN0IHRoYXQgYWxsb3dzIGFjY2VzcyB0byB0aGUgZmVlTWludFxuICogQHJldHVybnMge1pvZU1pbnQ8J25hdCc+fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFdyYXBJc3N1ZXJLaXRXaXRoWm9lTWludFxuICogQHBhcmFtIHtLZXl3b3JkfSBrZXl3b3JkIC0gdGhlIGtleXdvcmQgdG8gdXNlIGZvciB0aGUgaXNzdWVyXG4gKiBAcGFyYW0ge0lzc3VlcktpdH0gbG9jYWxJc3N1ZXJLaXQgLSBhbiBpc3N1ZXIga2l0IHRoYXQgb3JpZ2luYXRlc1xuICogd2l0aGluIFpvZVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIE1ha2Vab2VNaW50XG4gKiBAcGFyYW0ge0tleXdvcmR9IGtleXdvcmRcbiAqIEBwYXJhbSB7QXNzZXRLaW5kfSBbYXNzZXRLaW5kXVxuICogQHBhcmFtIHtBZGRpdGlvbmFsRGlzcGxheUluZm99IFtkaXNwbGF5SW5mb11cbiAqIEBwYXJhbSB7SXNzdWVyT3B0aW9uc1JlY29yZH0gW29wdGlvbnNdXG4gKiBAcmV0dXJucyB7Wm9lTWludH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBNYWtlTm9Fc2Nyb3dTZWF0XG4gKiBAcGFyYW0ge0FsbG9jYXRpb259IGluaXRpYWxBbGxvY2F0aW9uXG4gKiBAcGFyYW0ge1Byb3Bvc2FsUmVjb3JkfSBwcm9wb3NhbFxuICogQHBhcmFtIHtFeGl0T2JqfSBleGl0T2JqXG4gKiBAcGFyYW0ge1NlYXRIYW5kbGV9IHNlYXRIYW5kbGVcbiAqIEByZXR1cm5zIHtVc2VyU2VhdH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBSZXBsYWNlQWxsb2NhdGlvbnNcbiAqIEBwYXJhbSB7U2VhdEhhbmRsZUFsbG9jYXRpb25bXX0gc2VhdEhhbmRsZUFsbG9jYXRpb25zXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTZWF0SGFuZGxlQWxsb2NhdGlvblxuICogQHByb3BlcnR5IHtTZWF0SGFuZGxlfSBzZWF0SGFuZGxlXG4gKiBAcHJvcGVydHkge0FsbG9jYXRpb259IGFsbG9jYXRpb25cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7QXNzZXRLaW5kfSBbSz1Bc3NldEtpbmRdXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBab2VNaW50XG4gKiBAcHJvcGVydHkgeygpID0+IElzc3VlclJlY29yZDxLPn0gZ2V0SXNzdWVyUmVjb3JkXG4gKiBAcHJvcGVydHkgeyh0b3RhbFRvTWludDogQW1vdW50PEs+KSA9PiB2b2lkfSBtaW50QW5kRXNjcm93XG4gKiBAcHJvcGVydHkgeyh0b3RhbFRvQnVybjogQW1vdW50PEs+KSA9PiB2b2lkfSB3aXRoZHJhd0FuZEJ1cm5cbiAqIE5vdGUgdGhhdCB0aGUgYnVybmluZyBpcyBhc3luY2hyb25vdXMsIGFuZCBzbyBtYXkgbm90IGhhdmUgaGFwcGVuZWQgYnlcbiAqIHRoZSB0aW1lIHdpdGhkcmF3QW5kQnVybiByZXR1cm5zLiBXZSByZWx5IG9uIG91ciBvdGhlciBib29ra2VlcGluZyBzbyB0aGF0XG4gKiB0aGVzZSBhc3NldHMgYXJlIGFzc3VtZWQgYnVybmVkIGVsc2V3aGVyZSwgc28gbm8gb25lIHdpbGwgdHJ5IHRvIGFjY2Vzc1xuICogdGhlbSBldmVuIGJlZm9yZSB0aGV5IGFyZSBhY3R1YWxseSBidXJuZWQuXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBaQ0ZSb290XG4gKiBAcHJvcGVydHkge1N0YXJ0WmNmfSBzdGFydFpjZlxuICogQHByb3BlcnR5IHtSZXN0YXJ0Q29udHJhY3R9IHJlc3RhcnRDb250cmFjdFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRXhlY3V0ZUNvbnRyYWN0UmVzdWx0XG4gKiBAcHJvcGVydHkge29iamVjdH0gY3JlYXRvckZhY2V0XG4gKiBAcHJvcGVydHkge1Byb21pc2U8SW52aXRhdGlvbj59IGNyZWF0b3JJbnZpdGF0aW9uXG4gKiBAcHJvcGVydHkge29iamVjdH0gcHVibGljRmFjZXRcbiAqIEBwcm9wZXJ0eSB7SGFuZGxlT2ZmZXJPYmp9IGhhbmRsZU9mZmVyT2JqXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgU3RhcnRaY2ZcbiAqIEBwYXJhbSB7RVJlZjxab2VJbnN0YW5jZUFkbWluPn0gem9lSW5zdGFuY2VBZG1pblxuICogQHBhcmFtIHtJbnN0YW5jZVJlY29yZH0gaW5zdGFuY2VSZWNvcmRGcm9tWm9lXG4gKiBAcGFyYW0ge0lzc3VlclJlY29yZHN9IGlzc3VlclN0b3JhZ2VGcm9tWm9lXG4gKiBAcGFyYW0ge29iamVjdH0gW3ByaXZhdGVBcmdzXVxuICogQHJldHVybnMge1Byb21pc2U8RXhlY3V0ZUNvbnRyYWN0UmVzdWx0Pn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBSZXN0YXJ0Q29udHJhY3RcbiAqIEBwYXJhbSB7b2JqZWN0fSBbcHJpdmF0ZUFyZ3NdXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxFeGVjdXRlVXBncmFkZWFibGVDb250cmFjdFJlc3VsdD59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgTWFrZUV4aXRPYmpcbiAqIEBwYXJhbSB7UHJvcG9zYWxSZWNvcmR9IHByb3Bvc2FsXG4gKiBAcGFyYW0ge1pDRlNlYXR9IHpvZVNlYXRBZG1pblxuICogQHJldHVybnMge0V4aXRPYmp9XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFeGl0T2JqXG4gKiBAcHJvcGVydHkgeygpID0+IHZvaWR9IGV4aXRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtIYW5kbGU8J1NlYXQnPn0gU2VhdEhhbmRsZVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEdldEFzc2V0S2luZEJ5QnJhbmRcbiAqIEdldCB0aGUgYXNzZXRLaW5kIGZvciBhIGJyYW5kIGtub3duIGJ5IFpvZVxuICpcbiAqIFRvIGJlIGRlbGV0ZWQgd2hlbiBicmFuZHMgaGF2ZSBhIHByb3BlcnR5IGZvciBhc3NldEtpbmRcbiAqXG4gKiBAcGFyYW0ge0JyYW5kfSBicmFuZFxuICogQHJldHVybnMge0Fzc2V0S2luZH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtBcnJheTxJc3N1ZXJSZWNvcmQ+fSBJc3N1ZXJSZWNvcmRzXG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgTWFrZVpDRlNlYXRcbiAqIEBwYXJhbSB7U2VhdERhdGF9IHNlYXREYXRhXG4gKiBAcmV0dXJucyB7WkNGU2VhdH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBEcm9wQWxsUmVmZXJlbmNlc1xuICpcbiAqIERyb3BzIGFsbCBvZiB0aGUgcmVmZXJlbmNlcyBpbiB0aGUgc2VhdC1yZWxhdGVkIHdlYWtTdG9yZXMgYnlcbiAqIGRyb3BwaW5nIHRoZSBzdG9yZXNcbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gWmNmU2VhdE1hbmFnZXJcbiAqIEBwcm9wZXJ0eSB7TWFrZVpDRlNlYXR9IG1ha2VaQ0ZTZWF0XG4gKiBAcHJvcGVydHkge1JlYWxsb2NhdGV9IHJlYWxsb2NhdGVcbiAqIEBwcm9wZXJ0eSB7RHJvcEFsbFJlZmVyZW5jZXN9IGRyb3BBbGxSZWZlcmVuY2VzXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBaY2ZNaW50UmVhbGxvY2F0b3JcbiAqIEBwcm9wZXJ0eSB7KHpjZlNlYXQ6IFpDRlNlYXQsIG5ld0FsbG9jYXRpb246IEFsbG9jYXRpb24pID0+IHZvaWR9IHJlYWxsb2NhdGVcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBDcmVhdGVTZWF0TWFuYWdlclxuICpcbiAqIFRoZSBTZWF0TWFuYWdlciBob2xkcyB0aGUgYWN0aXZlIHpjZlNlYXRzIGFuZCBjYW4gcmVhbGxvY2F0ZSBhbmRcbiAqIG1ha2UgbmV3IHpjZlNlYXRzLlxuICpcbiAqIEBwYXJhbSB7RVJlZjxab2VJbnN0YW5jZUFkbWluPn0gem9lSW5zdGFuY2VBZG1pblxuICogQHBhcmFtIHtHZXRBc3NldEtpbmRCeUJyYW5kfSBnZXRBc3NldEtpbmRCeUJyYW5kXG4gKiBAcGFyYW0ge1NodXRkb3duV2l0aEZhaWx1cmV9IHNodXRkb3duV2l0aEZhaWx1cmVcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YScpLkJhZ2dhZ2V9IHpjZkJhZ2dhZ2VcbiAqIEByZXR1cm5zIHt7IHNlYXRNYW5hZ2VyOiBaY2ZTZWF0TWFuYWdlciwgemNmTWludFJlYWxsb2NhdG9yOiBaY2ZNaW50UmVhbGxvY2F0b3IgfX1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBJbnN0YW5jZVN0YXRlQWRkSXNzdWVyXG4gKlxuICogQWRkIGFuIGlzc3VlciBhbmQgaXRzIGtleXdvcmQgdG8gdGhlIGluc3RhbmNlUmVjb3JkIGZvciB0aGVcbiAqIGNvbnRyYWN0IGluc3RhbmNlXG4gKlxuICogQHBhcmFtIHtLZXl3b3JkfSBrZXl3b3JkXG4gKiBAcGFyYW0ge0lzc3VlclJlY29yZH0gaXNzdWVyUmVjb3JkXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBJbnN0YW5jZVN0YXRlR2V0VGVybXNcbiAqIEByZXR1cm5zIHtBbnlUZXJtc31cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBJbnN0YW5jZVN0YXRlR2V0SW5zdGFsbGF0aW9uXG4gKiBAcmV0dXJucyB7SW5zdGFsbGF0aW9ufVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEluc3RhbmNlUmVjb3JkR2V0SXNzdWVyc1xuICogQHJldHVybnMge0lzc3VlcktleXdvcmRSZWNvcmR9XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgSW5zdGFuY2VSZWNvcmRHZXRCcmFuZHNcbiAqIEByZXR1cm5zIHtCcmFuZEtleXdvcmRSZWNvcmR9XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBJbnN0YW5jZVN0YXRlXG4gKiBAcHJvcGVydHkge0luc3RhbmNlU3RhdGVBZGRJc3N1ZXJ9IGFkZElzc3VlclxuICogQHByb3BlcnR5IHtHZXRJbnN0YW5jZVJlY29yZH0gZ2V0SW5zdGFuY2VSZWNvcmRcbiAqIEBwcm9wZXJ0eSB7SW5zdGFuY2VTdGF0ZUdldFRlcm1zfSBnZXRUZXJtc1xuICogQHByb3BlcnR5IHtJbnN0YW5jZVN0YXRlR2V0SW5zdGFsbGF0aW9ufSBnZXRJbnN0YWxsYXRpb25cbiAqIEBwcm9wZXJ0eSB7SW5zdGFuY2VSZWNvcmRHZXRJc3N1ZXJzfSBnZXRJc3N1ZXJzXG4gKiBAcHJvcGVydHkge0luc3RhbmNlUmVjb3JkR2V0QnJhbmRzfSBnZXRCcmFuZHNcbiAqIEBwcm9wZXJ0eSB7KGtleXdvcmQ6IEtleXdvcmQpID0+IHZvaWR9IGFzc2VydFVuaXF1ZUtleXdvcmRcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBHZXRJbnN0YW5jZVJlY29yZFxuICogQHJldHVybnMge0luc3RhbmNlUmVjb3JkfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIElzc3VlclN0b3JhZ2VHZXRJc3N1ZXJSZWNvcmRzXG4gKiBAcGFyYW0ge0lzc3VlcltdfSBpc3N1ZXJzXG4gKiBAcmV0dXJucyB7SXNzdWVyUmVjb3Jkc31cbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACgpBY1VggAAFYIAAArAAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvbWFrZUhhbmRsZS5qc3siaW1wb3J0cyI6WyIuL3R5cGVHdWFyZHMuanMiLCJAYWdvcmljL2Fzc2VydCIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsiZGVmaW5lRHVyYWJsZUhhbmRsZSIsIm1ha2VIYW5kbGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0LGluaXRFbXB0eSxtYWtlRXhvLHByZXBhcmVFeG9DbGFzcyxIYW5kbGVJOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvYXNzZXJ0XCIsIFtbXCJhc3NlcnRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJpbml0RW1wdHlcIiwgWyRo4oCNX2EgPT4gKGluaXRFbXB0eSA9ICRo4oCNX2EpXV0sW1wibWFrZUV4b1wiLCBbJGjigI1fYSA9PiAobWFrZUV4byA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJwcmVwYXJlRXhvQ2xhc3NcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzcyA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVHdWFyZHMuanNcIiwgW1tcIkhhbmRsZUlcIiwgWyRo4oCNX2EgPT4gKEhhbmRsZUkgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBCYWdnYWdlICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtzdHJpbmd9IEhcbiAqIEBwYXJhbSB7QmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtIfSBoYW5kbGVUeXBlXG4gKiBAcmV0dXJucyB7SCBleHRlbmRzICdJbnN0YW5jZScgPyAoKSA9PiBJbnN0YW5jZSA6ICgpID0+IEhhbmRsZTxIPn1cbiAqL1xuY29uc3QgICAgICAgIGRlZmluZUR1cmFibGVIYW5kbGU9KGJhZ2dhZ2UsaGFuZGxlVHlwZSk9PntcbnR5cGVvZiBoYW5kbGVUeXBlPT09J3N0cmluZyd8fEZhaWwgYGhhbmRsZVR5cGUgbXVzdCBiZSBhIHN0cmluZ2A7XG5jb25zdCBtYWtlSGFuZGxlPXByZXBhcmVFeG9DbGFzcyhcbmJhZ2dhZ2UsXG4gYCR7aGFuZGxlVHlwZX1IYW5kbGVgLFxuSGFuZGxlSSxcbmluaXRFbXB0eSxcbnt9KTtcblxuLyogQHRzLWV4cGVjdC1lcnJvciBCaXQgYnkgb3VyIG93biBvcGFxdWUgdHlwZXMuKi9cbnJldHVybiAoLyoqIEB0eXBlIHsoKSA9PiBIYW5kbGU8SD59ICovbWFrZUhhbmRsZSk7XG4gfTskaOKAjV9vbmNlLmRlZmluZUR1cmFibGVIYW5kbGUoZGVmaW5lRHVyYWJsZUhhbmRsZSk7XG5oYXJkZW4oZGVmaW5lRHVyYWJsZUhhbmRsZSk7XG5cbi8qKlxuICogQ3JlYXRlIGFuIG9wYXF1ZSBoYW5kbGUgb2JqZWN0LlxuICpcbiAqIEB0ZW1wbGF0ZSB7c3RyaW5nfSBIXG4gKiBAcGFyYW0ge0h9IGhhbmRsZVR5cGUgdGhlIHN0cmluZyBsaXRlcmFsIHR5cGUgb2YgdGhlIGhhbmRsZVxuICogQHJldHVybnMge0ggZXh0ZW5kcyAnSW5zdGFuY2UnID8gSW5zdGFuY2UgOiBIYW5kbGU8SD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlSGFuZGxlPShoYW5kbGVUeXBlKT0+e1xudHlwZW9mIGhhbmRsZVR5cGU9PT0nc3RyaW5nJ3x8RmFpbCBgaGFuZGxlVHlwZSBtdXN0IGJlIGEgc3RyaW5nYDtcbi8qIFJldHVybiB0aGUgaW50ZXJzZWN0aW9uIHR5cGUgKHJlYWxseSBqdXN0IGFuIGVtcHR5IG9iamVjdCkuKi9cbi8qIEB0cy1leHBlY3QtZXJyb3IgQml0IGJ5IG91ciBvd24gb3BhcXVlIHR5cGVzLiovXG5yZXR1cm4gKC8qKiBAdHlwZSB7SGFuZGxlPEg+fSAqL21ha2VFeG8oYCR7aGFuZGxlVHlwZX1IYW5kbGVgLEhhbmRsZUkse30pKTtcbiB9OyRo4oCNX29uY2UubWFrZUhhbmRsZShtYWtlSGFuZGxlKTtcbmhhcmRlbihtYWtlSGFuZGxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJkZWZpbmVEdXJhYmxlSGFuZGxlIjpbImRlZmluZUR1cmFibGVIYW5kbGUiXSwibWFrZUhhbmRsZSI6WyJtYWtlSGFuZGxlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMb6lweiBQAAogUAADMAAABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9vYmpBcnJheUNvbnZlcnNpb24uanN7ImltcG9ydHMiOlsiQGFnb3JpYy9hc3NlcnQiXSwiZXhwb3J0cyI6WyJhcnJheVRvT2JqIiwiYXNzZXJ0U3Vic2V0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydCxGYWlsLHE7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9hc3NlcnRcIiwgW1tcImFzc2VydFwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0ID0gJGjigI1fYSldXSxbXCJGYWlsXCIsIFskaOKAjV9hID0+IChGYWlsID0gJGjigI1fYSldXSxbXCJxXCIsIFskaOKAjV9hID0+IChxID0gJGjigI1fYSldXV1dXSk7ICAgXG5cbi8qKlxuICogQHR5cGVkZWYge2JpZ2ludHxib29sZWFufG51bGx8bnVtYmVyfHN0cmluZ3xzeW1ib2x8dW5kZWZpbmVkfSBQcmltaXRpdmVcbiAqIEB0eXBlZGVmIHtzdHJpbmd8bnVtYmVyfHN5bWJvbH0gUHJvcGVydHlOYW1lXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIHtQcm9wZXJ0eU5hbWV9IFVcbiAqIEBwYXJhbSB7VFtdfSBhcnJheVxuICogQHBhcmFtIHtVW119IGtleXNcbiAqL1xuY29uc3QgICAgICAgIGFycmF5VG9PYmo9KGFycmF5LGtleXMpPT57XG5hcnJheS5sZW5ndGg9PT1rZXlzLmxlbmd0aHx8RmFpbCBgYXJyYXkgYW5kIGtleXMgbXVzdCBiZSBvZiBlcXVhbCBsZW5ndGhgO1xuY29uc3Qgb2JqPVxuLyoqIEB0eXBlIHtSZWNvcmQ8VSwgVD59ICovXG57fTtcbmtleXMuZm9yRWFjaCgoa2V5LGkpPT5vYmpba2V5XT1hcnJheVtpXSk7XG5yZXR1cm4gaGFyZGVuKG9iaik7XG4gfTtcblxuLyoqXG4gKiBBc3NlcnQgYWxsIHZhbHVlcyBmcm9tIGBwYXJ0YCBhcHBlYXIgaW4gYHdob2xlYC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ1tdfSB3aG9sZVxuICogQHBhcmFtIHtzdHJpbmdbXX0gcGFydFxuICovJGjigI1fb25jZS5hcnJheVRvT2JqKGFycmF5VG9PYmopO1xuY29uc3QgICAgICAgIGFzc2VydFN1YnNldD0od2hvbGUscGFydCk9PntcbnBhcnQuZm9yRWFjaCgoa2V5KT0+e1xuYXNzZXJ0LnR5cGVvZihrZXksJ3N0cmluZycpO1xud2hvbGUuaW5jbHVkZXMoa2V5KXx8XG5GYWlsIGBrZXkgJHtxKGtleSl9IHdhcyBub3Qgb25lIG9mIHRoZSBleHBlY3RlZCBrZXlzICR7cSh3aG9sZSl9YDtcbiB9KTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0U3Vic2V0KGFzc2VydFN1YnNldCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiYXJyYXlUb09iaiI6WyJhcnJheVRvT2JqIl0sImFzc2VydFN1YnNldCI6WyJhc3NlcnRTdWJzZXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA5bEJzNtDAADbQwAAKwAAAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9lcnRwIiwiQGFnb3JpYy9ub3RpZmllciIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3RpbWUiXSwiZXhwb3J0cyI6WyJBZG1pbkZhY2V0SSIsIkFtb3VudEtleXdvcmRSZWNvcmRTaGFwZSIsIkFtb3VudFBhdHRlcm5LZXl3b3JkUmVjb3JkU2hhcGUiLCJCcmFuZEtleXdvcmRSZWNvcmRTaGFwZSIsIkJ1bmRsZUNhcFNoYXBlIiwiQnVuZGxlU2hhcGUiLCJFeGl0T2JqZWN0SSIsIkV4aXRPYmplY3RTaGFwZSIsIkZlZU1pbnRBY2Nlc3NTaGFwZSIsIkZ1bGxQcm9wb3NhbFNoYXBlIiwiSGFuZGxlSSIsIkhhbmRsZU9mZmVySSIsIkluc3RhbGxhdGlvblNoYXBlIiwiSW5zdGFuY2VBZG1pbkkiLCJJbnN0YW5jZUFkbWluU2hhcGUiLCJJbnN0YW5jZUhhbmRsZVNoYXBlIiwiSW5zdGFuY2VSZWNvcmRTaGFwZSIsIkluc3RhbmNlU3RvcmFnZU1hbmFnZXJJS2l0IiwiSW52aXRhdGlvbkVsZW1lbnRTaGFwZSIsIkludml0YXRpb25IYW5kbGVTaGFwZSIsIkludml0YXRpb25TaGFwZSIsIklzc3VlcktleXdvcmRSZWNvcmRTaGFwZSIsIklzc3VlclBLZXl3b3JkUmVjb3JkU2hhcGUiLCJJc3N1ZXJSZWNvcmRTaGFwZSIsIktleXdvcmRTaGFwZSIsIk9mZmVySGFuZGxlckkiLCJQYXltZW50UEtleXdvcmRSZWNvcmRTaGFwZSIsIlByaWNlUXVvdGVTaGFwZSIsIlByb3Bvc2FsU2hhcGUiLCJTZWF0RGF0YVNoYXBlIiwiU2VhdEhhbmRsZUFsbG9jYXRpb25zU2hhcGUiLCJTZWF0U2hhcGUiLCJUZXJtc1NoYXBlIiwiVGltZXJTaGFwZSIsIlVud3JhcHBlZEluc3RhbGxhdGlvblNoYXBlIiwiWmNmTWludEkiLCJab2VNaW50SSIsIlpvZU1pbnRTaGFwZSIsIlpvZVNlcnZpY2VJIiwiWm9lU3RvcmFnZU1hbmFnZXJJS2l0IiwiaXNBZnRlckRlYWRsaW5lRXhpdFJ1bGUiLCJpc09uRGVtYW5kRXhpdFJ1bGUiLCJpc1dhaXZlZEV4aXRSdWxlIiwibWFrZUhhbmRsZVNoYXBlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEFtb3VudFNoYXBlLEFzc2V0S2luZFNoYXBlLEJyYW5kU2hhcGUsRGlzcGxheUluZm9TaGFwZSxJc3N1ZXJLaXRTaGFwZSxJc3N1ZXJTaGFwZSxQYXltZW50U2hhcGUsU3Vic2NyaWJlclNoYXBlLE0sVGltZXN0YW1wU2hhcGU7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBbW91bnRTaGFwZVwiLCBbJGjigI1fYSA9PiAoQW1vdW50U2hhcGUgPSAkaOKAjV9hKV1dLFtcIkFzc2V0S2luZFNoYXBlXCIsIFskaOKAjV9hID0+IChBc3NldEtpbmRTaGFwZSA9ICRo4oCNX2EpXV0sW1wiQnJhbmRTaGFwZVwiLCBbJGjigI1fYSA9PiAoQnJhbmRTaGFwZSA9ICRo4oCNX2EpXV0sW1wiRGlzcGxheUluZm9TaGFwZVwiLCBbJGjigI1fYSA9PiAoRGlzcGxheUluZm9TaGFwZSA9ICRo4oCNX2EpXV0sW1wiSXNzdWVyS2l0U2hhcGVcIiwgWyRo4oCNX2EgPT4gKElzc3VlcktpdFNoYXBlID0gJGjigI1fYSldXSxbXCJJc3N1ZXJTaGFwZVwiLCBbJGjigI1fYSA9PiAoSXNzdWVyU2hhcGUgPSAkaOKAjV9hKV1dLFtcIlBheW1lbnRTaGFwZVwiLCBbJGjigI1fYSA9PiAoUGF5bWVudFNoYXBlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvbm90aWZpZXJcIiwgW1tcIlN1YnNjcmliZXJTaGFwZVwiLCBbJGjigI1fYSA9PiAoU3Vic2NyaWJlclNoYXBlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy90aW1lXCIsIFtbXCJUaW1lc3RhbXBTaGFwZVwiLCBbJGjigI1fYSA9PiAoVGltZXN0YW1wU2hhcGUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKiBrZXl3b3JkcyBoYXZlIGFuIGluaXRpYWwgY2FwKi9cbmNvbnN0ICAgICAgICBLZXl3b3JkU2hhcGU9TS5zdHJpbmcoKTskaOKAjV9vbmNlLktleXdvcmRTaGFwZShLZXl3b3JkU2hhcGUpO1xuXG5jb25zdCAgICAgICAgSW52aXRhdGlvbkhhbmRsZVNoYXBlPU0ucmVtb3RhYmxlKCdJbnZpdGF0aW9uSGFuZGxlJyk7JGjigI1fb25jZS5JbnZpdGF0aW9uSGFuZGxlU2hhcGUoSW52aXRhdGlvbkhhbmRsZVNoYXBlKTtcbmNvbnN0ICAgICAgICBJbnZpdGF0aW9uU2hhcGU9TS5yZW1vdGFibGUoJ0ludml0YXRpb24nKTskaOKAjV9vbmNlLkludml0YXRpb25TaGFwZShJbnZpdGF0aW9uU2hhcGUpO1xuY29uc3QgICAgICAgIEluc3RhbmNlSGFuZGxlU2hhcGU9TS5yZW1vdGFibGUoJ0luc3RhbmNlSGFuZGxlJyk7JGjigI1fb25jZS5JbnN0YW5jZUhhbmRsZVNoYXBlKEluc3RhbmNlSGFuZGxlU2hhcGUpO1xuY29uc3QgICAgICAgIEluc3RhbGxhdGlvblNoYXBlPU0ucmVtb3RhYmxlKCdJbnN0YWxsYXRpb24nKTskaOKAjV9vbmNlLkluc3RhbGxhdGlvblNoYXBlKEluc3RhbGxhdGlvblNoYXBlKTtcbmNvbnN0ICAgICAgICBTZWF0U2hhcGU9TS5yZW1vdGFibGUoJ1NlYXQnKTskaOKAjV9vbmNlLlNlYXRTaGFwZShTZWF0U2hhcGUpO1xuXG5jb25zdCAgICAgICAgQW1vdW50S2V5d29yZFJlY29yZFNoYXBlPU0ucmVjb3JkT2YoS2V5d29yZFNoYXBlLEFtb3VudFNoYXBlKTskaOKAjV9vbmNlLkFtb3VudEtleXdvcmRSZWNvcmRTaGFwZShBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUpO1xuY29uc3QgICAgICAgIEFtb3VudFBhdHRlcm5LZXl3b3JkUmVjb3JkU2hhcGU9TS5yZWNvcmRPZihcbktleXdvcmRTaGFwZSxcbk0ucGF0dGVybigpKTskaOKAjV9vbmNlLkFtb3VudFBhdHRlcm5LZXl3b3JkUmVjb3JkU2hhcGUoQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmRTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBQYXltZW50UEtleXdvcmRSZWNvcmRTaGFwZT1NLnJlY29yZE9mKFxuS2V5d29yZFNoYXBlLFxuTS5lcmVmKFBheW1lbnRTaGFwZSkpOyRo4oCNX29uY2UuUGF5bWVudFBLZXl3b3JkUmVjb3JkU2hhcGUoUGF5bWVudFBLZXl3b3JkUmVjb3JkU2hhcGUpO1xuXG5jb25zdCAgICAgICAgSXNzdWVyS2V5d29yZFJlY29yZFNoYXBlPU0ucmVjb3JkT2YoS2V5d29yZFNoYXBlLElzc3VlclNoYXBlKTskaOKAjV9vbmNlLklzc3VlcktleXdvcmRSZWNvcmRTaGFwZShJc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUpO1xuY29uc3QgICAgICAgIElzc3VlclBLZXl3b3JkUmVjb3JkU2hhcGU9TS5yZWNvcmRPZihcbktleXdvcmRTaGFwZSxcbk0uZXJlZihJc3N1ZXJTaGFwZSkpOyRo4oCNX29uY2UuSXNzdWVyUEtleXdvcmRSZWNvcmRTaGFwZShJc3N1ZXJQS2V5d29yZFJlY29yZFNoYXBlKTtcblxuY29uc3QgICAgICAgIEJyYW5kS2V5d29yZFJlY29yZFNoYXBlPU0ucmVjb3JkT2YoS2V5d29yZFNoYXBlLEJyYW5kU2hhcGUpOyRo4oCNX29uY2UuQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUoQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUpO1xuXG5jb25zdCAgICAgICAgSXNzdWVyUmVjb3JkU2hhcGU9TS5zcGxpdFJlY29yZChcbntcbmJyYW5kOkJyYW5kU2hhcGUsXG5pc3N1ZXI6SXNzdWVyU2hhcGUsXG5hc3NldEtpbmQ6QXNzZXRLaW5kU2hhcGV9LFxuXG57ZGlzcGxheUluZm86RGlzcGxheUluZm9TaGFwZX0pOyRo4oCNX29uY2UuSXNzdWVyUmVjb3JkU2hhcGUoSXNzdWVyUmVjb3JkU2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBUZXJtc1NoYXBlPWhhcmRlbih7XG5pc3N1ZXJzOklzc3VlcktleXdvcmRSZWNvcmRTaGFwZSxcbmJyYW5kczpCcmFuZEtleXdvcmRSZWNvcmRTaGFwZX0pOyRo4oCNX29uY2UuVGVybXNTaGFwZShUZXJtc1NoYXBlKTtcblxuXG5jb25zdCAgICAgICAgSW5zdGFuY2VSZWNvcmRTaGFwZT1oYXJkZW4oe1xuaW5zdGFsbGF0aW9uOkluc3RhbGxhdGlvblNoYXBlLFxuaW5zdGFuY2U6SW5zdGFuY2VIYW5kbGVTaGFwZSxcbnRlcm1zOk0uc3BsaXRSZWNvcmQoVGVybXNTaGFwZSl9KTskaOKAjV9vbmNlLkluc3RhbmNlUmVjb3JkU2hhcGUoSW5zdGFuY2VSZWNvcmRTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIEhhbmRsZUk9TS5pbnRlcmZhY2UoJ0hhbmRsZScse30pOyRo4oCNX29uY2UuSGFuZGxlSShIYW5kbGVJKTtcblxuY29uc3QgICAgICAgIG1ha2VIYW5kbGVTaGFwZT0obmFtZSk9Pk0ucmVtb3RhYmxlKCBgJHtuYW1lfUhhbmRsZWApOyRo4oCNX29uY2UubWFrZUhhbmRsZVNoYXBlKG1ha2VIYW5kbGVTaGFwZSk7XG5jb25zdCAgICAgICAgVGltZXJTaGFwZT1tYWtlSGFuZGxlU2hhcGUoJ3RpbWVyJyk7XG5cbi8qKlxuICogQWZ0ZXIgZGVmYXVsdHMgYXJlIGZpbGxlZCBpblxuICpcbiAqIEBzZWUge1Byb3Bvc2FsUmVjb3JkfSB0eXBlXG4gKi8kaOKAjV9vbmNlLlRpbWVyU2hhcGUoVGltZXJTaGFwZSk7XG5jb25zdCAgICAgICAgRnVsbFByb3Bvc2FsU2hhcGU9aGFyZGVuKHtcbndhbnQ6QW1vdW50UGF0dGVybktleXdvcmRSZWNvcmRTaGFwZSxcbmdpdmU6QW1vdW50S2V5d29yZFJlY29yZFNoYXBlLFxuLyogVG8gYWNjZXB0IG9ubHkgb25lLCB3ZSBjb3VsZCB1c2UgTS5vciByYXRoZXIgdGhhbiBNLnNwbGl0UmVjb3JkLCovXG4vKiBidXQgdGhlIGVycm9yIG1lc3NhZ2VzIHdvdWxkIGhhdmUgYmVlbiB3b3JzZS4gUmF0aGVyLCovXG4vKiBjbGVhblByb3Bvc2FsJ3MgYXNzZXJ0RXhpdCBjaGVja3MgdGhhdCB0aGVyZSdzIGV4YWN0bHkgb25lLiovXG5leGl0Ok0uc3BsaXRSZWNvcmQoXG57fSxcbntcbm9uRGVtYW5kOm51bGwsXG53YWl2ZWQ6bnVsbCxcbmFmdGVyRGVhZGxpbmU6e1xudGltZXI6TS5lcmVmKFRpbWVyU2hhcGUpLFxuZGVhZGxpbmU6VGltZXN0YW1wU2hhcGV9fSxcblxuXG57fSl9KTtcblxuXG4vKiogQHNlZSB7UHJvcG9zYWx9IHR5cGUgKi8kaOKAjV9vbmNlLkZ1bGxQcm9wb3NhbFNoYXBlKEZ1bGxQcm9wb3NhbFNoYXBlKTtcbmNvbnN0ICAgICAgICBQcm9wb3NhbFNoYXBlPU0uc3BsaXRSZWNvcmQoe30sRnVsbFByb3Bvc2FsU2hhcGUse30pOyRo4oCNX29uY2UuUHJvcG9zYWxTaGFwZShQcm9wb3NhbFNoYXBlKTtcblxuY29uc3QgICAgICAgIGlzT25EZW1hbmRFeGl0UnVsZT0oZXhpdCk9PntcbmNvbnN0W2V4aXRLZXldPU9iamVjdC5rZXlzKGV4aXQpO1xucmV0dXJuIGV4aXRLZXk9PT0nb25EZW1hbmQnO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtFeGl0UnVsZX0gZXhpdFxuICogQHJldHVybnMge2V4aXQgaXMgV2FpdmVkRXhpdFJ1bGV9XG4gKi8kaOKAjV9vbmNlLmlzT25EZW1hbmRFeGl0UnVsZShpc09uRGVtYW5kRXhpdFJ1bGUpO1xuY29uc3QgICAgICAgIGlzV2FpdmVkRXhpdFJ1bGU9KGV4aXQpPT57XG5jb25zdFtleGl0S2V5XT1PYmplY3Qua2V5cyhleGl0KTtcbnJldHVybiBleGl0S2V5PT09J3dhaXZlZCc7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge0V4aXRSdWxlfSBleGl0XG4gKiBAcmV0dXJucyB7ZXhpdCBpcyBBZnRlckRlYWRsaW5lRXhpdFJ1bGV9XG4gKi8kaOKAjV9vbmNlLmlzV2FpdmVkRXhpdFJ1bGUoaXNXYWl2ZWRFeGl0UnVsZSk7XG5jb25zdCAgICAgICAgaXNBZnRlckRlYWRsaW5lRXhpdFJ1bGU9KGV4aXQpPT57XG5jb25zdFtleGl0S2V5XT1PYmplY3Qua2V5cyhleGl0KTtcbnJldHVybiBleGl0S2V5PT09J2FmdGVyRGVhZGxpbmUnO1xuIH07JGjigI1fb25jZS5pc0FmdGVyRGVhZGxpbmVFeGl0UnVsZShpc0FmdGVyRGVhZGxpbmVFeGl0UnVsZSk7XG5cbmNvbnN0ICAgICAgICBJbnZpdGF0aW9uRWxlbWVudFNoYXBlPU0uc3BsaXRSZWNvcmQoe1xuZGVzY3JpcHRpb246TS5zdHJpbmcoKSxcbmhhbmRsZTpJbnZpdGF0aW9uSGFuZGxlU2hhcGUsXG5pbnN0YW5jZTpJbnN0YW5jZUhhbmRsZVNoYXBlLFxuaW5zdGFsbGF0aW9uOkluc3RhbGxhdGlvblNoYXBlfSk7JGjigI1fb25jZS5JbnZpdGF0aW9uRWxlbWVudFNoYXBlKEludml0YXRpb25FbGVtZW50U2hhcGUpO1xuXG5cbmNvbnN0ICAgICAgICBPZmZlckhhbmRsZXJJPU0uaW50ZXJmYWNlKCdPZmZlckhhbmRsZXInLHtcbmhhbmRsZTpNLmNhbGwoU2VhdFNoYXBlKS5vcHRpb25hbChNLmFueSgpKS5yZXR1cm5zKE0uc3RyaW5nKCkpfSk7JGjigI1fb25jZS5PZmZlckhhbmRsZXJJKE9mZmVySGFuZGxlckkpO1xuXG5cbmNvbnN0ICAgICAgICBTZWF0SGFuZGxlQWxsb2NhdGlvbnNTaGFwZT1NLmFycmF5T2YoXG5oYXJkZW4oe1xuc2VhdEhhbmRsZTpTZWF0U2hhcGUsXG5hbGxvY2F0aW9uOkFtb3VudEtleXdvcmRSZWNvcmRTaGFwZX0pKTskaOKAjV9vbmNlLlNlYXRIYW5kbGVBbGxvY2F0aW9uc1NoYXBlKFNlYXRIYW5kbGVBbGxvY2F0aW9uc1NoYXBlKTtcblxuXG5cbmNvbnN0ICAgICAgICBab2VNaW50U2hhcGU9TS5yZW1vdGFibGUoJ1pvZU1pbnQnKTskaOKAjV9vbmNlLlpvZU1pbnRTaGFwZShab2VNaW50U2hhcGUpO1xuY29uc3QgICAgICAgIFpvZU1pbnRJPU0uaW50ZXJmYWNlKCdab2VNaW50Jyx7XG5nZXRJc3N1ZXJSZWNvcmQ6TS5jYWxsKCkucmV0dXJucyhJc3N1ZXJSZWNvcmRTaGFwZSksXG5taW50QW5kRXNjcm93Ok0uY2FsbChBbW91bnRTaGFwZSkucmV0dXJucygpLFxud2l0aGRyYXdBbmRCdXJuOk0uY2FsbChBbW91bnRTaGFwZSkucmV0dXJucygpfSk7JGjigI1fb25jZS5ab2VNaW50SShab2VNaW50SSk7XG5cblxuY29uc3QgICAgICAgIFpjZk1pbnRJPU0uaW50ZXJmYWNlKCdaY2ZNaW50Jyx7XG5nZXRJc3N1ZXJSZWNvcmQ6TS5jYWxsKCkucmV0dXJucyhJc3N1ZXJSZWNvcmRTaGFwZSksXG5taW50R2FpbnM6TS5jYWxsKEFtb3VudEtleXdvcmRSZWNvcmRTaGFwZSkuXG5vcHRpb25hbChNLnJlbW90YWJsZSgnemNmU2VhdCcpKS5cbnJldHVybnMoTS5yZW1vdGFibGUoJ3pjZlNlYXQnKSksXG5idXJuTG9zc2VzOk0uY2FsbChcbkFtb3VudEtleXdvcmRSZWNvcmRTaGFwZSxcbk0ucmVtb3RhYmxlKCd6Y2ZTZWF0JykpLlxucmV0dXJucygpfSk7JGjigI1fb25jZS5aY2ZNaW50SShaY2ZNaW50SSk7XG5cblxuY29uc3QgICAgICAgIEZlZU1pbnRBY2Nlc3NTaGFwZT1NLnJlbW90YWJsZSgnRmVlTWludEFjY2VzcycpOyRo4oCNX29uY2UuRmVlTWludEFjY2Vzc1NoYXBlKEZlZU1pbnRBY2Nlc3NTaGFwZSk7XG5cbmNvbnN0ICAgICAgICBFeGl0T2JqZWN0ST1NLmludGVyZmFjZSgnRXhpdCBPYmplY3QnLHtcbmV4aXQ6TS5jYWxsKCkucmV0dXJucygpfSk7JGjigI1fb25jZS5FeGl0T2JqZWN0SShFeGl0T2JqZWN0SSk7XG5cblxuY29uc3QgICAgICAgIEV4aXRPYmplY3RTaGFwZT1NLnJlbW90YWJsZSgnRXhpdE9iaicpOyRo4oCNX29uY2UuRXhpdE9iamVjdFNoYXBlKEV4aXRPYmplY3RTaGFwZSk7XG5jb25zdCAgICAgICAgSW5zdGFuY2VBZG1pblNoYXBlPU0ucmVtb3RhYmxlKCdJbnN0YW5jZUFkbWluJyk7JGjigI1fb25jZS5JbnN0YW5jZUFkbWluU2hhcGUoSW5zdGFuY2VBZG1pblNoYXBlKTtcbmNvbnN0ICAgICAgICBJbnN0YW5jZUFkbWluST1NLmludGVyZmFjZSgnSW5zdGFuY2VBZG1pbicse1xubWFrZUludml0YXRpb246TS5jYWxsKEludml0YXRpb25IYW5kbGVTaGFwZSxNLnN0cmluZygpKS5cbm9wdGlvbmFsKE0ucmVjb3JkKCksTS5wYXR0ZXJuKCkpLlxucmV0dXJucyhJbnZpdGF0aW9uU2hhcGUpLFxuc2F2ZUlzc3VlcjpNLmNhbGxXaGVuKE0uYXdhaXQoSXNzdWVyU2hhcGUpLEtleXdvcmRTaGFwZSkucmV0dXJucyhcbklzc3VlclJlY29yZFNoYXBlKSxcblxubWFrZU5vRXNjcm93U2VhdDpNLmNhbGwoXG5BbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUsXG5Qcm9wb3NhbFNoYXBlLFxuRXhpdE9iamVjdFNoYXBlLFxuU2VhdFNoYXBlKS5cbnJldHVybnMoU2VhdFNoYXBlKSxcbmV4aXRBbGxTZWF0czpNLmNhbGwoTS5hbnkoKSkucmV0dXJucygpLFxuZmFpbEFsbFNlYXRzOk0uY2FsbChNLmFueSgpKS5yZXR1cm5zKCksXG5leGl0U2VhdDpNLmNhbGwoU2VhdFNoYXBlLE0uYW55KCkpLnJldHVybnMoKSxcbmZhaWxTZWF0Ok0uY2FsbChTZWF0U2hhcGUsTS5hbnkoKSkucmV0dXJucygpLFxubWFrZVpvZU1pbnQ6TS5jYWxsKEtleXdvcmRTaGFwZSkuXG5vcHRpb25hbChcbkFzc2V0S2luZFNoYXBlLFxuRGlzcGxheUluZm9TaGFwZSxcbk0uc3BsaXRSZWNvcmQoaGFyZGVuKHt9KSxoYXJkZW4oe2VsZW1lbnRTaGFwZTpNLnBhdHRlcm4oKX0pKSkuXG5cbnJldHVybnMoTS5yZW1vdGFibGUoJ3pvZU1pbnQnKSksXG5yZWdpc3RlckZlZU1pbnQ6TS5jYWxsKEtleXdvcmRTaGFwZSxGZWVNaW50QWNjZXNzU2hhcGUpLnJldHVybnMoXG5NLnJlbW90YWJsZSgnZmVlTWludCcpKSxcblxucmVwbGFjZUFsbG9jYXRpb25zOk0uY2FsbChTZWF0SGFuZGxlQWxsb2NhdGlvbnNTaGFwZSkucmV0dXJucygpLFxuc3RvcEFjY2VwdGluZ09mZmVyczpNLmNhbGwoKS5yZXR1cm5zKCksXG5zZXRPZmZlckZpbHRlcjpNLmNhbGwoTS5hcnJheU9mKE0uc3RyaW5nKCkpKS5yZXR1cm5zKCksXG5nZXRPZmZlckZpbHRlcjpNLmNhbGwoKS5yZXR1cm5zKE0uYXJyYXlPZihNLnN0cmluZygpKSksXG5nZXRFeGl0U3Vic2NyaWJlcjpNLmNhbGwoU2VhdFNoYXBlKS5yZXR1cm5zKFN1YnNjcmliZXJTaGFwZSksXG5pc0Jsb2NrZWQ6TS5jYWxsKE0uc3RyaW5nKCkpLnJldHVybnMoTS5ib29sZWFuKCkpfSk7JGjigI1fb25jZS5JbnN0YW5jZUFkbWluSShJbnN0YW5jZUFkbWluSSk7XG5cblxuY29uc3QgICAgICAgIEluc3RhbmNlU3RvcmFnZU1hbmFnZXJJS2l0PWhhcmRlbih7XG5pbnN0YW5jZVN0b3JhZ2VNYW5hZ2VyOk0uaW50ZXJmYWNlKCdJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VyJyx7XG5nZXRUZXJtczpNLmNhbGwoKS5yZXR1cm5zKE0uc3BsaXRSZWNvcmQoVGVybXNTaGFwZSkpLFxuZ2V0SXNzdWVyczpNLmNhbGwoKS5yZXR1cm5zKElzc3VlcktleXdvcmRSZWNvcmRTaGFwZSksXG5nZXRCcmFuZHM6TS5jYWxsKCkucmV0dXJucyhCcmFuZEtleXdvcmRSZWNvcmRTaGFwZSksXG5nZXRJbnN0YWxsYXRpb246TS5jYWxsKCkucmV0dXJucyhJbnN0YWxsYXRpb25TaGFwZSksXG5nZXRJbnZpdGF0aW9uSXNzdWVyOk0uY2FsbCgpLnJldHVybnMoSXNzdWVyU2hhcGUpLFxuXG5zYXZlSXNzdWVyOk0uY2FsbChJc3N1ZXJTaGFwZSxLZXl3b3JkU2hhcGUpLnJldHVybnMoTS5wcm9taXNlKCkpLFxubWFrZVpvZU1pbnQ6TS5jYWxsKEtleXdvcmRTaGFwZSkuXG5vcHRpb25hbChcbkFzc2V0S2luZFNoYXBlLFxuRGlzcGxheUluZm9TaGFwZSxcbk0uc3BsaXRSZWNvcmQoaGFyZGVuKHt9KSxoYXJkZW4oe2VsZW1lbnRTaGFwZTpNLnBhdHRlcm4oKX0pKSkuXG5cbnJldHVybnMoTS5lcmVmKFpvZU1pbnRTaGFwZSkpLFxucmVnaXN0ZXJGZWVNaW50Ok0uY2FsbChLZXl3b3JkU2hhcGUsRmVlTWludEFjY2Vzc1NoYXBlKS5yZXR1cm5zKFxuTS5yZW1vdGFibGUoJ2ZlZU1pbnQnKSksXG5cbmdldEluc3RhbmNlUmVjb3JkOk0uY2FsbCgpLnJldHVybnMoSW5zdGFuY2VSZWNvcmRTaGFwZSksXG5nZXRJc3N1ZXJSZWNvcmRzOk0uY2FsbCgpLnJldHVybnMoTS5hcnJheU9mKElzc3VlclJlY29yZFNoYXBlKSksXG5nZXRXaXRoZHJhd0ZhY2V0Ok0uY2FsbCgpLnJldHVybnMoTS5yZW1vdGFibGUoJ1dpdGhkcmF3RmFjZXQnKSksXG5pbml0SW5zdGFuY2VBZG1pbjpNLmNhbGwoXG5JbnN0YW5jZUhhbmRsZVNoYXBlLFxuTS5yZW1vdGFibGUoJ2luc3RhbmNlQWRtaW4nKSkuXG5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmRlbGV0ZUluc3RhbmNlQWRtaW46TS5jYWxsKEluc3RhbmNlQWRtaW5JKS5yZXR1cm5zKCksXG5tYWtlSW52aXRhdGlvbjpNLmNhbGwoSW52aXRhdGlvbkhhbmRsZVNoYXBlLE0uc3RyaW5nKCkpLlxub3B0aW9uYWwoTS5yZWNvcmQoKSxNLnBhdHRlcm4oKSkuXG5yZXR1cm5zKFBheW1lbnRTaGFwZSksXG5nZXRSb290Ok0uY2FsbCgpLnJldHVybnMoTS5hbnkoKSksXG5nZXRBZG1pbk5vZGU6TS5jYWxsKCkucmV0dXJucyhNLnJlbW90YWJsZSgnYWRtaW5Ob2RlJykpfSksXG5cbndpdGhkcmF3RmFjZXQ6TS5pbnRlcmZhY2UoJ1dpdGhkcmF3RmFjZXQnLHtcbndpdGhkcmF3UGF5bWVudHM6TS5jYWxsKEFtb3VudEtleXdvcmRSZWNvcmRTaGFwZSkucmV0dXJucyhcblBheW1lbnRQS2V5d29yZFJlY29yZFNoYXBlKX0pLFxuXG5cbmhlbHBlcnM6TS5pbnRlcmZhY2UoJ0luc3RhbmNlU3RvcmFnZU1hbmFnZXIgaGVscGVyJyx7XG53cmFwSXNzdWVyS2l0V2l0aFpvZU1pbnQ6TS5jYWxsKFxuS2V5d29yZFNoYXBlLFxuSXNzdWVyS2l0U2hhcGUsXG5NLnJlbW90YWJsZSgnYWRtaW5Ob2RlJykpLlxucmV0dXJucyhab2VNaW50U2hhcGUpfSl9KTskaOKAjV9vbmNlLkluc3RhbmNlU3RvcmFnZU1hbmFnZXJJS2l0KEluc3RhbmNlU3RvcmFnZU1hbmFnZXJJS2l0KTtcblxuXG5cbmNvbnN0ICAgICAgICBCdW5kbGVDYXBTaGFwZT1NLnJlbW90YWJsZSgnYnVuZGxlQ2FwJyk7JGjigI1fb25jZS5CdW5kbGVDYXBTaGFwZShCdW5kbGVDYXBTaGFwZSk7XG5jb25zdCAgICAgICAgQnVuZGxlU2hhcGU9TS5hbmQoXG5NLnNwbGl0UmVjb3JkKHttb2R1bGVGb3JtYXQ6TS5hbnkoKX0pLFxuTS5yZWNvcmRPZihNLnN0cmluZygpLE0uc3RyaW5nKHtzdHJpbmdMZW5ndGhMaW1pdDpJbmZpbml0eX0pKSk7JGjigI1fb25jZS5CdW5kbGVTaGFwZShCdW5kbGVTaGFwZSk7XG5cblxuY29uc3QgICAgICAgIFVud3JhcHBlZEluc3RhbGxhdGlvblNoYXBlPU0uc3BsaXRSZWNvcmQoXG5oYXJkZW4oe1xuaW5zdGFsbGF0aW9uOkluc3RhbGxhdGlvblNoYXBlfSksXG5cbmhhcmRlbih7XG5idW5kbGU6TS5yZWNvcmRPZihNLnN0cmluZygpLE0uc3RyaW5nKHtzdHJpbmdMZW5ndGhMaW1pdDpJbmZpbml0eX0pKSxcbmJ1bmRsZUNhcDpCdW5kbGVDYXBTaGFwZSxcbmJ1bmRsZUlEOk0uc3RyaW5nKCl9KSxcblxuaGFyZGVuKHt9KSk7JGjigI1fb25jZS5VbndyYXBwZWRJbnN0YWxsYXRpb25TaGFwZShVbndyYXBwZWRJbnN0YWxsYXRpb25TaGFwZSk7XG5cblxuY29uc3QgICAgICAgIFpvZVN0b3JhZ2VNYW5hZ2VySUtpdD1oYXJkZW4oe1xuem9lU2VydmljZURhdGFBY2Nlc3M6TS5pbnRlcmZhY2UoJ1pvZVNlcnZpY2UgZGF0YUFjY2Vzcycse1xuZ2V0VGVybXM6TS5jYWxsKEluc3RhbmNlSGFuZGxlU2hhcGUpLnJldHVybnMoTS5zcGxpdFJlY29yZChUZXJtc1NoYXBlKSksXG5nZXRJc3N1ZXJzOk0uY2FsbChJbnN0YW5jZUhhbmRsZVNoYXBlKS5yZXR1cm5zKElzc3VlcktleXdvcmRSZWNvcmRTaGFwZSksXG5nZXRCcmFuZHM6TS5jYWxsKEluc3RhbmNlSGFuZGxlU2hhcGUpLnJldHVybnMoQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUpLFxuZ2V0SW5zdGFsbGF0aW9uOk0uY2FsbChJbnN0YW5jZUhhbmRsZVNoYXBlKS5yZXR1cm5zKFxuTS5lcmVmKE0ucmVtb3RhYmxlKCdJbnN0YWxsYXRpb24nKSkpLFxuXG5nZXRJbnZpdGF0aW9uSXNzdWVyOk0uY2FsbCgpLnJldHVybnMoSXNzdWVyU2hhcGUpLFxuXG5nZXRCdW5kbGVJREZyb21JbnN0YWxsYXRpb246TS5jYWxsKEluc3RhbGxhdGlvblNoYXBlKS5yZXR1cm5zKFxuTS5lcmVmKE0uc3RyaW5nKCkpKSxcblxuaW5zdGFsbEJ1bmRsZTpNLmNhbGwoTS5vcihJbnN0YW5jZUhhbmRsZVNoYXBlLEJ1bmRsZVNoYXBlKSkucmV0dXJucyhcbk0ucHJvbWlzZSgpKSxcblxuaW5zdGFsbEJ1bmRsZUlEOk0uY2FsbChNLnN0cmluZygpKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcblxuZ2V0UHVibGljRmFjZXQ6TS5jYWxsKEluc3RhbmNlSGFuZGxlU2hhcGUpLnJldHVybnMoXG5NLmVyZWYoTS5yZW1vdGFibGUoJ1B1YmxpY0ZhY2V0JykpKSxcblxuZ2V0T2ZmZXJGaWx0ZXI6TS5jYWxsKEluc3RhbmNlSGFuZGxlU2hhcGUpLnJldHVybnMoTS5hcnJheU9mKE0uc3RyaW5nKCkpKSxcbmdldFByb3Bvc2FsU2hhcGVGb3JJbnZpdGF0aW9uOk0uY2FsbChJbnZpdGF0aW9uSGFuZGxlU2hhcGUpLnJldHVybnMoXG5NLm9wdChNLnBhdHRlcm4oKSkpfSksXG5cblxubWFrZU9mZmVyQWNjZXNzOk0uaW50ZXJmYWNlKCdab2VTdG9yYWdlIG1ha2VPZmZlciBhY2Nlc3MnLHtcbmdldEFzc2V0S2luZEJ5QnJhbmQ6TS5jYWxsKEJyYW5kU2hhcGUpLnJldHVybnMoQXNzZXRLaW5kU2hhcGUpLFxuZ2V0SW5zdGFuY2VBZG1pbjpNLmNhbGwoSW5zdGFuY2VIYW5kbGVTaGFwZSkucmV0dXJucyhcbk0ucmVtb3RhYmxlKCdpbnN0YW5jZUFkbWluJykpLFxuXG5nZXRQcm9wb3NhbFNoYXBlRm9ySW52aXRhdGlvbjpNLmNhbGwoSW52aXRhdGlvbkhhbmRsZVNoYXBlKS5yZXR1cm5zKFxuTS5vcHQoTS5wYXR0ZXJuKCkpKSxcblxuZ2V0SW52aXRhdGlvbklzc3VlcjpNLmNhbGwoKS5yZXR1cm5zKElzc3VlclNoYXBlKSxcbmRlcG9zaXRQYXltZW50czpNLmNhbGwoUHJvcG9zYWxTaGFwZSxQYXltZW50UEtleXdvcmRSZWNvcmRTaGFwZSkucmV0dXJucyhcbk0ucHJvbWlzZSgpKX0pLFxuXG5cbnN0YXJ0SW5zdGFuY2VBY2Nlc3M6TS5pbnRlcmZhY2UoJ1pvZVN0b3JhZ2Ugc3RhcnRJbnN0YW5jZSBhY2Nlc3MnLHtcbm1ha2Vab2VJbnN0YW5jZVN0b3JhZ2VNYW5hZ2VyOk0uY2FsbChcbk0uYW55KCksXG5JbnN0YWxsYXRpb25TaGFwZSxcbk0uYW55KCksXG5Jc3N1ZXJQS2V5d29yZFJlY29yZFNoYXBlLFxuTS5vcihJbnN0YW5jZUhhbmRsZVNoYXBlLEJ1bmRsZVNoYXBlKSxcbk0ub3IoQnVuZGxlQ2FwU2hhcGUsQnVuZGxlU2hhcGUpKS5cbnJldHVybnMoTS5wcm9taXNlKCkpLFxudW53cmFwSW5zdGFsbGF0aW9uOk0uY2FsbFdoZW4oTS5lcmVmKEluc3RhbGxhdGlvblNoYXBlKSkucmV0dXJucyhcblVud3JhcHBlZEluc3RhbGxhdGlvblNoYXBlKX0pLFxuXG5cbmludml0YXRpb25Jc3N1ZXJBY2Nlc3M6TS5pbnRlcmZhY2UoJ1pvZVN0b3JhZ2UgaW52aXRhdGlvbklzc3Vlcicse1xuZ2V0SW52aXRhdGlvbklzc3VlcjpNLmNhbGwoKS5yZXR1cm5zKElzc3VlclNoYXBlKX0pfSk7JGjigI1fb25jZS5ab2VTdG9yYWdlTWFuYWdlcklLaXQoWm9lU3RvcmFnZU1hbmFnZXJJS2l0KTtcblxuXG5cbmNvbnN0ICAgICAgICBab2VTZXJ2aWNlST1NLmludGVyZmFjZSgnWm9lU2VydmljZScse1xuaW5zdGFsbDpNLmNhbGwoTS5hbnkoKSkucmV0dXJucyhNLnByb21pc2UoKSksXG5pbnN0YWxsQnVuZGxlSUQ6TS5jYWxsKE0uc3RyaW5nKCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxuc3RhcnRJbnN0YW5jZTpNLmNhbGwoTS5lcmVmKEluc3RhbGxhdGlvblNoYXBlKSkuXG5vcHRpb25hbChJc3N1ZXJQS2V5d29yZFJlY29yZFNoYXBlLE0uYW55KCksTS5hbnkoKSkuXG5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbm9mZmVyOk0uY2FsbChNLmVyZWYoSW52aXRhdGlvblNoYXBlKSkuXG5vcHRpb25hbChQcm9wb3NhbFNoYXBlLFBheW1lbnRQS2V5d29yZFJlY29yZFNoYXBlLE0uYW55KCkpLlxucmV0dXJucyhNLnByb21pc2UoKSksXG5cbmdldE9mZmVyRmlsdGVyOk0uY2FsbFdoZW4oTS5hd2FpdChJbnN0YW5jZUhhbmRsZVNoYXBlKSkucmV0dXJucyhcbk0uYXJyYXlPZihNLnN0cmluZygpKSksXG5cbmdldEludml0YXRpb25Jc3N1ZXI6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRGZWVJc3N1ZXI6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRCcmFuZHM6TS5jYWxsV2hlbihNLmF3YWl0KEluc3RhbmNlSGFuZGxlU2hhcGUpKS5yZXR1cm5zKFxuQnJhbmRLZXl3b3JkUmVjb3JkU2hhcGUpLFxuXG5nZXRJc3N1ZXJzOk0uY2FsbFdoZW4oTS5hd2FpdChJbnN0YW5jZUhhbmRsZVNoYXBlKSkucmV0dXJucyhcbklzc3VlcktleXdvcmRSZWNvcmRTaGFwZSksXG5cbmdldFB1YmxpY0ZhY2V0Ok0uY2FsbFdoZW4oTS5hd2FpdChJbnN0YW5jZUhhbmRsZVNoYXBlKSkucmV0dXJucyhcbk0ucmVtb3RhYmxlKCdQdWJsaWNGYWNldCcpKSxcblxuZ2V0VGVybXM6TS5jYWxsV2hlbihNLmF3YWl0KEluc3RhbmNlSGFuZGxlU2hhcGUpKS5yZXR1cm5zKE0uYW55KCkpLFxuZ2V0SW5zdGFsbGF0aW9uRm9ySW5zdGFuY2U6TS5jYWxsV2hlbihNLmF3YWl0KEluc3RhbmNlSGFuZGxlU2hhcGUpKS5yZXR1cm5zKFxuTS5lcmVmKE0ucmVtb3RhYmxlKCdJbnN0YWxsYXRpb24nKSkpLFxuXG5nZXRCdW5kbGVJREZyb21JbnN0YWxsYXRpb246TS5jYWxsKEluc3RhbGxhdGlvblNoYXBlKS5yZXR1cm5zKFxuTS5lcmVmKE0uc3RyaW5nKCkpKSxcblxuXG5nZXRJbnN0YWxsYXRpb246TS5jYWxsKE0uZXJlZihJbnZpdGF0aW9uU2hhcGUpKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmdldEluc3RhbmNlOk0uY2FsbChNLmVyZWYoSW52aXRhdGlvblNoYXBlKSkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRDb25maWd1cmF0aW9uOk0uY2FsbCgpLnJldHVybnMoe1xuZmVlSXNzdWVyQ29uZmlnOntcbm5hbWU6TS5zdHJpbmcoKSxcbmFzc2V0S2luZDonbmF0JyxcbmRpc3BsYXlJbmZvOkRpc3BsYXlJbmZvU2hhcGV9fSksXG5cblxuZ2V0SW52aXRhdGlvbkRldGFpbHM6TS5jYWxsKE0uZXJlZihJbnZpdGF0aW9uU2hhcGUpKS5yZXR1cm5zKE0uYW55KCkpLFxuZ2V0UHJvcG9zYWxTaGFwZUZvckludml0YXRpb246TS5jYWxsKEludml0YXRpb25IYW5kbGVTaGFwZSkucmV0dXJucyhcbk0ub3B0KFByb3Bvc2FsU2hhcGUpKX0pOyRo4oCNX29uY2UuWm9lU2VydmljZUkoWm9lU2VydmljZUkpO1xuXG5cblxuY29uc3QgICAgICAgIEFkbWluRmFjZXRJPU0uaW50ZXJmYWNlKCdaY2ZBZG1pbkZhY2V0Jyx7XG5nZXRWYXRTaHV0ZG93blByb21pc2U6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5yZXN0YXJ0Q29udHJhY3Q6TS5jYWxsKCkub3B0aW9uYWwoTS5hbnkoKSkucmV0dXJucyhNLnByb21pc2UoKSksXG51cGdyYWRlQ29udHJhY3Q6TS5jYWxsKE0uc3RyaW5nKCkpLm9wdGlvbmFsKE0uYW55KCkpLnJldHVybnMoTS5wcm9taXNlKCkpfSk7JGjigI1fb25jZS5BZG1pbkZhY2V0SShBZG1pbkZhY2V0SSk7XG5cblxuY29uc3QgICAgICAgIFNlYXREYXRhU2hhcGU9TS5zcGxpdFJlY29yZChcbntcbnByb3Bvc2FsOlByb3Bvc2FsU2hhcGUsXG5pbml0aWFsQWxsb2NhdGlvbjpBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUsXG5zZWF0SGFuZGxlOlNlYXRTaGFwZX0sXG5cbntcbm9mZmVyQXJnczpNLmFueSgpfSk7JGjigI1fb25jZS5TZWF0RGF0YVNoYXBlKFNlYXREYXRhU2hhcGUpO1xuXG5cblxuY29uc3QgICAgICAgIEhhbmRsZU9mZmVyST1NLmludGVyZmFjZSgnSGFuZGxlT2ZmZXInLHtcbmhhbmRsZU9mZmVyOk0uY2FsbChJbnZpdGF0aW9uSGFuZGxlU2hhcGUsU2VhdERhdGFTaGFwZSkucmV0dXJucyh7XG5vZmZlclJlc3VsdFByb21pc2U6TS5wcm9taXNlKCksXG5leGl0T2JqOkV4aXRPYmplY3RTaGFwZX0pfSk7JGjigI1fb25jZS5IYW5kbGVPZmZlckkoSGFuZGxlT2ZmZXJJKTtcblxuXG5cbmNvbnN0ICAgICAgICBQcmljZVF1b3RlU2hhcGU9aGFyZGVuKHtcbnF1b3RlQW1vdW50OkFtb3VudFNoYXBlLFxucXVvdGVQYXltZW50Ok0uZXJlZihQYXltZW50U2hhcGUpfSk7JGjigI1fb25jZS5QcmljZVF1b3RlU2hhcGUoUHJpY2VRdW90ZVNoYXBlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJLZXl3b3JkU2hhcGUiOlsiS2V5d29yZFNoYXBlIl0sIkludml0YXRpb25IYW5kbGVTaGFwZSI6WyJJbnZpdGF0aW9uSGFuZGxlU2hhcGUiXSwiSW52aXRhdGlvblNoYXBlIjpbIkludml0YXRpb25TaGFwZSJdLCJJbnN0YW5jZUhhbmRsZVNoYXBlIjpbIkluc3RhbmNlSGFuZGxlU2hhcGUiXSwiSW5zdGFsbGF0aW9uU2hhcGUiOlsiSW5zdGFsbGF0aW9uU2hhcGUiXSwiU2VhdFNoYXBlIjpbIlNlYXRTaGFwZSJdLCJBbW91bnRLZXl3b3JkUmVjb3JkU2hhcGUiOlsiQW1vdW50S2V5d29yZFJlY29yZFNoYXBlIl0sIkFtb3VudFBhdHRlcm5LZXl3b3JkUmVjb3JkU2hhcGUiOlsiQW1vdW50UGF0dGVybktleXdvcmRSZWNvcmRTaGFwZSJdLCJQYXltZW50UEtleXdvcmRSZWNvcmRTaGFwZSI6WyJQYXltZW50UEtleXdvcmRSZWNvcmRTaGFwZSJdLCJJc3N1ZXJLZXl3b3JkUmVjb3JkU2hhcGUiOlsiSXNzdWVyS2V5d29yZFJlY29yZFNoYXBlIl0sIklzc3VlclBLZXl3b3JkUmVjb3JkU2hhcGUiOlsiSXNzdWVyUEtleXdvcmRSZWNvcmRTaGFwZSJdLCJCcmFuZEtleXdvcmRSZWNvcmRTaGFwZSI6WyJCcmFuZEtleXdvcmRSZWNvcmRTaGFwZSJdLCJJc3N1ZXJSZWNvcmRTaGFwZSI6WyJJc3N1ZXJSZWNvcmRTaGFwZSJdLCJUZXJtc1NoYXBlIjpbIlRlcm1zU2hhcGUiXSwiSW5zdGFuY2VSZWNvcmRTaGFwZSI6WyJJbnN0YW5jZVJlY29yZFNoYXBlIl0sIkhhbmRsZUkiOlsiSGFuZGxlSSJdLCJtYWtlSGFuZGxlU2hhcGUiOlsibWFrZUhhbmRsZVNoYXBlIl0sIlRpbWVyU2hhcGUiOlsiVGltZXJTaGFwZSJdLCJGdWxsUHJvcG9zYWxTaGFwZSI6WyJGdWxsUHJvcG9zYWxTaGFwZSJdLCJQcm9wb3NhbFNoYXBlIjpbIlByb3Bvc2FsU2hhcGUiXSwiaXNPbkRlbWFuZEV4aXRSdWxlIjpbImlzT25EZW1hbmRFeGl0UnVsZSJdLCJpc1dhaXZlZEV4aXRSdWxlIjpbImlzV2FpdmVkRXhpdFJ1bGUiXSwiaXNBZnRlckRlYWRsaW5lRXhpdFJ1bGUiOlsiaXNBZnRlckRlYWRsaW5lRXhpdFJ1bGUiXSwiSW52aXRhdGlvbkVsZW1lbnRTaGFwZSI6WyJJbnZpdGF0aW9uRWxlbWVudFNoYXBlIl0sIk9mZmVySGFuZGxlckkiOlsiT2ZmZXJIYW5kbGVySSJdLCJTZWF0SGFuZGxlQWxsb2NhdGlvbnNTaGFwZSI6WyJTZWF0SGFuZGxlQWxsb2NhdGlvbnNTaGFwZSJdLCJab2VNaW50U2hhcGUiOlsiWm9lTWludFNoYXBlIl0sIlpvZU1pbnRJIjpbIlpvZU1pbnRJIl0sIlpjZk1pbnRJIjpbIlpjZk1pbnRJIl0sIkZlZU1pbnRBY2Nlc3NTaGFwZSI6WyJGZWVNaW50QWNjZXNzU2hhcGUiXSwiRXhpdE9iamVjdEkiOlsiRXhpdE9iamVjdEkiXSwiRXhpdE9iamVjdFNoYXBlIjpbIkV4aXRPYmplY3RTaGFwZSJdLCJJbnN0YW5jZUFkbWluU2hhcGUiOlsiSW5zdGFuY2VBZG1pblNoYXBlIl0sIkluc3RhbmNlQWRtaW5JIjpbIkluc3RhbmNlQWRtaW5JIl0sIkluc3RhbmNlU3RvcmFnZU1hbmFnZXJJS2l0IjpbIkluc3RhbmNlU3RvcmFnZU1hbmFnZXJJS2l0Il0sIkJ1bmRsZUNhcFNoYXBlIjpbIkJ1bmRsZUNhcFNoYXBlIl0sIkJ1bmRsZVNoYXBlIjpbIkJ1bmRsZVNoYXBlIl0sIlVud3JhcHBlZEluc3RhbGxhdGlvblNoYXBlIjpbIlVud3JhcHBlZEluc3RhbGxhdGlvblNoYXBlIl0sIlpvZVN0b3JhZ2VNYW5hZ2VySUtpdCI6WyJab2VTdG9yYWdlTWFuYWdlcklLaXQiXSwiWm9lU2VydmljZUkiOlsiWm9lU2VydmljZUkiXSwiQWRtaW5GYWNldEkiOlsiQWRtaW5GYWNldEkiXSwiU2VhdERhdGFTaGFwZSI6WyJTZWF0RGF0YVNoYXBlIl0sIkhhbmRsZU9mZmVySSI6WyJIYW5kbGVPZmZlckkiXSwiUHJpY2VRdW90ZVNoYXBlIjpbIlByaWNlUXVvdGVTaGFwZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADpDQFrlgcAAJYHAAAmAAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAamVzc2llLWNoZWNrKi9cblxuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuLyoqXG4gKiBAdGVtcGxhdGUge3N0cmluZ30gSCAtIHRoZSBuYW1lIG9mIHRoZSBoYW5kbGVcbiAqIEB0eXBlZGVmIHtIICYgWGltcG9ydChcIkBlbmRvL21hcnNoYWxcIikuUmVtb3RhYmxlfSBIYW5kbGUgQSB0eXBlIGNvbnN0cnVjdG9yIGZvciBhbiBvcGFxdWUgdHlwZVxuICogaWRlbnRpZmllZCBieSB0aGUgSCBzdHJpbmcuIFRoaXMgdXNlcyBhbiBpbnRlcnNlY3Rpb24gdHlwZVxuICogKCdNeUhhbmRsZScgJiB7fSkgdG8gdGFnIHRoZSBoYW5kbGUncyB0eXBlIGV2ZW4gdGhvdWdoIHRoZSBhY3R1YWxcbiAqIHZhbHVlIGlzIGp1c3QgYW4gZW1wdHkgb2JqZWN0LlxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge3N0cmluZ30gS2V5d29yZFxuICogQHR5cGVkZWYge0hhbmRsZTwnSW52aXRhdGlvbic+fSBJbnZpdGF0aW9uSGFuZGxlIC0gYW4gb3BhcXVlIGhhbmRsZSBmb3IgYW4gaW52aXRhdGlvblxuICogQHR5cGVkZWYge1JlY29yZDxLZXl3b3JkLCBJc3N1ZXI8YW55Pj59IElzc3VlcktleXdvcmRSZWNvcmRcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8S2V5d29yZCwgRVJlZjxJc3N1ZXI8YW55Pj4+fSBJc3N1ZXJQS2V5d29yZFJlY29yZFxuICogQHR5cGVkZWYge1JlY29yZDxLZXl3b3JkLCBCcmFuZDxhbnk+Pn0gQnJhbmRLZXl3b3JkUmVjb3JkXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBTdGFuZGFyZFRlcm1zXG4gKiBAcHJvcGVydHkge0lzc3VlcktleXdvcmRSZWNvcmR9IGlzc3VlcnMgLSByZWNvcmQgd2l0aFxuICoga2V5d29yZHMga2V5cywgaXNzdWVyIHZhbHVlc1xuICogQHByb3BlcnR5IHtCcmFuZEtleXdvcmRSZWNvcmR9IGJyYW5kcyAtIHJlY29yZCB3aXRoIGtleXdvcmRzXG4gKiBrZXlzLCBicmFuZCB2YWx1ZXNcbiAqXG4gKiBAdHlwZWRlZiB7U3RhbmRhcmRUZXJtcyAmIFJlY29yZDxzdHJpbmcsIGFueT59IEFueVRlcm1zXG4gKlxuICogQHR5cGVkZWYge29iamVjdH0gSW5zdGFuY2VSZWNvcmRcbiAqIEBwcm9wZXJ0eSB7SW5zdGFsbGF0aW9ufSBpbnN0YWxsYXRpb25cbiAqIEBwcm9wZXJ0eSB7WGltcG9ydChcIi4vem9lU2VydmljZS91dGlscy5qc1wiKS5JbnN0YW5jZTxhbnk+fSBpbnN0YW5jZVxuICogQHByb3BlcnR5IHtBbnlUZXJtc30gdGVybXMgLSBjb250cmFjdCBwYXJhbWV0ZXJzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge0Fzc2V0S2luZH0gW0s9QXNzZXRLaW5kXVxuICogQHR5cGVkZWYge29iamVjdH0gSXNzdWVyUmVjb3JkXG4gKiBAcHJvcGVydHkge0JyYW5kPEs+fSBicmFuZFxuICogQHByb3BlcnR5IHtJc3N1ZXI8Sz59IGlzc3VlclxuICogQHByb3BlcnR5IHtLfSBhc3NldEtpbmRcbiAqIEBwcm9wZXJ0eSB7RGlzcGxheUluZm88Sz59IFtkaXNwbGF5SW5mb11cbiAqXG4gKiBAdHlwZWRlZiB7QW1vdW50S2V5d29yZFJlY29yZH0gQWxsb2NhdGlvblxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtvYmplY3R9IFtSPXVua25vd25dIE9mZmVyIHJlc3VsdFxuICogQHRlbXBsYXRlIHtvYmplY3R9IFtBPW5ldmVyXSBPZmZlciBhcmdzXG4gKiBAdHlwZWRlZiB7UGF5bWVudDwnc2V0Jz59IEludml0YXRpb25cbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABqVac+LC0AACwtAAAxAAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvem9lU2VydmljZS90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qIEBqZXNzaWUtY2hlY2sqL1xuXG4vKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFpvZVNlcnZpY2VcbiAqXG4gKiBab2UgcHJvdmlkZXMgYSBmcmFtZXdvcmsgZm9yIGRlcGxveWluZyBhbmQgd29ya2luZyB3aXRoIHNtYXJ0XG4gKiBjb250cmFjdHMuIEl0IGlzIGFjY2Vzc2VkIGFzIGEgbG9uZy1saXZlZCBhbmQgd2VsbC10cnVzdGVkIHNlcnZpY2VcbiAqIHRoYXQgZW5mb3JjZXMgb2ZmZXIgc2FmZXR5IGZvciB0aGUgY29udHJhY3RzIHRoYXQgdXNlIGl0LiBab2UgaGFzIGFcbiAqIHNpbmdsZSBgaW52aXRhdGlvbklzc3VlcmAgZm9yIHRoZSBlbnRpcmV0eSBvZiBpdHMgbGlmZXRpbWUuIEJ5XG4gKiBoYXZpbmcgYSByZWZlcmVuY2UgdG8gWm9lLCBhIHVzZXIgY2FuIGdldCB0aGUgYGludml0YXRpb25Jc3N1ZXJgXG4gKiBhbmQgdGh1cyB2YWxpZGF0ZSBhbnkgYGludml0YXRpb25gIHRoZXkgcmVjZWl2ZSBmcm9tIHNvbWVvbmUgZWxzZS5cbiAqXG4gKiBab2UgaGFzIHR3byBkaWZmZXJlbnQgZmFjZXRzOiB0aGUgcHVibGljIFpvZSBzZXJ2aWNlIGFuZCB0aGVcbiAqIGNvbnRyYWN0IGZhY2V0IChaQ0YpLiBFYWNoIGNvbnRyYWN0IGluc3RhbmNlIGhhcyBhIGNvcHkgb2YgWkNGXG4gKiB3aXRoaW4gaXRzIHZhdC4gVGhlIGNvbnRyYWN0IGFuZCBaQ0YgbmV2ZXIgaGF2ZSBkaXJlY3QgYWNjZXNzIHRvXG4gKiB0aGUgdXNlcnMnIHBheW1lbnRzIG9yIHRoZSBab2UgcHVyc2VzLlxuICpcbiAqIEBwcm9wZXJ0eSB7R2V0SW52aXRhdGlvbklzc3Vlcn0gZ2V0SW52aXRhdGlvbklzc3VlclxuICpcbiAqIFpvZSBoYXMgYSBzaW5nbGUgYGludml0YXRpb25Jc3N1ZXJgIGZvciB0aGUgZW50aXJldHkgb2YgaXRzXG4gKiBsaWZldGltZS4gQnkgaGF2aW5nIGEgcmVmZXJlbmNlIHRvIFpvZSwgYSB1c2VyIGNhbiBnZXQgdGhlXG4gKiBgaW52aXRhdGlvbklzc3VlcmAgYW5kIHRodXMgdmFsaWRhdGUgYW55IGBpbnZpdGF0aW9uYCB0aGV5IHJlY2VpdmVcbiAqIGZyb20gc29tZW9uZSBlbHNlLiBUaGUgbWludCBhc3NvY2lhdGVkIHdpdGggdGhlIGludml0YXRpb25Jc3N1ZXJcbiAqIGNyZWF0ZXMgdGhlIEVSVFAgcGF5bWVudHMgdGhhdCByZXByZXNlbnQgdGhlIHJpZ2h0IHRvIGludGVyYWN0IHdpdGhcbiAqIGEgc21hcnQgY29udHJhY3QgaW4gcGFydGljdWxhciB3YXlzLlxuICpcbiAqIEBwcm9wZXJ0eSB7SW5zdGFsbEJ1bmRsZX0gaW5zdGFsbFxuICogQHByb3BlcnR5IHtJbnN0YWxsQnVuZGxlSUR9IGluc3RhbGxCdW5kbGVJRFxuICogQHByb3BlcnR5IHtYaW1wb3J0KCcuL3V0aWxzJykuU3RhcnRJbnN0YW5jZX0gc3RhcnRJbnN0YW5jZVxuICogQHByb3BlcnR5IHtPZmZlcn0gb2ZmZXJcbiAqIEBwcm9wZXJ0eSB7WGltcG9ydCgnLi91dGlscycpLkdldFB1YmxpY0ZhY2V0fSBnZXRQdWJsaWNGYWNldFxuICogQHByb3BlcnR5IHtHZXRJc3N1ZXJzfSBnZXRJc3N1ZXJzXG4gKiBAcHJvcGVydHkge0dldEJyYW5kc30gZ2V0QnJhbmRzXG4gKiBAcHJvcGVydHkge1hpbXBvcnQoJy4vdXRpbHMnKS5HZXRUZXJtc30gZ2V0VGVybXNcbiAqIEBwcm9wZXJ0eSB7R2V0T2ZmZXJGaWx0ZXJ9IGdldE9mZmVyRmlsdGVyXG4gKiBAcHJvcGVydHkge0dldEluc3RhbGxhdGlvbkZvckluc3RhbmNlfSBnZXRJbnN0YWxsYXRpb25Gb3JJbnN0YW5jZVxuICogQHByb3BlcnR5IHtHZXRJbnN0YW5jZX0gZ2V0SW5zdGFuY2VcbiAqIEBwcm9wZXJ0eSB7R2V0SW5zdGFsbGF0aW9ufSBnZXRJbnN0YWxsYXRpb25cbiAqIEBwcm9wZXJ0eSB7R2V0SW52aXRhdGlvbkRldGFpbHN9IGdldEludml0YXRpb25EZXRhaWxzXG4gKiBSZXR1cm4gYW4gb2JqZWN0IHdpdGggdGhlIGluc3RhbmNlLCBpbnN0YWxsYXRpb24sIGRlc2NyaXB0aW9uLCBpbnZpdGF0aW9uXG4gKiBoYW5kbGUsIGFuZCBhbnkgY3VzdG9tIHByb3BlcnRpZXMgc3BlY2lmaWMgdG8gdGhlIGNvbnRyYWN0LlxuICogQHByb3BlcnR5IHtHZXRGZWVJc3N1ZXJ9IGdldEZlZUlzc3VlclxuICogQHByb3BlcnR5IHtHZXRDb25maWd1cmF0aW9ufSBnZXRDb25maWd1cmF0aW9uXG4gKiBAcHJvcGVydHkge0dldEJ1bmRsZUlERnJvbUluc3RhbGxhdGlvbn0gZ2V0QnVuZGxlSURGcm9tSW5zdGFsbGF0aW9uXG4gKiBAcHJvcGVydHkgeyhpbnZpdGF0aW9uSGFuZGxlOiBJbnZpdGF0aW9uSGFuZGxlKSA9PiBQYXR0ZXJuIHwgdW5kZWZpbmVkfSBnZXRQcm9wb3NhbFNoYXBlRm9ySW52aXRhdGlvblxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEdldEludml0YXRpb25Jc3N1ZXJcbiAqIEByZXR1cm5zIHtQcm9taXNlPElzc3Vlcjwnc2V0Jz4+fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEdldEZlZUlzc3VlclxuICogQHJldHVybnMge1Byb21pc2U8SXNzdWVyPCduYXQnPj59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgR2V0Q29uZmlndXJhdGlvblxuICogQHJldHVybnMge3tcbiAqICAgZmVlSXNzdWVyQ29uZmlnOiBGZWVJc3N1ZXJDb25maWcsXG4gKiB9fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEdldElzc3VlcnNcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi91dGlscycpLkluc3RhbmNlPGFueT59IGluc3RhbmNlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxJc3N1ZXJLZXl3b3JkUmVjb3JkPn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBHZXRCcmFuZHNcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi91dGlscycpLkluc3RhbmNlPGFueT59IGluc3RhbmNlXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxCcmFuZEtleXdvcmRSZWNvcmQ+fVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEdldE9mZmVyRmlsdGVyXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdXRpbHMnKS5JbnN0YW5jZTxhbnk+fSBpbnN0YW5jZVxuICogQHJldHVybnMge3N0cmluZ1tdfVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFNldE9mZmVyRmlsdGVyXG4gKiBAcGFyYW0ge0luc3RhbmNlfSBpbnN0YW5jZVxuICogQHBhcmFtIHtzdHJpbmdbXX0gc3RyaW5nc1xuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIEdldEluc3RhbGxhdGlvbkZvckluc3RhbmNlXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdXRpbHMnKS5JbnN0YW5jZTxhbnk+fSBpbnN0YW5jZVxuICogQHJldHVybnMge1Byb21pc2U8SW5zdGFsbGF0aW9uPn1cbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBHZXRJbnN0YW5jZVxuICogQHBhcmFtIHtFUmVmPEludml0YXRpb24+fSBpbnZpdGF0aW9uXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxYaW1wb3J0KCcuL3V0aWxzJykuSW5zdGFuY2U8YW55Pj59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgR2V0SW5zdGFsbGF0aW9uXG4gKiBAcGFyYW0ge0VSZWY8SW52aXRhdGlvbj59IGludml0YXRpb25cbiAqIEByZXR1cm5zIHtQcm9taXNlPEluc3RhbGxhdGlvbj59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgR2V0SW52aXRhdGlvbkRldGFpbHNcbiAqIEBwYXJhbSB7RVJlZjxJbnZpdGF0aW9uPn0gaW52aXRhdGlvblxuICogQHJldHVybnMge1Byb21pc2U8SW52aXRhdGlvbkRldGFpbHM+fVxuICovXG5cbi8qIFRPRE8gcmVtb3ZlIHN1cHBvcnQgZm9yIHNvdXJjZSBidW5kbGVzLCBsZWF2aW5nIG9ubHkgc3VwcG9ydCBmb3IgaGFzaCBidW5kbGVzLiovXG4vKiBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQ1NjUqL1xuLyoqXG4gKiBAY2FsbGJhY2sgSW5zdGFsbEJ1bmRsZVxuICpcbiAqIENyZWF0ZSBhbiBpbnN0YWxsYXRpb24gYnkgc2FmZWx5IGV2YWx1YXRpbmcgdGhlIGNvZGUgYW5kXG4gKiByZWdpc3RlcmluZyBpdCB3aXRoIFpvZS4gUmV0dXJucyBhbiBpbnN0YWxsYXRpb24uXG4gKlxuICogQHBhcmFtIHtCdW5kbGUgfCBTb3VyY2VCdW5kbGV9IGJ1bmRsZVxuICogQHBhcmFtIHtzdHJpbmd9IFtidW5kbGVMYWJlbF1cbiAqIEByZXR1cm5zIHtQcm9taXNlPEluc3RhbGxhdGlvbj59XG4gKi9cblxuLyogVE9ETyBjb25zb2xpZGF0ZSBpbnN0YWxsQnVuZGxlSUQgaW50byBpbnN0YWxsLiovXG4vKiBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQ5NzQqL1xuLyoqXG4gKiBAY2FsbGJhY2sgSW5zdGFsbEJ1bmRsZUlEXG4gKlxuICogQ3JlYXRlIGFuIGluc3RhbGxhdGlvbiBmcm9tIGEgQnVuZGxlIElELiBSZXR1cm5zIGFuIGluc3RhbGxhdGlvbi5cbiAqXG4gKiBAcGFyYW0ge0J1bmRsZUlEfSBidW5kbGVJRFxuICogQHBhcmFtIHtzdHJpbmd9IFtidW5kbGVMYWJlbF1cbiAqIEByZXR1cm5zIHtQcm9taXNlPEluc3RhbGxhdGlvbj59XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgR2V0QnVuZGxlSURGcm9tSW5zdGFsbGF0aW9uXG4gKlxuICogVmVyaWZ5IHRoYXQgYW4gYWxsZWdlZCBJbnN0YWxsYXRpb24gaXMgcmVhbCwgYW5kIHJldHVybiB0aGUgQnVuZGxlIElEIGl0XG4gKiB3aWxsIHVzZSBmb3IgY29udHJhY3QgY29kZS5cbiAqXG4gKiBAcGFyYW0ge0VSZWY8SW5zdGFsbGF0aW9uPn0gYWxsZWdlZEluc3RhbGxhdGlvblxuICogQHJldHVybnMge1Byb21pc2U8QnVuZGxlSUQ+fVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYgezxBcmdzLCBSZXN1bHQ+KFxuICogICBpbnZpdGF0aW9uOiBFUmVmPEludml0YXRpb248UmVzdWx0LCBBcmdzPj4sXG4gKiAgIHByb3Bvc2FsPzogUHJvcG9zYWwsXG4gKiAgIHBheW1lbnRLZXl3b3JkUmVjb3JkPzogUGF5bWVudFBLZXl3b3JkUmVjb3JkLFxuICogICBvZmZlckFyZ3M/OiBBcmdzLFxuICogICApID0+IFByb21pc2U8VXNlclNlYXQ8UmVzdWx0Pj5cbiAqIH0gT2ZmZXJcbiAqXG4gKiBUbyByZWRlZW0gYW4gaW52aXRhdGlvbiwgdGhlIHVzZXIgbm9ybWFsbHkgcHJvdmlkZXMgYSBwcm9wb3NhbCAodGhlaXJcbiAqIHJ1bGVzIGZvciB0aGUgb2ZmZXIpIGFzIHdlbGwgYXMgcGF5bWVudHMgdG8gYmUgZXNjcm93ZWQgYnkgWm9lLiAgSWZcbiAqIGVpdGhlciB0aGUgcHJvcG9zYWwgb3IgcGF5bWVudHMgd291bGQgYmUgZW1wdHksIGluZGljYXRlIHRoaXMgYnlcbiAqIG9taXR0aW5nIHRoYXQgYXJndW1lbnQgb3IgcGFzc2luZyB1bmRlZmluZWQsIHJhdGhlciB0aGFuIHBhc3NpbmcgYW5cbiAqIGVtcHR5IHJlY29yZC5cbiAqXG4gKiBUaGUgcHJvcG9zYWwgaGFzIHRocmVlIHBhcnRzOiBgd2FudGAgYW5kIGBnaXZlYCBhcmUgdXNlZCBieSBab2UgdG9cbiAqIGVuZm9yY2Ugb2ZmZXIgc2FmZXR5LCBhbmQgYGV4aXRgIGlzIHVzZWQgdG8gc3BlY2lmeSB0aGUgcGFydGljdWxhclxuICogcGF5b3V0LWxpdmVuZXNzIHBvbGljeSB0aGF0IFpvZSBjYW4gZ3VhcmFudGVlLiBgd2FudGAgYW5kIGBnaXZlYFxuICogYXJlIG9iamVjdHMgd2l0aCBrZXl3b3JkcyBhcyBrZXlzIGFuZCBhbW91bnRzIGFzIHZhbHVlcy5cbiAqIGBwYXltZW50S2V5d29yZFJlY29yZGAgaXMgYSByZWNvcmQgd2l0aCBrZXl3b3JkcyBhcyBrZXlzLCBhbmQgdGhlXG4gKiB2YWx1ZXMgYXJlIHRoZSBhY3R1YWwgcGF5bWVudHMgdG8gYmUgZXNjcm93ZWQuIEEgcGF5bWVudCBpc1xuICogZXhwZWN0ZWQgZm9yIGV2ZXJ5IHJ1bGUgdW5kZXIgYGdpdmVgLlxuICovXG5cbi8qKlxuICogWm9lIHVzZXMgc2VhdHMgdG8gYWNjZXNzIG9yIG1hbmlwdWxhdGUgb2ZmZXJzLiBUaGV5IGxldCBjb250cmFjdHMgYW5kIHVzZXJzXG4gKiBpbnRlcmFjdCB3aXRoIHRoZW0uIFpvZSBoYXMgdHdvIGtpbmRzIG9mIHNlYXRzLiBaQ0ZTZWF0cyBhcmUgdXNlZCB3aXRoaW5cbiAqIGNvbnRyYWN0cyBhbmQgd2l0aCB6Y2YgbWV0aG9kcy4gVXNlclNlYXRzIHJlcHJlc2VudCBvZmZlcnMgZXh0ZXJuYWwgdG8gWm9lXG4gKiBhbmQgdGhlIGNvbnRyYWN0LiBUaGUgcGFydHkgd2hvIGV4ZXJjaXNlcyBhbiBpbnZpdGF0aW9uIGFuZCBzZW5kcyB0aGUgb2ZmZXIoKVxuICogbWVzc2FnZSB0byBab2UgZ2V0cyBhIFVzZXJTZWF0IHRoYXQgY2FuIGNoZWNrIHBheW91dHMnIHN0YXR1cyBvciByZXRyaWV2ZSB0aGVcbiAqIHJlc3VsdCBvZiBwcm9jZXNzaW5nIHRoZSBvZmZlciBpbiB0aGUgY29udHJhY3QuIFRoaXMgdmFyaWVzLCBidXQgZXhhbXBsZXMgYXJlXG4gKiBhIHN0cmluZyBhbmQgYW4gaW52aXRhdGlvbiBmb3IgYW5vdGhlciBzZWF0LlxuICpcbiAqIEFsc28sIGEgVXNlclNlYXQgY2FuIGJlIGhhbmRlZCB0byBhbiBhZ2VudCBvdXRzaWRlIFpvZSBhbmQgdGhlIGNvbnRyYWN0LFxuICogbGV0dGluZyB0aGVtIHF1ZXJ5IG9yIG1vbml0b3IgdGhlIGN1cnJlbnQgc3RhdGUsIGFjY2VzcyB0aGUgcGF5b3V0cyBhbmRcbiAqIHJlc3VsdCwgYW5kLCBpZiBpdCdzIGFsbG93ZWQgZm9yIHRoaXMgc2VhdCwgY2FsbCB0cnlFeGl0KCkuXG4gKlxuICogU2luY2UgYW55b25lIGNhbiBhdHRlbXB0IHRvIGV4aXQgdGhlIHNlYXQgaWYgdGhleSBoYXZlIGEgcmVmZXJlbmNlIHRvIGl0LCB5b3VcbiAqIHNob3VsZCBvbmx5IHNoYXJlIGEgVXNlclNlYXQgd2l0aCB0cnVzdGVkIHBhcnRpZXMuXG4gKlxuICogVXNlclNlYXQgaW5jbHVkZXMgcXVlcmllcyBmb3IgdGhlIGFzc29jaWF0ZWQgb2ZmZXIncyBjdXJyZW50IHN0YXRlIGFuZCBhblxuICogb3BlcmF0aW9uIHRvIHJlcXVlc3QgdGhhdCB0aGUgb2ZmZXIgZXhpdCwgYXMgZm9sbG93czpcbiAqXG4gKiBAc2VlIHtAbGluayBodHRwczovL2RvY3MuYWdvcmljLmNvbS96b2UvYXBpL3pvZS5odG1sI3VzZXJzZWF0LW9iamVjdH19XG4gKiBAdGVtcGxhdGUge29iamVjdH0gW09SPXVua25vd25dXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBVc2VyU2VhdFxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPFByb3Bvc2FsUmVjb3JkPn0gZ2V0UHJvcG9zYWxcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxQYXltZW50UEtleXdvcmRSZWNvcmQ+fSBnZXRQYXlvdXRzXG4gKiByZXR1cm5zIGEgcHJvbWlzZSBmb3IgYSBLZXl3b3JkUGF5bWVudFJlY29yZCBjb250YWluaW5nIGFsbCB0aGUgcGF5b3V0cyBmcm9tXG4gKiB0aGlzIHNlYXQuIFRoZSBwcm9taXNlIHdpbGwgcmVzb2x2ZSBhZnRlciB0aGUgc2VhdCBoYXMgZXhpdGVkLlxuICogQHByb3BlcnR5IHsoa2V5d29yZDogS2V5d29yZCkgPT4gUHJvbWlzZTxQYXltZW50PGFueT4+fSBnZXRQYXlvdXRcbiAqIHJldHVybnMgYSBwcm9taXNlIGZvciB0aGUgUGF5bWVudCBjb3JyZXNwb25kaW5nIHRvIHRoZSBpbmRpY2F0ZWQga2V5d29yZC5cbiAqIFRoZSBwcm9taXNlIHdpbGwgcmVzb2x2ZSBhZnRlciB0aGUgc2VhdCBoYXMgZXhpdGVkLlxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPE9SPn0gZ2V0T2ZmZXJSZXN1bHRcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gdm9pZH0gW3RyeUV4aXRdXG4gKiBOb3RlOiBPbmx5IHdvcmtzIGlmIHRoZSBzZWF0J3MgYHByb3Bvc2FsYCBoYXMgYW4gYE9uRGVtYW5kYCBgZXhpdGAgY2xhdXNlLiBab2Unc1xuICogb2ZmZXItc2FmZXR5IGd1YXJhbnRlZSBhcHBsaWVzIG5vIG1hdHRlciBob3cgYSBzZWF0J3MgaW50ZXJhY3Rpb24gd2l0aCBhXG4gKiBjb250cmFjdCBlbmRzLiBVbmRlciBub3JtYWwgY2lyY3Vtc3RhbmNlcywgdGhlIHBhcnRpY2lwYW50IG1pZ2h0IGJlIGFibGUgdG9cbiAqIGNhbGwgYHRyeUV4aXQoKWAsIG9yIHRoZSBjb250cmFjdCBtaWdodCBkbyBzb21ldGhpbmcgZXhwbGljaXRseS4gT24gZXhpdGluZyxcbiAqIHRoZSBzZWF0IGhvbGRlciBnZXRzIGl0cyBjdXJyZW50IGBhbGxvY2F0aW9uYCBhbmQgdGhlIGBzZWF0YCBjYW4gbm8gbG9uZ2VyXG4gKiBpbnRlcmFjdCB3aXRoIHRoZSBjb250cmFjdC5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gUHJvbWlzZTxib29sZWFuPn0gaGFzRXhpdGVkXG4gKiBSZXR1cm5zIHRydWUgaWYgdGhlIHNlYXQgaGFzIGV4aXRlZCwgZmFsc2UgaWYgaXQgaXMgc3RpbGwgYWN0aXZlLlxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPDB8MT59IG51bVdhbnRzU2F0aXNmaWVkIHJldHVybnMgMSBpZiB0aGUgcHJvcG9zYWwnc1xuICogd2FudCBjbGF1c2Ugd2FzIHNhdGlzZmllZCBieSB0aGUgZmluYWwgYWxsb2NhdGlvbiwgb3RoZXJ3aXNlIDAuIFRoaXMgaXNcbiAqIG51bWVyaWMgdG8gc3VwcG9ydCBhIHBsYW5uZWQgZW5oYW5jZW1lbnQgY2FsbGVkIFwibXVsdGlwbGVzXCIgd2hpY2ggd2lsbCBhbGxvd1xuICogdGhlIHJldHVybiB2YWx1ZSB0byBiZSBhbnkgbm9uLW5lZ2F0aXZlIG51bWJlci4gVGhlIHByb21pc2Ugd2lsbCByZXNvbHZlXG4gKiBhZnRlciB0aGUgc2VhdCBoYXMgZXhpdGVkLlxuICogQHByb3BlcnR5IHsoKSA9PiBQcm9taXNlPEFsbG9jYXRpb24+fSBnZXRGaW5hbEFsbG9jYXRpb25cbiAqIHJldHVybiBhIHByb21pc2UgZm9yIHRoZSBmaW5hbCBhbGxvY2F0aW9uLiBUaGUgcHJvbWlzZSB3aWxsIHJlc29sdmUgYWZ0ZXIgdGhlXG4gKiBzZWF0IGhhcyBleGl0ZWQuXG4gKiBAcHJvcGVydHkgeygpID0+IFN1YnNjcmliZXI8Q29tcGxldGlvbj59IGdldEV4aXRTdWJzY3JpYmVyIHJldHVybnMgYSBzdWJzY3JpYmVyIHRoYXRcbiAqIHdpbGwgYmUgbm90aWZpZWQgd2hlbiB0aGUgc2VhdCBoYXMgZXhpdGVkIG9yIGZhaWxlZC5cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtQYXJ0aWFsPFByb3Bvc2FsUmVjb3JkPn0gUHJvcG9zYWxcbiAqXG4gKiBAdHlwZWRlZiB7e2dpdmU6IEFtb3VudEtleXdvcmRSZWNvcmQsXG4gKiAgICAgICAgICAgIHdhbnQ6IEFtb3VudEtleXdvcmRSZWNvcmQsXG4gKiAgICAgICAgICAgIGV4aXQ6IEV4aXRSdWxlXG4gKiAgICAgICAgICAgfX0gUHJvcG9zYWxSZWNvcmRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtSZWNvcmQ8S2V5d29yZCwgQW1vdW50PGFueT4+fSBBbW91bnRLZXl3b3JkUmVjb3JkXG4gKlxuICogVGhlIGtleXMgYXJlIGtleXdvcmRzLCBhbmQgdGhlIHZhbHVlcyBhcmUgYW1vdW50cy4gRm9yIGV4YW1wbGU6XG4gKiB7IEFzc2V0OiBBbW91bnRNYXRoLm1ha2UoYXNzZXRCcmFuZCwgNW4pLCBQcmljZTpcbiAqIEFtb3VudE1hdGgubWFrZShwcmljZUJyYW5kLCA5bikgfVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gV2FrZXJcbiAqIEBwcm9wZXJ0eSB7KCkgPT4gdm9pZH0gd2FrZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMnKS5UaW1lc3RhbXB9IERlYWRsaW5lXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBUaW1lclxuICogQHByb3BlcnR5IHsoZGVhZGxpbmU6IERlYWRsaW5lLCB3YWtlclA6IEVSZWY8V2FrZXI+KSA9PiB2b2lkfSBzZXRXYWtldXBcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IE9uRGVtYW5kRXhpdFJ1bGVcbiAqIEBwcm9wZXJ0eSB7bnVsbH0gb25EZW1hbmRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFdhaXZlZEV4aXRSdWxlXG4gKiBAcHJvcGVydHkge251bGx9IHdhaXZlZFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQWZ0ZXJEZWFkbGluZUV4aXRSdWxlXG4gKiBAcHJvcGVydHkge3t0aW1lcjpUaW1lciwgZGVhZGxpbmU6RGVhZGxpbmV9fSBhZnRlckRlYWRsaW5lXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7T25EZW1hbmRFeGl0UnVsZSB8IFdhaXZlZEV4aXRSdWxlIHwgQWZ0ZXJEZWFkbGluZUV4aXRSdWxlfSBFeGl0UnVsZVxuICpcbiAqIFRoZSBwb3NzaWJsZSBrZXlzIGFyZSAnd2FpdmVkJywgJ29uRGVtYW5kJywgYW5kICdhZnRlckRlYWRsaW5lJy5cbiAqIGB0aW1lcmAgYW5kIGBkZWFkbGluZWAgb25seSBhcmUgdXNlZCBmb3IgdGhlIGBhZnRlckRlYWRsaW5lYCBrZXkuXG4gKiBUaGUgcG9zc2libGUgcmVjb3JkcyBhcmU6XG4gKiBgeyB3YWl2ZWQ6IG51bGwgfWBcbiAqIGB7IG9uRGVtYW5kOiBudWxsIH1gXG4gKiBgeyBhZnRlckRlYWRsaW5lOiB7IHRpbWVyIDpUaW1lcjxEZWFkbGluZT4sIGRlYWRsaW5lIDpEZWFkbGluZSB9IH1cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3V0aWxzJykuSW5zdGFuY2U8YW55Pn0gSW5zdGFuY2VcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3N3aW5nc2V0LXZhdCcpLlZhdEFkbWluU3ZjfSBWYXRBZG1pblN2Y1xuICovXG5cbi8qKlxuICogQHR5cGVkZWYge3tidW5kbGVDYXA6IFhpbXBvcnQoJ0BhZ29yaWMvc3dpbmdzZXQtdmF0JykuQnVuZGxlQ2FwIH0gfCB7bmFtZTogc3RyaW5nfSB8IHtpZDogQnVuZGxlSUR9fSBaQ0ZTcGVjXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7UmVjb3JkPHN0cmluZywgYW55Pn0gU291cmNlQnVuZGxlXG4gKiBPcGFxdWUgdHlwZSBmb3IgYSBKU09OYWJsZSBzb3VyY2UgYnVuZGxlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7UmVjb3JkPEtleXdvcmQsRVJlZjxQYXltZW50PGFueT4+Pn0gUGF5bWVudFBLZXl3b3JkUmVjb3JkXG4gKiBAdHlwZWRlZiB7UmVjb3JkPEtleXdvcmQsUGF5bWVudDxhbnk+Pn0gUGF5bWVudEtleXdvcmRSZWNvcmRcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEludml0YXRpb25EZXRhaWxzXG4gKiBAcHJvcGVydHkge0luc3RhbGxhdGlvbn0gaW5zdGFsbGF0aW9uXG4gKiBAcHJvcGVydHkge1hpbXBvcnQoJy4vdXRpbHMnKS5JbnN0YW5jZTxhbnk+fSBpbnN0YW5jZVxuICogQHByb3BlcnR5IHtJbnZpdGF0aW9uSGFuZGxlfSBoYW5kbGVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBkZXNjcmlwdGlvblxuICogQHByb3BlcnR5IHtSZWNvcmQ8c3RyaW5nLCBhbnk+fSBbY3VzdG9tRGV0YWlsc11cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBbU0Y9YW55XSBjb250cmFjdCBzdGFydCBmdW5jdGlvblxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vdXRpbHMnKS5JbnN0YWxsYXRpb248U0Y+fSBJbnN0YWxsYXRpb25cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7SW5zdGFsbGF0aW9ufSBJXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi91dGlscycpLkluc3RhbGxhdGlvblN0YXJ0PEk+fSBJbnN0YWxsYXRpb25TdGFydFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRmVlSXNzdWVyQ29uZmlnXG4gKiBAcHJvcGVydHkge3N0cmluZ30gbmFtZVxuICogQHByb3BlcnR5IHtBc3NldEtpbmR9IGFzc2V0S2luZFxuICogQHByb3BlcnR5IHtEaXNwbGF5SW5mb30gZGlzcGxheUluZm9cbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFpvZUZlZXNDb25maWdcbiAqIEBwcm9wZXJ0eSB7TmF0VmFsdWV9IGdldFB1YmxpY0ZhY2V0RmVlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7SGFuZGxlPCdmZWVNaW50QWNjZXNzJz59IEZlZU1pbnRBY2Nlc3NcbiAqL1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADY7Y2slxYAAJcWAAAwAAAAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC90b29scy90eXBlcy1hbWJpZW50LmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQGplc3NpZS1jaGVjayovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUHJpY2VRdW90ZVxuICogQHByb3BlcnR5IHtBbW91bnQ8J3NldCc+fSBxdW90ZUFtb3VudFxuICogQW1vdW50IHdob3NlIHZhbHVlIGlzIGEgUHJpY2VRdW90ZVZhbHVlXG4gKiBAcHJvcGVydHkge0VSZWY8UGF5bWVudDwnc2V0Jz4+fSBxdW90ZVBheW1lbnRcbiAqIFRoZSBgcXVvdGVBbW91bnRgIHdyYXBwZWQgYXMgYSBwYXltZW50XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7W1ByaWNlRGVzY3JpcHRpb25dfSBQcmljZVF1b3RlVmFsdWVcbiAqIEEgc2luZ2xlLXZhbHVlZCBzZXQgb2YgUHJpY2VEZXNjcmlwdGlvbnMuICBUaGlzIGlzIHRoZSBgdmFsdWVgIGluXG4gKiBQcmljZVF1b3RlLnF1b3RlQW1vdW50IChgeyBicmFuZCwgdmFsdWU6IFByaWNlUXVvdGVWYWx1ZSB9YCkuXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQcmljZURlc2NyaXB0aW9uXG4gKiBBIGRlc2NyaXB0aW9uIG9mIGEgc2luZ2xlIHF1b3RlXG4gKiBAcHJvcGVydHkge0Ftb3VudDwnbmF0Jz59IGFtb3VudEluXG4gKiBUaGUgYW1vdW50IHN1cHBsaWVkIHRvIGEgdHJhZGVcbiAqIEBwcm9wZXJ0eSB7QW1vdW50PCduYXQnPn0gYW1vdW50T3V0XG4gKiBUaGUgcXVvdGVkIHJlc3VsdCBvZiB0cmFkaW5nIGBhbW91bnRJbmBcbiAqIEBwcm9wZXJ0eSB7WGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVyU2VydmljZX0gdGltZXJcbiAqIFRoZSBzZXJ2aWNlIHRoYXQgZ2F2ZSB0aGUgYHRpbWVzdGFtcGBcbiAqIEBwcm9wZXJ0eSB7WGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVzdGFtcFJlY29yZH0gdGltZXN0YW1wXG4gKiBBIHRpbWVzdGFtcCBhY2NvcmRpbmcgdG8gYHRpbWVyYCBmb3IgdGhlIHF1b3RlXG4gKiBAcHJvcGVydHkge2FueX0gW2NvbmRpdGlvbnNdXG4gKiBBZGRpdGlvbmFsIGNvbmRpdGlvbnMgZm9yIHRoZSBxdW90ZVxuICovXG5cbi8qKlxuICogQGNhbGxiYWNrIFByaWNlUXVvdGVDcmVhdGVcbiAqIEBwYXJhbSB7UHJpY2VRdWVyeX0gcHJpY2VRdWVyeVxuICogQHJldHVybnMge0VSZWY8UHJpY2VRdW90ZT4gfCB1bmRlZmluZWR9XG4gKi9cblxuLyoqXG4gKiBAY2FsbGJhY2sgUHJpY2VRdW90ZVRyaWdnZXJcbiAqIEBwYXJhbSB7UHJpY2VRdW90ZUNyZWF0ZX0gY3JlYXRlUXVvdGVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFByaWNlQXV0aG9yaXR5QWRtaW5cbiAqIEBwcm9wZXJ0eSB7KGNyZWF0ZVF1b3RlOiBQcmljZVF1b3RlQ3JlYXRlKSA9PiBQcm9taXNlPHZvaWQ+fSBmaXJlVHJpZ2dlcnNcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFByaWNlQXV0aG9yaXR5S2l0XG4gKiBAcHJvcGVydHkge1ByaWNlQXV0aG9yaXR5fSBwcmljZUF1dGhvcml0eVxuICogQHByb3BlcnR5IHtQcmljZUF1dGhvcml0eUFkbWlufSBhZG1pbkZhY2V0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBNdXRhYmxlUXVvdGVcbiAqIEBwcm9wZXJ0eSB7KHJlYXNvbj86IGFueSkgPT4gdm9pZH0gY2FuY2VsXG4gKiBAcHJvcGVydHkgeyhhbW91bnRJbjogQW1vdW50PCduYXQnPiwgYW1vdW50T3V0OiBBbW91bnQ8J25hdCc+KSA9PiB2b2lkfSB1cGRhdGVMZXZlbFxuICogQHByb3BlcnR5IHsoKSA9PiBFUmVmPFByaWNlUXVvdGU+fSBnZXRQcm9taXNlXG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBQcmljZUF1dGhvcml0eVxuICogQW4gb2JqZWN0IHRoYXQgbWludHMgUHJpY2VRdW90ZXMgYW5kIGhhbmRsZXNcbiAqIHRyaWdnZXJzIGFuZCBub3RpZmllcnMgZm9yIGNoYW5nZXMgaW4gdGhlIHByaWNlXG4gKlxuICogQHByb3BlcnR5IHsoYnJhbmRJbjogQnJhbmQsIGJyYW5kT3V0OiBCcmFuZCkgPT4gRVJlZjxJc3N1ZXI8J3NldCc+Pn0gZ2V0UXVvdGVJc3N1ZXJcbiAqIEdldCB0aGUgRVJUUCBpc3N1ZXIgb2YgUHJpY2VRdW90ZXMgZm9yIGEgZ2l2ZW4gYnJhbmRJbi9icmFuZE91dCBwYWlyXG4gKlxuICogQHByb3BlcnR5IHsoYnJhbmRJbjogQnJhbmQsXG4gKiAgICAgICAgICAgICBicmFuZE91dDogQnJhbmRcbiAqICkgPT4gRVJlZjxYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXJTZXJ2aWNlPn0gZ2V0VGltZXJTZXJ2aWNlXG4gKiBHZXQgdGhlIHRpbWVyIHVzZWQgaW4gUHJpY2VRdW90ZXMgZm9yIGEgZ2l2ZW4gYnJhbmRJbi9icmFuZE91dCBwYWlyXG4gKlxuICogQHByb3BlcnR5IHsoYW1vdW50SW46IEFtb3VudDwnbmF0Jz4sXG4gKiAgICAgICAgICAgICBicmFuZE91dDogQnJhbmQ8J25hdCc+XG4gKiAgICAgICAgICAgICkgPT4gRVJlZjxOb3RpZmllcjxQcmljZVF1b3RlPj59IG1ha2VRdW90ZU5vdGlmaWVyXG4gKiBCZSBub3RpZmllZCBvZiB0aGUgbGF0ZXN0IFByaWNlUXVvdGVzIGZvciBhIGdpdmVuXG4gKiBgYW1vdW50SW5gLiAgVGhlIHJhdGUgYXQgd2hpY2ggdGhlc2UgYXJlIGlzc3VlZCBtYXkgYmUgdmVyeSBkaWZmZXJlbnQgYmV0d2VlblxuICogYHByaWNlQXV0aG9yaXRpZXNgLlxuICpcbiAqIEBwcm9wZXJ0eSB7KGRlYWRsaW5lOiBYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXN0YW1wLFxuICogICAgICAgICAgICAgYW1vdW50SW46IEFtb3VudDwnbmF0Jz4sXG4gKiAgICAgICAgICAgICBicmFuZE91dDogQnJhbmQ8J25hdCc+XG4gKiApID0+IFByb21pc2U8UHJpY2VRdW90ZT59IHF1b3RlQXRUaW1lXG4gKiBSZXNvbHZlcyBhZnRlciBgZGVhZGxpbmVgIHBhc3NlcyBvbiB0aGVcbiAqIHByaWNlQXV0aG9yaXR5J3MgdGltZXJTZXJ2aWNlIHdpdGggdGhlIHByaWNlIHF1b3RlIG9mIGBhbW91bnRJbmAgYXQgdGhhdCB0aW1lXG4gKlxuICogQHByb3BlcnR5IHsoYW1vdW50SW46IEFtb3VudDwnbmF0Jz4sXG4gKiAgICAgICAgICAgICBicmFuZE91dDogQnJhbmQ8J25hdCc+XG4gKiApID0+IFByb21pc2U8UHJpY2VRdW90ZT59IHF1b3RlR2l2ZW5cbiAqIEdldCBhIHF1b3RlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBhbW91bnRJblxuICpcbiAqIEBwcm9wZXJ0eSB7KGJyYW5kSW46IEJyYW5kPCduYXQnPixcbiAqICAgICAgICAgICAgIGFtb3VudE91dDogQW1vdW50PCduYXQnPikgPT4gUHJvbWlzZTxQcmljZVF1b3RlPn0gcXVvdGVXYW50ZWRcbiAqIEdldCBhIHF1b3RlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIHNwZWNpZmllZCBhbW91bnRPdXRcbiAqXG4gKiBAcHJvcGVydHkgeyhhbW91bnRJbjogQW1vdW50PCduYXQnPixcbiAqICAgICAgICAgICAgIGFtb3VudE91dExpbWl0OiBBbW91bnQ8J25hdCc+XG4gKiApID0+IFByb21pc2U8UHJpY2VRdW90ZT59IHF1b3RlV2hlbkdUXG4gKiBSZXNvbHZlIHdoZW4gYSBwcmljZSBxdW90ZSBvZiBgYW1vdW50SW5gIGV4Y2VlZHMgYGFtb3VudE91dExpbWl0YFxuICpcbiAqIEBwcm9wZXJ0eSB7KGFtb3VudEluOiBBbW91bnQ8J25hdCc+LFxuICogICAgICAgICAgICAgYW1vdW50T3V0TGltaXQ6IEFtb3VudDwnbmF0Jz5cbiAqICkgPT4gUHJvbWlzZTxQcmljZVF1b3RlPn0gcXVvdGVXaGVuR1RFXG4gKiBSZXNvbHZlIHdoZW4gYSBwcmljZSBxdW90ZSBvZiBgYW1vdW50SW5gIHJlYWNoZXMgb3IgZXhjZWVkcyBgYW1vdW50T3V0TGltaXRgXG4gKlxuICogQHByb3BlcnR5IHsoYW1vdW50SW46IEFtb3VudCxcbiAqICAgICAgICAgICAgIGFtb3VudE91dExpbWl0OiBBbW91bnRcbiAqICkgPT4gUHJvbWlzZTxQcmljZVF1b3RlPn0gcXVvdGVXaGVuTFRFXG4gKiBSZXNvbHZlIHdoZW4gYSBwcmljZSBxdW90ZSBvZiBgYW1vdW50SW5gIHJlYWNoZXMgb3IgZHJvcHMgYmVsb3dcbiAqIGBhbW91bnRPdXRMaW1pdGBcbiAqXG4gKiBAcHJvcGVydHkgeyhhbW91bnRJbjogQW1vdW50LFxuICogICAgICAgICAgICAgYW1vdW50T3V0TGltaXQ6IEFtb3VudFxuICogKSA9PiBQcm9taXNlPFByaWNlUXVvdGU+fSBxdW90ZVdoZW5MVFxuICogUmVzb2x2ZSB3aGVuIHRoZSBwcmljZSBxdW90ZSBvZiBgYW1vdW50SW5gIGRyb3BzIGJlbG93IGBhbW91bnRPdXRMaW1pdGBcbiAqXG4gKiBAcHJvcGVydHkgeyhhbW91bnRJbjogQW1vdW50LFxuICogICAgICAgICAgICAgYW1vdW50T3V0TGltaXQ6IEFtb3VudFxuICogKSA9PiBFUmVmPE11dGFibGVRdW90ZT59IG11dGFibGVRdW90ZVdoZW5HVFxuICogUmVzb2x2ZSB3aGVuIGEgcHJpY2UgcXVvdGUgb2YgYGFtb3VudEluYCBleGNlZWRzIGBhbW91bnRPdXRMaW1pdGBcbiAqXG4gKiBAcHJvcGVydHkgeyhhbW91bnRJbjogQW1vdW50LFxuICogICAgICAgICAgICAgYW1vdW50T3V0TGltaXQ6IEFtb3VudFxuICogKSA9PiBFUmVmPE11dGFibGVRdW90ZT59IG11dGFibGVRdW90ZVdoZW5HVEVcbiAqIFJlc29sdmUgd2hlbiBhIHByaWNlIHF1b3RlIG9mIGBhbW91bnRJbmAgcmVhY2hlcyBvciBleGNlZWRzXG4gKiBgYW1vdW50T3V0TGltaXRgXG4gKlxuICogQHByb3BlcnR5IHsoYW1vdW50SW46IEFtb3VudCxcbiAqICAgICAgICAgICAgIGFtb3VudE91dExpbWl0OiBBbW91bnRcbiAqICkgPT4gRVJlZjxNdXRhYmxlUXVvdGU+fSBtdXRhYmxlUXVvdGVXaGVuTFRFXG4gKiBSZXNvbHZlIHdoZW4gYSBwcmljZSBxdW90ZSBvZiBgYW1vdW50SW5gIHJlYWNoZXMgb3IgZHJvcHMgYmVsb3dcbiAqIGBhbW91bnRPdXRMaW1pdGBcbiAqXG4gKiBAcHJvcGVydHkgeyhhbW91bnRJbjogQW1vdW50LFxuICogICAgICAgICAgICAgYW1vdW50T3V0TGltaXQ6IEFtb3VudFxuICogKSA9PiBFUmVmPE11dGFibGVRdW90ZT59IG11dGFibGVRdW90ZVdoZW5MVFxuICogUmVzb2x2ZSB3aGVuIHRoZSBwcmljZSBxdW90ZSBvZiBgYW1vdW50SW5gIGRyb3BzIGJlbG93IGBhbW91bnRPdXRMaW1pdGBcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsoYW1vdW50OiBBbW91bnQ8J25hdCc+KSA9PiBBbW91bnQ8J25hdCc+fSBQcmljZUNhbGN1bGF0b3JcbiAqL1xuXG4vKipcbiAqIEBjYWxsYmFjayBQcmljZVF1ZXJ5XG4gKiBAcGFyYW0ge1ByaWNlQ2FsY3VsYXRvcn0gY2FsY0Ftb3VudEluXG4gKiBAcGFyYW0ge1ByaWNlQ2FsY3VsYXRvcn0gY2FsY0Ftb3VudE91dFxuICogQHJldHVybnMge3sgYW1vdW50SW46IEFtb3VudDwnbmF0Jz4sIGFtb3VudE91dDogQW1vdW50PCduYXQnPiwgdGltZXN0YW1wPzogWGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcycpLlRpbWVzdGFtcFJlY29yZCB9IHwgdW5kZWZpbmVkfVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gUHJpY2VMZXZlbFxuICogQSBkZXNjcmlwdGlvbiBvZiBhIHNpbmdsZSBxdW90ZVxuICpcbiAqIEBwcm9wZXJ0eSB7QW1vdW50PCduYXQnPn0gYW1vdW50SW5cbiAqIFRoZSBhbW91bnQgc3VwcGxpZWQgdG8gYSB0cmFkZVxuICogQHByb3BlcnR5IHtBbW91bnQ8J25hdCc+fSBhbW91bnRPdXRcbiAqIFRoZSBxdW90ZWQgcmVzdWx0IG9mIHRyYWRpbmcgYGFtb3VudEluYFxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAALfCvHviBgAA4gYAACUAAABAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wL3NyYy9oZWFwLmpzeyJpbXBvcnRzIjpbIkBhZ29yaWMvc3RvcmUiLCJAZW5kby9mYXIiXSwiZXhwb3J0cyI6WyJNIiwiaGVhcFpvbmUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbWFrZUV4byxkZWZpbmVFeG9DbGFzcyxkZWZpbmVFeG9DbGFzc0tpdCxtYWtlU2NhbGFyTWFwU3RvcmUsbWFrZVNjYWxhclNldFN0b3JlLG1ha2VTY2FsYXJXZWFrTWFwU3RvcmUsbWFrZVNjYWxhcldlYWtTZXRTdG9yZSxNLEZhcjskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJtYWtlRXhvXCIsIFskaOKAjV9hID0+IChtYWtlRXhvID0gJGjigI1fYSldXSxbXCJkZWZpbmVFeG9DbGFzc1wiLCBbJGjigI1fYSA9PiAoZGVmaW5lRXhvQ2xhc3MgPSAkaOKAjV9hKV1dLFtcImRlZmluZUV4b0NsYXNzS2l0XCIsIFskaOKAjV9hID0+IChkZWZpbmVFeG9DbGFzc0tpdCA9ICRo4oCNX2EpXV0sW1wibWFrZVNjYWxhck1hcFN0b3JlXCIsIFskaOKAjV9hID0+IChtYWtlU2NhbGFyTWFwU3RvcmUgPSAkaOKAjV9hKV1dLFtcIm1ha2VTY2FsYXJTZXRTdG9yZVwiLCBbJGjigI1fYSA9PiAobWFrZVNjYWxhclNldFN0b3JlID0gJGjigI1fYSldXSxbXCJtYWtlU2NhbGFyV2Vha01hcFN0b3JlXCIsIFskaOKAjV9hID0+IChtYWtlU2NhbGFyV2Vha01hcFN0b3JlID0gJGjigI1fYSldXSxbXCJtYWtlU2NhbGFyV2Vha1NldFN0b3JlXCIsIFskaOKAjV9hID0+IChtYWtlU2NhbGFyV2Vha1NldFN0b3JlID0gJGjigI1fYSldXSxbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSksJGjigI1fbGl2ZVtcIk1cIl1dXV1dLFtcIkBlbmRvL2ZhclwiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKipcbiAqIEB0eXBlIHtYaW1wb3J0KCcuJykuU3RvcmVzfVxuICovXG5jb25zdCBoZWFwU3RvcmVzPUZhcignaGVhcFN0b3Jlcycse1xuZGV0YWNoZWQ6KCk9PmhlYXBTdG9yZXMsXG5pc1N0b3JhYmxlOihfc3BlY2ltZW4pPT50cnVlLFxuXG5zZXRTdG9yZTptYWtlU2NhbGFyU2V0U3RvcmUsXG5tYXBTdG9yZTptYWtlU2NhbGFyTWFwU3RvcmUsXG53ZWFrTWFwU3RvcmU6bWFrZVNjYWxhcldlYWtNYXBTdG9yZSxcbndlYWtTZXRTdG9yZTptYWtlU2NhbGFyV2Vha1NldFN0b3JlfSk7XG5cblxuLyoqXG4gKiBBIGhlYXAgKGluLW1lbW9yeSkgem9uZSB0aGF0IHVzZXMgdGhlIGRlZmF1bHQgZXhvIGFuZCBzdG9yZSBpbXBsZW1lbnRhdGlvbnMuXG4gKlxuICogQHR5cGUge1hpbXBvcnQoJy4nKS5ab25lfVxuICovXG5jb25zdCAgICAgICAgaGVhcFpvbmU9RmFyKCdoZWFwWm9uZScse1xuZXhvQ2xhc3M6ZGVmaW5lRXhvQ2xhc3MsXG5leG9DbGFzc0tpdDpkZWZpbmVFeG9DbGFzc0tpdCxcbmV4bzptYWtlRXhvLFxuc3ViWm9uZTooX2xhYmVsLF9vcHRpb25zKT0+aGVhcFpvbmUsXG4uLi5oZWFwU3RvcmVzfSk7JGjigI1fb25jZS5oZWFwWm9uZShoZWFwWm9uZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnsiTSI6WyJNIixmYWxzZV19LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaGVhcFpvbmUiOlsiaGVhcFpvbmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA2PQZMI8JAACPCQAAJgAAAEBhZ29yaWMvem9uZS12MC4yLjMtdTExLjAvc3JjL2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vaGVhcC5qcyIsIkBhZ29yaWMvc3RvcmUiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL2hlYXAuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbWFrZUV4byxkZWZpbmVFeG9DbGFzcyxkZWZpbmVFeG9DbGFzc0tpdDskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3N0b3JlXCIsIFtbXCJtYWtlRXhvXCIsIFskaOKAjV9hID0+IChtYWtlRXhvID0gJGjigI1fYSldXSxbXCJkZWZpbmVFeG9DbGFzc1wiLCBbJGjigI1fYSA9PiAoZGVmaW5lRXhvQ2xhc3MgPSAkaOKAjV9hKV1dLFtcImRlZmluZUV4b0NsYXNzS2l0XCIsIFskaOKAjV9hID0+IChkZWZpbmVFeG9DbGFzc0tpdCA9ICRo4oCNX2EpXV1dXSxbXCIuL2hlYXAuanNcIiwgW11dXSk7ICAgXG5cblxuXG5cblxuLyogUmVmZXJlbmNlcyB0byBhbGxvdyB0aGUgYmVsb3cgdHlwZW9mcyB0byBzdWNjZWVkLiovXG5tYWtlRXhvO1xuZGVmaW5lRXhvQ2xhc3M7XG5kZWZpbmVFeG9DbGFzc0tpdDtcblxuLyoqXG4gKiBAdHlwZWRlZiB7RXhvWm9uZSAmIFN0b3Jlc30gWm9uZSBBIGJhZyBvZiBtZXRob2RzIGZvciBjcmVhdGluZyBkZWZlbnNpYmxlIG9iamVjdHMgYW5kXG4gKiBjb2xsZWN0aW9ucyB3aXRoIHRoZSBzYW1lIGFsbG9jYXRpb24gc2VtYW50aWNzIChlcGhlbWVyYWwsIHBlcnNpc3RlbnQsIGV0YylcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEV4b1pvbmVcbiAqIEBwcm9wZXJ0eSB7dHlwZW9mIG1ha2VFeG99IGV4byBjcmVhdGUgYSBzaW5nbGV0b24gZXhvLW9iamVjdCBpbnN0YW5jZSBib3VuZCB0byB0aGlzIHpvbmVcbiAqIEBwcm9wZXJ0eSB7dHlwZW9mIGRlZmluZUV4b0NsYXNzfSBleG9DbGFzcyBjcmVhdGUgYSBtYWtlciBmdW5jdGlvbiB0aGF0IGNhbiBiZSB1c2VkIHRvIGNyZWF0ZSBleG8tb2JqZWN0cyBib3VuZCB0byB0aGlzIHpvbmVcbiAqIEBwcm9wZXJ0eSB7dHlwZW9mIGRlZmluZUV4b0NsYXNzS2l0fSBleG9DbGFzc0tpdCBjcmVhdGUgYSBcImtpdFwiIG1ha2VyIGZ1bmN0aW9uIHRoYXQgY2FuIGJlIHVzZWQgdG8gY3JlYXRlIGEgcmVjb3JkIG9mIGV4by1vYmplY3RzIHNoYXJpbmcgdGhlIHNhbWUgc3RhdGVcbiAqIEBwcm9wZXJ0eSB7KGxhYmVsOiBzdHJpbmcsIG9wdGlvbnM/OiBTdG9yZU9wdGlvbnMpID0+IFpvbmV9IHN1YlpvbmUgY3JlYXRlIGEgbmV3IFpvbmUgdGhhdCBjYW4gYmUgcGFzc2VkIHRvIHVudHJ1c3RlZCBjb25zdW1lcnMgd2l0aG91dCBleHBvc2luZyB0aGUgc3RvcmFnZSBvZiB0aGUgcGFyZW50IHpvbmVcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IFN0b3Jlc1xuICogQHByb3BlcnR5IHsoKSA9PiBTdG9yZXN9IGRldGFjaGVkIG9idGFpbiBzdG9yZSBwcm92aWRlcnMgd2hpY2ggYXJlIGRldGFjaGVkICh0aGUgc3RvcmVzIGFyZSBhbm9ueW1vdXMgcmF0aGVyIHRoYW4gYm91bmQgdG8gYGxhYmVsYCBpbiB0aGUgem9uZSlcbiAqIEBwcm9wZXJ0eSB7KHNwZWNpbWVuOiB1bmtub3duKSA9PiBib29sZWFufSBpc1N0b3JhYmxlIHJldHVybiB0cnVlIGlmIHRoZSBzcGVjaW1lbiBjYW4gYmUgc3RvcmVkIGluIHRoZSB6b25lLCB3aGV0aGVyIGFzIGV4by1vYmplY3Qgc3RhdGUgb3IgaW4gYSBzdG9yZVxuICogQHByb3BlcnR5IHs8SyxWPihsYWJlbDogc3RyaW5nLCBvcHRpb25zPzogU3RvcmVPcHRpb25zKSA9PiBNYXBTdG9yZTxLLCBWPn0gbWFwU3RvcmUgcHJvdmlkZSBhIE1hcC1saWtlIHN0b3JlIG5hbWVkIGBsYWJlbGAgaW4gdGhlIHpvbmVcbiAqIEBwcm9wZXJ0eSB7PEs+KGxhYmVsOiBzdHJpbmcsIG9wdGlvbnM/OiBTdG9yZU9wdGlvbnMpID0+IFNldFN0b3JlPEs+fSBzZXRTdG9yZSBwcm92aWRlIGEgU2V0LWxpa2Ugc3RvcmUgbmFtZWQgYGxhYmVsYCBpbiB0aGUgem9uZVxuICogQHByb3BlcnR5IHs8SyxWPihcbiAqICAgbGFiZWw6IHN0cmluZywgb3B0aW9ucz86IFN0b3JlT3B0aW9ucykgPT4gV2Vha01hcFN0b3JlPEssIFY+XG4gKiB9IHdlYWtNYXBTdG9yZSBwcm92aWRlIGEgV2Vha01hcC1saWtlIHN0b3JlIG5hbWVkIGBsYWJlbGAgaW4gdGhlIHpvbmVcbiAqIEBwcm9wZXJ0eSB7PEs+KFxuICogICBsYWJlbDogc3RyaW5nLCBvcHRpb25zPzogU3RvcmVPcHRpb25zKSA9PiBXZWFrU2V0U3RvcmU8Sz5cbiAqIH0gd2Vha1NldFN0b3JlIHByb3ZpZGUgYSBXZWFrU2V0LWxpa2Ugc3RvcmUgbmFtZWQgYGxhYmVsYCBpbiB0aGUgem9uZVxuICovXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAB4o+7R+AQAAfgEAACEAAABAZW5kby9lbnYtb3B0aW9ucy12MC4xLjQvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZW52LW9wdGlvbnMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3NyYy9lbnYtb3B0aW9ucy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vc3JjL2Vudi1vcHRpb25zLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACyHOJ9mAwAAJgMAAArAAAAQGVuZG8vZW52LW9wdGlvbnMtdjAuMS40L3NyYy9lbnYtb3B0aW9ucy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsibWFrZUVudmlyb25tZW50Q2FwdG9yIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQHRzLWNoZWNrKi9cblxuLyogYEBlbmRvL2Vudi1vcHRpb25zYCBuZWVkcyB0byBiZSBpbXBvcnRlZCBxdWl0ZSBlYXJseSwgYW5kIHNvIHNob3VsZCovXG4vKiBhdm9pZCBpbXBvcnRpbmcgZnJvbSBzZXMgb3IgYW55dGhpbmcgdGhhdCBkZXBlbmRzIG9uIHNlcy4qL1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG4vKiBQcmVsdWRlIG9mIGNoZWFwIGdvb2QgLSBlbm91Z2ggaW1pdGF0aW9ucyBvZiB0aGluZ3Mgd2UnZCB1c2Ugb3IqL1xuLyogZG8gZGlmZmVyZW50bHkgaWYgd2UgY291bGQgZGVwZW5kIG9uIHNlcyovXG5cbmNvbnN0e2ZyZWV6ZX09T2JqZWN0O1xuY29uc3R7YXBwbHl9PVJlZmxlY3Q7XG5cbi8qIFNob3VsZCBiZSBlcXVpdmFsZW50IHRvIHRoZSBvbmUgaW4gc2VzJyBjb21tb25zLmpzIGV2ZW4gdGhvdWdoIGl0Ki9cbi8qIHVzZXMgdGhlIG90aGVyIHRlY2huaXF1ZS4qL1xuY29uc3QgdW5jdXJyeVRoaXM9XG4oZm4pPT5cbihyZWNlaXZlciwuLi5hcmdzKT0+XG5hcHBseShmbixyZWNlaXZlcixhcmdzKTtcbmNvbnN0IGFycmF5UHVzaD11bmN1cnJ5VGhpcyhBcnJheS5wcm90b3R5cGUucHVzaCk7XG5cbmNvbnN0IHE9SlNPTi5zdHJpbmdpZnk7XG5cbmNvbnN0IEZhaWw9KGxpdGVyYWxzLC4uLmFyZ3MpPT57XG5sZXQgbXNnPWxpdGVyYWxzWzBdO1xuZm9yKGxldCBpPTA7aTxhcmdzLmxlbmd0aDtpKz0xKXtcbm1zZz0gYCR7bXNnfSR7YXJnc1tpXX0ke2xpdGVyYWxzW2krMV19YDtcbiB9XG50aHJvdyBFcnJvcihtc2cpO1xuIH07XG5cbi8qIGVuZCBwcmVsdWRlKi9cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBgbWFrZUVudmlyb25tZW50Q2FwdG9yYCBwcm92aWRlcyBhIG1lY2hhbmlzbSBmb3IgZ2V0dGluZyBlbnZpcm9ubWVudFxuICogdmFyaWFibGVzLCBpZiB0aGV5IGFyZSBuZWVkZWQsIGFuZCBhIHdheSB0byBjYXRhbG9nIHRoZSBuYW1lcyBvZiBhbGxcbiAqIHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZXMgdGhhdCB3ZXJlIGNhcHR1cmVkLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBhR2xvYmFsXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlRW52aXJvbm1lbnRDYXB0b3I9KGFHbG9iYWwpPT57XG5jb25zdCBjYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXM9W107XG5cbi8qKlxuICogR2V0cyBhbiBlbnZpcm9ubWVudCBvcHRpb24gYnkgbmFtZSBhbmQgcmV0dXJucyB0aGUgb3B0aW9uIHZhbHVlIG9yIHRoZVxuICogZ2l2ZW4gZGVmYXVsdC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9uTmFtZVxuICogQHBhcmFtIHtzdHJpbmd9IGRlZmF1bHRTZXR0aW5nXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBnZXRFbnZpcm9ubWVudE9wdGlvbj0ob3B0aW9uTmFtZSxkZWZhdWx0U2V0dGluZyk9Pntcbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAZW5kby9uby1wb2x5bW9ycGhpYy1jYWxsKi9cbnR5cGVvZiBvcHRpb25OYW1lPT09J3N0cmluZyd8fFxuRmFpbCBgRW52aXJvbm1lbnQgb3B0aW9uIG5hbWUgJHtxKG9wdGlvbk5hbWUpfSBtdXN0IGJlIGEgc3RyaW5nLmA7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGVuZG8vbm8tcG9seW1vcnBoaWMtY2FsbCovXG50eXBlb2YgZGVmYXVsdFNldHRpbmc9PT0nc3RyaW5nJ3x8XG5GYWlsIGBFbnZpcm9ubWVudCBvcHRpb24gZGVmYXVsdCBzZXR0aW5nICR7cShcbmRlZmF1bHRTZXR0aW5nKVxuIH0gbXVzdCBiZSBhIHN0cmluZy5gO1xuXG4vKiogQHR5cGUge3N0cmluZ30gKi9cbmxldCBzZXR0aW5nPWRlZmF1bHRTZXR0aW5nO1xuY29uc3QgZ2xvYmFsUHJvY2Vzcz1hR2xvYmFsLnByb2Nlc3M7XG5pZihnbG9iYWxQcm9jZXNzJiZ0eXBlb2YgZ2xvYmFsUHJvY2Vzcz09PSdvYmplY3QnKXtcbmNvbnN0IGdsb2JhbEVudj1nbG9iYWxQcm9jZXNzLmVudjtcbmlmKGdsb2JhbEVudiYmdHlwZW9mIGdsb2JhbEVudj09PSdvYmplY3QnKXtcbmlmKG9wdGlvbk5hbWUgaW4gZ2xvYmFsRW52KXtcbmFycmF5UHVzaChjYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXMsb3B0aW9uTmFtZSk7XG5jb25zdCBvcHRpb25WYWx1ZT1nbG9iYWxFbnZbb3B0aW9uTmFtZV07XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGVuZG8vbm8tcG9seW1vcnBoaWMtY2FsbCovXG50eXBlb2Ygb3B0aW9uVmFsdWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBFbnZpcm9ubWVudCBvcHRpb24gbmFtZWQgJHtxKFxub3B0aW9uTmFtZSlcbiB9LCBpZiBwcmVzZW50LCBtdXN0IGhhdmUgYSBjb3JyZXNwb25kaW5nIHN0cmluZyB2YWx1ZSwgZ290ICR7cShcbm9wdGlvblZhbHVlKVxuIH1gO1xuc2V0dGluZz1vcHRpb25WYWx1ZTtcbiB9XG4gfVxuIH1cbnJldHVybiBzZXR0aW5nO1xuIH07XG5mcmVlemUoZ2V0RW52aXJvbm1lbnRPcHRpb24pO1xuXG5jb25zdCBnZXRDYXB0dXJlZEVudmlyb25tZW50T3B0aW9uTmFtZXM9KCk9PntcbnJldHVybiBmcmVlemUoWy4uLmNhcHR1cmVkRW52aXJvbm1lbnRPcHRpb25OYW1lc10pO1xuIH07XG5mcmVlemUoZ2V0Q2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzKTtcblxucmV0dXJuIGZyZWV6ZSh7Z2V0RW52aXJvbm1lbnRPcHRpb24sZ2V0Q2FwdHVyZWRFbnZpcm9ubWVudE9wdGlvbk5hbWVzfSk7XG4gfTskaOKAjV9vbmNlLm1ha2VFbnZpcm9ubWVudENhcHRvcihtYWtlRW52aXJvbm1lbnRDYXB0b3IpO1xuZnJlZXplKG1ha2VFbnZpcm9ubWVudENhcHRvcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZUVudmlyb25tZW50Q2FwdG9yIjpbIm1ha2VFbnZpcm9ubWVudENhcHRvciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADO3bE+kAsAAJALAAAkAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44L3NyYy9FLmpzeyJpbXBvcnRzIjpbIi4vdHJhY2stdHVybnMuanMiXSwiZXhwb3J0cyI6WyJkZWZhdWx0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHRyYWNrVHVybnM7JGjigI1faW1wb3J0cyhbW1wiLi90cmFjay10dXJucy5qc1wiLCBbW1widHJhY2tUdXJuc1wiLCBbJGjigI1fYSA9PiAodHJhY2tUdXJucyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cbi8qLyA8cmVmZXJlbmNlIHBhdGg9XCJpbmRleC5kLnRzXCIgLz4qL1xuXG4vKiogQHR5cGUge1Byb3h5SGFuZGxlcjxhbnk+fSAqL1xuY29uc3QgYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcj17XG5zZXQoX3RhcmdldCxfcHJvcCxfdmFsdWUpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5pc0V4dGVuc2libGUoX3RhcmdldCl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbnNldFByb3RvdHlwZU9mKF90YXJnZXQsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuZGVsZXRlUHJvcGVydHkoX3RhcmdldCxfcHJvcCl7XG5yZXR1cm4gZmFsc2U7XG4gfX07XG5cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUoeCkuXG4gKlxuICogQHBhcmFtIHsqfSB4IEFueSB2YWx1ZSBwYXNzZWQgdG8gRSh4KVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2luZGV4JykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXJ9IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmZ1bmN0aW9uIEVQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSl7XG5yZXR1cm4gaGFyZGVuKHtcbi4uLmJhc2VGcmVlemFibGVQcm94eUhhbmRsZXIsXG5nZXQoX3RhcmdldCxwLF9yZWNlaXZlcil7XG5yZXR1cm4gaGFyZGVuKCguLi5hcmdzKT0+SGFuZGxlZFByb21pc2UuYXBwbHlNZXRob2QoeCxwLGFyZ3MpKTtcbiB9LFxuYXBwbHkoX3RhcmdldCxfdGhpc0FyZyxhcmdBcnJheT1bXSl7XG5yZXR1cm4gSGFuZGxlZFByb21pc2UuYXBwbHlGdW5jdGlvbih4LGFyZ0FycmF5KTtcbiB9LFxuaGFzKF90YXJnZXQsX3Ape1xuLyogV2UganVzdCBwcmV0ZW5kIGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cbiB9XG5cbi8qKlxuICogQSBQcm94eSBoYW5kbGVyIGZvciBFLnNlbmRPbmx5KHgpXG4gKiBJdCBpcyBhIHZhcmlhbnQgb24gdGhlIEUoeCkgUHJveHkgaGFuZGxlci5cbiAqXG4gKiBAcGFyYW0geyp9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFLnNlbmRPbmx5KHgpXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vaW5kZXgnKS5IYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuZnVuY3Rpb24gRXNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2Upe1xucmV0dXJuIGhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0KF90YXJnZXQscCxfcmVjZWl2ZXIpe1xucmV0dXJuKC4uLmFyZ3MpPT57XG5IYW5kbGVkUHJvbWlzZS5hcHBseU1ldGhvZFNlbmRPbmx5KHgscCxhcmdzKTtcbnJldHVybiB1bmRlZmluZWQ7XG4gfTtcbiB9LFxuYXBwbHkoX3RhcmdldCxfdGhpc0FyZyxhcmdzQXJyYXk9W10pe1xuSGFuZGxlZFByb21pc2UuYXBwbHlGdW5jdGlvblNlbmRPbmx5KHgsYXJnc0FycmF5KTtcbnJldHVybiB1bmRlZmluZWQ7XG4gfSxcbmhhcyhfdGFyZ2V0LF9wKXtcbi8qIFdlIGp1c3QgcHJldGVuZCB0aGF0IGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cbiB9XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2luZGV4JykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtYaW1wb3J0KCcuL2luZGV4JykuRVByb3h5fVxuICovXG5mdW5jdGlvbiAgICAgICAgICAgICAgICBtYWtlRShIYW5kbGVkUHJvbWlzZSl7XG5mdW5jdGlvbiBFKHgpe1xuY29uc3QgaGFuZGxlcj1FUHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpO1xucmV0dXJuIGhhcmRlbihuZXcgUHJveHkoKCk9PnsgfSxoYW5kbGVyKSk7XG4gfVxuXG5jb25zdCBtYWtlRUdldHRlclByb3h5PSh4KT0+XG5uZXcgUHJveHkoT2JqZWN0LmNyZWF0ZShudWxsKSx7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuaGFzKF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIHRydWU7XG4gfSxcbmdldChfdGFyZ2V0LHByb3Ape1xucmV0dXJuIEhhbmRsZWRQcm9taXNlLmdldCh4LHByb3ApO1xuIH19KTtcblxuXG5FLmdldD1tYWtlRUdldHRlclByb3h5O1xuRS5yZXNvbHZlPUhhbmRsZWRQcm9taXNlLnJlc29sdmU7XG5FLnNlbmRPbmx5PSh4KT0+e1xuY29uc3QgaGFuZGxlcj1Fc2VuZE9ubHlQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSk7XG5yZXR1cm4gaGFyZGVuKG5ldyBQcm94eSgoKT0+eyB9LGhhbmRsZXIpKTtcbiB9O1xuXG5FLndoZW49KHgsb25mdWxmaWxsZWQ9dW5kZWZpbmVkLG9ucmVqZWN0ZWQ9dW5kZWZpbmVkKT0+e1xuY29uc3Rbb25zdWNjZXNzLG9uZmFpbHVyZV09dHJhY2tUdXJucyhbb25mdWxmaWxsZWQsb25yZWplY3RlZF0pO1xucmV0dXJuIEhhbmRsZWRQcm9taXNlLnJlc29sdmUoeCkudGhlbihvbnN1Y2Nlc3Msb25mYWlsdXJlKTtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKEUpO1xuIH0kaOKAjV9vbmNlLmRlZmF1bHQoICAgICBtYWtlRSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVmYXVsdCI6WyJkZWZhdWx0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGlKKwEdAgAAHQIAACoAAABAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE0Ljgvc3JjL25vLXNoaW0uanN7ImltcG9ydHMiOlsiLi9FLmpzIl0sImV4cG9ydHMiOlsiRSIsIkhhbmRsZWRQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG1ha2VFOyRo4oCNX2ltcG9ydHMoW1tcIi4vRS5qc1wiLCBbW1wiZGVmYXVsdFwiLCBbJGjigI1fYSA9PiAobWFrZUUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuY29uc3QgaHA9SGFuZGxlZFByb21pc2U7JGjigI1fb25jZS5ocChocCk7XG5jb25zdCAgICAgICAgRT1tYWtlRShIYW5kbGVkUHJvbWlzZSk7JGjigI1fb25jZS5FKEUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkhhbmRsZWRQcm9taXNlIjpbImhwIl0sIkUiOlsiRSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADrffS3ewwAAHsMAAAuAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44L3NyYy90cmFjay10dXJucy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsidHJhY2tUdXJucyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qIGdsb2JhbCBnbG9iYWxUaGlzICovXG4vKiBAdHMtbm9jaGVjayovXG5cbi8qIE5PVEU6IFdlIGNhbid0IGltcG9ydCB0aGVzZSBiZWNhdXNlIHRoZXkncmUgbm90IGluIHNjb3BlIGJlZm9yZSBsb2NrZG93bi4qL1xuLyogaW1wb3J0IHsgYXNzZXJ0LCBkZXRhaWxzIGFzIFggfSBmcm9tICdAYWdvcmljL2Fzc2VydCc7Ki9cblxuLyogV0FSTklORzogR2xvYmFsIE11dGFibGUgU3RhdGUhKi9cbi8qIFRoaXMgc3RhdGUgaXMgY29tbXVuaWNhdGVkIHRvIGBhc3NlcnRgIHRoYXQgbWFrZXMgaXQgYXZhaWxhYmxlIHRvIHRoZSovXG4vKiBjYXVzYWwgY29uc29sZSwgd2hpY2ggYWZmZWN0cyB0aGUgY29uc29sZSBsb2cgb3V0cHV0LiBOb3JtYWxseSB3ZSovXG4vKiByZWdhcmQgdGhlIGFiaWxpdHkgdG8gc2VlIGNvbnNvbGUgbG9nIG91dHB1dCBhcyBhIG1ldGEtbGV2ZWwgcHJpdmlsZWdlKi9cbi8qIGFuYWxvZ291cyB0byB0aGUgYWJpbGl0eSB0byBkZWJ1Zy4gQXNpZGUgZnJvbSB0aGF0LCB0aGlzIG1vZHVsZSBzaG91bGQqL1xuLyogbm90IGhhdmUgYW55IG9ic2VydmFibHkgbXV0YWJsZSBzdGF0ZS4qL1xuXG5sZXQgaGlkZGVuUHJpb3JFcnJvcjtcbmxldCBoaWRkZW5DdXJyZW50VHVybj0wO1xubGV0IGhpZGRlbkN1cnJlbnRFdmVudD0wO1xuXG4vKiBUdXJuIG9uIGlmIHlvdSBzZWVtIHRvIGJlIGxvc2luZyBlcnJvciBsb2dnaW5nIGF0IHRoZSB0b3Agb2YgdGhlIGV2ZW50IGxvb3AqL1xuY29uc3QgVkVSQk9TRT1mYWxzZTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7KCguLi5hcmdzOiBhbnlbXSkgPT4gYW55KSB8IHVuZGVmaW5lZH0gVHVyblN0YXJ0ZXJGblxuICogQW4gb3B0aW9uYWwgZnVuY3Rpb24gdGhhdCBpcyBub3QgdGhpcy1zZW5zaXRpdmUsIGV4cGVjdGVkIHRvIGJlIGNhbGxlZCBhdFxuICogYm90dG9tIG9mIHN0YWNrIHRvIHN0YXJ0IGEgbmV3IHR1cm4uXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUge1R1cm5TdGFydGVyRm5bXX0gVFxuICogR2l2ZW4gYSBsaXN0IG9mIGBUdXJuU3RhcnRlckZuYHMsIHJldHVybnMgYSBsaXN0IG9mIGBUdXJuU3RhcnRlckZuYHMgd2hvc2VcbiAqIGB0aGlzYC1mcmVlIGNhbGwgYmVoYXZpb3JzIGFyZSBub3Qgb2JzZXJ2YWJseSBkaWZmZXJlbnQgdG8gdGhvc2UgdGhhdFxuICogY2Fubm90IHNlZSBjb25zb2xlIG91dHB1dC4gVGhlIG9ubHkgcHVycG9zZSBpcyB0byBjYXVzZSBhZGRpdGlvbmFsXG4gKiBpbmZvcm1hdGlvbiB0byBhcHBlYXIgb24gdGhlIGNvbnNvbGUuXG4gKlxuICogVGhlIGNhbGwgdG8gYHRyYWNrVHVybnNgIGlzIGl0c2VsZiBhIHNlbmRpbmcgZXZlbnQsIHRoYXQgb2NjdXJzIGluIHNvbWUgY2FsbFxuICogc3RhY2sgaW4gc29tZSB0dXJuIG51bWJlciBhdCBzb21lIGV2ZW50IG51bWJlciB3aXRoaW4gdGhhdCB0dXJuLiBFYWNoIGNhbGxcbiAqIHRvIGFueSBvZiB0aGUgcmV0dXJuZWQgYFR1cm5TdGFydEZuYHMgaXMgYSByZWNlaXZpbmcgZXZlbnQgdGhhdCBiZWdpbnMgYSBuZXdcbiAqIHR1cm4uIFRoaXMgc2VuZGluZyBldmVudCBjYXVzZWQgZWFjaCBvZiB0aG9zZSByZWNlaXZpbmcgZXZlbnRzLlxuICpcbiAqIEBwYXJhbSB7VH0gZnVuY3NcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCAgICAgICAgdHJhY2tUdXJucz0oZnVuY3MpPT57XG5pZih0eXBlb2YgZ2xvYmFsVGhpcz09PSd1bmRlZmluZWQnfHwhZ2xvYmFsVGhpcy5hc3NlcnQpe1xucmV0dXJuIGZ1bmNzO1xuIH1cbmNvbnN0e2RldGFpbHM6WH09YXNzZXJ0O1xuXG5oaWRkZW5DdXJyZW50RXZlbnQrPTE7XG5jb25zdCBzZW5kaW5nRXJyb3I9bmV3IEVycm9yKFxuIGBFdmVudDogJHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbmlmKGhpZGRlblByaW9yRXJyb3IhPT11bmRlZmluZWQpe1xuYXNzZXJ0Lm5vdGUoc2VuZGluZ0Vycm9yLFggYENhdXNlZCBieTogJHtoaWRkZW5QcmlvckVycm9yfWApO1xuIH1cblxucmV0dXJuIGZ1bmNzLm1hcChcbihmdW5jKT0+XG5mdW5jJiYoXG4oLi4uYXJncyk9PntcbmhpZGRlblByaW9yRXJyb3I9c2VuZGluZ0Vycm9yO1xuaGlkZGVuQ3VycmVudFR1cm4rPTE7XG5oaWRkZW5DdXJyZW50RXZlbnQ9MDtcbnRyeXtcbmxldCByZXN1bHQ7XG50cnl7XG5yZXN1bHQ9ZnVuYyguLi5hcmdzKTtcbiB9Y2F0Y2goZXJyKXtcbmlmKGVyciBpbnN0YW5jZW9mIEVycm9yKXtcbmFzc2VydC5ub3RlKFxuZXJyLFxuWCBgVGhyb3duIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbiB9XG5pZihWRVJCT1NFKXtcbmNvbnNvbGUubG9nKCdUSFJPV04gdG8gdG9wIG9mIGV2ZW50IGxvb3AnLGVycik7XG4gfVxudGhyb3cgZXJyO1xuIH1cbi8qIE11c3QgY2FwdHVyZSB0aGlzIG5vdywgbm90IHdoZW4gdGhlIGNhdGNoIHRyaWdnZXJzLiovXG5jb25zdCBkZXRhaWxzTm90ZT1YIGBSZWplY3Rpb24gZnJvbTogJHtoaWRkZW5QcmlvckVycm9yfToke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gO1xuUHJvbWlzZS5yZXNvbHZlKHJlc3VsdCkuY2F0Y2goKHJlYXNvbik9PntcbmlmKHJlYXNvbiBpbnN0YW5jZW9mIEVycm9yKXtcbmFzc2VydC5ub3RlKHJlYXNvbixkZXRhaWxzTm90ZSk7XG4gfVxuaWYoVkVSQk9TRSl7XG5jb25zb2xlLmxvZygnUkVKRUNURUQgYXQgdG9wIG9mIGV2ZW50IGxvb3AnLHJlYXNvbik7XG4gfVxuIH0pO1xucmV0dXJuIHJlc3VsdDtcbiB9ZmluYWxseXtcbmhpZGRlblByaW9yRXJyb3I9dW5kZWZpbmVkO1xuIH1cbiB9KSk7XG5cbiB9OyRo4oCNX29uY2UudHJhY2tUdXJucyh0cmFja1R1cm5zKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJ0cmFja1R1cm5zIjpbInRyYWNrVHVybnMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAfiRuLdIRAADSEQAAJAAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMi9zcmMvRS5qc3siaW1wb3J0cyI6WyIuL3RyYWNrLXR1cm5zLmpzIl0sImV4cG9ydHMiOlsiZGVmYXVsdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCB0cmFja1R1cm5zOyRo4oCNX2ltcG9ydHMoW1tcIi4vdHJhY2stdHVybnMuanNcIiwgW1tcInRyYWNrVHVybnNcIiwgWyRo4oCNX2EgPT4gKHRyYWNrVHVybnMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGUge1Byb3h5SGFuZGxlcjxhbnk+fSAqL1xuY29uc3QgYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcj17XG5zZXQoX3RhcmdldCxfcHJvcCxfdmFsdWUpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5pc0V4dGVuc2libGUoX3RhcmdldCl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbnNldFByb3RvdHlwZU9mKF90YXJnZXQsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuZGVsZXRlUHJvcGVydHkoX3RhcmdldCxfcHJvcCl7XG5yZXR1cm4gZmFsc2U7XG4gfX07XG5cblxuLyogRSBQcm94eSBoYW5kbGVycyBwcmV0ZW5kIHRoYXQgYW55IHByb3BlcnR5IGV4aXN0cyBvbiB0aGUgdGFyZ2V0IGFuZCByZXR1cm5zKi9cbi8qIGEgZnVuY3Rpb24gZm9yIHRoZWlyIHZhbHVlLiBXaGlsZSB0aGlzIGZ1bmN0aW9uIGlzIFwiYm91bmRcIiBieSBjb250ZXh0LCBpdCBpcyovXG4vKiBtZWFudCB0byBiZSBjYWxsZWQgYXMgYSBtZXRob2QuIEZvciB0aGF0IHJlYXNvbiwgdGhlIHJldHVybmVkIGZ1bmN0aW9uKi9cbi8qIGluY2x1ZGVzIGEgY2hlY2sgdGhhdCB0aGUgYHRoaXNgIGFyZ3VtZW50IGNvcnJlc3BvbmRzIHRvIHRoZSBpbml0aWFsKi9cbi8qIHJlY2VpdmVyIHdoZW4gdGhlIGZ1bmN0aW9uIHdhcyByZXRyaWV2ZWQuKi9cbi8qIEUgUHJveHkgaGFuZGxlcnMgYWxzbyBmb3J3YXJkIGRpcmVjdCBjYWxscyB0byB0aGUgdGFyZ2V0IGluIGNhc2UgdGhlIHJlbW90ZSovXG4vKiBpcyBhIGZ1bmN0aW9uIGluc3RlYWQgb2YgYW4gb2JqZWN0LiBObyBzdWNoIHJlY2VpdmVyIGNoZWNrcyBhcmUgbmVjZXNzYXJ5IGluKi9cbi8qIHRoYXQgY2FzZS4qL1xuXG4vKipcbiAqIEEgUHJveHkgaGFuZGxlciBmb3IgRSh4KS5cbiAqXG4gKiBAcGFyYW0geyp9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFKHgpXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vaW5kZXgnKS5IYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuZnVuY3Rpb24gRVByb3h5SGFuZGxlcih4LEhhbmRsZWRQcm9taXNlKXtcbnJldHVybiBoYXJkZW4oe1xuLi4uYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcixcbmdldChfdGFyZ2V0LHAscmVjZWl2ZXIpe1xucmV0dXJuIGhhcmRlbihcbntcbi8qIFRoaXMgZnVuY3Rpb24gcHVycG9zZWx5IGNoZWNrcyB0aGUgYHRoaXNgIHZhbHVlIChzZWUgYWJvdmUpKi9cbi8qIEluIG9yZGVyIHRvIGJlIGB0aGlzYCBzZW5zaXRpdmUgaXQgaXMgZGVmaW5lZCB1c2luZyBjb25jaXNlIG1ldGhvZCovXG4vKiBzeW50YXggcmF0aGVyIHRoYW4gYXMgYW4gYXJyb3cgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGUgZnVuY3Rpb24qL1xuLyogaXMgbm90IGNvbnN0cnVjdGFibGUsIGl0IGFsc28gYXZvaWRzIHRoZSBgZnVuY3Rpb25gIHN5bnRheC4qL1xuW3BdKC4uLmFyZ3Mpe1xuaWYodGhpcyE9PXJlY2VpdmVyKXtcbi8qIFJlamVjdCB0aGUgYXN5bmMgZnVuY3Rpb24gY2FsbCovXG5yZXR1cm4gSGFuZGxlZFByb21pc2UucmVqZWN0KFxuYXNzZXJ0LmVycm9yKFxuWCBgVW5leHBlY3RlZCByZWNlaXZlciBmb3IgXCIke3B9XCIgbWV0aG9kIG9mIEUoJHtxKHgpfSlgKSk7XG5cblxuIH1cblxucmV0dXJuIEhhbmRsZWRQcm9taXNlLmFwcGx5TWV0aG9kKHgscCxhcmdzKTtcbiB9XG4vKiBAdHMtZXhwZWN0LWVycm9yIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvNTAzMTkqL31bXG5wXSk7XG5cbiB9LFxuYXBwbHkoX3RhcmdldCxfdGhpc0FyZyxhcmdBcnJheT1bXSl7XG5yZXR1cm4gSGFuZGxlZFByb21pc2UuYXBwbHlGdW5jdGlvbih4LGFyZ0FycmF5KTtcbiB9LFxuaGFzKF90YXJnZXQsX3Ape1xuLyogV2UganVzdCBwcmV0ZW5kIGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cbiB9XG5cbi8qKlxuICogQSBQcm94eSBoYW5kbGVyIGZvciBFLnNlbmRPbmx5KHgpXG4gKiBJdCBpcyBhIHZhcmlhbnQgb24gdGhlIEUoeCkgUHJveHkgaGFuZGxlci5cbiAqXG4gKiBAcGFyYW0geyp9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFLnNlbmRPbmx5KHgpXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vaW5kZXgnKS5IYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuZnVuY3Rpb24gRXNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2Upe1xucmV0dXJuIGhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0KF90YXJnZXQscCxyZWNlaXZlcil7XG5yZXR1cm4gaGFyZGVuKFxue1xuLyogVGhpcyBmdW5jdGlvbiBwdXJwb3NlbHkgY2hlY2tzIHRoZSBgdGhpc2AgdmFsdWUgKHNlZSBhYm92ZSkqL1xuLyogSW4gb3JkZXIgdG8gYmUgYHRoaXNgIHNlbnNpdGl2ZSBpdCBpcyBkZWZpbmVkIHVzaW5nIGNvbmNpc2UgbWV0aG9kKi9cbi8qIHN5bnRheCByYXRoZXIgdGhhbiBhcyBhbiBhcnJvdyBmdW5jdGlvbi4gVG8gZW5zdXJlIHRoZSBmdW5jdGlvbiovXG4vKiBpcyBub3QgY29uc3RydWN0YWJsZSwgaXQgYWxzbyBhdm9pZHMgdGhlIGBmdW5jdGlvbmAgc3ludGF4LiovXG5bcF0oLi4uYXJncyl7XG4vKiBUaHJvdyBzaW5jZSB0aGUgZnVuY3Rpb24gcmV0dXJucyBub3RoaW5nKi9cbnRoaXM9PT1yZWNlaXZlcnx8XG5GYWlsIGBVbmV4cGVjdGVkIHJlY2VpdmVyIGZvciBcIiR7cShwKX1cIiBtZXRob2Qgb2YgRS5zZW5kT25seSgke3EoXG54KVxuIH0pYDtcbkhhbmRsZWRQcm9taXNlLmFwcGx5TWV0aG9kU2VuZE9ubHkoeCxwLGFyZ3MpO1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG4vKiBAdHMtZXhwZWN0LWVycm9yIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvNTAzMTkqL31bXG5wXSk7XG5cbiB9LFxuYXBwbHkoX3RhcmdldCxfdGhpc0FyZyxhcmdzQXJyYXk9W10pe1xuSGFuZGxlZFByb21pc2UuYXBwbHlGdW5jdGlvblNlbmRPbmx5KHgsYXJnc0FycmF5KTtcbnJldHVybiB1bmRlZmluZWQ7XG4gfSxcbmhhcyhfdGFyZ2V0LF9wKXtcbi8qIFdlIGp1c3QgcHJldGVuZCB0aGF0IGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cbiB9XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL2luZGV4JykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtYaW1wb3J0KCcuL2luZGV4JykuRVByb3h5fVxuICovXG5mdW5jdGlvbiAgICAgICAgICAgICAgICBtYWtlRShIYW5kbGVkUHJvbWlzZSl7XG5mdW5jdGlvbiBFKHgpe1xuY29uc3QgaGFuZGxlcj1FUHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpO1xucmV0dXJuIGhhcmRlbihuZXcgUHJveHkoKCk9PnsgfSxoYW5kbGVyKSk7XG4gfVxuXG5jb25zdCBtYWtlRUdldHRlclByb3h5PSh4KT0+XG5uZXcgUHJveHkoT2JqZWN0LmNyZWF0ZShudWxsKSx7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuaGFzKF90YXJnZXQsX3Byb3Ape1xucmV0dXJuIHRydWU7XG4gfSxcbmdldChfdGFyZ2V0LHByb3Ape1xucmV0dXJuIEhhbmRsZWRQcm9taXNlLmdldCh4LHByb3ApO1xuIH19KTtcblxuXG5FLmdldD1tYWtlRUdldHRlclByb3h5O1xuRS5yZXNvbHZlPUhhbmRsZWRQcm9taXNlLnJlc29sdmU7XG5FLnNlbmRPbmx5PSh4KT0+e1xuY29uc3QgaGFuZGxlcj1Fc2VuZE9ubHlQcm94eUhhbmRsZXIoeCxIYW5kbGVkUHJvbWlzZSk7XG5yZXR1cm4gaGFyZGVuKG5ldyBQcm94eSgoKT0+eyB9LGhhbmRsZXIpKTtcbiB9O1xuXG5FLndoZW49KHgsb25mdWxmaWxsZWQsb25yZWplY3RlZCk9PntcbmNvbnN0W29uc3VjY2VzcyxvbmZhaWx1cmVdPXRyYWNrVHVybnMoW29uZnVsZmlsbGVkLG9ucmVqZWN0ZWRdKTtcbnJldHVybiBIYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpLnRoZW4ob25zdWNjZXNzLG9uZmFpbHVyZSk7XG4gfTtcblxucmV0dXJuIGhhcmRlbihFKTtcbiB9JGjigI1fb25jZS5kZWZhdWx0KCAgICAgbWFrZUUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHQiOlsiZGVmYXVsdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA3C+1PHwIAAB8CAAAqAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yL3NyYy9uby1zaGltLmpzeyJpbXBvcnRzIjpbIi4vRS5qcyJdLCJleHBvcnRzIjpbIkUiLCJIYW5kbGVkUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlRTskaOKAjV9pbXBvcnRzKFtbXCIuL0UuanNcIiwgW1tcImRlZmF1bHRcIiwgWyRo4oCNX2EgPT4gKG1ha2VFID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuY29uc3QgaHA9SGFuZGxlZFByb21pc2U7JGjigI1fb25jZS5ocChocCk7XG5jb25zdCAgICAgICAgRT1tYWtlRShIYW5kbGVkUHJvbWlzZSk7JGjigI1fb25jZS5FKEUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkhhbmRsZWRQcm9taXNlIjpbImhwIl0sIkUiOlsiRSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAChWCM/jxAAAI8QAAAuAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yL3NyYy90cmFjay10dXJucy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsidHJhY2tUdXJucyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qIGdsb2JhbCBnbG9iYWxUaGlzICovXG4vKiBAdHMtbm9jaGVjayovXG5cbmNvbnN0e2ZyZWV6ZX09T2JqZWN0O1xuXG4vKiBOT1RFOiBXZSBjYW4ndCBpbXBvcnQgdGhlc2UgYmVjYXVzZSB0aGV5J3JlIG5vdCBpbiBzY29wZSBiZWZvcmUgbG9ja2Rvd24uKi9cbi8qIGltcG9ydCB7IGFzc2VydCwgZGV0YWlscyBhcyBYLCBGYWlsIH0gZnJvbSAnQGFnb3JpYy9hc3NlcnQnOyovXG5cbi8qIFdBUk5JTkc6IEdsb2JhbCBNdXRhYmxlIFN0YXRlISovXG4vKiBUaGlzIHN0YXRlIGlzIGNvbW11bmljYXRlZCB0byBgYXNzZXJ0YCB0aGF0IG1ha2VzIGl0IGF2YWlsYWJsZSB0byB0aGUqL1xuLyogY2F1c2FsIGNvbnNvbGUsIHdoaWNoIGFmZmVjdHMgdGhlIGNvbnNvbGUgbG9nIG91dHB1dC4gTm9ybWFsbHkgd2UqL1xuLyogcmVnYXJkIHRoZSBhYmlsaXR5IHRvIHNlZSBjb25zb2xlIGxvZyBvdXRwdXQgYXMgYSBtZXRhLWxldmVsIHByaXZpbGVnZSovXG4vKiBhbmFsb2dvdXMgdG8gdGhlIGFiaWxpdHkgdG8gZGVidWcuIEFzaWRlIGZyb20gdGhhdCwgdGhpcyBtb2R1bGUgc2hvdWxkKi9cbi8qIG5vdCBoYXZlIGFueSBvYnNlcnZhYmx5IG11dGFibGUgc3RhdGUuKi9cblxubGV0IGhpZGRlblByaW9yRXJyb3I7XG5sZXQgaGlkZGVuQ3VycmVudFR1cm49MDtcbmxldCBoaWRkZW5DdXJyZW50RXZlbnQ9MDtcblxuLyogVE9ETyBVc2UgZW52aXJvbm1lbnQtb3B0aW9ucy5qcyBjdXJyZW50bHkgaW4gc2VzL3NyYyBhZnRlciBmYWN0b3JpbmcgaXQgb3V0Ki9cbi8qIHRvIGEgbmV3IHBhY2thZ2UuKi9cbmNvbnN0IGVudj0oZ2xvYmFsVGhpcy5wcm9jZXNzfHx7fSkuZW52fHx7fTtcblxuLyogVHVybiBvbiBpZiB5b3Ugc2VlbSB0byBiZSBsb3NpbmcgZXJyb3IgbG9nZ2luZyBhdCB0aGUgdG9wIG9mIHRoZSBldmVudCBsb29wKi9cbmNvbnN0IFZFUkJPU0U9KGVudi5ERUJVR3x8JycpLnNwbGl0KCc6JykuaW5jbHVkZXMoJ3RyYWNrLXR1cm5zJyk7XG5cbmNvbnN0IHZhbGlkT3B0aW9uVmFsdWVzPWZyZWV6ZShbdW5kZWZpbmVkLCdlbmFibGVkJywnZGlzYWJsZWQnXSk7XG5cbi8qIFRyYWNrLXR1cm5zIGlzIGVuYWJsZWQgYnkgZGVmYXVsdCBhbmQgY2FuIGJlIGRpc2FibGVkIGJ5IGFuIGVudmlyb25tZW50Ki9cbi8qIG9wdGlvbi4qL1xuY29uc3QgZW52T3B0aW9uVmFsdWU9ZW52LlRSQUNLX1RVUk5TO1xuaWYoIXZhbGlkT3B0aW9uVmFsdWVzLmluY2x1ZGVzKGVudk9wdGlvblZhbHVlKSl7XG50aHJvdyBuZXcgVHlwZUVycm9yKFxuIGB1bnJlY29nbml6ZWQgVFJBQ0tfVFVSTlMgJHtKU09OLnN0cmluZ2lmeShlbnZPcHRpb25WYWx1ZSl9YCk7XG5cbiB9XG5jb25zdCBFTkFCTEVEPShlbnZPcHRpb25WYWx1ZXx8J2Rpc2FibGVkJyk9PT0nZW5hYmxlZCc7XG5cbi8qIFdlIGhvaXN0IHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zIG91dCBvZiB0cmFja1R1cm5zKCkgdG8gZGlzY291cmFnZSB0aGUqL1xuLyogY2xvc3VyZXMgZnJvbSBob2xkaW5nIG9udG8gJ2FyZ3MnIG9yICdmdW5jJyBsb25nZXIgdGhhbiBuZWNlc3NhcnksKi9cbi8qIHdoaWNoIHdlJ3ZlIHNlZW4gY2F1c2UgSGFuZGxlZFByb21pc2UgYXJndW1lbnRzIHRvIGJlIHJldGFpbmVkIGZvciovXG4vKiBhIHN1cnByaXNpbmdseSBsb25nIHRpbWUuKi9cblxuY29uc3QgYWRkUmVqZWN0aW9uTm90ZT0oZGV0YWlsc05vdGUpPT4ocmVhc29uKT0+e1xuaWYocmVhc29uIGluc3RhbmNlb2YgRXJyb3Ipe1xuYXNzZXJ0Lm5vdGUocmVhc29uLGRldGFpbHNOb3RlKTtcbiB9XG5pZihWRVJCT1NFKXtcbmNvbnNvbGUubG9nKCdSRUpFQ1RFRCBhdCB0b3Agb2YgZXZlbnQgbG9vcCcscmVhc29uKTtcbiB9XG4gfTtcblxuY29uc3Qgd3JhcEZ1bmN0aW9uPVxuKGZ1bmMsc2VuZGluZ0Vycm9yLFgpPT5cbiguLi5hcmdzKT0+e1xuaGlkZGVuUHJpb3JFcnJvcj1zZW5kaW5nRXJyb3I7XG5oaWRkZW5DdXJyZW50VHVybis9MTtcbmhpZGRlbkN1cnJlbnRFdmVudD0wO1xudHJ5e1xubGV0IHJlc3VsdDtcbnRyeXtcbnJlc3VsdD1mdW5jKC4uLmFyZ3MpO1xuIH1jYXRjaChlcnIpe1xuaWYoZXJyIGluc3RhbmNlb2YgRXJyb3Ipe1xuYXNzZXJ0Lm5vdGUoXG5lcnIsXG5YIGBUaHJvd24gZnJvbTogJHtoaWRkZW5QcmlvckVycm9yfToke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gKTtcblxuIH1cbmlmKFZFUkJPU0Upe1xuY29uc29sZS5sb2coJ1RIUk9XTiB0byB0b3Agb2YgZXZlbnQgbG9vcCcsZXJyKTtcbiB9XG50aHJvdyBlcnI7XG4gfVxuLyogTXVzdCBjYXB0dXJlIHRoaXMgbm93LCBub3Qgd2hlbiB0aGUgY2F0Y2ggdHJpZ2dlcnMuKi9cbmNvbnN0IGRldGFpbHNOb3RlPVggYFJlamVjdGlvbiBmcm9tOiAke2hpZGRlblByaW9yRXJyb3J9OiR7aGlkZGVuQ3VycmVudFR1cm59LiR7aGlkZGVuQ3VycmVudEV2ZW50fWA7XG5Qcm9taXNlLnJlc29sdmUocmVzdWx0KS5jYXRjaChhZGRSZWplY3Rpb25Ob3RlKGRldGFpbHNOb3RlKSk7XG5yZXR1cm4gcmVzdWx0O1xuIH1maW5hbGx5e1xuaGlkZGVuUHJpb3JFcnJvcj11bmRlZmluZWQ7XG4gfVxuIH07XG5cbi8qKlxuICogQHR5cGVkZWYgeygoLi4uYXJnczogYW55W10pID0+IGFueSkgfCB1bmRlZmluZWR9IFR1cm5TdGFydGVyRm5cbiAqIEFuIG9wdGlvbmFsIGZ1bmN0aW9uIHRoYXQgaXMgbm90IHRoaXMtc2Vuc2l0aXZlLCBleHBlY3RlZCB0byBiZSBjYWxsZWQgYXRcbiAqIGJvdHRvbSBvZiBzdGFjayB0byBzdGFydCBhIG5ldyB0dXJuLlxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtUdXJuU3RhcnRlckZuW119IFRcbiAqIEdpdmVuIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzLCByZXR1cm5zIGEgbGlzdCBvZiBgVHVyblN0YXJ0ZXJGbmBzIHdob3NlXG4gKiBgdGhpc2AtZnJlZSBjYWxsIGJlaGF2aW9ycyBhcmUgbm90IG9ic2VydmFibHkgZGlmZmVyZW50IHRvIHRob3NlIHRoYXRcbiAqIGNhbm5vdCBzZWUgY29uc29sZSBvdXRwdXQuIFRoZSBvbmx5IHB1cnBvc2UgaXMgdG8gY2F1c2UgYWRkaXRpb25hbFxuICogaW5mb3JtYXRpb24gdG8gYXBwZWFyIG9uIHRoZSBjb25zb2xlLlxuICpcbiAqIFRoZSBjYWxsIHRvIGB0cmFja1R1cm5zYCBpcyBpdHNlbGYgYSBzZW5kaW5nIGV2ZW50LCB0aGF0IG9jY3VycyBpbiBzb21lIGNhbGxcbiAqIHN0YWNrIGluIHNvbWUgdHVybiBudW1iZXIgYXQgc29tZSBldmVudCBudW1iZXIgd2l0aGluIHRoYXQgdHVybi4gRWFjaCBjYWxsXG4gKiB0byBhbnkgb2YgdGhlIHJldHVybmVkIGBUdXJuU3RhcnRGbmBzIGlzIGEgcmVjZWl2aW5nIGV2ZW50IHRoYXQgYmVnaW5zIGEgbmV3XG4gKiB0dXJuLiBUaGlzIHNlbmRpbmcgZXZlbnQgY2F1c2VkIGVhY2ggb2YgdGhvc2UgcmVjZWl2aW5nIGV2ZW50cy5cbiAqXG4gKiBAcGFyYW0ge1R9IGZ1bmNzXG4gKiBAcmV0dXJucyB7VH1cbiAqL1xuY29uc3QgICAgICAgIHRyYWNrVHVybnM9KGZ1bmNzKT0+e1xuaWYoIUVOQUJMRUR8fHR5cGVvZiBnbG9iYWxUaGlzPT09J3VuZGVmaW5lZCd8fCFnbG9iYWxUaGlzLmFzc2VydCl7XG5yZXR1cm4gZnVuY3M7XG4gfVxuY29uc3R7ZGV0YWlsczpYfT1hc3NlcnQ7XG5cbmhpZGRlbkN1cnJlbnRFdmVudCs9MTtcbmNvbnN0IHNlbmRpbmdFcnJvcj1uZXcgRXJyb3IoXG4gYEV2ZW50OiAke2hpZGRlbkN1cnJlbnRUdXJufS4ke2hpZGRlbkN1cnJlbnRFdmVudH1gKTtcblxuaWYoaGlkZGVuUHJpb3JFcnJvciE9PXVuZGVmaW5lZCl7XG5hc3NlcnQubm90ZShzZW5kaW5nRXJyb3IsWCBgQ2F1c2VkIGJ5OiAke2hpZGRlblByaW9yRXJyb3J9YCk7XG4gfVxuXG5yZXR1cm4gZnVuY3MubWFwKChmdW5jKT0+ZnVuYyYmd3JhcEZ1bmN0aW9uKGZ1bmMsc2VuZGluZ0Vycm9yLFgpKTtcbiB9OyRo4oCNX29uY2UudHJhY2tUdXJucyh0cmFja1R1cm5zKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJ0cmFja1R1cm5zIjpbInRyYWNrVHVybnMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAtC+LggcuAAAHLgAAJAAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuNi9zcmMvRS5qc3siaW1wb3J0cyI6WyIuL3RyYWNrLXR1cm5zLmpzIl0sImV4cG9ydHMiOlsiZGVmYXVsdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCB0cmFja1R1cm5zOyRo4oCNX2ltcG9ydHMoW1tcIi4vdHJhY2stdHVybnMuanNcIiwgW1tcInRyYWNrVHVybnNcIiwgWyRo4oCNX2EgPT4gKHRyYWNrVHVybnMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuY29uc3R7ZGV0YWlsczpYLHF1b3RlOnEsRmFpbH09YXNzZXJ0O1xuY29uc3R7YXNzaWduLGNyZWF0ZX09T2JqZWN0O1xuXG4vKiogQHR5cGUge1Byb3h5SGFuZGxlcjxhbnk+fSAqL1xuY29uc3QgYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcj17XG5zZXQoX3RhcmdldCxfcHJvcCxfdmFsdWUpe1xucmV0dXJuIGZhbHNlO1xuIH0sXG5pc0V4dGVuc2libGUoX3RhcmdldCl7XG5yZXR1cm4gZmFsc2U7XG4gfSxcbnNldFByb3RvdHlwZU9mKF90YXJnZXQsX3ZhbHVlKXtcbnJldHVybiBmYWxzZTtcbiB9LFxuZGVsZXRlUHJvcGVydHkoX3RhcmdldCxfcHJvcCl7XG5yZXR1cm4gZmFsc2U7XG4gfX07XG5cblxuLyogRSBQcm94eSBoYW5kbGVycyBwcmV0ZW5kIHRoYXQgYW55IHByb3BlcnR5IGV4aXN0cyBvbiB0aGUgdGFyZ2V0IGFuZCByZXR1cm5zKi9cbi8qIGEgZnVuY3Rpb24gZm9yIHRoZWlyIHZhbHVlLiBXaGlsZSB0aGlzIGZ1bmN0aW9uIGlzIFwiYm91bmRcIiBieSBjb250ZXh0LCBpdCBpcyovXG4vKiBtZWFudCB0byBiZSBjYWxsZWQgYXMgYSBtZXRob2QuIEZvciB0aGF0IHJlYXNvbiwgdGhlIHJldHVybmVkIGZ1bmN0aW9uKi9cbi8qIGluY2x1ZGVzIGEgY2hlY2sgdGhhdCB0aGUgYHRoaXNgIGFyZ3VtZW50IGNvcnJlc3BvbmRzIHRvIHRoZSBpbml0aWFsKi9cbi8qIHJlY2VpdmVyIHdoZW4gdGhlIGZ1bmN0aW9uIHdhcyByZXRyaWV2ZWQuKi9cbi8qIEUgUHJveHkgaGFuZGxlcnMgYWxzbyBmb3J3YXJkIGRpcmVjdCBjYWxscyB0byB0aGUgdGFyZ2V0IGluIGNhc2UgdGhlIHJlbW90ZSovXG4vKiBpcyBhIGZ1bmN0aW9uIGluc3RlYWQgb2YgYW4gb2JqZWN0LiBObyBzdWNoIHJlY2VpdmVyIGNoZWNrcyBhcmUgbmVjZXNzYXJ5IGluKi9cbi8qIHRoYXQgY2FzZS4qL1xuXG4vKipcbiAqIEEgUHJveHkgaGFuZGxlciBmb3IgRSh4KS5cbiAqXG4gKiBAcGFyYW0geyp9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFKHgpXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMnKS5IYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICogQHJldHVybnMge1Byb3h5SGFuZGxlcn0gdGhlIFByb3h5IGhhbmRsZXJcbiAqL1xuY29uc3QgbWFrZUVQcm94eUhhbmRsZXI9KHgsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHAscmVjZWl2ZXIpPT57XG5yZXR1cm4gaGFyZGVuKFxue1xuLyogVGhpcyBmdW5jdGlvbiBwdXJwb3NlbHkgY2hlY2tzIHRoZSBgdGhpc2AgdmFsdWUgKHNlZSBhYm92ZSkqL1xuLyogSW4gb3JkZXIgdG8gYmUgYHRoaXNgIHNlbnNpdGl2ZSBpdCBpcyBkZWZpbmVkIHVzaW5nIGNvbmNpc2UgbWV0aG9kKi9cbi8qIHN5bnRheCByYXRoZXIgdGhhbiBhcyBhbiBhcnJvdyBmdW5jdGlvbi4gVG8gZW5zdXJlIHRoZSBmdW5jdGlvbiovXG4vKiBpcyBub3QgY29uc3RydWN0YWJsZSwgaXQgYWxzbyBhdm9pZHMgdGhlIGBmdW5jdGlvbmAgc3ludGF4LiovXG5bcF0oLi4uYXJncyl7XG5pZih0aGlzIT09cmVjZWl2ZXIpe1xuLyogUmVqZWN0IHRoZSBhc3luYyBmdW5jdGlvbiBjYWxsKi9cbnJldHVybiBIYW5kbGVkUHJvbWlzZS5yZWplY3QoXG5hc3NlcnQuZXJyb3IoXG5YIGBVbmV4cGVjdGVkIHJlY2VpdmVyIGZvciBcIiR7cH1cIiBtZXRob2Qgb2YgRSgke3EoeCl9KWApKTtcblxuXG4gfVxuXG5yZXR1cm4gSGFuZGxlZFByb21pc2UuYXBwbHlNZXRob2QoeCxwLGFyZ3MpO1xuIH1cbi8qIEB0cy1leHBlY3QtZXJyb3IgaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy81MDMxOSovfVtcbnBdKTtcblxuIH0sXG5hcHBseTooX3RhcmdldCxfdGhpc0FyZyxhcmdBcnJheT1bXSk9PntcbnJldHVybiBIYW5kbGVkUHJvbWlzZS5hcHBseUZ1bmN0aW9uKHgsYXJnQXJyYXkpO1xuIH0sXG5oYXM6KF90YXJnZXQsX3ApPT57XG4vKiBXZSBqdXN0IHByZXRlbmQgZXZlcnl0aGluZyBleGlzdHMuKi9cbnJldHVybiB0cnVlO1xuIH19KTtcblxuXG4vKipcbiAqIEEgUHJveHkgaGFuZGxlciBmb3IgRS5zZW5kT25seSh4KVxuICogSXQgaXMgYSB2YXJpYW50IG9uIHRoZSBFKHgpIFByb3h5IGhhbmRsZXIuXG4gKlxuICogQHBhcmFtIHsqfSB4IEFueSB2YWx1ZSBwYXNzZWQgdG8gRS5zZW5kT25seSh4KVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzJykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXJ9IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmNvbnN0IG1ha2VFU2VuZE9ubHlQcm94eUhhbmRsZXI9KHgsSGFuZGxlZFByb21pc2UpPT5cbmhhcmRlbih7XG4uLi5iYXNlRnJlZXphYmxlUHJveHlIYW5kbGVyLFxuZ2V0OihfdGFyZ2V0LHAscmVjZWl2ZXIpPT57XG5yZXR1cm4gaGFyZGVuKFxue1xuLyogVGhpcyBmdW5jdGlvbiBwdXJwb3NlbHkgY2hlY2tzIHRoZSBgdGhpc2AgdmFsdWUgKHNlZSBhYm92ZSkqL1xuLyogSW4gb3JkZXIgdG8gYmUgYHRoaXNgIHNlbnNpdGl2ZSBpdCBpcyBkZWZpbmVkIHVzaW5nIGNvbmNpc2UgbWV0aG9kKi9cbi8qIHN5bnRheCByYXRoZXIgdGhhbiBhcyBhbiBhcnJvdyBmdW5jdGlvbi4gVG8gZW5zdXJlIHRoZSBmdW5jdGlvbiovXG4vKiBpcyBub3QgY29uc3RydWN0YWJsZSwgaXQgYWxzbyBhdm9pZHMgdGhlIGBmdW5jdGlvbmAgc3ludGF4LiovXG5bcF0oLi4uYXJncyl7XG4vKiBUaHJvdyBzaW5jZSB0aGUgZnVuY3Rpb24gcmV0dXJucyBub3RoaW5nKi9cbnRoaXM9PT1yZWNlaXZlcnx8XG5GYWlsIGBVbmV4cGVjdGVkIHJlY2VpdmVyIGZvciBcIiR7cShwKX1cIiBtZXRob2Qgb2YgRS5zZW5kT25seSgke3EoXG54KVxuIH0pYDtcbkhhbmRsZWRQcm9taXNlLmFwcGx5TWV0aG9kU2VuZE9ubHkoeCxwLGFyZ3MpO1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG4vKiBAdHMtZXhwZWN0LWVycm9yIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvNTAzMTkqL31bXG5wXSk7XG5cbiB9LFxuYXBwbHk6KF90YXJnZXQsX3RoaXNBcmcsYXJnc0FycmF5PVtdKT0+e1xuSGFuZGxlZFByb21pc2UuYXBwbHlGdW5jdGlvblNlbmRPbmx5KHgsYXJnc0FycmF5KTtcbnJldHVybiB1bmRlZmluZWQ7XG4gfSxcbmhhczooX3RhcmdldCxfcCk9Pntcbi8qIFdlIGp1c3QgcHJldGVuZCB0aGF0IGV2ZXJ5dGhpbmcgZXhpc3RzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cblxuLyoqXG4gKiBBIFByb3h5IGhhbmRsZXIgZm9yIEUuZ2V0KHgpXG4gKiBJdCBpcyBhIHZhcmlhbnQgb24gdGhlIEUoeCkgUHJveHkgaGFuZGxlci5cbiAqXG4gKiBAcGFyYW0geyp9IHggQW55IHZhbHVlIHBhc3NlZCB0byBFLmdldCh4KVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzJykuSGFuZGxlZFByb21pc2VDb25zdHJ1Y3Rvcn0gSGFuZGxlZFByb21pc2VcbiAqIEByZXR1cm5zIHtQcm94eUhhbmRsZXJ9IHRoZSBQcm94eSBoYW5kbGVyXG4gKi9cbmNvbnN0IG1ha2VFR2V0UHJveHlIYW5kbGVyPSh4LEhhbmRsZWRQcm9taXNlKT0+XG5oYXJkZW4oe1xuLi4uYmFzZUZyZWV6YWJsZVByb3h5SGFuZGxlcixcbmhhczooX3RhcmdldCxfcHJvcCk9PnRydWUsXG5nZXQ6KF90YXJnZXQscHJvcCk9PkhhbmRsZWRQcm9taXNlLmdldCh4LHByb3ApfSk7XG5cblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMnKS5IYW5kbGVkUHJvbWlzZUNvbnN0cnVjdG9yfSBIYW5kbGVkUHJvbWlzZVxuICovXG5jb25zdCBtYWtlRT0oSGFuZGxlZFByb21pc2UpPT57XG5yZXR1cm4gaGFyZGVuKFxuYXNzaWduKFxuLyoqXG4gKiBFKHgpIHJldHVybnMgYSBwcm94eSBvbiB3aGljaCB5b3UgY2FuIGNhbGwgYXJiaXRyYXJ5IG1ldGhvZHMuIEVhY2ggb2YgdGhlc2VcbiAqIG1ldGhvZCBjYWxscyByZXR1cm5zIGEgcHJvbWlzZS4gVGhlIG1ldGhvZCB3aWxsIGJlIGludm9rZWQgb24gd2hhdGV2ZXJcbiAqICd4JyBkZXNpZ25hdGVzIChvciByZXNvbHZlcyB0bykgaW4gYSBmdXR1cmUgdHVybiwgbm90IHRoaXMgb25lLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1R9IHggdGFyZ2V0IGZvciBtZXRob2QvZnVuY3Rpb24gY2FsbFxuICogQHJldHVybnMge0VDYWxsYWJsZU9yTWV0aG9kczxSZW1vdGVGdW5jdGlvbnM8VD4+fSBtZXRob2QvZnVuY3Rpb24gY2FsbCBwcm94eVxuICovXG4oeCk9PmhhcmRlbihuZXcgUHJveHkoKCk9PnsgfSxtYWtlRVByb3h5SGFuZGxlcih4LEhhbmRsZWRQcm9taXNlKSkpLFxue1xuLyoqXG4gKiBFLmdldCh4KSByZXR1cm5zIGEgcHJveHkgb24gd2hpY2ggeW91IGNhbiBnZXQgYXJiaXRyYXJ5IHByb3BlcnRpZXMuXG4gKiBFYWNoIG9mIHRoZXNlIHByb3BlcnRpZXMgcmV0dXJucyBhIHByb21pc2UgZm9yIHRoZSBwcm9wZXJ0eS4gIFRoZSBwcm9taXNlXG4gKiB2YWx1ZSB3aWxsIGJlIHRoZSBwcm9wZXJ0eSBmZXRjaGVkIGZyb20gd2hhdGV2ZXIgJ3gnIGRlc2lnbmF0ZXMgKG9yXG4gKiByZXNvbHZlcyB0bykgaW4gYSBmdXR1cmUgdHVybiwgbm90IHRoaXMgb25lLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1R9IHggdGFyZ2V0IGZvciBwcm9wZXJ0eSBnZXRcbiAqIEByZXR1cm5zIHtFR2V0dGVyczxMb2NhbFJlY29yZDxUPj59IHByb3BlcnR5IGdldCBwcm94eVxuICogQHJlYWRvbmx5XG4gKi9cbmdldDooeCk9PlxuaGFyZGVuKFxubmV3IFByb3h5KGNyZWF0ZShudWxsKSxtYWtlRUdldFByb3h5SGFuZGxlcih4LEhhbmRsZWRQcm9taXNlKSkpLFxuXG5cbi8qKlxuICogRS5yZXNvbHZlKHgpIGNvbnZlcnRzIHggdG8gYSBoYW5kbGVkIHByb21pc2UuIEl0IGlzXG4gKiBzaG9ydGhhbmQgZm9yIEhhbmRsZWRQcm9taXNlLnJlc29sdmUoeClcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHZhbHVlIHRvIGNvbnZlcnQgdG8gYSBoYW5kbGVkIHByb21pc2VcbiAqIEByZXR1cm5zIHtQcm9taXNlPEF3YWl0ZWQ8VD4+fSBoYW5kbGVkIHByb21pc2UgZm9yIHhcbiAqIEByZWFkb25seVxuICovXG5yZXNvbHZlOkhhbmRsZWRQcm9taXNlLnJlc29sdmUsXG5cbi8qKlxuICogRS5zZW5kT25seSByZXR1cm5zIGEgcHJveHkgc2ltaWxhciB0byBFLCBidXQgZm9yIHdoaWNoIHRoZSByZXN1bHRzXG4gKiBhcmUgaWdub3JlZCAodW5kZWZpbmVkIGlzIHJldHVybmVkKS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSB4IHRhcmdldCBmb3IgbWV0aG9kL2Z1bmN0aW9uIGNhbGxcbiAqIEByZXR1cm5zIHtFU2VuZE9ubHlDYWxsYWJsZU9yTWV0aG9kczxSZW1vdGVGdW5jdGlvbnM8VD4+fSBtZXRob2QvZnVuY3Rpb24gY2FsbCBwcm94eVxuICogQHJlYWRvbmx5XG4gKi9cbnNlbmRPbmx5Oih4KT0+XG5oYXJkZW4oXG5uZXcgUHJveHkoKCk9PnsgfSxtYWtlRVNlbmRPbmx5UHJveHlIYW5kbGVyKHgsSGFuZGxlZFByb21pc2UpKSksXG5cblxuLyoqXG4gKiBFLndoZW4oeCwgcmVzLCByZWopIGlzIGVxdWl2YWxlbnQgdG9cbiAqIEhhbmRsZWRQcm9taXNlLnJlc29sdmUoeCkudGhlbihyZXMsIHJlailcbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIFtVID0gVF1cbiAqIEBwYXJhbSB7VHxQcm9taXNlTGlrZTxUPn0geCB2YWx1ZSB0byBjb252ZXJ0IHRvIGEgaGFuZGxlZCBwcm9taXNlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gRVJlZjxVPn0gW29uZnVsZmlsbGVkXVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IEVSZWY8VT59IFtvbnJlamVjdGVkXVxuICogQHJldHVybnMge1Byb21pc2U8VT59XG4gKiBAcmVhZG9ubHlcbiAqL1xud2hlbjooeCxvbmZ1bGZpbGxlZCxvbnJlamVjdGVkKT0+XG5IYW5kbGVkUHJvbWlzZS5yZXNvbHZlKHgpLnRoZW4oXG4uLi50cmFja1R1cm5zKFtvbmZ1bGZpbGxlZCxvbnJlamVjdGVkXSkpfSkpO1xuXG5cblxuXG4gfTtcblxuY29uc3R7ZGVmYXVsdDokY+KAjV9kZWZhdWx0fT17ZGVmYXVsdDptYWtlRX07XG5cbi8qKiBAdHlwZWRlZiB7UmV0dXJuVHlwZTxtYWtlRT59IEVQcm94eSAqL1xuXG4vKipcbiAqIENyZWF0ZXMgYSB0eXBlIHRoYXQgYWNjZXB0cyBib3RoIG5lYXIgYW5kIG1hcnNoYWxsZWQgcmVmZXJlbmNlcyB0aGF0IHdlcmVcbiAqIHJldHVybmVkIGZyb20gYFJlbW90YWJsZWAgb3IgYEZhcmAsIGFuZCBhbHNvIHByb21pc2VzIGZvciBzdWNoIHJlZmVyZW5jZXMuXG4gKlxuICogQHRlbXBsYXRlIFByaW1hcnkgVGhlIHR5cGUgb2YgdGhlIHByaW1hcnkgcmVmZXJlbmNlLlxuICogQHRlbXBsYXRlIFtMb2NhbD1EYXRhT25seTxQcmltYXJ5Pl0gVGhlIGxvY2FsIHByb3BlcnRpZXMgb2YgdGhlIG9iamVjdC5cbiAqIEB0eXBlZGVmIHtFUmVmPExvY2FsICYgWGltcG9ydCgnLi90eXBlcycpLlJlbW90YWJsZUJyYW5kPExvY2FsLCBQcmltYXJ5Pj59IEZhclJlZlxuICovXG5cbi8qKlxuICogYERhdGFPbmx5PFQ+YCBtZWFucyB0byByZXR1cm4gYSByZWNvcmQgdHlwZSBgVDJgIGNvbnNpc3Rpbmcgb25seSBvZlxuICogcHJvcGVydGllcyB0aGF0IGFyZSAqbm90KiBmdW5jdGlvbnMuXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgdG8gYmUgZmlsdGVyZWQuXG4gKiBAdHlwZWRlZiB7T21pdDxULCBGaWx0ZXJlZEtleXM8VCwgWGltcG9ydCgnLi90eXBlcycpLkNhbGxhYmxlPj59IERhdGFPbmx5XG4gKi9cblxuLyoqXG4gKiBAc2VlIHtAbGluayBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzMxMzk0fVxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHtQcm9taXNlTGlrZTxUPiB8IFR9IEVSZWZcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7WGltcG9ydCgnLi90eXBlcycpLkNhbGxhYmxlfSBUXG4gKiBAdHlwZWRlZiB7KFxuICogICBSZXR1cm5UeXBlPFQ+IGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT4gICAgICAgICAgICAgICAgICAgICAgIC8vIGlmIGZ1bmN0aW9uIHJldHVybnMgYSBwcm9taXNlXG4gKiAgICAgPyBUICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gcmV0dXJuIHRoZSBmdW5jdGlvblxuICogICAgIDogKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFByb21pc2U8QXdhaXRlZDxSZXR1cm5UeXBlPFQ+Pj4gIC8vIG1ha2UgaXQgcmV0dXJuIGEgcHJvbWlzZVxuICogKX0gRUNhbGxhYmxlXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVhZG9ubHkgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBYaW1wb3J0KCcuL3R5cGVzJykuQ2FsbGFibGVcbiAqICAgICA/IEVDYWxsYWJsZTxUW1BdPlxuICogICAgIDogbmV2ZXI7XG4gKiB9fSBFTWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHt7XG4gKiAgIHJlYWRvbmx5IFtQIGluIGtleW9mIFRdOiBUW1BdIGV4dGVuZHMgUHJvbWlzZUxpa2U8aW5mZXIgVT5cbiAqICAgICA/IFRbUF1cbiAqICAgICA6IFByb21pc2U8QXdhaXRlZDxUW1BdPj47XG4gKiB9fSBFR2V0dGVyc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHtYaW1wb3J0KCcuL3R5cGVzJykuQ2FsbGFibGV9IFRcbiAqIEB0eXBlZGVmIHsoLi4uYXJnczogUGFyYW1ldGVyczxUPikgPT4gUHJvbWlzZTx2b2lkPn0gRVNlbmRPbmx5Q2FsbGFibGVcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7e1xuICogICByZWFkb25seSBbUCBpbiBrZXlvZiBUXTogVFtQXSBleHRlbmRzIFhpbXBvcnQoJy4vdHlwZXMnKS5DYWxsYWJsZVxuICogICAgID8gRVNlbmRPbmx5Q2FsbGFibGU8VFtQXT5cbiAqICAgICA6IG5ldmVyO1xuICogfX0gRVNlbmRPbmx5TWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBYaW1wb3J0KCcuL3R5cGVzJykuQ2FsbGFibGVcbiAqICAgICA/IEVTZW5kT25seUNhbGxhYmxlPFQ+ICYgRVNlbmRPbmx5TWV0aG9kczxSZXF1aXJlZDxUPj5cbiAqICAgICA6IEVTZW5kT25seU1ldGhvZHM8UmVxdWlyZWQ8VD4+XG4gKiApfSBFU2VuZE9ubHlDYWxsYWJsZU9yTWV0aG9kc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBYaW1wb3J0KCcuL3R5cGVzJykuQ2FsbGFibGVcbiAqICAgICA/IEVDYWxsYWJsZTxUPiAmIEVNZXRob2RzPFJlcXVpcmVkPFQ+PlxuICogICAgIDogRU1ldGhvZHM8UmVxdWlyZWQ8VD4+XG4gKiApfSBFQ2FsbGFibGVPck1ldGhvZHNcbiAqL1xuXG4vKipcbiAqIFJldHVybiBhIHVuaW9uIG9mIHByb3BlcnR5IG5hbWVzL3N5bWJvbHMvbnVtYmVycyBQIGZvciB3aGljaCB0aGUgcmVjb3JkIGVsZW1lbnQgVFtQXSdzIHR5cGUgZXh0ZW5kcyBVLlxuICpcbiAqIEdpdmVuIGNvbnN0IHggPSB7IGE6IDEyMywgYjogJ2hlbGxvJywgYzogNDIsIDQ5OiAoKSA9PiB7fSwgNTM6IDY3IH0sXG4gKlxuICogRmlsdGVyZWRLZXlzPHR5cGVvZiB4LCBudW1iZXI+IGlzIHRoZSB0eXBlICdhJyB8ICdjJyB8IDUzLlxuICogRmlsdGVyZWRLZXlzPHR5cGVvZiB4LCBzdHJpbmc+IGlzIHRoZSB0eXBlICdiJy5cbiAqIEZpbHRlcmVkS2V5czx0eXBlb2YgeCwgNDIgfCA2Nz4gaXMgdGhlIHR5cGUgJ2MnIHwgNTMuXG4gKiBGaWx0ZXJlZEtleXM8dHlwZW9mIHgsIGJvb2xlYW4+IGlzIHRoZSB0eXBlIG5ldmVyLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdGVtcGxhdGUgVVxuICogQHR5cGVkZWYge3sgW1AgaW4ga2V5b2YgVF06IFRbUF0gZXh0ZW5kcyBVID8gUCA6IG5ldmVyOyB9W2tleW9mIFRdfSBGaWx0ZXJlZEtleXNcbiAqL1xuXG4vKipcbiAqIGBQaWNrQ2FsbGFibGU8VD5gIG1lYW5zIHRvIHJldHVybiBhIHNpbmdsZSByb290IGNhbGxhYmxlIG9yIGEgcmVjb3JkIHR5cGVcbiAqIGNvbnNpc3Rpbmcgb25seSBvZiBwcm9wZXJ0aWVzIHRoYXQgYXJlIGZ1bmN0aW9ucy5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIFhpbXBvcnQoJy4vdHlwZXMnKS5DYWxsYWJsZVxuICogICAgID8gKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IFJldHVyblR5cGU8VD4gICAgICAgICAgICAgICAgICAgICAvLyBhIHJvb3QgY2FsbGFibGUsIG5vIG1ldGhvZHNcbiAqICAgICA6IFBpY2s8VCwgRmlsdGVyZWRLZXlzPFQsIFhpbXBvcnQoJy4vdHlwZXMnKS5DYWxsYWJsZT4+ICAgICAgICAgIC8vIGFueSBjYWxsYWJsZSBtZXRob2RzXG4gKiApfSBQaWNrQ2FsbGFibGVcbiAqL1xuXG4vKipcbiAqIGBSZW1vdGVGdW5jdGlvbnM8VD5gIG1lYW5zIHRvIHJldHVybiB0aGUgZnVuY3Rpb25zIGFuZCBwcm9wZXJ0aWVzIHRoYXQgYXJlIHJlbW90ZWx5IGNhbGxhYmxlLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdHlwZWRlZiB7KFxuICogICBUIGV4dGVuZHMgWGltcG9ydCgnLi90eXBlcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+ICAgICAvLyBpZiBhIGdpdmVuIFQgaXMgc29tZSByZW1vdGUgaW50ZXJmYWNlIFJcbiAqICAgICA/IFBpY2tDYWxsYWJsZTxSPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyB0aGVuIHJldHVybiB0aGUgY2FsbGFibGUgcHJvcGVydGllcyBvZiBSXG4gKiAgICAgOiBBd2FpdGVkPFQ+IGV4dGVuZHMgWGltcG9ydCgnLi90eXBlcycpLlJlbW90YWJsZUJyYW5kPGluZmVyIEwsIGluZmVyIFI+IC8vIG90aGVyd2lzZSwgaWYgdGhlIGZpbmFsIHJlc29sdXRpb24gb2YgVCBpcyBzb21lIHJlbW90ZSBpbnRlcmZhY2UgUlxuICogICAgID8gUGlja0NhbGxhYmxlPFI+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIHRoZW4gcmV0dXJuIHRoZSBjYWxsYWJsZSBwcm9wZXJ0aWVzIG9mIFJcbiAqICAgICA6IFQgZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBvdGhlcndpc2UsIGlmIFQgaXMgYSBwcm9taXNlXG4gKiAgICAgPyBBd2FpdGVkPFQ+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlbiByZXR1cm4gcmVzb2x2ZWQgdmFsdWUgVFxuICogICAgIDogVCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIG90aGVyd2lzZSwgcmV0dXJuIFRcbiAqICl9IFJlbW90ZUZ1bmN0aW9uc1xuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEB0eXBlZGVmIHsoXG4gKiAgIFQgZXh0ZW5kcyBYaW1wb3J0KCcuL3R5cGVzJykuUmVtb3RhYmxlQnJhbmQ8aW5mZXIgTCwgaW5mZXIgUj5cbiAqICAgICA/IExcbiAqICAgICA6IEF3YWl0ZWQ8VD4gZXh0ZW5kcyBYaW1wb3J0KCcuL3R5cGVzJykuUmVtb3RhYmxlQnJhbmQ8aW5mZXIgTCwgaW5mZXIgUj5cbiAqICAgICA/IExcbiAqICAgICA6IFQgZXh0ZW5kcyBQcm9taXNlTGlrZTxpbmZlciBVPlxuICogICAgID8gQXdhaXRlZDxUPlxuICogICAgIDogVFxuICogKX0gTG9jYWxSZWNvcmRcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBbUiA9IHVua25vd25dXG4gKiBAdHlwZWRlZiB7e1xuICogICBwcm9taXNlOiBQcm9taXNlPFI+O1xuICogICBzZXR0bGVyOiBYaW1wb3J0KCcuL3R5cGVzJykuU2V0dGxlcjxSPjtcbiAqIH19IEVQcm9taXNlS2l0XG4gKi9cblxuLyoqXG4gKiBUeXBlIGZvciBhbiBvYmplY3QgdGhhdCBtdXN0IG9ubHkgYmUgaW52b2tlZCB3aXRoIEUuICBJdCBzdXBwb3J0cyBhIGdpdmVuXG4gKiBpbnRlcmZhY2UgYnV0IGRlY2xhcmVzIGFsbCB0aGUgZnVuY3Rpb25zIGFzIGFzeW5jYWJsZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYgeyhcbiAqICAgVCBleHRlbmRzIFhpbXBvcnQoJy4vdHlwZXMnKS5DYWxsYWJsZVxuICogICAgID8gKC4uLmFyZ3M6IFBhcmFtZXRlcnM8VD4pID0+IEVSZWY8QXdhaXRlZDxFT25seTxSZXR1cm5UeXBlPFQ+Pj4+XG4gKiAgICAgOiBUIGV4dGVuZHMgUmVjb3JkPFByb3BlcnR5S2V5LCBYaW1wb3J0KCcuL3R5cGVzJykuQ2FsbGFibGU+XG4gKiAgICAgPyB7XG4gKiAgICAgICAgIFtLIGluIGtleW9mIFRdOiBUW0tdIGV4dGVuZHMgWGltcG9ydCgnLi90eXBlcycpLkNhbGxhYmxlXG4gKiAgICAgICAgICAgPyAoLi4uYXJnczogUGFyYW1ldGVyczxUW0tdPikgPT4gRVJlZjxBd2FpdGVkPEVPbmx5PFJldHVyblR5cGU8VFtLXT4+Pj5cbiAqICAgICAgICAgICA6IFRbS107XG4gKiAgICAgICB9XG4gKiAgICAgOiBUXG4gKiApfSBFT25seVxuICovJGjigI1fb25jZS5kZWZhdWx0KCRj4oCNX2RlZmF1bHQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImRlZmF1bHQiOlsiZGVmYXVsdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACYGTuzNAEAADQBAAAqAAAAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy42L3NyYy9leHBvcnRzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAPsYdN1FAgAARQIAACoAAABAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjYvc3JjL25vLXNoaW0uanN7ImltcG9ydHMiOlsiLi9FLmpzIiwiLi9leHBvcnRzLmpzIl0sImV4cG9ydHMiOlsiRSIsIkhhbmRsZWRQcm9taXNlIl0sInJlZXhwb3J0cyI6WyIuL2V4cG9ydHMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbWFrZUU7JGjigI1faW1wb3J0cyhbW1wiLi9FLmpzXCIsIFtbXCJkZWZhdWx0XCIsIFskaOKAjV9hID0+IChtYWtlRSA9ICRo4oCNX2EpXV1dXSxbXCIuL2V4cG9ydHMuanNcIiwgW11dXSk7ICAgXG5cbmNvbnN0IGhwPUhhbmRsZWRQcm9taXNlOyRo4oCNX29uY2UuaHAoaHApO1xuY29uc3QgICAgICAgIEU9bWFrZUUoaHApOyRo4oCNX29uY2UuRShFKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJIYW5kbGVkUHJvbWlzZSI6WyJocCJdLCJFIjpbIkUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA6qEddJcQAACXEAAALgAAAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuNi9zcmMvdHJhY2stdHVybnMuanN7ImltcG9ydHMiOlsiQGVuZG8vZW52LW9wdGlvbnMiXSwiZXhwb3J0cyI6WyJ0cmFja1R1cm5zIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG1ha2VFbnZpcm9ubWVudENhcHRvcjskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9lbnYtb3B0aW9uc1wiLCBbW1wibWFrZUVudmlyb25tZW50Q2FwdG9yXCIsIFskaOKAjV9hID0+IChtYWtlRW52aXJvbm1lbnRDYXB0b3IgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5jb25zdHtnZXRFbnZpcm9ubWVudE9wdGlvbn09bWFrZUVudmlyb25tZW50Q2FwdG9yKGdsb2JhbFRoaXMpO1xuXG4vKiBOT1RFOiBXZSBjYW4ndCBpbXBvcnQgdGhlc2UgYmVjYXVzZSB0aGV5J3JlIG5vdCBpbiBzY29wZSBiZWZvcmUgbG9ja2Rvd24uKi9cbi8qIGltcG9ydCB7IGFzc2VydCwgZGV0YWlscyBhcyBYLCBGYWlsIH0gZnJvbSAnQGFnb3JpYy9hc3NlcnQnOyovXG5cbi8qIFdBUk5JTkc6IEdsb2JhbCBNdXRhYmxlIFN0YXRlISovXG4vKiBUaGlzIHN0YXRlIGlzIGNvbW11bmljYXRlZCB0byBgYXNzZXJ0YCB0aGF0IG1ha2VzIGl0IGF2YWlsYWJsZSB0byB0aGUqL1xuLyogY2F1c2FsIGNvbnNvbGUsIHdoaWNoIGFmZmVjdHMgdGhlIGNvbnNvbGUgbG9nIG91dHB1dC4gTm9ybWFsbHkgd2UqL1xuLyogcmVnYXJkIHRoZSBhYmlsaXR5IHRvIHNlZSBjb25zb2xlIGxvZyBvdXRwdXQgYXMgYSBtZXRhLWxldmVsIHByaXZpbGVnZSovXG4vKiBhbmFsb2dvdXMgdG8gdGhlIGFiaWxpdHkgdG8gZGVidWcuIEFzaWRlIGZyb20gdGhhdCwgdGhpcyBtb2R1bGUgc2hvdWxkKi9cbi8qIG5vdCBoYXZlIGFueSBvYnNlcnZhYmx5IG11dGFibGUgc3RhdGUuKi9cblxubGV0IGhpZGRlblByaW9yRXJyb3I7XG5sZXQgaGlkZGVuQ3VycmVudFR1cm49MDtcbmxldCBoaWRkZW5DdXJyZW50RXZlbnQ9MDtcblxuY29uc3QgREVCVUc9Z2V0RW52aXJvbm1lbnRPcHRpb24oJ0RFQlVHJywnJyk7XG5cbi8qIFR1cm4gb24gaWYgeW91IHNlZW0gdG8gYmUgbG9zaW5nIGVycm9yIGxvZ2dpbmcgYXQgdGhlIHRvcCBvZiB0aGUgZXZlbnQgbG9vcCovXG5jb25zdCBWRVJCT1NFPURFQlVHLnNwbGl0KCc6JykuaW5jbHVkZXMoJ3RyYWNrLXR1cm5zJyk7XG5cbi8qIFRyYWNrLXR1cm5zIGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGNhbiBiZSBlbmFibGVkIGJ5IGFuIGVudmlyb25tZW50Ki9cbi8qIG9wdGlvbi4qL1xuY29uc3QgVFJBQ0tfVFVSTlM9Z2V0RW52aXJvbm1lbnRPcHRpb24oJ1RSQUNLX1RVUk5TJywnZGlzYWJsZWQnKTtcbmlmKFRSQUNLX1RVUk5TIT09J2VuYWJsZWQnJiZUUkFDS19UVVJOUyE9PSdkaXNhYmxlZCcpe1xudGhyb3cgVHlwZUVycm9yKCBgdW5yZWNvZ25pemVkIFRSQUNLX1RVUk5TICR7SlNPTi5zdHJpbmdpZnkoVFJBQ0tfVFVSTlMpfWApO1xuIH1cbmNvbnN0IEVOQUJMRUQ9KFRSQUNLX1RVUk5TfHwnZGlzYWJsZWQnKT09PSdlbmFibGVkJztcblxuLyogV2UgaG9pc3QgdGhlIGZvbGxvd2luZyBmdW5jdGlvbnMgb3V0IG9mIHRyYWNrVHVybnMoKSB0byBkaXNjb3VyYWdlIHRoZSovXG4vKiBjbG9zdXJlcyBmcm9tIGhvbGRpbmcgb250byAnYXJncycgb3IgJ2Z1bmMnIGxvbmdlciB0aGFuIG5lY2Vzc2FyeSwqL1xuLyogd2hpY2ggd2UndmUgc2VlbiBjYXVzZSBIYW5kbGVkUHJvbWlzZSBhcmd1bWVudHMgdG8gYmUgcmV0YWluZWQgZm9yKi9cbi8qIGEgc3VycHJpc2luZ2x5IGxvbmcgdGltZS4qL1xuXG5jb25zdCBhZGRSZWplY3Rpb25Ob3RlPShkZXRhaWxzTm90ZSk9PihyZWFzb24pPT57XG5pZihyZWFzb24gaW5zdGFuY2VvZiBFcnJvcil7XG5hc3NlcnQubm90ZShyZWFzb24sZGV0YWlsc05vdGUpO1xuIH1cbmlmKFZFUkJPU0Upe1xuY29uc29sZS5sb2coJ1JFSkVDVEVEIGF0IHRvcCBvZiBldmVudCBsb29wJyxyZWFzb24pO1xuIH1cbiB9O1xuXG5jb25zdCB3cmFwRnVuY3Rpb249XG4oZnVuYyxzZW5kaW5nRXJyb3IsWCk9PlxuKC4uLmFyZ3MpPT57XG5oaWRkZW5QcmlvckVycm9yPXNlbmRpbmdFcnJvcjtcbmhpZGRlbkN1cnJlbnRUdXJuKz0xO1xuaGlkZGVuQ3VycmVudEV2ZW50PTA7XG50cnl7XG5sZXQgcmVzdWx0O1xudHJ5e1xucmVzdWx0PWZ1bmMoLi4uYXJncyk7XG4gfWNhdGNoKGVycil7XG5pZihlcnIgaW5zdGFuY2VvZiBFcnJvcil7XG5hc3NlcnQubm90ZShcbmVycixcblggYFRocm93biBmcm9tOiAke2hpZGRlblByaW9yRXJyb3J9OiR7aGlkZGVuQ3VycmVudFR1cm59LiR7aGlkZGVuQ3VycmVudEV2ZW50fWApO1xuXG4gfVxuaWYoVkVSQk9TRSl7XG5jb25zb2xlLmxvZygnVEhST1dOIHRvIHRvcCBvZiBldmVudCBsb29wJyxlcnIpO1xuIH1cbnRocm93IGVycjtcbiB9XG4vKiBNdXN0IGNhcHR1cmUgdGhpcyBub3csIG5vdCB3aGVuIHRoZSBjYXRjaCB0cmlnZ2Vycy4qL1xuY29uc3QgZGV0YWlsc05vdGU9WCBgUmVqZWN0aW9uIGZyb206ICR7aGlkZGVuUHJpb3JFcnJvcn06JHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YDtcblByb21pc2UucmVzb2x2ZShyZXN1bHQpLmNhdGNoKGFkZFJlamVjdGlvbk5vdGUoZGV0YWlsc05vdGUpKTtcbnJldHVybiByZXN1bHQ7XG4gfWZpbmFsbHl7XG5oaWRkZW5QcmlvckVycm9yPXVuZGVmaW5lZDtcbiB9XG4gfTtcblxuLyoqXG4gKiBHaXZlbiBhIGxpc3Qgb2YgYFR1cm5TdGFydGVyRm5gcywgcmV0dXJucyBhIGxpc3Qgb2YgYFR1cm5TdGFydGVyRm5gcyB3aG9zZVxuICogYHRoaXNgLWZyZWUgY2FsbCBiZWhhdmlvcnMgYXJlIG5vdCBvYnNlcnZhYmx5IGRpZmZlcmVudCB0byB0aG9zZSB0aGF0XG4gKiBjYW5ub3Qgc2VlIGNvbnNvbGUgb3V0cHV0LiBUaGUgb25seSBwdXJwb3NlIGlzIHRvIGNhdXNlIGFkZGl0aW9uYWxcbiAqIGluZm9ybWF0aW9uIHRvIGFwcGVhciBvbiB0aGUgY29uc29sZS5cbiAqXG4gKiBUaGUgY2FsbCB0byBgdHJhY2tUdXJuc2AgaXMgaXRzZWxmIGEgc2VuZGluZyBldmVudCwgdGhhdCBvY2N1cnMgaW4gc29tZSBjYWxsXG4gKiBzdGFjayBpbiBzb21lIHR1cm4gbnVtYmVyIGF0IHNvbWUgZXZlbnQgbnVtYmVyIHdpdGhpbiB0aGF0IHR1cm4uIEVhY2ggY2FsbFxuICogdG8gYW55IG9mIHRoZSByZXR1cm5lZCBgVHVyblN0YXJ0Rm5gcyBpcyBhIHJlY2VpdmluZyBldmVudCB0aGF0IGJlZ2lucyBhIG5ld1xuICogdHVybi4gVGhpcyBzZW5kaW5nIGV2ZW50IGNhdXNlZCBlYWNoIG9mIHRob3NlIHJlY2VpdmluZyBldmVudHMuXG4gKlxuICogQHRlbXBsYXRlIHtUdXJuU3RhcnRlckZuW119IFRcbiAqIEBwYXJhbSB7VH0gZnVuY3NcbiAqIEByZXR1cm5zIHtUfVxuICovXG5jb25zdCAgICAgICAgdHJhY2tUdXJucz0oZnVuY3MpPT57XG5pZighRU5BQkxFRHx8dHlwZW9mIGdsb2JhbFRoaXM9PT0ndW5kZWZpbmVkJ3x8IWdsb2JhbFRoaXMuYXNzZXJ0KXtcbnJldHVybiBmdW5jcztcbiB9XG5jb25zdHtkZXRhaWxzOlh9PWFzc2VydDtcblxuaGlkZGVuQ3VycmVudEV2ZW50Kz0xO1xuY29uc3Qgc2VuZGluZ0Vycm9yPUVycm9yKFxuIGBFdmVudDogJHtoaWRkZW5DdXJyZW50VHVybn0uJHtoaWRkZW5DdXJyZW50RXZlbnR9YCk7XG5cbmlmKGhpZGRlblByaW9yRXJyb3IhPT11bmRlZmluZWQpe1xuYXNzZXJ0Lm5vdGUoc2VuZGluZ0Vycm9yLFggYENhdXNlZCBieTogJHtoaWRkZW5QcmlvckVycm9yfWApO1xuIH1cblxucmV0dXJuICgvKiogQHR5cGUge1R9ICovXG5mdW5jcy5tYXAoKGZ1bmMpPT5mdW5jJiZ3cmFwRnVuY3Rpb24oZnVuYyxzZW5kaW5nRXJyb3IsWCkpKTtcblxuIH07XG5cbi8qKlxuICogQW4gb3B0aW9uYWwgZnVuY3Rpb24gdGhhdCBpcyBub3QgdGhpcy1zZW5zaXRpdmUsIGV4cGVjdGVkIHRvIGJlIGNhbGxlZCBhdFxuICogYm90dG9tIG9mIHN0YWNrIHRvIHN0YXJ0IGEgbmV3IHR1cm4uXG4gKlxuICogQHR5cGVkZWYgeygoLi4uYXJnczogYW55W10pID0+IGFueSkgfCB1bmRlZmluZWR9IFR1cm5TdGFydGVyRm5cbiAqLyRo4oCNX29uY2UudHJhY2tUdXJucyh0cmFja1R1cm5zKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJ0cmFja1R1cm5zIjpbInRyYWNrVHVybnMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAOlKtTRwCAAAcAgAAGQAAAEBlbmRvL2V4by12MC4yLjIvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMvZXhvLW1ha2Vycy5qcyJdLCJleHBvcnRzIjpbImRlZmluZUV4b0NsYXNzIiwiZGVmaW5lRXhvQ2xhc3MiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy9leG8tbWFrZXJzLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2V4by1tYWtlcnMuanMiOltbImluaXRFbXB0eSIsImluaXRFbXB0eSJdLFsiZGVmaW5lRXhvQ2xhc3MiLCJkZWZpbmVFeG9DbGFzcyJdLFsiZGVmaW5lRXhvQ2xhc3NLaXQiLCJkZWZpbmVFeG9DbGFzc0tpdCJdLFsibWFrZUV4byIsIm1ha2VFeG8iXV19LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMa361ZjGAAAYxgAACIAAABAZW5kby9leG8tdjAuMi4yL3NyYy9leG8tbWFrZXJzLmpzeyJpbXBvcnRzIjpbIi4vZXhvLXRvb2xzLmpzIiwiQGVuZG8vcGF0dGVybnMiXSwiZXhwb3J0cyI6WyJkZWZpbmVFeG9DbGFzcyIsImRlZmluZUV4b0NsYXNzS2l0IiwiaW5pdEVtcHR5IiwibWFrZUV4byJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBvYmplY3RNYXAsZGVmZW5kUHJvdG90eXBlLGRlZmVuZFByb3RvdHlwZUtpdDskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9wYXR0ZXJuc1wiLCBbW1wib2JqZWN0TWFwXCIsIFskaOKAjV9hID0+IChvYmplY3RNYXAgPSAkaOKAjV9hKV1dXV0sW1wiLi9leG8tdG9vbHMuanNcIiwgW1tcImRlZmVuZFByb3RvdHlwZVwiLCBbJGjigI1fYSA9PiAoZGVmZW5kUHJvdG90eXBlID0gJGjigI1fYSldXSxbXCJkZWZlbmRQcm90b3R5cGVLaXRcIiwgWyRo4oCNX2EgPT4gKGRlZmVuZFByb3RvdHlwZUtpdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cbmNvbnN0e2NyZWF0ZSxzZWFsLGZyZWV6ZSxkZWZpbmVQcm9wZXJ0eX09T2JqZWN0O1xuXG4vKiBUT0RPIFVzZSBlbnZpcm9ubWVudC1vcHRpb25zLmpzIGN1cnJlbnRseSBpbiBzZXMvc3JjIGFmdGVyIGZhY3RvcmluZyBpdCBvdXQqL1xuLyogdG8gYSBuZXcgcGFja2FnZS4qL1xuY29uc3QgZW52PShnbG9iYWxUaGlzLnByb2Nlc3N8fHt9KS5lbnZ8fHt9O1xuXG4vKiBUdXJuIG9uIHRvIGdpdmUgZWFjaCBleG8gaW5zdGFuY2UgaXRzIG93biB0b1N0cmluZ1RhZyB2YWx1ZS4qL1xuY29uc3QgTEFCRUxfSU5TVEFOQ0VTPShlbnYuREVCVUd8fCcnKS5cbnNwbGl0KCcsJykuXG5pbmNsdWRlcygnbGFiZWwtaW5zdGFuY2VzJyk7XG5cbmNvbnN0IG1ha2VTZWxmPShwcm90byxpbnN0YW5jZUNvdW50KT0+e1xuY29uc3Qgc2VsZj1jcmVhdGUocHJvdG8pO1xuaWYoTEFCRUxfSU5TVEFOQ0VTKXtcbmRlZmluZVByb3BlcnR5KHNlbGYsU3ltYm9sLnRvU3RyaW5nVGFnLHtcbnZhbHVlOiBgJHtwcm90b1tTeW1ib2wudG9TdHJpbmdUYWddfSMke2luc3RhbmNlQ291bnR9YCxcbndyaXRhYmxlOmZhbHNlLFxuZW51bWVyYWJsZTpmYWxzZSxcbmNvbmZpZ3VyYWJsZTpmYWxzZX0pO1xuXG4gfVxucmV0dXJuIGhhcmRlbihzZWxmKTtcbiB9O1xuXG5jb25zdCBlbXB0eVJlY29yZD1oYXJkZW4oe30pO1xuXG4vKipcbiAqIFdoZW4gY2FsbGluZyBgZGVmaW5lRHVyYWJsZUtpbmRgIGFuZFxuICogaXRzIHNpYmxpbmdzLCB1c2VkIGFzIHRoZSBgaW5pdGAgZnVuY3Rpb24gYXJndW1lbnQgdG8gaW5kaWNhdGUgdGhhdCB0aGVcbiAqIHN0YXRlIHJlY29yZCBvZiB0aGUgKHZpcnR1YWwvZHVyYWJsZSkgaW5zdGFuY2VzIG9mIHRoZSBraW5kL2V4b0NsYXNzXG4gKiBzaG91bGQgYmUgZW1wdHksIGFuZCB0aGF0IHRoZSByZXR1cm5lZCBtYWtlciBmdW5jdGlvbiBzaG91bGQgaGF2ZSB6ZXJvXG4gKiBwYXJhbWV0ZXJzLlxuICpcbiAqIEByZXR1cm5zIHt7fX1cbiAqL1xuY29uc3QgICAgICAgIGluaXRFbXB0eT0oKT0+ZW1wdHlSZWNvcmQ7XG5cbi8qKlxuICogQHR5cGVkZWYge1hpbXBvcnQoJy4vZXhvLXRvb2xzLmpzJykuRmFjZXROYW1lfSBGYWNldE5hbWVcbiAqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL2V4by10b29scy5qcycpLk1ldGhvZHN9IE1ldGhvZHNcbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBbUyA9IGFueV1cbiAqIEB0ZW1wbGF0ZSB7TWV0aG9kc30gW00gPSBhbnldXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9leG8tdG9vbHMuanMnKS5DbGFzc0NvbnRleHR9IENsYXNzQ29udGV4dFxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFtTID0gYW55XVxuICogQHRlbXBsYXRlIHtSZWNvcmQ8RmFjZXROYW1lLCBNZXRob2RzPn0gW0YgPSBhbnldXG4gKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9leG8tdG9vbHMuanMnKS5LaXRDb250ZXh0fSBLaXRDb250ZXh0XG4gKi9cblxuLyoqXG4gKiBAdHlwZWRlZiB7e1tuYW1lOiBzdHJpbmddOiBYaW1wb3J0KCdAZW5kby9wYXR0ZXJucycpLlBhdHRlcm59fSBTdGF0ZVNoYXBlXG4gKiBJdCBsb29rcyBsaWtlIGEgY29weVJlY29yZCBwYXR0ZXJuLCBidXQgdGhlIGludGVycHJldGF0aW9uIGlzIGRpZmZlcmVudC5cbiAqIEVhY2ggcHJvcGVydHkgaXMgZGlzdGluY3QsIGlzIGNoZWNrZWQgYW5kIGNoYW5nZWQgc2VwYXJhdGVseS5cbiAqL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBDXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBGYXJDbGFzc09wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KGNvbnRleHQ6IEMpID0+IHZvaWR9IFtmaW5pc2hdXG4gKiBAcHJvcGVydHkge1N0YXRlU2hhcGV9IFtzdGF0ZVNoYXBlXVxuICovXG5cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gSSBpbml0IGZ1bmN0aW9uXG4gKiBAdGVtcGxhdGUge01ldGhvZHN9IE0gbWV0aG9kc1xuICogQHBhcmFtIHtzdHJpbmd9IHRhZ1xuICogQHBhcmFtIHthbnl9IGludGVyZmFjZUd1YXJkXG4gKiBAcGFyYW0ge0l9IGluaXRcbiAqIEBwYXJhbSB7TSAmIFRoaXNUeXBlPHsgc2VsZjogTSwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT59IG1ldGhvZHNcbiAqIEBwYXJhbSB7RmFyQ2xhc3NPcHRpb25zPENsYXNzQ29udGV4dDxSZXR1cm5UeXBlPEk+LCBNPj59IFtvcHRpb25zXVxuICogQHJldHVybnMgeyguLi5hcmdzOiBQYXJhbWV0ZXJzPEk+KSA9PiAoTSAmIFhpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDx7fSwgTT4pfVxuICovJGjigI1fb25jZS5pbml0RW1wdHkoaW5pdEVtcHR5KTtcbmNvbnN0ICAgICAgICBkZWZpbmVFeG9DbGFzcz0odGFnLGludGVyZmFjZUd1YXJkLGluaXQsbWV0aG9kcyxvcHRpb25zKT0+e1xuY29uc3R7ZmluaXNoPXVuZGVmaW5lZH09b3B0aW9uc3x8e307XG4vKiogQHR5cGUge1dlYWtNYXA8TSxDbGFzc0NvbnRleHQ8UmV0dXJuVHlwZTxJPiwgTT4+fSAqL1xuY29uc3QgY29udGV4dE1hcD1uZXcgV2Vha01hcCgpO1xuY29uc3QgcHJvdG89ZGVmZW5kUHJvdG90eXBlKFxudGFnLFxuKHNlbGYpPT4vKiogQHR5cGUge2FueX0gKi9jb250ZXh0TWFwLmdldChzZWxmKSxcbm1ldGhvZHMsXG50cnVlLFxuaW50ZXJmYWNlR3VhcmQpO1xuXG5sZXQgaW5zdGFuY2VDb3VudD0wO1xuLyoqXG4gKiBAcGFyYW0gIHtQYXJhbWV0ZXJzPEk+fSBhcmdzXG4gKi9cbmNvbnN0IG1ha2VJbnN0YW5jZT0oLi4uYXJncyk9Pntcbi8qIEJlIGNhcmVmdWwgbm90IHRvIGZyZWV6ZSB0aGUgc3RhdGUgcmVjb3JkKi9cbmNvbnN0IHN0YXRlPXNlYWwoaW5pdCguLi5hcmdzKSk7XG5pbnN0YW5jZUNvdW50Kz0xO1xuLyoqIEB0eXBlIHtNfSAqL1xuY29uc3Qgc2VsZj1tYWtlU2VsZihwcm90byxpbnN0YW5jZUNvdW50KTtcblxuLyogQmUgY2FyZWZ1bCBub3QgdG8gZnJlZXplIHRoZSBzdGF0ZSByZWNvcmQqL1xuLyoqIEB0eXBlIHtDbGFzc0NvbnRleHQ8UmV0dXJuVHlwZTxJPixNPn0gKi9cbmNvbnN0IGNvbnRleHQ9ZnJlZXplKHtzdGF0ZSxzZWxmfSk7XG5jb250ZXh0TWFwLnNldChzZWxmLGNvbnRleHQpO1xuaWYoZmluaXNoKXtcbmZpbmlzaChjb250ZXh0KTtcbiB9XG5yZXR1cm4gKC8qKiBAdHlwZSB7TSAmIFhpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDx7fSwgTT59ICovXG5zZWxmKTtcblxuIH07XG5yZXR1cm4gaGFyZGVuKG1ha2VJbnN0YW5jZSk7XG4gfTskaOKAjV9vbmNlLmRlZmluZUV4b0NsYXNzKGRlZmluZUV4b0NsYXNzKTtcbmhhcmRlbihkZWZpbmVFeG9DbGFzcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHsoLi4uYXJnczogYW55W10pID0+IGFueX0gSSBpbml0IGZ1bmN0aW9uXG4gKiBAdGVtcGxhdGUge1JlY29yZDxGYWNldE5hbWUsIE1ldGhvZHM+fSBGIGZhY2V0IG1ldGhvZHNcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEBwYXJhbSB7YW55fSBpbnRlcmZhY2VHdWFyZEtpdFxuICogQHBhcmFtIHtJfSBpbml0XG4gKiBAcGFyYW0ge0YgJiBUaGlzVHlwZTx7IGZhY2V0czogRiwgc3RhdGU6IFJldHVyblR5cGU8ST4gfT4gfSBtZXRob2RzS2l0XG4gKiBAcGFyYW0ge0ZhckNsYXNzT3B0aW9uczxLaXRDb250ZXh0PFJldHVyblR5cGU8ST4sRj4+fSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHsoLi4uYXJnczogUGFyYW1ldGVyczxJPikgPT4gRn1cbiAqL1xuY29uc3QgICAgICAgIGRlZmluZUV4b0NsYXNzS2l0PShcbnRhZyxcbmludGVyZmFjZUd1YXJkS2l0LFxuaW5pdCxcbm1ldGhvZHNLaXQsXG5vcHRpb25zKT0+XG57XG5jb25zdHtmaW5pc2g9dW5kZWZpbmVkfT1vcHRpb25zfHx7fTtcbmNvbnN0IGNvbnRleHRNYXBLaXQ9b2JqZWN0TWFwKG1ldGhvZHNLaXQsKCk9Pm5ldyBXZWFrTWFwKCkpO1xuY29uc3QgZ2V0Q29udGV4dEtpdD1vYmplY3RNYXAoXG5tZXRob2RzS2l0LFxuKF92LG5hbWUpPT4oZmFjZXQpPT5jb250ZXh0TWFwS2l0W25hbWVdLmdldChmYWNldCkpO1xuXG5jb25zdCBwcm90b3R5cGVLaXQ9ZGVmZW5kUHJvdG90eXBlS2l0KFxudGFnLFxuZ2V0Q29udGV4dEtpdCxcbm1ldGhvZHNLaXQsXG50cnVlLFxuaW50ZXJmYWNlR3VhcmRLaXQpO1xuXG5sZXQgaW5zdGFuY2VDb3VudD0wO1xuLyoqXG4gKiBAcGFyYW0ge1BhcmFtZXRlcnM8ST59IGFyZ3NcbiAqL1xuY29uc3QgbWFrZUluc3RhbmNlS2l0PSguLi5hcmdzKT0+e1xuLyogQmUgY2FyZWZ1bCBub3QgdG8gZnJlZXplIHRoZSBzdGF0ZSByZWNvcmQqL1xuY29uc3Qgc3RhdGU9c2VhbChpbml0KC4uLmFyZ3MpKTtcbi8qIERvbid0IGZyZWV6ZSBjb250ZXh0IHVudGlsIHdlIGFkZCBmYWNldHMqL1xuLyoqIEB0eXBlIHtLaXRDb250ZXh0PFJldHVyblR5cGU8ST4sRj59ICovXG5jb25zdCBjb250ZXh0PXtzdGF0ZSxmYWNldHM6e319O1xuaW5zdGFuY2VDb3VudCs9MTtcbmNvbnN0IGZhY2V0cz1vYmplY3RNYXAocHJvdG90eXBlS2l0LChwcm90byxmYWNldE5hbWUpPT57XG5jb25zdCBzZWxmPW1ha2VTZWxmKHByb3RvLGluc3RhbmNlQ291bnQpO1xuY29udGV4dE1hcEtpdFtmYWNldE5hbWVdLnNldChzZWxmLGNvbnRleHQpO1xucmV0dXJuIHNlbGY7XG4gfSk7XG5jb250ZXh0LmZhY2V0cz1mYWNldHM7XG4vKiBCZSBjYXJlZnVsIG5vdCB0byBmcmVlemUgdGhlIHN0YXRlIHJlY29yZCovXG5mcmVlemUoY29udGV4dCk7XG5pZihmaW5pc2gpe1xuZmluaXNoKGNvbnRleHQpO1xuIH1cbnJldHVybiBjb250ZXh0LmZhY2V0cztcbiB9O1xucmV0dXJuIGhhcmRlbihtYWtlSW5zdGFuY2VLaXQpO1xuIH07JGjigI1fb25jZS5kZWZpbmVFeG9DbGFzc0tpdChkZWZpbmVFeG9DbGFzc0tpdCk7XG5oYXJkZW4oZGVmaW5lRXhvQ2xhc3NLaXQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7TWV0aG9kc30gVFxuICogQHBhcmFtIHtzdHJpbmd9IHRhZ1xuICogQHBhcmFtIHtYaW1wb3J0KCdAZW5kby9wYXR0ZXJucycpLkludGVyZmFjZUd1YXJkIHwgdW5kZWZpbmVkfSBpbnRlcmZhY2VHdWFyZCBDQVZFQVQ6IHN0YXRpYyB0eXBpbmcgZG9lcyBub3QgeWV0IHN1cHBvcnQgYGNhbGxXaGVuYCB0cmFuc2Zvcm1hdGlvblxuICogQHBhcmFtIHtUfSBtZXRob2RzXG4gKiBAcGFyYW0ge0ZhckNsYXNzT3B0aW9uczxDbGFzc0NvbnRleHQ8e30sVD4+fSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHtUICYgWGltcG9ydCgnQGVuZG8vZXZlbnR1YWwtc2VuZCcpLlJlbW90YWJsZUJyYW5kPHt9LCBUPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VFeG89KHRhZyxpbnRlcmZhY2VHdWFyZCxtZXRob2RzLG9wdGlvbnM9dW5kZWZpbmVkKT0+e1xuY29uc3QgbWFrZUluc3RhbmNlPWRlZmluZUV4b0NsYXNzKFxudGFnLFxuaW50ZXJmYWNlR3VhcmQsXG5pbml0RW1wdHksXG5tZXRob2RzLFxub3B0aW9ucyk7XG5cbnJldHVybiBtYWtlSW5zdGFuY2UoKTtcbiB9OyRo4oCNX29uY2UubWFrZUV4byhtYWtlRXhvKTtcbmhhcmRlbihtYWtlRXhvKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJpbml0RW1wdHkiOlsiaW5pdEVtcHR5Il0sImRlZmluZUV4b0NsYXNzIjpbImRlZmluZUV4b0NsYXNzIl0sImRlZmluZUV4b0NsYXNzS2l0IjpbImRlZmluZUV4b0NsYXNzS2l0Il0sIm1ha2VFeG8iOlsibWFrZUV4byJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAxsK3ycSYAAHEmAAAhAAAAQGVuZG8vZXhvLXYwLjIuMi9zcmMvZXhvLXRvb2xzLmpzeyJpbXBvcnRzIjpbIkBlbmRvL2ZhciIsIkBlbmRvL3BhdHRlcm5zIl0sImV4cG9ydHMiOlsiZGVmZW5kUHJvdG90eXBlIiwiZGVmZW5kUHJvdG90eXBlS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsRmFyLGxpc3REaWZmZXJlbmNlLG9iamVjdE1hcCxtdXN0TWF0Y2gsTTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9mYXJcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3BhdHRlcm5zXCIsIFtbXCJsaXN0RGlmZmVyZW5jZVwiLCBbJGjigI1fYSA9PiAobGlzdERpZmZlcmVuY2UgPSAkaOKAjV9hKV1dLFtcIm9iamVjdE1hcFwiLCBbJGjigI1fYSA9PiAob2JqZWN0TWFwID0gJGjigI1fYSldXSxbXCJtdXN0TWF0Y2hcIiwgWyRo4oCNX2EgPT4gKG11c3RNYXRjaCA9ICRo4oCNX2EpXV0sW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGF0dGVybnMnKS5NZXRob2R9IE1ldGhvZCAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXR0ZXJucycpLk1ldGhvZEd1YXJkfSBNZXRob2RHdWFyZCAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXR0ZXJucycpLkludGVyZmFjZUd1YXJkfSBJbnRlcmZhY2VHdWFyZCAqL1xuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcbmNvbnN0e2FwcGx5LG93bktleXN9PVJlZmxlY3Q7XG5jb25zdHtkZWZpbmVQcm9wZXJ0aWVzfT1PYmplY3Q7XG5cbi8qKlxuICogQSBtZXRob2QgZ3VhcmQsIGZvciBpbmNsdXNpb24gaW4gYW4gaW50ZXJmYWNlIGd1YXJkLCB0aGF0IGVuZm9yY2VzIG9ubHkgdGhhdFxuICogYWxsIGFyZ3VtZW50cyBhcmUgcGFzc2FibGUgYW5kIHRoYXQgdGhlIHJlc3VsdCBpcyBwYXNzYWJsZS4gKEluIGZhciBjbGFzc2VzLFxuICogXCJhbnlcIiBtZWFucyBhbnkgKnBhc3NhYmxlKi4pIFRoaXMgaXMgdGhlIGxlYXN0IHBvc3NpYmxlIGVuZm9yY2VtZW50IGZvciBhXG4gKiBtZXRob2QgZ3VhcmQsIGFuZCBpcyBpbXBsaWVkIGJ5IGFsbCBvdGhlciBtZXRob2QgZ3VhcmRzLlxuICovXG5jb25zdCBNaW5NZXRob2RHdWFyZD1NLmNhbGwoKS5yZXN0KE0uYW55KCkpLnJldHVybnMoTS5hbnkoKSk7XG5cbmNvbnN0IGRlZmVuZFN5bmNBcmdzPShhcmdzLG1ldGhvZEd1YXJkLGxhYmVsKT0+e1xuY29uc3R7YXJnR3VhcmRzLG9wdGlvbmFsQXJnR3VhcmRzLHJlc3RBcmdHdWFyZH09bWV0aG9kR3VhcmQ7XG5jb25zdCBwYXJhbXNQYXR0ZXJuPU0uc3BsaXRBcnJheShcbmFyZ0d1YXJkcyxcbm9wdGlvbmFsQXJnR3VhcmRzLFxucmVzdEFyZ0d1YXJkKTtcblxubXVzdE1hdGNoKGhhcmRlbihhcmdzKSxwYXJhbXNQYXR0ZXJuLGxhYmVsKTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7TWV0aG9kfSBtZXRob2RcbiAqIEBwYXJhbSB7TWV0aG9kR3VhcmR9IG1ldGhvZEd1YXJkXG4gKiBAcGFyYW0ge3N0cmluZ30gbGFiZWxcbiAqIEByZXR1cm5zIHtNZXRob2R9XG4gKi9cbmNvbnN0IGRlZmVuZFN5bmNNZXRob2Q9KG1ldGhvZCxtZXRob2RHdWFyZCxsYWJlbCk9PntcbmNvbnN0e3JldHVybkd1YXJkfT1tZXRob2RHdWFyZDtcbmNvbnN0e3N5bmNNZXRob2R9PXtcbi8qIE5vdGUgcHVycG9zZWZ1bCB1c2Ugb2YgYHRoaXNgIGFuZCBjb25jaXNlIG1ldGhvZCBzeW50YXgqL1xuc3luY01ldGhvZCguLi5hcmdzKXtcbmRlZmVuZFN5bmNBcmdzKGhhcmRlbihhcmdzKSxtZXRob2RHdWFyZCxsYWJlbCk7XG5jb25zdCByZXN1bHQ9YXBwbHkobWV0aG9kLHRoaXMsYXJncyk7XG5tdXN0TWF0Y2goaGFyZGVuKHJlc3VsdCkscmV0dXJuR3VhcmQsIGAke2xhYmVsfTogcmVzdWx0YCk7XG5yZXR1cm4gcmVzdWx0O1xuIH19O1xuXG5yZXR1cm4gc3luY01ldGhvZDtcbiB9O1xuXG5jb25zdCBpc0F3YWl0QXJnR3VhcmQ9KGFyZ0d1YXJkKT0+XG5hcmdHdWFyZCYmdHlwZW9mIGFyZ0d1YXJkPT09J29iamVjdCcmJmFyZ0d1YXJkLmtsYXNzPT09J2F3YWl0QXJnJztcblxuY29uc3QgZGVzeW5jPShtZXRob2RHdWFyZCk9PntcbmNvbnN0e2FyZ0d1YXJkcyxvcHRpb25hbEFyZ0d1YXJkcz1bXSxyZXN0QXJnR3VhcmR9PW1ldGhvZEd1YXJkO1xuIWlzQXdhaXRBcmdHdWFyZChyZXN0QXJnR3VhcmQpfHxcbkZhaWwgYFJlc3QgYXJncyBtYXkgbm90IGJlIGF3YWl0ZWQ6ICR7cmVzdEFyZ0d1YXJkfWA7XG5jb25zdCByYXdBcmdHdWFyZHM9Wy4uLmFyZ0d1YXJkcywuLi5vcHRpb25hbEFyZ0d1YXJkc107XG5cbmNvbnN0IGF3YWl0SW5kZXhlcz1bXTtcbmZvcihsZXQgaT0wO2k8cmF3QXJnR3VhcmRzLmxlbmd0aDtpKz0xKXtcbmNvbnN0IGFyZ0d1YXJkPXJhd0FyZ0d1YXJkc1tpXTtcbmlmKGlzQXdhaXRBcmdHdWFyZChhcmdHdWFyZCkpe1xucmF3QXJnR3VhcmRzW2ldPWFyZ0d1YXJkLmFyZ0d1YXJkO1xuYXdhaXRJbmRleGVzLnB1c2goaSk7XG4gfVxuIH1cbnJldHVybntcbmF3YWl0SW5kZXhlcyxcbnJhd01ldGhvZEd1YXJkOntcbmFyZ0d1YXJkczpyYXdBcmdHdWFyZHMuc2xpY2UoMCxhcmdHdWFyZHMubGVuZ3RoKSxcbm9wdGlvbmFsQXJnR3VhcmRzOnJhd0FyZ0d1YXJkcy5zbGljZShhcmdHdWFyZHMubGVuZ3RoKSxcbnJlc3RBcmdHdWFyZH19O1xuXG5cbiB9O1xuXG5jb25zdCBkZWZlbmRBc3luY01ldGhvZD0obWV0aG9kLG1ldGhvZEd1YXJkLGxhYmVsKT0+e1xuY29uc3R7cmV0dXJuR3VhcmR9PW1ldGhvZEd1YXJkO1xuY29uc3R7YXdhaXRJbmRleGVzLHJhd01ldGhvZEd1YXJkfT1kZXN5bmMobWV0aG9kR3VhcmQpO1xuY29uc3R7YXN5bmNNZXRob2R9PXtcbi8qIE5vdGUgcHVycG9zZWZ1bCB1c2Ugb2YgYHRoaXNgIGFuZCBjb25jaXNlIG1ldGhvZCBzeW50YXgqL1xuYXN5bmNNZXRob2QoLi4uYXJncyl7XG5jb25zdCBhd2FpdExpc3Q9YXdhaXRJbmRleGVzLm1hcCgoaSk9PmFyZ3NbaV0pO1xuY29uc3QgcD1Qcm9taXNlLmFsbChhd2FpdExpc3QpO1xuY29uc3QgcmF3QXJncz1bLi4uYXJnc107XG5jb25zdCByZXN1bHRQPUUud2hlbihwLChhd2FpdGVkQXJncyk9PntcbmZvcihsZXQgaj0wO2o8YXdhaXRJbmRleGVzLmxlbmd0aDtqKz0xKXtcbnJhd0FyZ3NbYXdhaXRJbmRleGVzW2pdXT1hd2FpdGVkQXJnc1tqXTtcbiB9XG5kZWZlbmRTeW5jQXJncyhyYXdBcmdzLHJhd01ldGhvZEd1YXJkLGxhYmVsKTtcbnJldHVybiBhcHBseShtZXRob2QsdGhpcyxyYXdBcmdzKTtcbiB9KTtcbnJldHVybiBFLndoZW4ocmVzdWx0UCwocmVzdWx0KT0+e1xubXVzdE1hdGNoKGhhcmRlbihyZXN1bHQpLHJldHVybkd1YXJkLCBgJHtsYWJlbH06IHJlc3VsdGApO1xucmV0dXJuIHJlc3VsdDtcbiB9KTtcbiB9fTtcblxucmV0dXJuIGFzeW5jTWV0aG9kO1xuIH07XG5cbi8qKlxuICpcbiAqIEBwYXJhbSB7TWV0aG9kfSBtZXRob2RcbiAqIEBwYXJhbSB7TWV0aG9kR3VhcmR9IG1ldGhvZEd1YXJkXG4gKiBAcGFyYW0ge3N0cmluZ30gbGFiZWxcbiAqL1xuY29uc3QgZGVmZW5kTWV0aG9kPShtZXRob2QsbWV0aG9kR3VhcmQsbGFiZWwpPT57XG5jb25zdHtrbGFzcyxjYWxsS2luZH09bWV0aG9kR3VhcmQ7XG5hc3NlcnQoa2xhc3M9PT0nbWV0aG9kR3VhcmQnKTtcbmlmKGNhbGxLaW5kPT09J3N5bmMnKXtcbnJldHVybiBkZWZlbmRTeW5jTWV0aG9kKG1ldGhvZCxtZXRob2RHdWFyZCxsYWJlbCk7XG4gfWVsc2V7XG5hc3NlcnQoY2FsbEtpbmQ9PT0nYXN5bmMnKTtcbnJldHVybiBkZWZlbmRBc3luY01ldGhvZChtZXRob2QsbWV0aG9kR3VhcmQsbGFiZWwpO1xuIH1cbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtzdHJpbmd9IEZhY2V0TmFtZVxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge1JlY29yZDxzdHJpbmcgfCBzeW1ib2wsIENhbGxhYmxlRnVuY3Rpb24+fSBNZXRob2RzXG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1MgPSBhbnldXG4gKiBAdGVtcGxhdGUge01ldGhvZHN9IFtNID0gYW55XVxuICogQHR5cGVkZWYge3sgc3RhdGU6IFMsIHNlbGY6IE0gfX0gQ2xhc3NDb250ZXh0XG4gKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgW1MgPSBhbnldXG4gKiBAdGVtcGxhdGUge1JlY29yZDxGYWNldE5hbWUsIE1ldGhvZHM+fSBbRiA9IGFueV1cbiAqIEB0eXBlZGVmIHt7IHN0YXRlOiBTLCBmYWNldHM6IEYgfX0gS2l0Q29udGV4dFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYgeyhmYWNldDogYW55KSA9PiBLaXRDb250ZXh0fSBLaXRDb250ZXh0UHJvdmlkZXJcbiAqIEB0eXBlZGVmIHsoKHJlcHJlc2VudGF0aXZlOiBhbnkpID0+IENsYXNzQ29udGV4dCkgfCBLaXRDb250ZXh0UHJvdmlkZXJ9IENvbnRleHRQcm92aWRlclxuICovXG5cbi8qKlxuICogQHBhcmFtIHtzdHJpbmd9IG1ldGhvZFRhZ1xuICogQHBhcmFtIHtDb250ZXh0UHJvdmlkZXJ9IGNvbnRleHRQcm92aWRlclxuICogQHBhcmFtIHtDYWxsYWJsZUZ1bmN0aW9ufSBiZWhhdmlvck1ldGhvZFxuICogQHBhcmFtIHtib29sZWFufSBbdGhpc2Z1bE1ldGhvZHNdXG4gKiBAcGFyYW0ge01ldGhvZEd1YXJkfSBbbWV0aG9kR3VhcmRdXG4gKi9cbmNvbnN0IGJpbmRNZXRob2Q9KFxubWV0aG9kVGFnLFxuY29udGV4dFByb3ZpZGVyLFxuYmVoYXZpb3JNZXRob2QsXG50aGlzZnVsTWV0aG9kcz1mYWxzZSxcbm1ldGhvZEd1YXJkPXVuZGVmaW5lZCk9Plxue1xuYXNzZXJ0LnR5cGVvZihiZWhhdmlvck1ldGhvZCwnZnVuY3Rpb24nKTtcblxuY29uc3QgZ2V0Q29udGV4dD0oc2VsZik9PntcbmNvbnN0IGNvbnRleHQ9Y29udGV4dFByb3ZpZGVyKHNlbGYpO1xuY29udGV4dHx8XG5GYWlsIGAke3EobWV0aG9kVGFnKX0gbWF5IG9ubHkgYmUgYXBwbGllZCB0byBhIHZhbGlkIGluc3RhbmNlOiAke3NlbGZ9YDtcbnJldHVybiBjb250ZXh0O1xuIH07XG5cbi8qIFZpb2xhdGluZyBhbGwgSmVzc2llIHJ1bGVzIHRvIGNyZWF0ZSByZXByZXNlbnRhdGl2ZXMgdGhhdCBpbmhlcml0Ki9cbi8qIG1ldGhvZHMgZnJvbSBhIHNoYXJlZCBwcm90b3R5cGUuIFRoZSBib3VuZCBtZXRob2QgdGhlcmVmb3JlIG5lZWRzKi9cbi8qIHRvIG1lbnRpb24gYHRoaXNgLiBXZSBkZWZpbmUgaXQgdXNpbmcgY29uY2lzZSBtZXRob2Qgc3ludGF4Ki9cbi8qIHNvIHRoYXQgaXQgd2lsbCBiZSBgdGhpc2Agc2Vuc2l0aXZlIGJ1dCBub3QgY29uc3RydWN0YWJsZS4qL1xuLyoqL1xuLyogV2Ugbm9ybWFsbHkgY29uc2lkZXIgYHRoaXNgIHVuc2FmZSBiZWNhdXNlIG9mIHRoZSBoYXphcmQgb2YgYSovXG4vKiBtZXRob2Qgb2Ygb25lIGFic3RyYWN0aW9uIGJlaW5nIGFwcGxpZWQgdG8gYW4gaW5zdGFuY2Ugb2YqL1xuLyogYW5vdGhlciBhYnN0cmFjdGlvbi4gVG8gcHJldmVudCB0aGF0IGF0dGFjaywgdGhlIGJvdW5kIG1ldGhvZCovXG4vKiBjaGVja3MgdGhhdCBpdHMgYHRoaXNgIGlzIGluIHRoZSBtYXAgaW4gd2hpY2ggaXRzIHJlcHJlc2VudGF0aXZlcyovXG4vKiBhcmUgcmVnaXN0ZXJlZC4qL1xubGV0e21ldGhvZH09dGhpc2Z1bE1ldGhvZHM/XG57XG5tZXRob2QoLi4uYXJncyl7XG50aGlzfHxcbkZhaWwgYHRoaXNmdWwgbWV0aG9kICR7bWV0aG9kVGFnfSBjYWxsZWQgd2l0aG91dCAndGhpcycgb2JqZWN0YDtcbmNvbnN0IGNvbnRleHQ9Z2V0Q29udGV4dCh0aGlzKTtcbnJldHVybiBhcHBseShiZWhhdmlvck1ldGhvZCxjb250ZXh0LGFyZ3MpO1xuIH19OlxuXG57XG5tZXRob2QoLi4uYXJncyl7XG5jb25zdCBjb250ZXh0PWdldENvbnRleHQodGhpcyk7XG5yZXR1cm4gYXBwbHkoYmVoYXZpb3JNZXRob2QsbnVsbCxbY29udGV4dCwuLi5hcmdzXSk7XG4gfX07XG5cbmlmKG1ldGhvZEd1YXJkKXtcbm1ldGhvZD1kZWZlbmRNZXRob2QobWV0aG9kLG1ldGhvZEd1YXJkLG1ldGhvZFRhZyk7XG4gfWVsc2UgaWYodGhpc2Z1bE1ldGhvZHMpe1xuLyogRm9yIGZhciBjbGFzc2VzIGVuc3VyZSB0aGF0IGlucHV0cyBhbmQgb3V0cHV0cyBhcmUgcGFzc2FibGUuKi9cbm1ldGhvZD1kZWZlbmRNZXRob2QobWV0aG9kLE1pbk1ldGhvZEd1YXJkLG1ldGhvZFRhZyk7XG4gfVxuZGVmaW5lUHJvcGVydGllcyhtZXRob2Qse1xubmFtZTp7dmFsdWU6bWV0aG9kVGFnfSxcbmxlbmd0aDp7XG52YWx1ZTp0aGlzZnVsTWV0aG9kcz9iZWhhdmlvck1ldGhvZC5sZW5ndGg6YmVoYXZpb3JNZXRob2QubGVuZ3RoLTF9fSk7XG5cblxucmV0dXJuIG1ldGhvZDtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7UmVjb3JkPHN0cmluZyB8IHN5bWJvbCwgQ2FsbGFibGVGdW5jdGlvbj59IFRcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEBwYXJhbSB7Q29udGV4dFByb3ZpZGVyfSBjb250ZXh0UHJvdmlkZXJcbiAqIEBwYXJhbSB7VH0gYmVoYXZpb3JNZXRob2RzXG4gKiBAcGFyYW0ge2Jvb2xlYW59IFt0aGlzZnVsTWV0aG9kc11cbiAqIEBwYXJhbSB7SW50ZXJmYWNlR3VhcmR9IFtpbnRlcmZhY2VHdWFyZF1cbiAqIEByZXR1cm5zIHtUICYgWGltcG9ydCgnQGVuZG8vZXZlbnR1YWwtc2VuZCcpLlJlbW90YWJsZUJyYW5kPHt9LCBUPn1cbiAqL1xuY29uc3QgICAgICAgIGRlZmVuZFByb3RvdHlwZT0oXG50YWcsXG5jb250ZXh0UHJvdmlkZXIsXG5iZWhhdmlvck1ldGhvZHMsXG50aGlzZnVsTWV0aG9kcz1mYWxzZSxcbmludGVyZmFjZUd1YXJkPXVuZGVmaW5lZCk9Plxue1xuY29uc3QgcHJvdG90eXBlPXt9O1xuY29uc3QgbWV0aG9kTmFtZXM9b3duS2V5cyhiZWhhdmlvck1ldGhvZHMpLmZpbHRlcihcbi8qIEJ5IGlnbm9yaW5nIGFueSBtZXRob2QgbmFtZWQgXCJjb25zdHJ1Y3RvclwiLCB3ZSBjYW4gdXNlIGEqL1xuLyogY2xhc3MucHJvdG90eXBlIGFzIGEgYmVoYXZpb3JNZXRob2RzLiovXG4obmFtZSk9Pm5hbWUhPT0nY29uc3RydWN0b3InKTtcblxubGV0IG1ldGhvZEd1YXJkcztcbmlmKGludGVyZmFjZUd1YXJkKXtcbmNvbnN0e1xua2xhc3MsXG5pbnRlcmZhY2VOYW1lLFxubWV0aG9kR3VhcmRzOm1nLFxuc2xvcHB5PWZhbHNlfT1cbmludGVyZmFjZUd1YXJkO1xubWV0aG9kR3VhcmRzPW1nO1xuYXNzZXJ0LmVxdWFsKGtsYXNzLCdJbnRlcmZhY2UnKTtcbmFzc2VydC50eXBlb2YoaW50ZXJmYWNlTmFtZSwnc3RyaW5nJyk7XG57XG5jb25zdCBtZXRob2RHdWFyZE5hbWVzPW93bktleXMobWV0aG9kR3VhcmRzKTtcbmNvbnN0IHVuaW1wbGVtZW50ZWQ9bGlzdERpZmZlcmVuY2UobWV0aG9kR3VhcmROYW1lcyxtZXRob2ROYW1lcyk7XG51bmltcGxlbWVudGVkLmxlbmd0aD09PTB8fFxuRmFpbCBgbWV0aG9kcyAke3EodW5pbXBsZW1lbnRlZCl9IG5vdCBpbXBsZW1lbnRlZCBieSAke3EodGFnKX1gO1xuaWYoIXNsb3BweSl7XG5jb25zdCB1bmd1YXJkZWQ9bGlzdERpZmZlcmVuY2UobWV0aG9kTmFtZXMsbWV0aG9kR3VhcmROYW1lcyk7XG51bmd1YXJkZWQubGVuZ3RoPT09MHx8XG5GYWlsIGBtZXRob2RzICR7cSh1bmd1YXJkZWQpfSBub3QgZ3VhcmRlZCBieSAke3EoaW50ZXJmYWNlTmFtZSl9YDtcbiB9XG4gfVxuIH1cbmZvcihjb25zdCBwcm9wIG9mIG1ldGhvZE5hbWVzKXtcbnByb3RvdHlwZVtwcm9wXT1iaW5kTWV0aG9kKFxuIGBJbiAke3EocHJvcCl9IG1ldGhvZCBvZiAoJHt0YWd9KWAsXG5jb250ZXh0UHJvdmlkZXIsXG5iZWhhdmlvck1ldGhvZHNbcHJvcF0sXG50aGlzZnVsTWV0aG9kcyxcbi8qIFRPRE8gc29tZSB0b29sIGRvZXMgbm90IHlldCB1bmRlcnN0YW5kIHRoZSBgPy5bYCBzeW50YXgqL1xubWV0aG9kR3VhcmRzJiZtZXRob2RHdWFyZHNbcHJvcF0pO1xuXG4gfVxuXG5yZXR1cm4gRmFyKHRhZywvKiogQHR5cGUge1R9ICovcHJvdG90eXBlKTtcbiB9OyRo4oCNX29uY2UuZGVmZW5kUHJvdG90eXBlKGRlZmVuZFByb3RvdHlwZSk7XG5oYXJkZW4oZGVmZW5kUHJvdG90eXBlKTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gdGFnXG4gKiBAcGFyYW0ge1JlY29yZDxGYWNldE5hbWUsIEtpdENvbnRleHRQcm92aWRlcj59IGNvbnRleHRQcm92aWRlcktpdFxuICogQHBhcmFtIHtSZWNvcmQ8RmFjZXROYW1lLCBSZWNvcmQ8c3RyaW5nIHwgc3ltYm9sLCBDYWxsYWJsZUZ1bmN0aW9uPj59IGJlaGF2aW9yTWV0aG9kc0tpdFxuICogQHBhcmFtIHtib29sZWFufSBbdGhpc2Z1bE1ldGhvZHNdXG4gKiBAcGFyYW0ge1JlY29yZDxzdHJpbmcsIEludGVyZmFjZUd1YXJkPn0gW2ludGVyZmFjZUd1YXJkS2l0XVxuICovXG5jb25zdCAgICAgICAgZGVmZW5kUHJvdG90eXBlS2l0PShcbnRhZyxcbmNvbnRleHRQcm92aWRlcktpdCxcbmJlaGF2aW9yTWV0aG9kc0tpdCxcbnRoaXNmdWxNZXRob2RzPWZhbHNlLFxuaW50ZXJmYWNlR3VhcmRLaXQ9dW5kZWZpbmVkKT0+XG57XG5jb25zdCBmYWNldE5hbWVzPW93bktleXMoYmVoYXZpb3JNZXRob2RzS2l0KS5zb3J0KCk7XG5mYWNldE5hbWVzLmxlbmd0aD4xfHxGYWlsIGBBIG11bHRpLWZhY2V0IG9iamVjdCBtdXN0IGhhdmUgbXVsdGlwbGUgZmFjZXRzYDtcbmlmKGludGVyZmFjZUd1YXJkS2l0KXtcbmNvbnN0IGludGVyZmFjZU5hbWVzPW93bktleXMoaW50ZXJmYWNlR3VhcmRLaXQpO1xuY29uc3QgZXh0cmFJbnRlcmZhY2VOYW1lcz1saXN0RGlmZmVyZW5jZShmYWNldE5hbWVzLGludGVyZmFjZU5hbWVzKTtcbmV4dHJhSW50ZXJmYWNlTmFtZXMubGVuZ3RoPT09MHx8XG5GYWlsIGBJbnRlcmZhY2VzICR7cShleHRyYUludGVyZmFjZU5hbWVzKX0gbm90IGltcGxlbWVudGVkIGJ5ICR7cSh0YWcpfWA7XG5jb25zdCBleHRyYUZhY2V0TmFtZXM9bGlzdERpZmZlcmVuY2UoaW50ZXJmYWNlTmFtZXMsZmFjZXROYW1lcyk7XG5leHRyYUZhY2V0TmFtZXMubGVuZ3RoPT09MHx8XG5GYWlsIGBGYWNldHMgJHtxKGV4dHJhRmFjZXROYW1lcyl9IG9mICR7cSh0YWcpfSBub3QgZ3VhcmRlZCBieSBpbnRlcmZhY2VzYDtcbiB9XG5jb25zdCBjb250ZXh0TWFwTmFtZXM9b3duS2V5cyhjb250ZXh0UHJvdmlkZXJLaXQpO1xuY29uc3QgZXh0cmFDb250ZXh0TmFtZXM9bGlzdERpZmZlcmVuY2UoZmFjZXROYW1lcyxjb250ZXh0TWFwTmFtZXMpO1xuZXh0cmFDb250ZXh0TmFtZXMubGVuZ3RoPT09MHx8XG5GYWlsIGBDb250ZXh0cyAke3EoZXh0cmFDb250ZXh0TmFtZXMpfSBub3QgaW1wbGVtZW50ZWQgYnkgJHtxKHRhZyl9YDtcbmNvbnN0IGV4dHJhRmFjZXROYW1lcz1saXN0RGlmZmVyZW5jZShjb250ZXh0TWFwTmFtZXMsZmFjZXROYW1lcyk7XG5leHRyYUZhY2V0TmFtZXMubGVuZ3RoPT09MHx8XG5GYWlsIGBGYWNldHMgJHtxKGV4dHJhRmFjZXROYW1lcyl9IG9mICR7cSh0YWcpfSBtaXNzaW5nIGNvbnRleHRzYDtcbnJldHVybiBvYmplY3RNYXAoYmVoYXZpb3JNZXRob2RzS2l0LChiZWhhdmlvck1ldGhvZHMsZmFjZXROYW1lKT0+XG5kZWZlbmRQcm90b3R5cGUoXG4gYCR7dGFnfSAke2ZhY2V0TmFtZX1gLFxuY29udGV4dFByb3ZpZGVyS2l0W2ZhY2V0TmFtZV0sXG5iZWhhdmlvck1ldGhvZHMsXG50aGlzZnVsTWV0aG9kcyxcbmludGVyZmFjZUd1YXJkS2l0JiZpbnRlcmZhY2VHdWFyZEtpdFtmYWNldE5hbWVdKSk7XG5cblxuIH07JGjigI1fb25jZS5kZWZlbmRQcm90b3R5cGVLaXQoZGVmZW5kUHJvdG90eXBlS2l0KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJkZWZlbmRQcm90b3R5cGUiOlsiZGVmZW5kUHJvdG90eXBlIl0sImRlZmVuZFByb3RvdHlwZUtpdCI6WyJkZWZlbmRQcm90b3R5cGVLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAQQwzlEACAABAAgAAHgAAAEBlbmRvL2Zhci12MC4yLjE4L3NyYy9pbmRleC5qc3siaW1wb3J0cyI6WyJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbImdldEludGVyZmFjZU9mIiwiZ2V0SW50ZXJmYWNlT2YiLG51bGxdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW11dLFtcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiQGVuZG8vZXZlbnR1YWwtc2VuZCI6W1siRSIsIkUiXV0sIkBlbmRvL3Bhc3Mtc3R5bGUiOltbIkZhciIsIkZhciJdLFsiZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdLFsicGFzc1N0eWxlT2YiLCJwYXNzU3R5bGVPZiJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAQQwzlEACAABAAgAAHgAAAEBlbmRvL2Zhci12MC4yLjIyL3NyYy9pbmRleC5qc3siaW1wb3J0cyI6WyJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vcGFzcy1zdHlsZSJdLCJleHBvcnRzIjpbImdldEludGVyZmFjZU9mIiwiZ2V0SW50ZXJmYWNlT2YiLG51bGxdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW11dLFtcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiQGVuZG8vZXZlbnR1YWwtc2VuZCI6W1siRSIsIkUiXV0sIkBlbmRvL3Bhc3Mtc3R5bGUiOltbIkZhciIsIkZhciJdLFsiZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdLFsicGFzc1N0eWxlT2YiLCJwYXNzU3R5bGVPZiJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAApY8690oHAABKBwAAHQAAAEBlbmRvL21hcnNoYWwtdjAuOC41L2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2RlZXBseUZ1bGZpbGxlZC5qcyIsIi4vc3JjL2VuY29kZVBhc3NhYmxlLmpzIiwiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9zcmMvbWFyc2hhbC1qdXN0aW4uanMiLCIuL3NyYy9tYXJzaGFsLXN0cmluZ2lmeS5qcyIsIi4vc3JjL21hcnNoYWwuanMiLCIuL3NyYy9yYW5rT3JkZXIuanMiLCIuL3NyYy90eXBlcy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiZXhwb3J0cyI6WyJjb21wYXJlUmFuayIsImNvbXBhcmVSYW5rIiwibWFrZURlY29kZVBhc3NhYmxlIiwibWFrZURlY29kZVBhc3NhYmxlIiwicGFyc2UiLCJwYXJzZSIsbnVsbCxudWxsLG51bGwsbnVsbF0sInJlZXhwb3J0cyI6WyIuL3NyYy90eXBlcy5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanNcIiwgW11dLFtcIi4vc3JjL2VuY29kZVRvQ2FwRGF0YS5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC5qc1wiLCBbXV0sW1wiLi9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanNcIiwgW11dLFtcIi4vc3JjL21hcnNoYWwtanVzdGluLmpzXCIsIFtdXSxbXCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qc1wiLCBbXV0sW1wiLi9zcmMvcmFua09yZGVyLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV0sW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6eyIuL3NyYy9kZWVwbHlGdWxmaWxsZWQuanMiOltbImRlZXBseUZ1bGZpbGxlZCIsImRlZXBseUZ1bGZpbGxlZCJdXSwiLi9zcmMvZW5jb2RlVG9DYXBEYXRhLmpzIjpbWyJRQ0xBU1MiLCJRQ0xBU1MiXV0sIi4vc3JjL21hcnNoYWwuanMiOltbIm1ha2VNYXJzaGFsIiwibWFrZU1hcnNoYWwiXV0sIi4vc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzIjpbWyJzdHJpbmdpZnkiLCJzdHJpbmdpZnkiXSxbInBhcnNlIiwicGFyc2UiXV0sIi4vc3JjL21hcnNoYWwtanVzdGluLmpzIjpbWyJkZWNvZGVUb0p1c3RpbiIsImRlY29kZVRvSnVzdGluIl1dLCIuL3NyYy9lbmNvZGVQYXNzYWJsZS5qcyI6W1sibWFrZUVuY29kZVBhc3NhYmxlIiwibWFrZUVuY29kZVBhc3NhYmxlIl0sWyJtYWtlRGVjb2RlUGFzc2FibGUiLCJtYWtlRGVjb2RlUGFzc2FibGUiXSxbImlzRW5jb2RlZFJlbW90YWJsZSIsImlzRW5jb2RlZFJlbW90YWJsZSJdLFsiemVyb1BhZCIsInplcm9QYWQiXSxbInJlY29yZE5hbWVzIiwicmVjb3JkTmFtZXMiXSxbInJlY29yZFZhbHVlcyIsInJlY29yZFZhbHVlcyJdXSwiLi9zcmMvcmFua09yZGVyLmpzIjpbWyJhc3NlcnRSYW5rU29ydGVkIiwiYXNzZXJ0UmFua1NvcnRlZCJdLFsiY29tcGFyZVJhbmsiLCJjb21wYXJlUmFuayJdLFsiaXNSYW5rU29ydGVkIiwiaXNSYW5rU29ydGVkIl0sWyJzb3J0QnlSYW5rIiwic29ydEJ5UmFuayJdLFsiY29tcGFyZUFudGlSYW5rIiwiY29tcGFyZUFudGlSYW5rIl0sWyJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsIm1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0Il0sWyJnZXRQYXNzU3R5bGVDb3ZlciIsImdldFBhc3NTdHlsZUNvdmVyIl0sWyJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaW50ZXJzZWN0UmFua0NvdmVycyJdLFsidW5pb25SYW5rQ292ZXJzIiwidW5pb25SYW5rQ292ZXJzIl1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAANCCZ7lA0AAJQNAAArAAAAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL2RlZXBseUZ1bGZpbGxlZC5qc3siaW1wb3J0cyI6WyJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vcGFzcy1zdHlsZSIsIkBlbmRvL3Byb21pc2Uta2l0Il0sImV4cG9ydHMiOlsiZGVlcGx5RnVsZmlsbGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsaXNQcm9taXNlLGdldFRhZyxpc09iamVjdCxtYWtlVGFnZ2VkLHBhc3NTdHlsZU9mOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcImdldFRhZ1wiLCBbJGjigI1fYSA9PiAoZ2V0VGFnID0gJGjigI1fYSldXSxbXCJpc09iamVjdFwiLCBbJGjigI1fYSA9PiAoaXNPYmplY3QgPSAkaOKAjV9hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRo4oCNX2EgPT4gKG1ha2VUYWdnZWQgPSAkaOKAjV9hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9ldmVudHVhbC1zZW5kJykuRVJlZjxUPn0gRVJlZiAqL1xuXG5jb25zdHtkZXRhaWxzOlgscXVvdGU6cX09YXNzZXJ0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2Zyb21FbnRyaWVzfT1PYmplY3Q7XG5cbi8qKlxuICogR2l2ZW4gYSBQYXNzYWJsZSBgdmFsYCB3aG9zZSBwYXNzLWJ5LWNvcHkgc3RydWN0dXJlIG1heSBjb250YWluIGxlYWZcbiAqIHByb21pc2VzLCByZXR1cm4gYSBwcm9taXNlIGZvciBhIHJlcGxhY2VtZW50IFBhc3NhYmxlLFxuICogd2hlcmUgdGhhdCByZXBsYWNlbWVudCBpcyAqZGVlcGx5IGZ1bGZpbGxlZCosIGkuZS4sIGl0c1xuICogcGFzcy1ieS1jb3B5IHN0cnVjdHVyZSBkb2VzIG5vdCBjb250YWluIGFueSBwcm9taXNlcy5cbiAqXG4gKiBUaGlzIGlzIGEgZGVlcCBmb3JtIG9mIGBQcm9taXNlLmFsbGAgc3BlY2lhbGl6ZWQgZm9yIFBhc3NhYmxlcy4gRm9yIGVhY2hcbiAqIGVuY291bnRlcmVkIHByb21pc2UsIHJlcGxhY2UgaXQgd2l0aCB0aGUgZGVlcGx5IGZ1bGZpbGxlZCBmb3JtIG9mXG4gKiBpdHMgZnVsZmlsbG1lbnQuXG4gKiBJZiBhbnkgb2YgdGhlIHByb21pc2VzIHJlamVjdCwgdGhlbiB0aGUgcHJvbWlzZSBmb3IgdGhlIHJlcGxhY2VtZW50XG4gKiByZWplY3RzLiBJZiBhbnkgb2YgdGhlIHByb21pc2VzIG5ldmVyIHNldHRsZSwgdGhlbiB0aGUgcHJvbWlzZSBmb3JcbiAqIHRoZSByZXBsYWNlbWVudCBuZXZlciBzZXR0bGVzLlxuICpcbiAqIElmIHRoZSByZXBsYWNlbWVudCB3b3VsZCBub3QgYmUgUGFzc2FibGUsIGkuZS4sIGlmIGB2YWxgIGlzIG5vdFxuICogUGFzc2FibGUsIG9yIGlmIGFueSBvZiB0aGUgdHJhbnNpdGl2ZSBwcm9taXNlcyBmdWxmaWxsIHRvIHNvbWV0aGluZ1xuICogdGhhdCBpcyBub3QgUGFzc2FibGUsIHRoZW4gdGhlIHJldHVybmVkIHByb21pc2UgcmVqZWN0cy5cbiAqXG4gKiBJZiBgdmFsYCBvciBpdHMgcGFydHMgYXJlIG5vbi1rZXkgUGFzc2FibGVzIG9ubHkgKmJlY2F1c2UqIHRoZXkgY29udGFpbnNcbiAqIHByb21pc2VzLCB0aGUgZGVlcGx5IGZ1bGZpbGxlZCBmb3JtcyBvZiB2YWwgb3IgaXRzIHBhcnRzIG1heSBiZSBrZXlzLiBUaGlzXG4gKiBpcyBmb3IgdGhlIGhpZ2hlciBcInN0b3JlXCIgbGV2ZWwgb2YgYWJzdHJhY3Rpb24gdG8gZGV0ZXJtaW5lLCBiZWNhdXNlIGl0XG4gKiBkZWZpbmVzIHRoZSBcImtleVwiIG5vdGlvbiBpbiBxdWVzdGlvbi5cbiAqXG4gKiAvLyBUT0RPOiBUaGF0IGhpZ2hlciBsZXZlbCBpcyBpbiB0aGUgcHJvY2VzcyBvZiBiZWluZyBtaWdyYXRlZCBmcm9tXG4gKiAvLyBgQGFnb3JpYy9zdG9yZWAgdG8gYEBlbmRvL3BhdHRlcm5zYC4gT25jZSB0aGF0IGlzIGZhciBlbm91Z2ggYWxvbmcsXG4gKiAvLyByZXZpc2UgdGhlIGFib3ZlIGNvbW1lbnQgdG8gbWF0Y2guXG4gKiAvLyBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTQ1MVxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge1Byb21pc2U8UGFzc2FibGU+fVxuICovXG5jb25zdCAgICAgICAgZGVlcGx5RnVsZmlsbGVkPWFzeW5jKHZhbCk9PntcbmlmKCFpc09iamVjdCh2YWwpKXtcbnJldHVybiB2YWw7XG4gfVxuaWYoaXNQcm9taXNlKHZhbCkpe1xucmV0dXJuIEUud2hlbih2YWwsKG5vbnApPT5kZWVwbHlGdWxmaWxsZWQobm9ucCkpO1xuIH1cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZih2YWwpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ2NvcHlSZWNvcmQnOntcbmNvbnN0IG5hbWVzPW93bktleXModmFsKTtcbmNvbnN0IHZhbFBzPW5hbWVzLm1hcCgobmFtZSk9PmRlZXBseUZ1bGZpbGxlZCh2YWxbbmFtZV0pKTtcbnJldHVybiBFLndoZW4oUHJvbWlzZS5hbGwodmFsUHMpLCh2YWxzKT0+XG5oYXJkZW4oZnJvbUVudHJpZXModmFscy5tYXAoKGMsaSk9PltuYW1lc1tpXSxjXSkpKSk7XG5cbiB9XG5jYXNlJ2NvcHlBcnJheSc6e1xuY29uc3QgdmFsUHM9dmFsLm1hcCgocCk9PmRlZXBseUZ1bGZpbGxlZChwKSk7XG5yZXR1cm4gRS53aGVuKFByb21pc2UuYWxsKHZhbFBzKSwodmFscyk9PmhhcmRlbih2YWxzKSk7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IHRhZz1nZXRUYWcodmFsKTtcbnJldHVybiBFLndoZW4oZGVlcGx5RnVsZmlsbGVkKHZhbC5wYXlsb2FkKSwocGF5bG9hZCk9PlxubWFrZVRhZ2dlZCh0YWcscGF5bG9hZCkpO1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbnJldHVybiB2YWw7XG4gfVxuY2FzZSdlcnJvcic6e1xucmV0dXJuIHZhbDtcbiB9XG5jYXNlJ3Byb21pc2UnOntcbnJldHVybiBFLndoZW4odmFsLChub25wKT0+ZGVlcGx5RnVsZmlsbGVkKG5vbnApKTtcbiB9XG5kZWZhdWx0OntcbmFzc2VydC5mYWlsKFggYFVuZXhwZWN0ZWQgcGFzc1N0eWxlICR7cShwYXNzU3R5bGUpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfTskaOKAjV9vbmNlLmRlZXBseUZ1bGZpbGxlZChkZWVwbHlGdWxmaWxsZWQpO1xuaGFyZGVuKGRlZXBseUZ1bGZpbGxlZCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZGVlcGx5RnVsZmlsbGVkIjpbImRlZXBseUZ1bGZpbGxlZCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAA7cs+A5D8AAOQ/AAAqAAAAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL2VuY29kZVBhc3NhYmxlLmpzeyJpbXBvcnRzIjpbIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiZXhwb3J0cyI6WyJpc0VuY29kZWRSZW1vdGFibGUiLCJtYWtlRGVjb2RlUGFzc2FibGUiLCJtYWtlRW5jb2RlUGFzc2FibGUiLCJwYXNzU3R5bGVQcmVmaXhlcyIsInJlY29yZE5hbWVzIiwicmVjb3JkVmFsdWVzIiwiemVyb1BhZCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBnZXRUYWcsbWFrZVRhZ2dlZCxwYXNzU3R5bGVPZixhc3NlcnRSZWNvcmQsaXNFcnJvckxpa2UsbmFtZUZvclBhc3NhYmxlU3ltYm9sLHBhc3NhYmxlU3ltYm9sRm9yTmFtZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjigI1fYSA9PiAobWFrZVRhZ2dlZCA9ICRo4oCNX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXSxbXCJhc3NlcnRSZWNvcmRcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlY29yZCA9ICRo4oCNX2EpXV0sW1wiaXNFcnJvckxpa2VcIiwgWyRo4oCNX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjigI1fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRo4oCNX2EgPT4gKG5hbWVGb3JQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV0sW1wicGFzc2FibGVTeW1ib2xGb3JOYW1lXCIsIFskaOKAjV9hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUGFzc1N0eWxlfSBQYXNzU3R5bGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUmVtb3RhYmxlT2JqZWN0fSBSZW1vdGFibGUgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLkNvcHlSZWNvcmQ8VD59IENvcHlSZWNvcmQgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJhbmtDb3Zlcn0gUmFua0NvdmVyICovXG5cbmNvbnN0e3F1b3RlOnEsRmFpbH09YXNzZXJ0O1xuY29uc3R7ZnJvbUVudHJpZXMsaXN9PU9iamVjdDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbi8qKlxuICogQXNzdW1pbmcgdGhhdCBgcmVjb3JkYCBpcyBhIENvcHlSZWNvcmQsIHdlIGhhdmUgb25seVxuICogc3RyaW5nLW5hbWVkIG93biBwcm9wZXJ0aWVzLiBgcmVjb3JkTmFtZXNgIHJldHVybnMgdGhvc2UgbmFtZSAqcmV2ZXJzZSpcbiAqIHNvcnRlZCwgYmVjYXVzZSB0aGF0J3MgaG93IHJlY29yZHMgYXJlIGNvbXBhcmVkLCBlbmNvZGVkLCBhbmQgc29ydGVkLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0NvcHlSZWNvcmQ8VD59IHJlY29yZFxuICogQHJldHVybnMge3N0cmluZ1tdfVxuICovXG5jb25zdCAgICAgICAgcmVjb3JkTmFtZXM9KHJlY29yZCk9PlxuLyogaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI2MCNkaXNjdXNzaW9uX3IxMDAzNjU3MjQ0Ki9cbi8qIGNvbXBhcmVzIHR3byB3YXlzIG9mIHJldmVyc2Ugc29ydGluZywgYW5kIHNob3dzIHRoYXQgYC5zb3J0KCkucmV2ZXJzZSgpYCovXG4vKiBpcyBjdXJyZW50bHkgZmFzdGVyIG9uIE1vZGRhYmxlIFhTLCB3aGlsZSB0aGUgb3RoZXIgd2F5LCovXG4vKiBgLnNvcnQocmV2ZXJzZUNvbXBhcmF0b3IpYCwgaXMgZmFzdGVyIG9uIHY4LiBXZSBjdXJyZW50bHkgY2FyZSBtb3JlIGFib3V0Ki9cbi8qIFhTIHBlcmZvcm1hbmNlLCBzbyB3ZSByZXZlcnNlIHNvcnQgdXNpbmcgYC5zb3J0KCkucmV2ZXJzZSgpYC4qL1xuaGFyZGVuKC8qKiBAdHlwZSB7c3RyaW5nW119ICovb3duS2V5cyhyZWNvcmQpLnNvcnQoKS5yZXZlcnNlKCkpOyRo4oCNX29uY2UucmVjb3JkTmFtZXMocmVjb3JkTmFtZXMpO1xuaGFyZGVuKHJlY29yZE5hbWVzKTtcblxuLyoqXG4gKiBBc3N1bWluZyB0aGF0IGByZWNvcmRgIGlzIGEgQ29weVJlY29yZCBhbmQgYG5hbWVzYCBpcyBgcmVjb3JkTmFtZXMocmVjb3JkKWAsXG4gKiByZXR1cm4gdGhlIGNvcnJlc3BvbmRpbmcgYXJyYXkgb2YgcHJvcGVydHkgdmFsdWVzLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0NvcHlSZWNvcmQ8VD59IHJlY29yZFxuICogQHBhcmFtIHtzdHJpbmdbXX0gbmFtZXNcbiAqIEByZXR1cm5zIHtUW119XG4gKi9cbmNvbnN0ICAgICAgICByZWNvcmRWYWx1ZXM9KHJlY29yZCxuYW1lcyk9PlxuaGFyZGVuKG5hbWVzLm1hcCgobmFtZSk9PnJlY29yZFtuYW1lXSkpOyRo4oCNX29uY2UucmVjb3JkVmFsdWVzKHJlY29yZFZhbHVlcyk7XG5oYXJkZW4ocmVjb3JkVmFsdWVzKTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IG5cbiAqIEBwYXJhbSB7bnVtYmVyfSBzaXplXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCAgICAgICAgemVyb1BhZD0obixzaXplKT0+e1xuY29uc3QgblN0cj0gYCR7bn1gO1xuYXNzZXJ0KG5TdHIubGVuZ3RoPD1zaXplKTtcbmNvbnN0IHN0cj0gYDAwMDAwMDAwMDAwMDAwMDAwMDAwJHtuU3RyfWA7XG5jb25zdCByZXN1bHQ9c3RyLnN1YnN0cmluZyhzdHIubGVuZ3RoLXNpemUpO1xuYXNzZXJ0KHJlc3VsdC5sZW5ndGg9PT1zaXplKTtcbnJldHVybiByZXN1bHQ7XG4gfTskaOKAjV9vbmNlLnplcm9QYWQoemVyb1BhZCk7XG5oYXJkZW4oemVyb1BhZCk7XG5cbi8qIFRoaXMgaXMgdGhlIEphdmFTY3JpcHQgYW5hbG9nIHRvIGEgQyB1bmlvbjogYSB3YXkgdG8gbWFwIGJldHdlZW4gYSBmbG9hdCBhcyBhKi9cbi8qIG51bWJlciBhbmQgdGhlIGJpdHMgdGhhdCByZXByZXNlbnQgdGhlIGZsb2F0IGFzIGEgYnVmZmVyIGZ1bGwgb2YgYnl0ZXMuICBOb3RlKi9cbi8qIHRoYXQgdGhlIG11dGF0aW9uIG9mIHN0YXRpYyBzdGF0ZSBoZXJlIG1ha2VzIHRoaXMgaW52YWxpZCBKZXNzaWUgY29kZSwgYnV0Ki9cbi8qIGRvaW5nIGl0IHRoaXMgd2F5IHNhdmVzIHRoZSBudWdhdG9yeSBhbmQgZ3JhdHVpdG91cyBhbGxvY2F0aW9ucyB0aGF0IHdvdWxkKi9cbi8qIGhhcHBlbiBldmVyeSB0aW1lIHlvdSBkbyBhIGNvbnZlcnNpb24gLS0gYW5kIGluIHByYWN0aWNhbCB0ZXJtcyBpdCdzIHNhZmUqL1xuLyogYmVjYXVzZSB3ZSBwdXQgdGhlIHZhbHVlIGluIG9uZSBzaWRlIGFuZCB0aGVuIGltbWVkaWF0ZWx5IHRha2UgaXQgb3V0IHRoZSovXG4vKiBvdGhlcjsgdGhlcmUgaXMgbm8gYWN0dWFsIHN0YXRlIHJldGFpbmVkIGluIHRoZSBjbGFzc2ljIHNlbnNlIGFuZCB0aHVzIG5vKi9cbi8qIHJlLWVudHJhbmN5IGlzc3VlLiovXG5jb25zdCBhc051bWJlcj1uZXcgRmxvYXQ2NEFycmF5KDEpO1xuY29uc3QgYXNCaXRzPW5ldyBCaWdVaW50NjRBcnJheShhc051bWJlci5idWZmZXIpO1xuXG4vKiBKYXZhU2NyaXB0IG51bWJlcnMgYXJlIGVuY29kZWQgYnkgb3V0cHV0dGluZyB0aGUgYmFzZS0xNiovXG4vKiByZXByZXNlbnRhdGlvbiBvZiB0aGUgYmluYXJ5IHZhbHVlIG9mIHRoZSB1bmRlcmx5aW5nIElFRUUgZmxvYXRpbmcgcG9pbnQqL1xuLyogcmVwcmVzZW50YXRpb24uICBGb3IgbmVnYXRpdmUgdmFsdWVzLCBhbGwgYml0cyBvZiB0aGlzIHJlcHJlc2VudGF0aW9uIGFyZSovXG4vKiBjb21wbGVtZW50ZWQgcHJpb3IgdG8gdGhlIGJhc2UtMTYgY29udmVyc2lvbiwgd2hpbGUgZm9yIHBvc2l0aXZlIHZhbHVlcywgdGhlKi9cbi8qIHNpZ24gYml0IGlzIGNvbXBsZW1lbnRlZC4gIFRoaXMgZW5zdXJlcyBib3RoIHRoYXQgbmVnYXRpdmUgdmFsdWVzIHNvcnQgYmVmb3JlKi9cbi8qIHBvc2l0aXZlIHZhbHVlcyBhbmQgdGhhdCBuZWdhdGl2ZSB2YWx1ZXMgc29ydCBhY2NvcmRpbmcgdG8gdGhlaXIgbmVnYXRpdmUqL1xuLyogbWFnbml0dWRlIHJhdGhlciB0aGFuIHRoZWlyIHBvc2l0aXZlIG1hZ25pdHVkZS4gIFRoaXMgcmVzdWx0cyBpbiBhbiBBU0NJSSovXG4vKiBlbmNvZGluZyB3aG9zZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgaXMgdGhlIHNhbWUgYXMgdGhlIG51bWVyaWMgc29ydCBvcmRlciovXG4vKiBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLiovXG5cbi8qIFRPRE8gQ2hvb3NlIHRoZSBzYW1lIGNhbm9uaWNhbCBOYU4gZW5jb2RpbmcgdGhhdCBjb3NtV2FzbSBhbmQgZXdhc20gY2hvc2UuKi9cbmNvbnN0IENhbm9uaWNhbE5hTkJpdHM9J2ZmZjgwMDAwMDAwMDAwMDAnO1xuXG4vKipcbiAqIEBwYXJhbSB7bnVtYmVyfSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaW5hcnk2ND0obik9Pntcbi8qIE5vcm1hbGl6ZSAtMCB0byAwIGFuZCBOYU4gdG8gYSBjYW5vbmljYWwgZW5jb2RpbmcqL1xuaWYoaXMobiwtMCkpe1xubj0wO1xuIH1lbHNlIGlmKGlzKG4sTmFOKSl7XG5yZXR1cm4gYGYke0Nhbm9uaWNhbE5hTkJpdHN9YDtcbiB9XG5hc051bWJlclswXT1uO1xubGV0IGJpdHM9YXNCaXRzWzBdO1xuaWYobjwwKXtcbmJpdHNePTB4ZmZmZmZmZmZmZmZmZmZmZm47XG4gfWVsc2V7XG5iaXRzXj0weDgwMDAwMDAwMDAwMDAwMDBuO1xuIH1cbnJldHVybiBgZiR7emVyb1BhZChiaXRzLnRvU3RyaW5nKDE2KSwxNil9YDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCBkZWNvZGVCaW5hcnk2ND0oZW5jb2RlZCk9PntcbmVuY29kZWQuc3RhcnRzV2l0aCgnZicpfHxGYWlsIGBFbmNvZGVkIG51bWJlciBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5sZXQgYml0cz1CaWdJbnQoIGAweCR7ZW5jb2RlZC5zdWJzdHJpbmcoMSl9YCk7XG5pZihlbmNvZGVkWzFdPCc4Jyl7XG5iaXRzXj0weGZmZmZmZmZmZmZmZmZmZmZuO1xuIH1lbHNle1xuYml0c149MHg4MDAwMDAwMDAwMDAwMDAwbjtcbiB9XG5hc0JpdHNbMF09Yml0cztcbmNvbnN0IHJlc3VsdD1hc051bWJlclswXTtcbiFpcyhyZXN1bHQsLTApfHxGYWlsIGBVbmV4cGVjdGVkIG5lZ2F0aXZlIHplcm86ICR7ZW5jb2RlZH1gO1xucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEVuY29kZSBhIEphdmFTY3JpcHQgYmlnaW50IHVzaW5nIGEgdmFyaWFudCBvZiBFbGlhcyBkZWx0YSBjb2RpbmcsIHdpdGggYW5cbiAqIGluaXRpYWwgY29tcG9uZW50IGZvciB0aGUgbGVuZ3RoIG9mIHRoZSBkaWdpdCBjb3VudCBhcyBhIHVuYXJ5IHN0cmluZywgYVxuICogc2Vjb25kIGNvbXBvbmVudCBmb3IgdGhlIGRlY2ltYWwgZGlnaXQgY291bnQsIGFuZCBhIHRoaXJkIGNvbXBvbmVudCBmb3IgdGhlXG4gKiBkZWNpbWFsIGRpZ2l0cyBwcmVjZWRlZCBieSBhIGdyYXR1aXRvdXMgc2VwYXJhdGluZyBjb2xvbi5cbiAqIFRvIGVuc3VyZSB0aGF0IHRoZSBsZXhpY29ncmFwaGljIHNvcnQgb3JkZXIgb2YgZW5jb2RlZCB2YWx1ZXMgbWF0Y2hlcyB0aGVcbiAqIG51bWVyaWMgc29ydCBvcmRlciBvZiB0aGUgY29ycmVzcG9uZGluZyBudW1iZXJzLCB0aGUgY2hhcmFjdGVycyBvZiB0aGUgdW5hcnlcbiAqIHByZWZpeCBhcmUgZGlmZmVyZW50IGZvciBuZWdhdGl2ZSB2YWx1ZXMgKHR5cGUgXCJuXCIgZm9sbG93ZWQgYnkgYW55IG51bWJlciBvZlxuICogXCIjXCJzIFt3aGljaCBzb3J0IGJlZm9yZSBkZWNpbWFsIGRpZ2l0c10pIHZzLiBwb3NpdGl2ZSBhbmQgemVybyB2YWx1ZXMgKHR5cGVcbiAqIFwicFwiIGZvbGxvd2VkIGJ5IGFueSBudW1iZXIgb2YgXCJ+XCJzIFt3aGljaCBzb3J0IGFmdGVyIGRlY2ltYWwgZGlnaXRzXSkgYW5kXG4gKiBlYWNoIGRlY2ltYWwgZGlnaXQgb2YgdGhlIGVuY29kaW5nIGZvciBhIG5lZ2F0aXZlIHZhbHVlIGlzIHJlcGxhY2VkIHdpdGggaXRzXG4gKiB0ZW4ncyBjb21wbGVtZW50IChzbyB0aGF0IG5lZ2F0aXZlIHZhbHVlcyBvZiB0aGUgc2FtZSBzY2FsZSBzb3J0IGJ5XG4gKiAqZGVzY2VuZGluZyogYWJzb2x1dGUgdmFsdWUpLlxuICpcbiAqIEBwYXJhbSB7YmlnaW50fSBuXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBlbmNvZGVCaWdJbnQ9KG4pPT57XG5jb25zdCBhYnM9bjwwbj8tbjpuO1xuY29uc3QgbkRpZ2l0cz1hYnMudG9TdHJpbmcoKS5sZW5ndGg7XG5jb25zdCBsRGlnaXRzPW5EaWdpdHMudG9TdHJpbmcoKS5sZW5ndGg7XG5pZihuPDBuKXtcbnJldHVybiBgbiR7XG4vKiBBIFwiI1wiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJyMnLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgY291bnQgb2YgZGlnaXRzLiovXG4oMTAqKmxEaWdpdHMtbkRpZ2l0cykudG9TdHJpbmcoKS5wYWRTdGFydChsRGlnaXRzLCcwJylcbiB9OiR7XG4vKiBUaGUgdGVuJ3MgY29tcGxlbWVudCBvZiB0aGUgZGlnaXRzLiovXG4oMTBuKipCaWdJbnQobkRpZ2l0cykrbikudG9TdHJpbmcoKS5wYWRTdGFydChuRGlnaXRzLCcwJylcbiB9YDtcbiB9ZWxzZXtcbnJldHVybiBgcCR7XG4vKiBBIFwiflwiIGZvciBlYWNoIGRpZ2l0IGJleW9uZCB0aGUgZmlyc3QqL1xuLyogaW4gdGhlIGRlY2ltYWwgKmNvdW50KiBvZiBkZWNpbWFsIGRpZ2l0cy4qL1xuJ34nLnJlcGVhdChsRGlnaXRzLTEpXG4gfSR7XG4vKiBUaGUgY291bnQgb2YgZGlnaXRzLiovXG5uRGlnaXRzXG4gfToke1xuLyogVGhlIGRpZ2l0cy4qL1xublxuIH1gO1xuIH1cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBlbmNvZGVkXG4gKiBAcmV0dXJucyB7YmlnaW50fVxuICovXG5jb25zdCBkZWNvZGVCaWdJbnQ9KGVuY29kZWQpPT57XG5jb25zdCB0eXBlUHJlZml4PWVuY29kZWQuY2hhckF0KDApOy8qIGZhc3RlciB0aGFuIGVuY29kZWRbMF0qL1xubGV0IHJlbT1lbmNvZGVkLnNsaWNlKDEpO1xudHlwZVByZWZpeD09PSdwJ3x8XG50eXBlUHJlZml4PT09J24nfHxcbkZhaWwgYEVuY29kZWQgYmlnaW50IGV4cGVjdGVkOiAke2VuY29kZWR9YDtcblxuY29uc3QgbERpZ2l0cz1yZW0uc2VhcmNoKC9bMC05XS8pKzE7XG5sRGlnaXRzPj0xfHxGYWlsIGBEaWdpdCBjb3VudCBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5yZW09cmVtLnNsaWNlKGxEaWdpdHMtMSk7XG5cbnJlbS5sZW5ndGg+PWxEaWdpdHN8fEZhaWwgYENvbXBsZXRlIGRpZ2l0IGNvdW50IGV4cGVjdGVkOiAke2VuY29kZWR9YDtcbmNvbnN0IHNuRGlnaXRzPXJlbS5zbGljZSgwLGxEaWdpdHMpO1xucmVtPXJlbS5zbGljZShsRGlnaXRzKTtcbi9eWzAtOV0rJC8udGVzdChzbkRpZ2l0cyl8fEZhaWwgYERlY2ltYWwgZGlnaXQgY291bnQgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xubGV0IG5EaWdpdHM9cGFyc2VJbnQoc25EaWdpdHMsMTApO1xuaWYodHlwZVByZWZpeD09PSduJyl7XG4vKiBUT0RPIEFzc2VydCB0byByZWplY3QgZm9yYmlkZGVuIGVuY29kaW5ncyovXG4vKiBsaWtlIFwibjA6XCIgYW5kIFwibjAwOuKAplwiIGFuZCBcIm45MTrigKZcIiB0aHJvdWdoIFwibjk5OuKAplwiPyovXG5uRGlnaXRzPTEwKipsRGlnaXRzLW5EaWdpdHM7XG4gfVxuXG5yZW0uc3RhcnRzV2l0aCgnOicpfHxGYWlsIGBTZXBhcmF0b3IgZXhwZWN0ZWQ6ICR7ZW5jb2RlZH1gO1xucmVtPXJlbS5zbGljZSgxKTtcbnJlbS5sZW5ndGg9PT1uRGlnaXRzfHxcbkZhaWwgYEZpeGVkLWxlbmd0aCBkaWdpdCBzZXF1ZW5jZSBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5sZXQgbj1CaWdJbnQocmVtKTtcbmlmKHR5cGVQcmVmaXg9PT0nbicpe1xuLyogVE9ETyBBc3NlcnQgdG8gcmVqZWN0IGZvcmJpZGRlbiBlbmNvZGluZ3MqL1xuLyogbGlrZSBcIm45OjBcIiBhbmQgXCJuODowMFwiIGFuZCBcIm44OjkxXCIgdGhyb3VnaCBcIm44Ojk5XCI/Ki9cbm49LSgxMG4qKkJpZ0ludChuRGlnaXRzKS1uKTtcbiB9XG5cbnJldHVybiBuO1xuIH07XG5cbi8qIGAnXFx1MDAwMCdgIGlzIHRoZSB0ZXJtaW5hdG9yIGFmdGVyIGVsZW1lbnRzLiovXG4vKiBgJ1xcdTAwMDEnYCBpcyB0aGUgYmFja3NsYXNoLWxpa2UgZXNjYXBlIGNoYXJhY3RlciwgZm9yKi9cbi8qIGVzY2FwaW5nIGJvdGggb2YgdGhlc2UgY2hhcmFjdGVycy4qL1xuXG5jb25zdCBlbmNvZGVBcnJheT0oYXJyYXksZW5jb2RlUGFzc2FibGUpPT57XG5jb25zdCBjaGFycz1bJ1snXTtcbmZvcihjb25zdCBlbGVtZW50IG9mIGFycmF5KXtcbmNvbnN0IGVuYz1lbmNvZGVQYXNzYWJsZShlbGVtZW50KTtcbmZvcihjb25zdCBjIG9mIGVuYyl7XG5pZihjPT09J1xcdTAwMDAnfHxjPT09J1xcdTAwMDEnKXtcbmNoYXJzLnB1c2goJ1xcdTAwMDEnKTtcbiB9XG5jaGFycy5wdXNoKGMpO1xuIH1cbmNoYXJzLnB1c2goJ1xcdTAwMDAnKTtcbiB9XG5yZXR1cm4gY2hhcnMuam9pbignJyk7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge3N0cmluZ30gZW5jb2RlZFxuICogQHBhcmFtIHsoZW5jb2RlZDogc3RyaW5nKSA9PiBQYXNzYWJsZX0gZGVjb2RlUGFzc2FibGVcbiAqIEByZXR1cm5zIHtBcnJheX1cbiAqL1xuY29uc3QgZGVjb2RlQXJyYXk9KGVuY29kZWQsZGVjb2RlUGFzc2FibGUpPT57XG5lbmNvZGVkLnN0YXJ0c1dpdGgoJ1snKXx8RmFpbCBgRW5jb2RlZCBhcnJheSBleHBlY3RlZDogJHtlbmNvZGVkfWA7XG5jb25zdCBlbGVtZW50cz1bXTtcbmNvbnN0IGVsZW1DaGFycz1bXTtcbmZvcihsZXQgaT0xO2k8ZW5jb2RlZC5sZW5ndGg7aSs9MSl7XG5jb25zdCBjPWVuY29kZWRbaV07XG5pZihjPT09J1xcdTAwMDAnKXtcbmNvbnN0IGVuY29kZWRFbGVtZW50PWVsZW1DaGFycy5qb2luKCcnKTtcbmVsZW1DaGFycy5sZW5ndGg9MDtcbmNvbnN0IGVsZW1lbnQ9ZGVjb2RlUGFzc2FibGUoZW5jb2RlZEVsZW1lbnQpO1xuZWxlbWVudHMucHVzaChlbGVtZW50KTtcbiB9ZWxzZSBpZihjPT09J1xcdTAwMDEnKXtcbmkrPTE7XG5pPGVuY29kZWQubGVuZ3RofHxGYWlsIGB1bmV4cGVjdGVkIGVuZCBvZiBlbmNvZGluZyAke2VuY29kZWR9YDtcbmNvbnN0IGMyPWVuY29kZWRbaV07XG5jMj09PSdcXHUwMDAwJ3x8XG5jMj09PSdcXHUwMDAxJ3x8XG5GYWlsIGBVbmV4cGVjdGVkIGNoYXJhY3RlciBhZnRlciB1MDAwMSBlc2NhcGU6ICR7YzJ9YDtcbmVsZW1DaGFycy5wdXNoKGMyKTtcbiB9ZWxzZXtcbmVsZW1DaGFycy5wdXNoKGMpO1xuIH1cbiB9XG5lbGVtQ2hhcnMubGVuZ3RoPT09MHx8RmFpbCBgZW5jb2RpbmcgdGVybWluYXRlZCBlYXJseTogJHtlbmNvZGVkfWA7XG5yZXR1cm4gaGFyZGVuKGVsZW1lbnRzKTtcbiB9O1xuXG5jb25zdCBlbmNvZGVSZWNvcmQ9KHJlY29yZCxlbmNvZGVQYXNzYWJsZSk9PntcbmNvbnN0IG5hbWVzPXJlY29yZE5hbWVzKHJlY29yZCk7XG5jb25zdCB2YWx1ZXM9cmVjb3JkVmFsdWVzKHJlY29yZCxuYW1lcyk7XG5yZXR1cm4gYCgke2VuY29kZUFycmF5KGhhcmRlbihbbmFtZXMsdmFsdWVzXSksZW5jb2RlUGFzc2FibGUpfWA7XG4gfTtcblxuY29uc3QgZGVjb2RlUmVjb3JkPShlbmNvZGVkLGRlY29kZVBhc3NhYmxlKT0+e1xuYXNzZXJ0KGVuY29kZWQuc3RhcnRzV2l0aCgnKCcpKTtcbmNvbnN0IGtleXN2YWxzPWRlY29kZUFycmF5KGVuY29kZWQuc3Vic3RyaW5nKDEpLGRlY29kZVBhc3NhYmxlKTtcbmtleXN2YWxzLmxlbmd0aD09PTJ8fEZhaWwgYGV4cGVjdGVkIGtleXMsdmFsdWVzIHBhaXI6ICR7ZW5jb2RlZH1gO1xuY29uc3Rba2V5cyx2YWxzXT1rZXlzdmFscztcblxucGFzc1N0eWxlT2Yoa2V5cyk9PT0nY29weUFycmF5JyYmXG5wYXNzU3R5bGVPZih2YWxzKT09PSdjb3B5QXJyYXknJiZcbmtleXMubGVuZ3RoPT09dmFscy5sZW5ndGgmJlxua2V5cy5ldmVyeSgoa2V5KT0+dHlwZW9mIGtleT09PSdzdHJpbmcnKXx8XG5GYWlsIGBub3QgYSB2YWxpZCByZWNvcmQgZW5jb2Rpbmc6ICR7ZW5jb2RlZH1gO1xuY29uc3QgbWFwRW50cmllcz1rZXlzLm1hcCgoa2V5LGkpPT5ba2V5LHZhbHNbaV1dKTtcbmNvbnN0IHJlY29yZD1oYXJkZW4oZnJvbUVudHJpZXMobWFwRW50cmllcykpO1xuYXNzZXJ0UmVjb3JkKHJlY29yZCwnZGVjb2RlZCByZWNvcmQnKTtcbnJldHVybiByZWNvcmQ7XG4gfTtcblxuY29uc3QgZW5jb2RlVGFnZ2VkPSh0YWdnZWQsZW5jb2RlUGFzc2FibGUpPT5cbiBgOiR7ZW5jb2RlQXJyYXkoaGFyZGVuKFtnZXRUYWcodGFnZ2VkKSx0YWdnZWQucGF5bG9hZF0pLGVuY29kZVBhc3NhYmxlKX1gO1xuXG5jb25zdCBkZWNvZGVUYWdnZWQ9KGVuY29kZWQsZGVjb2RlUGFzc2FibGUpPT57XG5hc3NlcnQoZW5jb2RlZC5zdGFydHNXaXRoKCc6JykpO1xuY29uc3QgdGFncGF5bG9hZD1kZWNvZGVBcnJheShlbmNvZGVkLnN1YnN0cmluZygxKSxkZWNvZGVQYXNzYWJsZSk7XG50YWdwYXlsb2FkLmxlbmd0aD09PTJ8fEZhaWwgYGV4cGVjdGVkIHRhZyxwYXlsb2FkIHBhaXI6ICR7ZW5jb2RlZH1gO1xuY29uc3RbdGFnLHBheWxvYWRdPXRhZ3BheWxvYWQ7XG5wYXNzU3R5bGVPZih0YWcpPT09J3N0cmluZyd8fFxuRmFpbCBgbm90IGEgdmFsaWQgdGFnZ2VkIGVuY29kaW5nOiAke2VuY29kZWR9YDtcbnJldHVybiBtYWtlVGFnZ2VkKHRhZyxwYXlsb2FkKTtcbiB9O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEVuY29kZU9wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICByZW1vdGFibGU6IFJlbW90YWJsZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVSZW1vdGFibGVdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgcHJvbWlzZTogUHJvbWlzZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVQcm9taXNlXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVycm9yOiBFcnJvcixcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gc3RyaW5nLFxuICogKSA9PiBzdHJpbmd9IFtlbmNvZGVFcnJvcl1cbiAqL1xuXG4vKipcbiAqIEBwYXJhbSB7RW5jb2RlT3B0aW9uc30gW2VuY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7KHBhc3NhYmxlOiBQYXNzYWJsZSkgPT4gc3RyaW5nfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVBhc3NhYmxlPShlbmNvZGVPcHRpb25zPXt9KT0+e1xuY29uc3R7XG5lbmNvZGVSZW1vdGFibGU9KHJlbSxfKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7cmVtfWAsXG5lbmNvZGVQcm9taXNlPShwcm9tLF8pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7cHJvbX1gLFxuZW5jb2RlRXJyb3I9KGVycixfKT0+RmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtlcnJ9YH09XG5lbmNvZGVPcHRpb25zO1xuXG5jb25zdCBlbmNvZGVQYXNzYWJsZT0ocGFzc2FibGUpPT57XG5pZihpc0Vycm9yTGlrZShwYXNzYWJsZSkpe1xucmV0dXJuIGVuY29kZUVycm9yKHBhc3NhYmxlLGVuY29kZVBhc3NhYmxlKTtcbiB9XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocGFzc2FibGUpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ251bGwnOntcbnJldHVybid2JztcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6e1xucmV0dXJuJ3onO1xuIH1cbmNhc2UnbnVtYmVyJzp7XG5yZXR1cm4gZW5jb2RlQmluYXJ5NjQocGFzc2FibGUpO1xuIH1cbmNhc2Unc3RyaW5nJzp7XG5yZXR1cm4gYHMke3Bhc3NhYmxlfWA7XG4gfVxuY2FzZSdib29sZWFuJzp7XG5yZXR1cm4gYGIke3Bhc3NhYmxlfWA7XG4gfVxuY2FzZSdiaWdpbnQnOntcbnJldHVybiBlbmNvZGVCaWdJbnQocGFzc2FibGUpO1xuIH1cbmNhc2UncmVtb3RhYmxlJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlUmVtb3RhYmxlKHBhc3NhYmxlLGVuY29kZVBhc3NhYmxlKTtcbnJlc3VsdC5zdGFydHNXaXRoKCdyJyl8fFxuRmFpbCBgaW50ZXJuYWw6IFJlbW90YWJsZSBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCJyXCI6ICR7cmVzdWx0fWA7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVFcnJvcihwYXNzYWJsZSxlbmNvZGVQYXNzYWJsZSk7XG5yZXN1bHQuc3RhcnRzV2l0aCgnIScpfHxcbkZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCIhXCI6ICR7cmVzdWx0fWA7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVByb21pc2UocGFzc2FibGUsZW5jb2RlUGFzc2FibGUpO1xucmVzdWx0LnN0YXJ0c1dpdGgoJz8nKXx8XG5GYWlsIGBpbnRlcm5hbDogUHJvbWlzZSBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCI/XCI6ICR7cmVzdWx0fWA7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmNhc2Unc3ltYm9sJzp7XG5yZXR1cm4gYHkke25hbWVGb3JQYXNzYWJsZVN5bWJvbChwYXNzYWJsZSl9YDtcbiB9XG5jYXNlJ2NvcHlBcnJheSc6e1xucmV0dXJuIGVuY29kZUFycmF5KHBhc3NhYmxlLGVuY29kZVBhc3NhYmxlKTtcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbnJldHVybiBlbmNvZGVSZWNvcmQocGFzc2FibGUsZW5jb2RlUGFzc2FibGUpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5yZXR1cm4gZW5jb2RlVGFnZ2VkKHBhc3NhYmxlLGVuY29kZVBhc3NhYmxlKTtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYGEgJHtxKHBhc3NTdHlsZSl9IGNhbm5vdCBiZSB1c2VkIGFzIGEgY29sbGVjdGlvbiBwYXNzYWJsZWA7XG4gfX1cblxuIH07XG5yZXR1cm4gaGFyZGVuKGVuY29kZVBhc3NhYmxlKTtcbiB9OyRo4oCNX29uY2UubWFrZUVuY29kZVBhc3NhYmxlKG1ha2VFbmNvZGVQYXNzYWJsZSk7XG5oYXJkZW4obWFrZUVuY29kZVBhc3NhYmxlKTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBEZWNvZGVPcHRpb25zXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFJlbW90YWJsZTogc3RyaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IHN0cmluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUmVtb3RhYmxlfSBbZGVjb2RlUmVtb3RhYmxlXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRQcm9taXNlOiBzdHJpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogc3RyaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBQcm9taXNlfSBbZGVjb2RlUHJvbWlzZV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkRXJyb3I6IHN0cmluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlOiBzdHJpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IEVycm9yfSBbZGVjb2RlRXJyb3JdXG4gKi9cblxuLyoqXG4gKiBAcGFyYW0ge0RlY29kZU9wdGlvbnN9IFtkZWNvZGVPcHRpb25zXVxuICogQHJldHVybnMgeyhlbmNvZGVkOiBzdHJpbmcpID0+IFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgbWFrZURlY29kZVBhc3NhYmxlPShkZWNvZGVPcHRpb25zPXt9KT0+e1xuY29uc3R7XG5kZWNvZGVSZW1vdGFibGU9KHJlbSxfKT0+RmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7cmVtfWAsXG5kZWNvZGVQcm9taXNlPShwcm9tLF8pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7cHJvbX1gLFxuZGVjb2RlRXJyb3I9KGVycixfKT0+RmFpbCBgZXJyb3IgdW5leHBlY3RlZDogJHtlcnJ9YH09XG5kZWNvZGVPcHRpb25zO1xuXG5jb25zdCBkZWNvZGVQYXNzYWJsZT0oZW5jb2RlZCk9PntcbnN3aXRjaChlbmNvZGVkLmNoYXJBdCgwKSl7XG5jYXNlJ3YnOntcbnJldHVybiBudWxsO1xuIH1cbmNhc2Uneic6e1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG5jYXNlJ2YnOntcbnJldHVybiBkZWNvZGVCaW5hcnk2NChlbmNvZGVkKTtcbiB9XG5jYXNlJ3MnOntcbnJldHVybiBlbmNvZGVkLnN1YnN0cmluZygxKTtcbiB9XG5jYXNlJ2InOntcbnJldHVybiBlbmNvZGVkLnN1YnN0cmluZygxKSE9PSdmYWxzZSc7XG4gfVxuY2FzZSduJzpcbmNhc2UncCc6e1xucmV0dXJuIGRlY29kZUJpZ0ludChlbmNvZGVkKTtcbiB9XG5jYXNlJ3InOntcbnJldHVybiBkZWNvZGVSZW1vdGFibGUoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSk7XG4gfVxuY2FzZSc/Jzp7XG5yZXR1cm4gZGVjb2RlUHJvbWlzZShlbmNvZGVkLGRlY29kZVBhc3NhYmxlKTtcbiB9XG5jYXNlJyEnOntcbnJldHVybiBkZWNvZGVFcnJvcihlbmNvZGVkLGRlY29kZVBhc3NhYmxlKTtcbiB9XG5jYXNlJ3knOntcbnJldHVybiBwYXNzYWJsZVN5bWJvbEZvck5hbWUoZW5jb2RlZC5zdWJzdHJpbmcoMSkpO1xuIH1cbmNhc2UnWyc6e1xucmV0dXJuIGRlY29kZUFycmF5KGVuY29kZWQsZGVjb2RlUGFzc2FibGUpO1xuIH1cbmNhc2UnKCc6e1xucmV0dXJuIGRlY29kZVJlY29yZChlbmNvZGVkLGRlY29kZVBhc3NhYmxlKTtcbiB9XG5jYXNlJzonOntcbnJldHVybiBkZWNvZGVUYWdnZWQoZW5jb2RlZCxkZWNvZGVQYXNzYWJsZSk7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBGYWlsIGBpbnZhbGlkIGRhdGFiYXNlIGtleTogJHtlbmNvZGVkfWA7XG4gfX1cblxuIH07XG5yZXR1cm4gaGFyZGVuKGRlY29kZVBhc3NhYmxlKTtcbiB9OyRo4oCNX29uY2UubWFrZURlY29kZVBhc3NhYmxlKG1ha2VEZWNvZGVQYXNzYWJsZSk7XG5oYXJkZW4obWFrZURlY29kZVBhc3NhYmxlKTtcblxuY29uc3QgICAgICAgIGlzRW5jb2RlZFJlbW90YWJsZT0oZW5jb2RlZCk9PmVuY29kZWQuY2hhckF0KDApPT09J3InOyRo4oCNX29uY2UuaXNFbmNvZGVkUmVtb3RhYmxlKGlzRW5jb2RlZFJlbW90YWJsZSk7XG5oYXJkZW4oaXNFbmNvZGVkUmVtb3RhYmxlKTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEB0eXBlIHtSZWNvcmQ8UGFzc1N0eWxlLCBzdHJpbmc+fVxuICogVGhlIHNpbmdsZSBwcmVmaXggY2hhcmFjdGVycyB0byBiZSB1c2VkIGZvciBlYWNoIFBhc3NTdHlsZSBjYXRlZ29yeS5cbiAqIGBiaWdpbnRgIGlzIGEgdHdvIGNoYXJhY3RlciBzdHJpbmcgYmVjYXVzZSBlYWNoIG9mIHRob3NlIGNoYXJhY3RlcnNcbiAqIGluZGl2aWR1YWxseSBpcyBhIHZhbGlkIGJpZ2ludCBwcmVmaXguIGBuYCBmb3IgXCJuZWdhdGl2ZVwiIGFuZCBgcGAgZm9yXG4gKiBcInBvc2l0aXZlXCIuIFRoZSBvcmRlcmluZyBvZiB0aGVzZSBwcmVmaXhlcyBpcyB0aGUgc2FtZSBhcyB0aGVcbiAqIHJhbmtPcmRlcmluZyBvZiB0aGVpciByZXNwZWN0aXZlIFBhc3NTdHlsZXMuIFRoaXMgdGFibGUgaXMgaW1wb3J0ZWQgYnlcbiAqIHJhbmtPcmRlci5qcyBmb3IgdGhpcyBwdXJwb3NlLlxuICpcbiAqIEluIGFkZGl0aW9uLCBgfGAgaXMgdGhlIHJlbW90YWJsZS0+b3JkaW5hbCBtYXBwaW5nIHByZWZpeDpcbiAqIFRoaXMgaXMgbm90IHVzZWQgaW4gY292ZXJzIGJ1dCBpdCBpc1xuICogcmVzZXJ2ZWQgZnJvbSB0aGUgc2FtZSBzZXQgb2Ygc3RyaW5ncy4gTm90ZSB0aGF0IHRoZSBwcmVmaXggaXMgPiBhbnlcbiAqIHByZWZpeCB1c2VkIGJ5IGFueSBjb3ZlciBzbyB0aGF0IG9yZGluYWwgbWFwcGluZyBrZXlzIGFyZSBhbHdheXMgb3V0c2lkZVxuICogdGhlIHJhbmdlIG9mIHZhbGlkIGNvbGxlY3Rpb24gZW50cnkga2V5cy5cbiAqL1xuY29uc3QgICAgICAgIHBhc3NTdHlsZVByZWZpeGVzPXtcbmVycm9yOichJyxcbmNvcHlSZWNvcmQ6JygnLFxudGFnZ2VkOic6JyxcbnByb21pc2U6Jz8nLFxuY29weUFycmF5OidbJyxcbmJvb2xlYW46J2InLFxubnVtYmVyOidmJyxcbmJpZ2ludDonbnAnLFxucmVtb3RhYmxlOidyJyxcbnN0cmluZzoncycsXG5udWxsOid2JyxcbnN5bWJvbDoneScsXG51bmRlZmluZWQ6J3onfTskaOKAjV9vbmNlLnBhc3NTdHlsZVByZWZpeGVzKHBhc3NTdHlsZVByZWZpeGVzKTtcblxuT2JqZWN0LnNldFByb3RvdHlwZU9mKHBhc3NTdHlsZVByZWZpeGVzLG51bGwpO1xuaGFyZGVuKHBhc3NTdHlsZVByZWZpeGVzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJyZWNvcmROYW1lcyI6WyJyZWNvcmROYW1lcyJdLCJyZWNvcmRWYWx1ZXMiOlsicmVjb3JkVmFsdWVzIl0sInplcm9QYWQiOlsiemVyb1BhZCJdLCJtYWtlRW5jb2RlUGFzc2FibGUiOlsibWFrZUVuY29kZVBhc3NhYmxlIl0sIm1ha2VEZWNvZGVQYXNzYWJsZSI6WyJtYWtlRGVjb2RlUGFzc2FibGUiXSwiaXNFbmNvZGVkUmVtb3RhYmxlIjpbImlzRW5jb2RlZFJlbW90YWJsZSJdLCJwYXNzU3R5bGVQcmVmaXhlcyI6WyJwYXNzU3R5bGVQcmVmaXhlcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADEU6fw/D8AAPw/AAArAAAAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL2VuY29kZVRvQ2FwRGF0YS5qc3siaW1wb3J0cyI6WyJAZW5kby9wYXNzLXN0eWxlIl0sImV4cG9ydHMiOlsiUUNMQVNTIiwibWFrZURlY29kZUZyb21DYXBEYXRhIiwibWFrZUVuY29kZVRvQ2FwRGF0YSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBwYXNzU3R5bGVPZixpc0Vycm9yTGlrZSxtYWtlVGFnZ2VkLGlzT2JqZWN0LGdldFRhZyxoYXNPd25Qcm9wZXJ0eU9mLGFzc2VydFBhc3NhYmxlU3ltYm9sLG5hbWVGb3JQYXNzYWJsZVN5bWJvbCxwYXNzYWJsZVN5bWJvbEZvck5hbWU7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXSxbXCJpc0Vycm9yTGlrZVwiLCBbJGjigI1fYSA9PiAoaXNFcnJvckxpa2UgPSAkaOKAjV9hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRo4oCNX2EgPT4gKG1ha2VUYWdnZWQgPSAkaOKAjV9hKV1dLFtcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wiZ2V0VGFnXCIsIFskaOKAjV9hID0+IChnZXRUYWcgPSAkaOKAjV9hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRo4oCNX2EgPT4gKGhhc093blByb3BlcnR5T2YgPSAkaOKAjV9hKV1dLFtcImFzc2VydFBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV0sW1wibmFtZUZvclBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaOKAjV9hKV1dLFtcInBhc3NhYmxlU3ltYm9sRm9yTmFtZVwiLCBbJGjigI1fYSA9PiAocGFzc2FibGVTeW1ib2xGb3JOYW1lID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRW5jb2Rpbmd9IEVuY29kaW5nICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5SZW1vdGFibGV9IFJlbW90YWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRW5jb2RpbmdVbmlvbn0gRW5jb2RpbmdVbmlvbiAqL1xuXG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMsXG5kZWZpbmVQcm9wZXJ0aWVzLFxuaXMsXG5lbnRyaWVzLFxuZnJvbUVudHJpZXMsXG5mcmVlemV9PVxuT2JqZWN0O1xuY29uc3R7ZGV0YWlsczpYLEZhaWwscXVvdGU6cX09YXNzZXJ0O1xuXG4vKipcbiAqIFNwZWNpYWwgcHJvcGVydHkgbmFtZSB0aGF0IGluZGljYXRlcyBhbiBlbmNvZGluZyB0aGF0IG5lZWRzIHNwZWNpYWxcbiAqIGRlY29kaW5nLlxuICovXG5jb25zdCBRQ0xBU1M9J0BxY2xhc3MnOyRo4oCNX29uY2UuUUNMQVNTKFFDTEFTUyk7XG5cblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSBlbmNvZGVkXG4gKiBAcmV0dXJucyB7ZW5jb2RlZCBpcyBFbmNvZGluZ1VuaW9ufVxuICovXG5jb25zdCBoYXNRQ2xhc3M9KGVuY29kZWQpPT5oYXNPd25Qcm9wZXJ0eU9mKGVuY29kZWQsUUNMQVNTKTtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSBlbmNvZGVkXG4gKiBAcGFyYW0ge3N0cmluZ30gcWNsYXNzXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgcWNsYXNzTWF0Y2hlcz0oZW5jb2RlZCxxY2xhc3MpPT5cbmlzT2JqZWN0KGVuY29kZWQpJiZcbiFpc0FycmF5KGVuY29kZWQpJiZcbmhhc1FDbGFzcyhlbmNvZGVkKSYmXG5lbmNvZGVkW1FDTEFTU109PT1xY2xhc3M7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRW5jb2RlVG9DYXBEYXRhT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIHJlbW90YWJsZTogUmVtb3RhYmxlLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ1xuICogKSA9PiBFbmNvZGluZ30gW2VuY29kZVJlbW90YWJsZVRvQ2FwRGF0YV1cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBwcm9taXNlOiBQcm9taXNlLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ1xuICogKSA9PiBFbmNvZGluZ30gW2VuY29kZVByb21pc2VUb0NhcERhdGFdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZXJyb3I6IEVycm9yLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ1xuICogKSA9PiBFbmNvZGluZ30gW2VuY29kZUVycm9yVG9DYXBEYXRhXVxuICovXG5cbmNvbnN0IGRvbnRFbmNvZGVSZW1vdGFibGVUb0NhcERhdGE9KHJlbSk9PkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke3JlbX1gO1xuXG5jb25zdCBkb250RW5jb2RlUHJvbWlzZVRvQ2FwRGF0YT0ocHJvbSk9PkZhaWwgYHByb21pc2UgdW5leHBlY3RlZDogJHtwcm9tfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVFcnJvclRvQ2FwRGF0YT0oZXJyKT0+RmFpbCBgZXJyb3Igb2JqZWN0IHVuZXhwZWN0ZWQ6ICR7ZXJyfWA7XG5cbi8qKlxuICogQHBhcmFtIHtFbmNvZGVUb0NhcERhdGFPcHRpb25zfSBbZW5jb2RlT3B0aW9uc11cbiAqIEByZXR1cm5zIHsocGFzc2FibGU6IFBhc3NhYmxlKSA9PiBFbmNvZGluZ31cbiAqL1xuY29uc3QgICAgICAgIG1ha2VFbmNvZGVUb0NhcERhdGE9KGVuY29kZU9wdGlvbnM9e30pPT57XG5jb25zdHtcbmVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YT1kb250RW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhLFxuZW5jb2RlUHJvbWlzZVRvQ2FwRGF0YT1kb250RW5jb2RlUHJvbWlzZVRvQ2FwRGF0YSxcbmVuY29kZUVycm9yVG9DYXBEYXRhPWRvbnRFbmNvZGVFcnJvclRvQ2FwRGF0YX09XG5lbmNvZGVPcHRpb25zO1xuXG4vKipcbiAqIE11c3QgZW5jb2RlIGB2YWxgIGludG8gcGxhaW4gSlNPTiBkYXRhICpjYW5vbmljYWxseSosIHN1Y2ggdGhhdFxuICogYEpTT04uc3RyaW5naWZ5KGVuY29kZSh2MSkpID09PSBKU09OLnN0cmluZ2lmeShlbmNvZGUodjEpKWAuIEZvciBtb3N0XG4gKiBlbmNvZGluZ3MsIHRoZSBvcmRlciBvZiBwcm9wZXJ0aWVzIG9mIGVhY2ggbm9kZSBvZiB0aGUgb3V0cHV0XG4gKiBzdHJ1Y3R1cmUgaXMgZGV0ZXJtaW5lZCBieSB0aGUgYWxnb3JpdGhtIGJlbG93IHdpdGhvdXQgc3BlY2lhbFxuICogYXJyYW5nZW1lbnQsIHVzdWFsbHkgYnkgYmVpbmcgZXhwcmVzc2VkIGRpcmVjdGx5IGFzIGFuIG9iamVjdCBsaXRlcmFsLlxuICogVGhlIGV4Y2VwdGlvbiBpcyBjb3B5UmVjb3Jkcywgd2hvc2UgbmF0dXJhbCBlbnVtZXJhdGlvbiBvcmRlclxuICogY2FuIGRpZmZlciBiZXR3ZWVuIGNvcHlSZWNvcmRzIHRoYXQgb3VyIGRpc3RyaWJ1dGVkIG9iamVjdCBzZW1hbnRpY3NcbiAqIGNvbnNpZGVycyB0byBiZSBlcXVpdmFsZW50LlxuICogU2luY2UsIGZvciBlYWNoIGNvcHlSZWNvcmQsIHdlIG9ubHkgYWNjZXB0IHN0cmluZyBwcm9wZXJ0eSBuYW1lcyxcbiAqIG5vdCBzeW1ib2xzLCB3ZSBjYW4gY2Fub25pY2FsbHkgc29ydCB0aGUgbmFtZXMgZmlyc3QuXG4gKiBKU09OLnN0cmluZ2lmeSB3aWxsIHRoZW4gdmlzaXQgdGhlc2UgaW4gdGhhdCBzb3J0ZWQgb3JkZXIuXG4gKlxuICogRW5jb2Rpbmcgd2l0aCBhIGNhbm9uaWNhbC1KU09OIGVuY29kZXIgd291bGQgYWxzbyBzb2x2ZSB0aGlzIGNhbm9uaWNhbG5lc3NcbiAqIHByb2JsZW0gaW4gYSBtb3JlIG1vZHVsYXIgYW5kIGVuY2Fwc3VsYXRlZCBtYW5uZXIuIE5vdGUgdGhhdCB0aGVcbiAqIGFjdHVhbCBvcmRlciBwcm9kdWNlZCBoZXJlLCB0aG91Z2ggaXQgYWdyZWVzIHdpdGggY2Fub25pY2FsLUpTT04gb25cbiAqIGNvcHlSZWNvcmQgcHJvcGVydHkgb3JkZXJpbmcsIGRpZmZlcnMgZnJvbSBjYW5vbmljYWwtSlNPTiBhcyBhIHdob2xlXG4gKiBpbiB0aGF0IHRoZSBvdGhlciByZWNvcmQgcHJvcGVydGllcyBhcmUgdmlzaXRlZCBpbiB0aGUgb3JkZXIgaW4gd2hpY2hcbiAqIHRoZXkgYXJlIGxpdGVyYWxseSB3cml0dGVuIGJlbG93LiBUT0RPIHBlcmhhcHMgd2Ugc2hvdWxkIGluZGVlZCBzd2l0Y2hcbiAqIHRvIGEgY2Fub25pY2FsIEpTT04gZW5jb2RlciwgYW5kIG5vdCBkZWxpY2F0ZWx5IGRlcGVuZCBvbiB0aGUgb3JkZXJcbiAqIGluIHdoaWNoIHRoZXNlIG9iamVjdCBsaXRlcmFscyBhcmUgd3JpdHRlbi5cbiAqXG4gKiBSZWFkZXJzIG11c3Qgbm90IGNhcmUgYWJvdXQgdGhpcyBvcmRlciBhbnl3YXkuIFdlIGltcG9zZSB0aGlzIHJlcXVpcmVtZW50XG4gKiBtYWlubHkgdG8gcmVkdWNlIG5vbi1kZXRlcm1pbmlzbSBleHBvc2VkIG91dHNpZGUgYSB2YXQuXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcGFzc2FibGVcbiAqIEByZXR1cm5zIHtFbmNvZGluZ30gZXhjZXB0IHRoYXQgYGVuY29kZVRvQ2FwRGF0YWAgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb0NhcERhdGFgIGlzIG5vdFxuICogZGlyZWN0bHkgZXhwb3NlZC5cbiAqIFdoYXQncyBleHBvc2VkIGluc3RlYWQgaXMgYSB3cmFwcGVyIHRoYXQgZnJlZXplcyB0aGUgb3V0cHV0IGJlZm9yZVxuICogcmV0dXJuaW5nLiBJZiB0aGlzIHR1cm5zIG91dCB0byBpbXBlZGUgc3RhdGljIGFuYWx5c2lzIGZvciBgaGFyZGVuYCBzYWZldHksXG4gKiB3ZSBjYW4gYWx3YXlzIHB1dCB0aGUgKG5vdyByZWR1bmRhbnQpIGhhcmRlbnMgYmFjayBpbi4gVGhleSBkb24ndCBodXJ0LlxuICovXG5jb25zdCBlbmNvZGVUb0NhcERhdGFSZWN1cj0ocGFzc2FibGUpPT57XG4vKiBGaXJzdCB3ZSBoYW5kbGUgYWxsIHByaW1pdGl2ZXMuIFNvbWUgY2FuIGJlIHJlcHJlc2VudGVkIGRpcmVjdGx5IGFzKi9cbi8qIEpTT04sIGFuZCBzb21lIG11c3QgYmUgZW5jb2RlZCBhcyBbUUNMQVNTXSBjb21wb3NpdGVzLiovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocGFzc2FibGUpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ251bGwnOlxuY2FzZSdib29sZWFuJzpcbmNhc2Unc3RyaW5nJzp7XG4vKiBwYXNzIHRocm91Z2ggdG8gSlNPTiovXG5yZXR1cm4gcGFzc2FibGU7XG4gfVxuY2FzZSd1bmRlZmluZWQnOntcbnJldHVybntbUUNMQVNTXTondW5kZWZpbmVkJ307XG4gfVxuY2FzZSdudW1iZXInOntcbi8qIFNwZWNpYWwtY2FzZSBudW1iZXJzIHdpdGggbm8gZGlnaXQtYmFzZWQgcmVwcmVzZW50YXRpb24uKi9cbmlmKE51bWJlci5pc05hTihwYXNzYWJsZSkpe1xucmV0dXJue1tRQ0xBU1NdOidOYU4nfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybntbUUNMQVNTXTonSW5maW5pdHknfTtcbiB9ZWxzZSBpZihwYXNzYWJsZT09PS1JbmZpbml0eSl7XG5yZXR1cm57W1FDTEFTU106Jy1JbmZpbml0eSd9O1xuIH1cbi8qIFBhc3MgdGhyb3VnaCBldmVyeXRoaW5nIGVsc2UsIHJlcGxhY2luZyAtMCB3aXRoIDAuKi9cbnJldHVybiBpcyhwYXNzYWJsZSwtMCk/MDpwYXNzYWJsZTtcbiB9XG5jYXNlJ2JpZ2ludCc6e1xucmV0dXJue1xuW1FDTEFTU106J2JpZ2ludCcsXG5kaWdpdHM6U3RyaW5nKHBhc3NhYmxlKX07XG5cbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJue1xuW1FDTEFTU106J3N5bWJvbCcsXG5uYW1lfTtcblxuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuaWYoaGFzT3duUHJvcGVydHlPZihwYXNzYWJsZSxRQ0xBU1MpKXtcbi8qIEhpbGJlcnQgaG90ZWwqL1xuY29uc3R7W1FDTEFTU106cWNsYXNzVmFsdWUsLi4ucmVzdH09cGFzc2FibGU7XG4vKiogQHR5cGUge0VuY29kaW5nfSAqL1xuY29uc3QgcmVzdWx0PXtcbltRQ0xBU1NdOidoaWxiZXJ0Jyxcbm9yaWdpbmFsOmVuY29kZVRvQ2FwRGF0YVJlY3VyKHFjbGFzc1ZhbHVlKX07XG5cbmlmKG93bktleXMocmVzdCkubGVuZ3RoPj0xKXtcbi8qIFdlIGhhcmRlbiB0aGUgZW50aXJlIGNhcERhdGEgZW5jb2RpbmcgYmVmb3JlIHdlIHJldHVybiBpdC4qL1xuLyogYGVuY29kZVRvQ2FwRGF0YWAgcmVxdWlyZXMgdGhhdCBpdHMgaW5wdXQgYmUgUGFzc2FibGUsIGFuZCovXG4vKiB0aGVyZWZvcmUgaGFyZGVuZWQuKi9cbi8qIFRoZSBgZnJlZXplYCBoZXJlIGlzIG5lZWRlZCBhbnl3YXksIGJlY2F1c2UgdGhlIGByZXN0YCBpcyovXG4vKiBmcmVzaGx5IGNvbnN0cnVjdGVkIGJ5IHRoZSBgLi4uYCBhYm92ZSwgYW5kIHdlJ3JlIHVzaW5nIGl0Ki9cbi8qIGFzIGltcHV0IGluIGFub3RoZXIgY2FsbCB0byBgZW5jb2RlVG9DYXBEYXRhYC4qL1xucmVzdWx0LnJlc3Q9ZW5jb2RlVG9DYXBEYXRhUmVjdXIoZnJlZXplKHJlc3QpKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbi8qIEN1cnJlbnRseSBjb3B5UmVjb3JkIGFsbG93cyBvbmx5IHN0cmluZyBrZXlzIHNvIHRoaXMgd2lsbCovXG4vKiB3b3JrLiBJZiB3ZSBhbGxvdyBzb3J0YWJsZSBzeW1ib2wga2V5cywgdGhpcyB3aWxsIG5lZWQgdG8qL1xuLyogYmVjb21lIG1vcmUgaW50ZXJlc3RpbmcuKi9cbmNvbnN0IG5hbWVzPW93bktleXMocGFzc2FibGUpLnNvcnQoKTtcbnJldHVybiBmcm9tRW50cmllcyhcbm5hbWVzLm1hcCgobmFtZSk9PltuYW1lLGVuY29kZVRvQ2FwRGF0YVJlY3VyKHBhc3NhYmxlW25hbWVdKV0pKTtcblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xucmV0dXJue1xuW1FDTEFTU106J3RhZ2dlZCcsXG50YWc6Z2V0VGFnKHBhc3NhYmxlKSxcbnBheWxvYWQ6ZW5jb2RlVG9DYXBEYXRhUmVjdXIocGFzc2FibGUucGF5bG9hZCl9O1xuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhKFxucGFzc2FibGUsXG5lbmNvZGVUb0NhcERhdGFSZWN1cik7XG5cbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbi8qIGB0aHJvd2AgaXMgbm9vcCBzaW5jZSBgRmFpbGAgdGhyb3dzLiBCdXQgbGludGVyIGNvbmZ1c2VkKi9cbnRocm93IEZhaWwgYGludGVybmFsOiBSZW1vdGFibGUgZW5jb2RpbmcgbXVzdCBiZSBhbiBvYmplY3Qgd2l0aCAke3EoXG5RQ0xBU1MpXG4gfSAke3EoJ3Nsb3QnKX06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UncHJvbWlzZSc6e1xuY29uc3QgZW5jb2RlZD1lbmNvZGVQcm9taXNlVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKTtcbmlmKHFjbGFzc01hdGNoZXMoZW5jb2RlZCwnc2xvdCcpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBQcm9taXNlIGVuY29kaW5nIG11c3QgYmUgYW4gb2JqZWN0IHdpdGggJHtxKFxuUUNMQVNTLFxuJ3Nsb3QnKVxuIH06ICR7ZW5jb2RlZH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlRXJyb3JUb0NhcERhdGEocGFzc2FibGUsZW5jb2RlVG9DYXBEYXRhUmVjdXIpO1xuaWYocWNsYXNzTWF0Y2hlcyhlbmNvZGVkLCdlcnJvcicpKXtcbnJldHVybiBlbmNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBFcnJvciBlbmNvZGluZyBtdXN0IGJlIGFuIG9iamVjdCB3aXRoICR7cShcblFDTEFTUyxcbidlcnJvcicpXG4gfTogJHtlbmNvZGVkfWA7XG4gfVxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChcblggYGludGVybmFsOiBVbnJlY29nbml6ZWQgcGFzc1N0eWxlICR7cShwYXNzU3R5bGUpfWAsXG5UeXBlRXJyb3IpO1xuXG4gfX1cblxuIH07XG5jb25zdCBlbmNvZGVUb0NhcERhdGE9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5yZXR1cm4gaGFyZGVuKGVuY29kZUVycm9yVG9DYXBEYXRhKHBhc3NhYmxlLGVuY29kZVRvQ2FwRGF0YVJlY3VyKSk7XG4gfVxucmV0dXJuIGhhcmRlbihlbmNvZGVUb0NhcERhdGFSZWN1cihwYXNzYWJsZSkpO1xuIH07XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvQ2FwRGF0YSk7XG4gfTskaOKAjV9vbmNlLm1ha2VFbmNvZGVUb0NhcERhdGEobWFrZUVuY29kZVRvQ2FwRGF0YSk7XG5oYXJkZW4obWFrZUVuY29kZVRvQ2FwRGF0YSk7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVjb2RlT3B0aW9uc1xuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRSZW1vdGFibGU6IEVuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IEVuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiAoUHJvbWlzZXxSZW1vdGFibGUpfSBbZGVjb2RlUmVtb3RhYmxlRnJvbUNhcERhdGFdXG4gKiBAcHJvcGVydHkgeyhcbiAqICAgZW5jb2RlZFByb21pc2U6IEVuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGU6IEVuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiAoUHJvbWlzZXxSZW1vdGFibGUpfSBbZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhXVxuICogQHByb3BlcnR5IHsoXG4gKiAgIGVuY29kZWRFcnJvcjogRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZTogRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IEVycm9yfSBbZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YV1cbiAqL1xuXG5jb25zdCBkb250RGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGE9KHNsb3RFbmNvZGluZyk9PlxuRmFpbCBgcmVtb3RhYmxlIG9yIHByb21pc2UgdW5leHBlY3RlZDogJHtzbG90RW5jb2Rpbmd9YDtcbmNvbnN0IGRvbnREZWNvZGVFcnJvckZyb21DYXBEYXRhPShlcnJvckVuY29kaW5nKT0+XG5GYWlsIGBlcnJvciB1bmV4cGVjdGVkOiAke2Vycm9yRW5jb2Rpbmd9YDtcblxuLyoqXG4gKiBUaGUgY3VycmVudCBlbmNvZGluZyBkb2VzIG5vdCBnaXZlIHRoZSBkZWNvZGVyIGVub3VnaCBpbnRvIHRvIGRpc3Rpbmd1aXNoXG4gKiB3aGV0aGVyIGEgc2xvdCByZXByZXNlbnRzIGEgcHJvbWlzZSBvciBhIHJlbW90YWJsZS4gQXMgYW4gaW1wbGVtZW50YXRpb25cbiAqIHJlc3RyaWN0aW9uIHVudGlsIHRoaXMgaXMgZml4ZWQsIGlmIGVpdGhlciBpcyBwcm92aWRlZCwgYm90aCBtdXN0IGJlXG4gKiBwcm92aWRlZCBhbmQgdGhleSBtdXN0IGJlIHRoZSBzYW1lLlxuICpcbiAqIFRoaXMgc2VlbXMgbGlrZSB0aGUgYmVzdCBzdGFydGluZyBwb2ludCB0byBpbmNyZW1lbnRhbGx5IGV2b2x2ZSB0byBhblxuICogQVBJIHdoZXJlIHRoZXNlIGNhbiByZWxpYWJseSBkaWZmZXIuXG4gKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy80MzM0XG4gKlxuICogQHBhcmFtIHtEZWNvZGVPcHRpb25zfSBbZGVjb2RlT3B0aW9uc11cbiAqIEByZXR1cm5zIHsoZW5jb2RlZDogRW5jb2RpbmcpID0+IFBhc3NhYmxlfVxuICovXG5jb25zdCAgICAgICAgbWFrZURlY29kZUZyb21DYXBEYXRhPShkZWNvZGVPcHRpb25zPXt9KT0+e1xuY29uc3R7XG5kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YT1kb250RGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGEsXG5kZWNvZGVQcm9taXNlRnJvbUNhcERhdGE9ZG9udERlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhLFxuZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YT1kb250RGVjb2RlRXJyb3JGcm9tQ2FwRGF0YX09XG5kZWNvZGVPcHRpb25zO1xuXG5kZWNvZGVSZW1vdGFibGVGcm9tQ2FwRGF0YT09PWRlY29kZVByb21pc2VGcm9tQ2FwRGF0YXx8XG5GYWlsIGBBbiBpbXBsZW1lbnRhdGlvbiByZXN0cmljdGlvbiBmb3Igbm93OiBJZiBlaXRoZXIgZGVjb2RlUmVtb3RhYmxlRnJvbUNhcERhdGEgb3IgZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhIGlzIHByb3ZpZGVkLCBib3RoIG11c3QgYmUgcHJvdmlkZWQgYW5kIHRoZXkgbXVzdCBiZSB0aGUgc2FtZTogJHtxKFxuZGVjb2RlUmVtb3RhYmxlRnJvbUNhcERhdGEpXG4gfSB2cyAke3EoZGVjb2RlUHJvbWlzZUZyb21DYXBEYXRhKX1gO1xuXG4vKipcbiAqIGBkZWNvZGVGcm9tQ2FwRGF0YWAgbWF5IHJlbHkgb24gYGpzb25FbmNvZGVkYCBiZWluZyB0aGUgcmVzdWx0IG9mIGFcbiAqIHBsYWluIGNhbGwgdG8gSlNPTi5wYXJzZS4gSG93ZXZlciwgaXQgKmNhbm5vdCogcmVseSBvbiBganNvbkVuY29kZWRgXG4gKiBoYXZpbmcgYmVlbiBwcm9kdWNlZCBieSBKU09OLnN0cmluZ2lmeSBvbiB0aGUgb3V0cHV0IG9mIGBlbmNvZGVUb0NhcERhdGFgXG4gKiBhYm92ZSwgaS5lLiwgYGRlY29kZUZyb21DYXBEYXRhYCBjYW5ub3QgcmVseSBvbiBganNvbkVuY29kZWRgIGJlaW5nIGFcbiAqIHZhbGlkIG1hcnNoYWxsZWQgcmVwcmVzZW50YXRpb24uIFJhdGhlciwgYGRlY29kZUZyb21DYXBEYXRhYCBtdXN0XG4gKiB2YWxpZGF0ZSB0aGF0LlxuICpcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IGpzb25FbmNvZGVkIG11c3QgYmUgaGFyZGVuZWRcbiAqL1xuY29uc3QgZGVjb2RlRnJvbUNhcERhdGE9KGpzb25FbmNvZGVkKT0+e1xuaWYoIWlzT2JqZWN0KGpzb25FbmNvZGVkKSl7XG4vKiBwcmltaXRpdmVzIHBhc3MgdGhyb3VnaCovXG5yZXR1cm4ganNvbkVuY29kZWQ7XG4gfVxuaWYoaXNBcnJheShqc29uRW5jb2RlZCkpe1xucmV0dXJuIGpzb25FbmNvZGVkLm1hcCgoZW5jb2RlZFZhbCk9PmRlY29kZUZyb21DYXBEYXRhKGVuY29kZWRWYWwpKTtcbiB9ZWxzZSBpZihoYXNRQ2xhc3MoanNvbkVuY29kZWQpKXtcbmNvbnN0IHFjbGFzcz1qc29uRW5jb2RlZFtRQ0xBU1NdO1xudHlwZW9mIHFjbGFzcz09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgJHtxKFFDTEFTUyl9IHR5cGVvZiAke3EodHlwZW9mIHFjbGFzcyl9YDtcbnN3aXRjaChxY2xhc3Mpe1xuLyogRW5jb2Rpbmcgb2YgcHJpbWl0aXZlcyBub3QgaGFuZGxlZCBieSBKU09OKi9cbmNhc2UndW5kZWZpbmVkJzp7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH1cbmNhc2UnTmFOJzp7XG5yZXR1cm4gTmFOO1xuIH1cbmNhc2UnSW5maW5pdHknOntcbnJldHVybiBJbmZpbml0eTtcbiB9XG5jYXNlJy1JbmZpbml0eSc6e1xucmV0dXJuLUluZmluaXR5O1xuIH1cbmNhc2UnYmlnaW50Jzp7XG4vKiBVc2luZyBAdHMtaWdub3JlIHJhdGhlciB0aGFuIEB0cy1leHBlY3QtZXJyb3IgYmVsb3cgYmVjYXVzZSovXG4vKiB3aXRoIEB0cy1leHBlY3QtZXJyb3IgSSBnZXQgYSByZWQgdW5kZXJsaW5lIGluIHZzY29kZSwgYnV0Ki9cbi8qIHdpdGhvdXQgaXQgSSBnZXQgZXJyb3JzIGZyb20gYHlhcm4gbGludGAuKi9cbi8qIEB0cy1pZ25vcmUgaW5hZGVxdWF0ZSB0eXBlIGluZmVyZW5jZSovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI1OSNkaXNjdXNzaW9uX3I5NTQ1NjE5MDEqL1xuY29uc3R7ZGlnaXRzfT1qc29uRW5jb2RlZDtcbnR5cGVvZiBkaWdpdHM9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkIGRpZ2l0cyB0eXBlb2YgJHtxKHR5cGVvZiBkaWdpdHMpfWA7XG5yZXR1cm4gQmlnSW50KGRpZ2l0cyk7XG4gfVxuY2FzZSdAQGFzeW5jSXRlcmF0b3InOntcbi8qIERlcHJlY2F0ZWQgcWNsYXNzLiBUT0RPIG1ha2UgY29uZGl0aW9uYWwqL1xuLyogb24gZW52aXJvbm1lbnQgdmFyaWFibGUuIEV2ZW50dWFsbHkgcmVtb3ZlLCBidXQgYWZ0ZXIgY29uZmlkZW50Ki9cbi8qIHRoYXQgdGhlcmUgYXJlIG5vIG1vcmUgc3VwcG9ydGVkIHNlbmRlcnMuKi9cbi8qKi9cbi8qIFVzaW5nIEB0cy1pZ25vcmUgcmF0aGVyIHRoYW4gQHRzLWV4cGVjdC1lcnJvciBiZWxvdyBiZWNhdXNlKi9cbi8qIHdpdGggQHRzLWV4cGVjdC1lcnJvciBJIGdldCBhIHJlZCB1bmRlcmxpbmUgaW4gdnNjb2RlLCBidXQqL1xuLyogd2l0aG91dCBpdCBJIGdldCBlcnJvcnMgZnJvbSBgeWFybiBsaW50YC4qL1xuLyogQHRzLWlnbm9yZSBpbmFkZXF1YXRlIHR5cGUgaW5mZXJlbmNlKi9cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vcHVsbC8xMjU5I2Rpc2N1c3Npb25fcjk1NDU2MTkwMSovXG5yZXR1cm4gU3ltYm9sLmFzeW5jSXRlcmF0b3I7XG4gfVxuY2FzZSdzeW1ib2wnOntcbi8qIFVzaW5nIEB0cy1pZ25vcmUgcmF0aGVyIHRoYW4gQHRzLWV4cGVjdC1lcnJvciBiZWxvdyBiZWNhdXNlKi9cbi8qIHdpdGggQHRzLWV4cGVjdC1lcnJvciBJIGdldCBhIHJlZCB1bmRlcmxpbmUgaW4gdnNjb2RlLCBidXQqL1xuLyogd2l0aG91dCBpdCBJIGdldCBlcnJvcnMgZnJvbSBgeWFybiBsaW50YC4qL1xuLyogQHRzLWlnbm9yZSBpbmFkZXF1YXRlIHR5cGUgaW5mZXJlbmNlKi9cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vcHVsbC8xMjU5I2Rpc2N1c3Npb25fcjk1NDU2MTkwMSovXG5jb25zdHtuYW1lfT1qc29uRW5jb2RlZDtcbnJldHVybiBwYXNzYWJsZVN5bWJvbEZvck5hbWUobmFtZSk7XG4gfVxuY2FzZSd0YWdnZWQnOntcbi8qIFVzaW5nIEB0cy1pZ25vcmUgcmF0aGVyIHRoYW4gQHRzLWV4cGVjdC1lcnJvciBiZWxvdyBiZWNhdXNlKi9cbi8qIHdpdGggQHRzLWV4cGVjdC1lcnJvciBJIGdldCBhIHJlZCB1bmRlcmxpbmUgaW4gdnNjb2RlLCBidXQqL1xuLyogd2l0aG91dCBpdCBJIGdldCBlcnJvcnMgZnJvbSBgeWFybiBsaW50YC4qL1xuLyogQHRzLWlnbm9yZSBpbmFkZXF1YXRlIHR5cGUgaW5mZXJlbmNlKi9cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vZW5kb2pzL2VuZG8vcHVsbC8xMjU5I2Rpc2N1c3Npb25fcjk1NDU2MTkwMSovXG5jb25zdHt0YWcscGF5bG9hZH09anNvbkVuY29kZWQ7XG5yZXR1cm4gbWFrZVRhZ2dlZCh0YWcsZGVjb2RlRnJvbUNhcERhdGEocGF5bG9hZCkpO1xuIH1cbmNhc2Unc2xvdCc6e1xuLyogU2VlIG5vdGUgYWJvdmUgYWJvdXQgaG93IHRoZSBjdXJyZW50IGVuY29kaW5nIGNhbm5vdCByZWxpYWJseSovXG4vKiBkaXN0aW5ndWlzaCB3aGljaCB3ZSBzaG91bGQgY2FsbCwgc28gaW4gdGhlIG5vbi1kZWZhdWx0IGNhc2UqL1xuLyogYm90aCBtdXN0IGJlIHRoZSBzYW1lIGFuZCBpdCBkb2Vzbid0IG1hdHRlciB3aGljaCB3ZSBjYWxsLiovXG5jb25zdCBkZWNvZGVkPWRlY29kZVJlbW90YWJsZUZyb21DYXBEYXRhKFxuanNvbkVuY29kZWQsXG5kZWNvZGVGcm9tQ2FwRGF0YSk7XG5cbi8qIEJFV0FSRTogY2FwZGF0YSBkb2VzIG5vdCBjaGVjayB0aGF0IGBkZWNvZGVkYCBpcyovXG4vKiBhIHByb21pc2Ugb3IgYSByZW1vdGFibGUsIHNpbmNlIHRoYXQgd291bGQgYnJlYWsgc29tZSovXG4vKiBjYXBkYXRhIGNsaWVudHMuIFdlIGFyZSBkZXByZWNhdGluZyBjYXBkYXRhLCBhbmQgdGhlc2UgY2xpZW50cyovXG4vKiB3aWxsIG5lZWQgdG8gdXBkYXRlIGJlZm9yZSBzd2l0Y2hpbmcgdG8gc21hbGxjYXBzLiovXG5yZXR1cm4gZGVjb2RlZDtcbiB9XG5jYXNlJ2Vycm9yJzp7XG5jb25zdCBkZWNvZGVkPWRlY29kZUVycm9yRnJvbUNhcERhdGEoXG5qc29uRW5jb2RlZCxcbmRlY29kZUZyb21DYXBEYXRhKTtcblxuaWYocGFzc1N0eWxlT2YoZGVjb2RlZCk9PT0nZXJyb3InKXtcbnJldHVybiBkZWNvZGVkO1xuIH1cbnRocm93IEZhaWwgYGludGVybmFsOiBkZWNvZGVFcnJvckZyb21DYXBEYXRhIG9wdGlvbiBtdXN0IHJldHVybiBhbiBlcnJvcjogJHtkZWNvZGVkfWA7XG4gfVxuY2FzZSdoaWxiZXJ0Jzp7XG4vKiBVc2luZyBAdHMtaWdub3JlIHJhdGhlciB0aGFuIEB0cy1leHBlY3QtZXJyb3IgYmVsb3cgYmVjYXVzZSovXG4vKiB3aXRoIEB0cy1leHBlY3QtZXJyb3IgSSBnZXQgYSByZWQgdW5kZXJsaW5lIGluIHZzY29kZSwgYnV0Ki9cbi8qIHdpdGhvdXQgaXQgSSBnZXQgZXJyb3JzIGZyb20gYHlhcm4gbGludGAuKi9cbi8qIEB0cy1pZ25vcmUgaW5hZGVxdWF0ZSB0eXBlIGluZmVyZW5jZSovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL3B1bGwvMTI1OSNkaXNjdXNzaW9uX3I5NTQ1NjE5MDEqL1xuY29uc3R7b3JpZ2luYWwscmVzdH09anNvbkVuY29kZWQ7XG5oYXNPd25Qcm9wZXJ0eU9mKGpzb25FbmNvZGVkLCdvcmlnaW5hbCcpfHxcbkZhaWwgYEludmFsaWQgSGlsYmVydCBIb3RlbCBlbmNvZGluZyAke2pzb25FbmNvZGVkfWA7XG4vKiBEb24ndCBoYXJkZW4gc2luY2Ugd2UncmUgbm90IGRvbmUgbXV0YXRpbmcgaXQqL1xuY29uc3QgcmVzdWx0PXtbUUNMQVNTXTpkZWNvZGVGcm9tQ2FwRGF0YShvcmlnaW5hbCl9O1xuaWYoaGFzT3duUHJvcGVydHlPZihqc29uRW5jb2RlZCwncmVzdCcpKXtcbmNvbnN0IGlzTm9uRW1wdHlPYmplY3Q9XG50eXBlb2YgcmVzdD09PSdvYmplY3QnJiZcbnJlc3QhPT1udWxsJiZcbm93bktleXMocmVzdCkubGVuZ3RoPj0xO1xuaWYoIWlzTm9uRW1wdHlPYmplY3Qpe1xudGhyb3cgRmFpbCBgUmVzdCBlbmNvZGluZyBtdXN0IGJlIGEgbm9uLWVtcHR5IG9iamVjdDogJHtyZXN0fWA7XG4gfVxuY29uc3QgcmVzdE9iaj1kZWNvZGVGcm9tQ2FwRGF0YShyZXN0KTtcbi8qIFRPRE8gcmVhbGx5IHNob3VsZCBhc3NlcnQgdGhhdCBgcGFzc1N0eWxlT2YocmVzdClgIGlzKi9cbi8qIGAnY29weVJlY29yZCdgIGJ1dCB3ZSdkIGhhdmUgdG8gaGFyZGVuIGl0IGFuZCBpdCBpcyB0b28qL1xuLyogZWFybHkgdG8gZG8gdGhhdC4qL1xuIWhhc093blByb3BlcnR5T2YocmVzdE9iaixRQ0xBU1MpfHxcbkZhaWwgYFJlc3QgbXVzdCBub3QgY29udGFpbiBpdHMgb3duIGRlZmluaXRpb24gb2YgJHtxKFFDTEFTUyl9YDtcbmRlZmluZVByb3BlcnRpZXMocmVzdWx0LGdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocmVzdE9iaikpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfVxuLyogQHRzLWV4cGVjdC1lcnJvciBUaGlzIGlzIHRoZSBlcnJvciBjYXNlIHdlJ3JlIHRlc3RpbmcgZm9yKi9cbmNhc2UnaWJpZCc6e1xudGhyb3cgRmFpbCBgVGhlIGNhcERhdGEgcHJvdG9jb2wgbm8gbG9uZ2VyIHN1cHBvcnRzICR7cShRQ0xBU1MpfSAke3EoXG5xY2xhc3MpXG4gfWA7XG4gfVxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGB1bnJlY29nbml6ZWQgJHtxKFFDTEFTUyl9ICR7cShxY2xhc3MpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfWVsc2V7XG5hc3NlcnQodHlwZW9mIGpzb25FbmNvZGVkPT09J29iamVjdCcmJmpzb25FbmNvZGVkIT09bnVsbCk7XG5jb25zdCBkZWNvZGVFbnRyeT0oW25hbWUsZW5jb2RlZFZhbF0pPT57XG50eXBlb2YgbmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYFByb3BlcnR5ICR7cShuYW1lKX0gb2YgJHtqc29uRW5jb2RlZH0gbXVzdCBiZSBhIHN0cmluZ2A7XG5yZXR1cm5bbmFtZSxkZWNvZGVGcm9tQ2FwRGF0YShlbmNvZGVkVmFsKV07XG4gfTtcbmNvbnN0IGRlY29kZWRFbnRyaWVzPWVudHJpZXMoanNvbkVuY29kZWQpLm1hcChkZWNvZGVFbnRyeSk7XG5yZXR1cm4gZnJvbUVudHJpZXMoZGVjb2RlZEVudHJpZXMpO1xuIH1cbiB9O1xucmV0dXJuIGhhcmRlbihkZWNvZGVGcm9tQ2FwRGF0YSk7XG4gfTskaOKAjV9vbmNlLm1ha2VEZWNvZGVGcm9tQ2FwRGF0YShtYWtlRGVjb2RlRnJvbUNhcERhdGEpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IlFDTEFTUyI6WyJRQ0xBU1MiXSwibWFrZUVuY29kZVRvQ2FwRGF0YSI6WyJtYWtlRW5jb2RlVG9DYXBEYXRhIl0sIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YSI6WyJtYWtlRGVjb2RlRnJvbUNhcERhdGEiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAs173a8U7AADFOwAALQAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9lbmNvZGVUb1NtYWxsY2Fwcy5qc3siaW1wb3J0cyI6WyJAZW5kby9wYXNzLXN0eWxlIl0sImV4cG9ydHMiOlsibWFrZURlY29kZUZyb21TbWFsbGNhcHMiLCJtYWtlRW5jb2RlVG9TbWFsbGNhcHMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcGFzc1N0eWxlT2YsaXNFcnJvckxpa2UsbWFrZVRhZ2dlZCxnZXRUYWcsaGFzT3duUHJvcGVydHlPZixhc3NlcnRQYXNzYWJsZVN5bWJvbCxuYW1lRm9yUGFzc2FibGVTeW1ib2wscGFzc2FibGVTeW1ib2xGb3JOYW1lOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV0sW1wiaXNFcnJvckxpa2VcIiwgWyRo4oCNX2EgPT4gKGlzRXJyb3JMaWtlID0gJGjigI1fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaOKAjV9hID0+IChtYWtlVGFnZ2VkID0gJGjigI1fYSldXSxbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjigI1fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UGFzc2FibGVTeW1ib2xcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFBhc3NhYmxlU3ltYm9sID0gJGjigI1fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRo4oCNX2EgPT4gKG5hbWVGb3JQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV0sW1wicGFzc2FibGVTeW1ib2xGb3JOYW1lXCIsIFskaOKAjV9hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUmVtb3RhYmxlfSBSZW1vdGFibGUgKi9cbi8qIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuU21hbGxjYXBzRW5jb2Rpbmd9IFNtYWxsY2Fwc0VuY29kaW5nICpYLyovXG4vKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlNtYWxsY2Fwc0VuY29kaW5nVW5pb259IFNtYWxsY2Fwc0VuY29kaW5nVW5pb24gKlgvKi9cbi8qKiBAdHlwZWRlZiB7YW55fSBTbWFsbGNhcHNFbmNvZGluZyAqL1xuLyoqIEB0eXBlZGVmIHthbnl9IFNtYWxsY2Fwc0VuY29kaW5nVW5pb24gKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7aXMsZW50cmllcyxmcm9tRW50cmllc309T2JqZWN0O1xuY29uc3R7ZGV0YWlsczpYLEZhaWwscXVvdGU6cX09YXNzZXJ0O1xuXG5jb25zdCBCQU5HPSchJy5jaGFyQ29kZUF0KDApO1xuY29uc3QgREFTSD0nLScuY2hhckNvZGVBdCgwKTtcblxuLyoqXG4gKiBBbiBgZW5jb2RlVG9TbWFsbGNhcHNgIGZ1bmN0aW9uIHRha2VzIGEgcGFzc2FibGUgYW5kIHJldHVybnMgYVxuICogSlNPTi1yZXByZXNlbnRhYmxlIG9iamVjdCAoaS5lLiwgcm91bmQtdHJpcHBpbmcgaXQgdGhyb3VnaFxuICogYEpTT04uc3RyaW5naWZ5YCBhbmQgYEpTT04ucGFyc2VgIHdpdGggbm8gcmVwbGFjZXJzIG9yIHJldml2ZXJzXG4gKiByZXR1cm5zIGFuIGVxdWl2YWxlbnQgc3RydWN0dXJlIGV4Y2VwdCBmb3Igb2JqZWN0IGlkZW50aXR5KS5cbiAqIFdlIGNhbGwgdGhpcyByZXByZXNlbnRhdGlvbiBhIFNtYWxsY2FwcyBFbmNvZGluZy5cbiAqXG4gKiBBIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBmdW5jdGlvbiB0YWtlcyBhcyBhcmd1bWVudCB3aGF0IGl0XG4gKiAqYXNzdW1lcyogaXMgdGhlIHJlc3VsdCBvZiBhIHBsYWluIGBKU09OLnBhcnNlYCB3aXRoIG5vIHJlc29sdmVyLiBJdCB0aGVuXG4gKiBtdXN0IHZhbGlkYXRlIHRoYXQgaXQgaXMgYSB2YWxpZCBTbWFsbGNhcHMgRW5jb2RpbmcsIGFuZCBpZiBpdCBpcyxcbiAqIHJldHVybiBhIGNvcnJlc3BvbmRpbmcgcGFzc2FibGUuXG4gKlxuICogU21hbGxjYXBzIGNvbnNpZGVycyB0aGUgY2hhcmFjdGVycyBiZXR3ZWVuIGAhYCAoYXNjaWkgY29kZSAzMywgQkFORylcbiAqIGFuZCBgLWAgKGFzY2lpIGNvZGUgNDUsIERBU0gpIHRvIGJlIHNwZWNpYWwgcHJlZml4ZXMgYWxsb3dpbmdcbiAqIHJlcHJlc2VudGF0aW9uIG9mIEpTT04taW5jb21wYXRpYmxlIGRhdGEgdXNpbmcgc3RyaW5ncy5cbiAqIFRoZXNlIGNoYXJhY3RlcnMsIGluIG9yZGVyLCBhcmUgYCFcIiMkJSYnKCkqKywtYFxuICogT2YgdGhlc2UsIHNtYWxsY2FwcyBjdXJyZW50bHkgdXNlcyB0aGUgZm9sbG93aW5nOlxuICpcbiAqICAqIGAhYCAtIGVzY2FwZWQgc3RyaW5nXG4gKiAgKiBgK2AgLSBub24tbmVnYXRpdmUgYmlnaW50XG4gKiAgKiBgLWAgLSBuZWdhdGl2ZSBiaWdpbnRcbiAqICAqIGAjYCAtIG1hbmlmZXN0IGNvbnN0YW50XG4gKiAgKiBgJWAgLSBzeW1ib2xcbiAqICAqIGAkYCAtIHJlbW90YWJsZVxuICogICogYCZgIC0gcHJvbWlzZVxuICpcbiAqIEFsbCBvdGhlciBzcGVjaWFsIGNoYXJhY3RlcnMgKGBcIicoKSosYCkgYXJlIHJlc2VydmVkIGZvciBmdXR1cmUgdXNlLlxuICpcbiAqIFRoZSBtYW5pZmVzdCBjb25zdGFudHMgdGhhdCBzbWFsbGNhcHMgY3VycmVudGx5IHVzZXMgZm9yIHZhbHVlczpcbiAqICAqIGAjdW5kZWZpbmVkYFxuICogICogYCNOYU5gXG4gKiAgKiBgI0luZmluaXR5YFxuICogICogYCMtSW5maW5pdHlgXG4gKlxuICogYW5kIGZvciBwcm9wZXJ0eSBuYW1lcyBhbmFsb2dvdXMgdG8gY2FwZGF0YSBAcWNsYXNzOlxuICogICogYCN0YWdgXG4gKiAgKiBgI2Vycm9yYFxuICpcbiAqIEFsbCBvdGhlciBlbmNvZGVkIHN0cmluZ3MgYmVnaW5uaW5nIHdpdGggYCNgIGFyZSByZXNlcnZlZCBmb3JcbiAqIGZ1dHVyZSB1c2UuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IGVuY29kZWRTdHJcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBzdGFydHNTcGVjaWFsPShlbmNvZGVkU3RyKT0+e1xuaWYoZW5jb2RlZFN0cj09PScnKXtcbnJldHVybiBmYWxzZTtcbiB9XG4vKiBjaGFyQ29kZUF0KDApIGFuZCBudW1iZXIgY29tcGFyZSBpcyBhIGJpdCBmYXN0ZXIuKi9cbmNvbnN0IGNvZGU9ZW5jb2RlZFN0ci5jaGFyQ29kZUF0KDApO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIHlvZGEqL1xucmV0dXJuIEJBTkc8PWNvZGUmJmNvZGU8PURBU0g7XG4gfTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBFbmNvZGVUb1NtYWxsY2Fwc09wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICByZW1vdGFibGU6IFJlbW90YWJsZSxcbiAqICAgZW5jb2RlUmVjdXI6IChwOiBQYXNzYWJsZSkgPT4gU21hbGxjYXBzRW5jb2RpbmdcbiAqICkgPT4gU21hbGxjYXBzRW5jb2Rpbmd9IFtlbmNvZGVSZW1vdGFibGVUb1NtYWxsY2Fwc11cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBwcm9taXNlOiBQcm9taXNlLFxuICogICBlbmNvZGVSZWN1cjogKHA6IFBhc3NhYmxlKSA9PiBTbWFsbGNhcHNFbmNvZGluZ1xuICogKSA9PiBTbWFsbGNhcHNFbmNvZGluZ30gW2VuY29kZVByb21pc2VUb1NtYWxsY2Fwc11cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlcnJvcjogRXJyb3IsXG4gKiAgIGVuY29kZVJlY3VyOiAocDogUGFzc2FibGUpID0+IFNtYWxsY2Fwc0VuY29kaW5nXG4gKiApID0+IFNtYWxsY2Fwc0VuY29kaW5nfSBbZW5jb2RlRXJyb3JUb1NtYWxsY2Fwc11cbiAqL1xuXG5jb25zdCBkb250RW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHM9KHJlbSk9PlxuRmFpbCBgcmVtb3RhYmxlIHVuZXhwZWN0ZWQ6ICR7cmVtfWA7XG5cbmNvbnN0IGRvbnRFbmNvZGVQcm9taXNlVG9TbWFsbGNhcHM9KHByb20pPT5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7cHJvbX1gO1xuXG5jb25zdCBkb250RW5jb2RlRXJyb3JUb1NtYWxsY2Fwcz0oZXJyKT0+XG5GYWlsIGBlcnJvciBvYmplY3QgdW5leHBlY3RlZDogJHtxKGVycil9YDtcblxuLyoqXG4gKiBAcGFyYW0ge0VuY29kZVRvU21hbGxjYXBzT3B0aW9uc30gW2VuY29kZU9wdGlvbnNdXG4gKiBlbmNvZGVPcHRpb25zIGlzIGFjdHVhbGx5IG9wdGlvbmFsLCBidXQgbm90IG1hcmtlZCBhcyBzdWNoIHRvIHdvcmsgYXJvdW5kXG4gKiBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvaXNzdWVzLzUwMjg2XG4gKlxuICogQHJldHVybnMgeyhwYXNzYWJsZTogUGFzc2FibGUpID0+IFNtYWxsY2Fwc0VuY29kaW5nfVxuICovXG5jb25zdCAgICAgICAgbWFrZUVuY29kZVRvU21hbGxjYXBzPShlbmNvZGVPcHRpb25zPXt9KT0+e1xuY29uc3R7XG5lbmNvZGVSZW1vdGFibGVUb1NtYWxsY2Fwcz1kb250RW5jb2RlUmVtb3RhYmxlVG9TbWFsbGNhcHMsXG5lbmNvZGVQcm9taXNlVG9TbWFsbGNhcHM9ZG9udEVuY29kZVByb21pc2VUb1NtYWxsY2FwcyxcbmVuY29kZUVycm9yVG9TbWFsbGNhcHM9ZG9udEVuY29kZUVycm9yVG9TbWFsbGNhcHN9PVxuZW5jb2RlT3B0aW9ucztcblxuY29uc3QgYXNzZXJ0RW5jb2RlZEVycm9yPShlbmNvZGluZyk9PntcbnR5cGVvZiBlbmNvZGluZz09PSdvYmplY3QnJiZoYXNPd25Qcm9wZXJ0eU9mKGVuY29kaW5nLCcjZXJyb3InKXx8XG5GYWlsIGBpbnRlcm5hbDogRXJyb3IgZW5jb2RpbmcgbXVzdCBoYXZlIFwiI2Vycm9yXCIgcHJvcGVydHk6ICR7cShcbmVuY29kaW5nKVxuIH1gO1xuLyogQXNzZXJ0IHRoYXQgdGhlICNlcnJvciBwcm9wZXJ0eSBkZWNvZGVzIHRvIGEgc3RyaW5nLiovXG5jb25zdCBtZXNzYWdlPWVuY29kaW5nWycjZXJyb3InXTtcbnR5cGVvZiBtZXNzYWdlPT09J3N0cmluZycmJihcbiFzdGFydHNTcGVjaWFsKG1lc3NhZ2UpfHxtZXNzYWdlLnN0YXJ0c1dpdGgoJyEnKSl8fFxuRmFpbCBgaW50ZXJuYWw6IEVycm9yIGVuY29kaW5nIG11c3QgaGF2ZSBzdHJpbmcgbWVzc2FnZTogJHtxKG1lc3NhZ2UpfWA7XG4gfTtcblxuLyoqXG4gKiBNdXN0IGVuY29kZSBgdmFsYCBpbnRvIHBsYWluIEpTT04gZGF0YSAqY2Fub25pY2FsbHkqLCBzdWNoIHRoYXRcbiAqIGBKU09OLnN0cmluZ2lmeShlbmNvZGUodjEpKSA9PT0gSlNPTi5zdHJpbmdpZnkoZW5jb2RlKHYxKSlgLiBGb3IgbW9zdFxuICogZW5jb2RpbmdzLCB0aGUgb3JkZXIgb2YgcHJvcGVydGllcyBvZiBlYWNoIG5vZGUgb2YgdGhlIG91dHB1dFxuICogc3RydWN0dXJlIGlzIGRldGVybWluZWQgYnkgdGhlIGFsZ29yaXRobSBiZWxvdyB3aXRob3V0IHNwZWNpYWxcbiAqIGFycmFuZ2VtZW50LCB1c3VhbGx5IGJ5IGJlaW5nIGV4cHJlc3NlZCBkaXJlY3RseSBhcyBhbiBvYmplY3QgbGl0ZXJhbC5cbiAqIFRoZSBleGNlcHRpb24gaXMgY29weVJlY29yZHMsIHdob3NlIG5hdHVyYWwgZW51bWVyYXRpb24gb3JkZXJcbiAqIGNhbiBkaWZmZXIgYmV0d2VlbiBjb3B5UmVjb3JkcyB0aGF0IG91ciBkaXN0cmlidXRlZCBvYmplY3Qgc2VtYW50aWNzXG4gKiBjb25zaWRlcnMgdG8gYmUgZXF1aXZhbGVudC5cbiAqIFNpbmNlLCBmb3IgZWFjaCBjb3B5UmVjb3JkLCB3ZSBvbmx5IGFjY2VwdCBzdHJpbmcgcHJvcGVydHkgbmFtZXMsXG4gKiBub3Qgc3ltYm9scywgd2UgY2FuIGNhbm9uaWNhbGx5IHNvcnQgdGhlIG5hbWVzIGZpcnN0LlxuICogSlNPTi5zdHJpbmdpZnkgd2lsbCB0aGVuIHZpc2l0IHRoZXNlIGluIHRoYXQgc29ydGVkIG9yZGVyLlxuICpcbiAqIEVuY29kaW5nIHdpdGggYSBjYW5vbmljYWwtSlNPTiBlbmNvZGVyIHdvdWxkIGFsc28gc29sdmUgdGhpcyBjYW5vbmljYWxuZXNzXG4gKiBwcm9ibGVtIGluIGEgbW9yZSBtb2R1bGFyIGFuZCBlbmNhcHN1bGF0ZWQgbWFubmVyLiBOb3RlIHRoYXQgdGhlXG4gKiBhY3R1YWwgb3JkZXIgcHJvZHVjZWQgaGVyZSwgdGhvdWdoIGl0IGFncmVlcyB3aXRoIGNhbm9uaWNhbC1KU09OIG9uXG4gKiBjb3B5UmVjb3JkIHByb3BlcnR5IG9yZGVyaW5nLCBkaWZmZXJzIGZyb20gY2Fub25pY2FsLUpTT04gYXMgYSB3aG9sZVxuICogaW4gdGhhdCB0aGUgb3RoZXIgcmVjb3JkIHByb3BlcnRpZXMgYXJlIHZpc2l0ZWQgaW4gdGhlIG9yZGVyIGluIHdoaWNoXG4gKiB0aGV5IGFyZSBsaXRlcmFsbHkgd3JpdHRlbiBiZWxvdy4gVE9ETyBwZXJoYXBzIHdlIHNob3VsZCBpbmRlZWQgc3dpdGNoXG4gKiB0byBhIGNhbm9uaWNhbCBKU09OIGVuY29kZXIsIGFuZCBub3QgZGVsaWNhdGVseSBkZXBlbmQgb24gdGhlIG9yZGVyXG4gKiBpbiB3aGljaCB0aGVzZSBvYmplY3QgbGl0ZXJhbHMgYXJlIHdyaXR0ZW4uXG4gKlxuICogUmVhZGVycyBtdXN0IG5vdCBjYXJlIGFib3V0IHRoaXMgb3JkZXIgYW55d2F5LiBXZSBpbXBvc2UgdGhpcyByZXF1aXJlbWVudFxuICogbWFpbmx5IHRvIHJlZHVjZSBub24tZGV0ZXJtaW5pc20gZXhwb3NlZCBvdXRzaWRlIGEgdmF0LlxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHBhc3NhYmxlXG4gKiBAcmV0dXJucyB7U21hbGxjYXBzRW5jb2Rpbmd9IGV4Y2VwdCB0aGF0IGBlbmNvZGVUb1NtYWxsY2Fwc2AgZG9lcyBub3QgZ2VuZXJhbGx5XG4gKiBgaGFyZGVuYCB0aGlzIHJlc3VsdCBiZWZvcmUgcmV0dXJuaW5nLiBSYXRoZXIsIGBlbmNvZGVUb1NtYWxsY2Fwc2AgaXMgbm90XG4gKiBkaXJlY3RseSBleHBvc2VkLlxuICogV2hhdCdzIGV4cG9zZWQgaW5zdGVhZCBpcyBhIHdyYXBwZXIgdGhhdCBmcmVlemVzIHRoZSBvdXRwdXQgYmVmb3JlXG4gKiByZXR1cm5pbmcuIElmIHRoaXMgdHVybnMgb3V0IHRvIGltcGVkZSBzdGF0aWMgYW5hbHlzaXMgZm9yIGBoYXJkZW5gIHNhZmV0eSxcbiAqIHdlIGNhbiBhbHdheXMgcHV0IHRoZSAobm93IHJlZHVuZGFudCkgaGFyZGVucyBiYWNrIGluLiBUaGV5IGRvbid0IGh1cnQuXG4gKi9cbmNvbnN0IGVuY29kZVRvU21hbGxjYXBzUmVjdXI9KHBhc3NhYmxlKT0+e1xuLyogRmlyc3Qgd2UgaGFuZGxlIGFsbCBwcmltaXRpdmVzLiBTb21lIGNhbiBiZSByZXByZXNlbnRlZCBkaXJlY3RseSBhcyovXG4vKiBKU09OLCBhbmQgc29tZSBtdXN0IGJlIGVuY29kZWQgaW50byBzbWFsbGNhcHMgc3RyaW5ncy4qL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhc3NhYmxlKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdudWxsJzpcbmNhc2UnYm9vbGVhbic6e1xuLyogcGFzcyB0aHJvdWdoIHRvIEpTT04qL1xucmV0dXJuIHBhc3NhYmxlO1xuIH1cbmNhc2Unc3RyaW5nJzp7XG5pZihzdGFydHNTcGVjaWFsKHBhc3NhYmxlKSl7XG4vKiBTdHJpbmdzIHRoYXQgc3RhcnQgd2l0aCBhIHNwZWNpYWwgY2hhciBhcmUgcXVvdGVkIHdpdGggYCFgLiovXG4vKiBTaW5jZSBgIWAgaXMgaXRzZWxmIGEgc3BlY2lhbCBjaGFyYWN0ZXIsIHRoaXMgdHJpdmlhbGx5IGRvZXMqL1xuLyogdGhlIEhpbGJlcnQgaG90ZWwuIEFsc28sIHNpbmNlIHRoZSBzcGVjaWFsIGNoYXJhY3RlcnMgYXJlKi9cbi8qIGEgY29udGludW91cyBzdWJyYW5nZSBvZiBhc2NpaSwgdGhpcyBxdW90aW5nIGlzIHNvcnQtb3JkZXIqL1xuLyogcHJlc2VydmluZy4qL1xucmV0dXJuIGAhJHtwYXNzYWJsZX1gO1xuIH1cbi8qIEFsbCBvdGhlciBzdHJpbmdzIHBhc3MgdGhyb3VnaCB0byBKU09OKi9cbnJldHVybiBwYXNzYWJsZTtcbiB9XG5jYXNlJ3VuZGVmaW5lZCc6e1xucmV0dXJuJyN1bmRlZmluZWQnO1xuIH1cbmNhc2UnbnVtYmVyJzp7XG4vKiBTcGVjaWFsLWNhc2UgbnVtYmVycyB3aXRoIG5vIGRpZ2l0LWJhc2VkIHJlcHJlc2VudGF0aW9uLiovXG5pZihOdW1iZXIuaXNOYU4ocGFzc2FibGUpKXtcbnJldHVybicjTmFOJztcbiB9ZWxzZSBpZihwYXNzYWJsZT09PUluZmluaXR5KXtcbnJldHVybicjSW5maW5pdHknO1xuIH1lbHNlIGlmKHBhc3NhYmxlPT09LUluZmluaXR5KXtcbnJldHVybicjLUluZmluaXR5JztcbiB9XG4vKiBQYXNzIHRocm91Z2ggZXZlcnl0aGluZyBlbHNlLCByZXBsYWNpbmcgLTAgd2l0aCAwLiovXG5yZXR1cm4gaXMocGFzc2FibGUsLTApPzA6cGFzc2FibGU7XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0IHN0cj1TdHJpbmcocGFzc2FibGUpO1xucmV0dXJuICgvKiogQHR5cGUge2JpZ2ludH0gKi9wYXNzYWJsZTwwbj9zdHI6YCske3N0cn1gKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuYXNzZXJ0UGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xuY29uc3QgbmFtZT0vKiogQHR5cGUge3N0cmluZ30gKi9uYW1lRm9yUGFzc2FibGVTeW1ib2wocGFzc2FibGUpO1xucmV0dXJuIGAlJHtuYW1lfWA7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBDdXJyZW50bHkgY29weVJlY29yZCBhbGxvd3Mgb25seSBzdHJpbmcga2V5cyBzbyB0aGlzIHdpbGwqL1xuLyogd29yay4gSWYgd2UgYWxsb3cgc29ydGFibGUgc3ltYm9sIGtleXMsIHRoaXMgd2lsbCBuZWVkIHRvKi9cbi8qIGJlY29tZSBtb3JlIGludGVyZXN0aW5nLiovXG5jb25zdCBuYW1lcz1vd25LZXlzKHBhc3NhYmxlKS5zb3J0KCk7XG5yZXR1cm4gZnJvbUVudHJpZXMoXG5uYW1lcy5tYXAoKG5hbWUpPT5bXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKG5hbWUpLFxuZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZVtuYW1lXSldKSk7XG5cblxuIH1cbmNhc2UnY29weUFycmF5Jzp7XG5yZXR1cm4gcGFzc2FibGUubWFwKGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5yZXR1cm57XG4nI3RhZyc6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihnZXRUYWcocGFzc2FibGUpKSxcbnBheWxvYWQ6ZW5jb2RlVG9TbWFsbGNhcHNSZWN1cihwYXNzYWJsZS5wYXlsb2FkKX07XG5cbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xuY29uc3QgcmVzdWx0PWVuY29kZVJlbW90YWJsZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuc3RhcnRzV2l0aCgnJCcpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuLyogYHRocm93YCBpcyBub29wIHNpbmNlIGBGYWlsYCB0aHJvd3MuIEJ1dCBsaW50ZXIgY29uZnVzZWQqL1xudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFJlbW90YWJsZSBlbmNvZGluZyBtdXN0IHN0YXJ0IHdpdGggXCIkXCI6ICR7cmVzdWx0fWA7XG4gfVxuY2FzZSdwcm9taXNlJzp7XG5jb25zdCByZXN1bHQ9ZW5jb2RlUHJvbWlzZVRvU21hbGxjYXBzKFxucGFzc2FibGUsXG5lbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKTtcblxuaWYodHlwZW9mIHJlc3VsdD09PSdzdHJpbmcnJiZyZXN1bHQuc3RhcnRzV2l0aCgnJicpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxudGhyb3cgRmFpbCBgaW50ZXJuYWw6IFByb21pc2UgZW5jb2RpbmcgbXVzdCBzdGFydCB3aXRoIFwiJlwiOiAke3Jlc3VsdH1gO1xuIH1cbmNhc2UnZXJyb3InOntcbmNvbnN0IHJlc3VsdD1lbmNvZGVFcnJvclRvU21hbGxjYXBzKHBhc3NhYmxlLGVuY29kZVRvU21hbGxjYXBzUmVjdXIpO1xuYXNzZXJ0RW5jb2RlZEVycm9yKHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmRlZmF1bHQ6e1xuYXNzZXJ0LmZhaWwoXG5YIGBpbnRlcm5hbDogVW5yZWNvZ25pemVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX1gLFxuVHlwZUVycm9yKTtcblxuIH19XG5cbiB9O1xuY29uc3QgZW5jb2RlVG9TbWFsbGNhcHM9KHBhc3NhYmxlKT0+e1xuaWYoaXNFcnJvckxpa2UocGFzc2FibGUpKXtcbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIHRvIGFjY29tbW9kYXRlIGVycm9ycyB0aGF0IGFyZSBub3QqL1xuLyogdmFsaWQgUGFzc2FibGVzLiBGb3IgZXhhbXBsZSwgYmVjYXVzZSB0aGV5J3JlIG5vdCBmcm96ZW4uKi9cbi8qIFRoZSBzcGVjaWFsIGNhc2UgY2FuIG9ubHkgZXZlciBhcHBseSBhdCB0aGUgcm9vdCwgYW5kIHRoZXJlZm9yZSovXG4vKiBvdXRzaWRlIHRoZSByZWN1cnNpb24sIHNpbmNlIGFuIGVycm9yIGNvdWxkIG9ubHkgYmUgZGVlcGVyIGluKi9cbi8qIGEgcGFzc2FibGUgc3RydWN0dXJlIGlmIGl0IHdlcmUgcGFzc2FibGUuKi9cbi8qKi9cbi8qIFdlIHB1bGwgb3V0IHRoaXMgc3BlY2lhbCBjYXNlIGJlY2F1c2UsIGZvciB0aGVzZSBlcnJvcnMsIHdlJ3JlIG11Y2gqL1xuLyogbW9yZSBpbnRlcmVzdGVkIGluIHJlcG9ydGluZyB3aGF0ZXZlciBkaWFnbm9zdGljIGluZm9ybWF0aW9uIHRoZXkqL1xuLyogY2FycnkgdGhhbiB3ZSBhcmUgYWJvdXQgcmVwb3J0aW5nIHByb2JsZW1zIGVuY291bnRlcmVkIGluIHJlcG9ydGluZyovXG4vKiB0aGlzIGluZm9ybWF0aW9uLiovXG5jb25zdCByZXN1bHQ9aGFyZGVuKFxuZW5jb2RlRXJyb3JUb1NtYWxsY2FwcyhwYXNzYWJsZSxlbmNvZGVUb1NtYWxsY2Fwc1JlY3VyKSk7XG5cbmFzc2VydEVuY29kZWRFcnJvcihyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9XG5yZXR1cm4gaGFyZGVuKGVuY29kZVRvU21hbGxjYXBzUmVjdXIocGFzc2FibGUpKTtcbiB9O1xucmV0dXJuIGhhcmRlbihlbmNvZGVUb1NtYWxsY2Fwcyk7XG4gfTskaOKAjV9vbmNlLm1ha2VFbmNvZGVUb1NtYWxsY2FwcyhtYWtlRW5jb2RlVG9TbWFsbGNhcHMpO1xuaGFyZGVuKG1ha2VFbmNvZGVUb1NtYWxsY2Fwcyk7XG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gRGVjb2RlRnJvbVNtYWxsY2Fwc09wdGlvbnNcbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUmVtb3RhYmxlOiBTbWFsbGNhcHNFbmNvZGluZyxcbiAqICAgZGVjb2RlUmVjdXI6IChlIDpTbWFsbGNhcHNFbmNvZGluZykgPT4gUGFzc2FibGVcbiAqICkgPT4gUmVtb3RhYmxlfSBbZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwc11cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkUHJvbWlzZTogU21hbGxjYXBzRW5jb2RpbmcsXG4gKiAgIGRlY29kZVJlY3VyOiAoZSA6U21hbGxjYXBzRW5jb2RpbmcpID0+IFBhc3NhYmxlXG4gKiApID0+IFByb21pc2V9IFtkZWNvZGVQcm9taXNlRnJvbVNtYWxsY2Fwc11cbiAqIEBwcm9wZXJ0eSB7KFxuICogICBlbmNvZGVkRXJyb3I6IFNtYWxsY2Fwc0VuY29kaW5nLFxuICogICBkZWNvZGVSZWN1cjogKGUgOlNtYWxsY2Fwc0VuY29kaW5nKSA9PiBQYXNzYWJsZVxuICogKSA9PiBFcnJvcn0gW2RlY29kZUVycm9yRnJvbVNtYWxsY2Fwc11cbiAqL1xuXG5jb25zdCBkb250RGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT5cbkZhaWwgYHJlbW90YWJsZSB1bmV4cGVjdGVkOiAke2VuY29kaW5nfWA7XG5jb25zdCBkb250RGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHM9KGVuY29kaW5nKT0+XG5GYWlsIGBwcm9taXNlIHVuZXhwZWN0ZWQ6ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IGRvbnREZWNvZGVFcnJvckZyb21TbWFsbGNhcHM9KGVuY29kaW5nKT0+XG5GYWlsIGBlcnJvciB1bmV4cGVjdGVkOiAke3EoZW5jb2RpbmcpfWA7XG5cbi8qKlxuICogQHBhcmFtIHtEZWNvZGVGcm9tU21hbGxjYXBzT3B0aW9uc30gW2RlY29kZU9wdGlvbnNdXG4gKiBAcmV0dXJucyB7KGVuY29kZWQ6IFNtYWxsY2Fwc0VuY29kaW5nKSA9PiBQYXNzYWJsZX1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VEZWNvZGVGcm9tU21hbGxjYXBzPShkZWNvZGVPcHRpb25zPXt9KT0+e1xuY29uc3R7XG5kZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzPWRvbnREZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzLFxuZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHM9ZG9udERlY29kZVByb21pc2VGcm9tU21hbGxjYXBzLFxuZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzPWRvbnREZWNvZGVFcnJvckZyb21TbWFsbGNhcHN9PVxuZGVjb2RlT3B0aW9ucztcblxuLyoqXG4gKiBgZGVjb2RlRnJvbVNtYWxsY2Fwc2AgbWF5IHJlbHkgb24gYGVuY29kaW5nYCBiZWluZyB0aGUgcmVzdWx0IG9mIGFcbiAqIHBsYWluIGNhbGwgdG8gSlNPTi5wYXJzZS4gSG93ZXZlciwgaXQgKmNhbm5vdCogcmVseSBvbiBgZW5jb2RpbmdgXG4gKiBoYXZpbmcgYmVlbiBwcm9kdWNlZCBieSBKU09OLnN0cmluZ2lmeSBvbiB0aGUgb3V0cHV0IG9mIGBlbmNvZGVUb1NtYWxsY2Fwc2BcbiAqIGFib3ZlLCBpLmUuLCBgZGVjb2RlRnJvbVNtYWxsY2Fwc2AgY2Fubm90IHJlbHkgb24gYGVuY29kaW5nYCBiZWluZyBhXG4gKiB2YWxpZCBtYXJzaGFsbGVkIHJlcHJlc2VudGF0aW9uLiBSYXRoZXIsIGBkZWNvZGVGcm9tU21hbGxjYXBzYCBtdXN0XG4gKiB2YWxpZGF0ZSB0aGF0LlxuICpcbiAqIEBwYXJhbSB7U21hbGxjYXBzRW5jb2Rpbmd9IGVuY29kaW5nIG11c3QgYmUgaGFyZGVuZWRcbiAqL1xuY29uc3QgZGVjb2RlRnJvbVNtYWxsY2Fwcz0oZW5jb2RpbmcpPT57XG5zd2l0Y2godHlwZW9mIGVuY29kaW5nKXtcbmNhc2UnYm9vbGVhbic6XG5jYXNlJ251bWJlcic6e1xucmV0dXJuIGVuY29kaW5nO1xuIH1cbmNhc2Unc3RyaW5nJzp7XG5pZighc3RhcnRzU3BlY2lhbChlbmNvZGluZykpe1xucmV0dXJuIGVuY29kaW5nO1xuIH1cbmNvbnN0IGM9ZW5jb2RpbmcuY2hhckF0KDApO1xuc3dpdGNoKGMpe1xuY2FzZSchJzp7XG4vKiB1bi1oaWxiZXJ0LWlmeSB0aGUgc3RyaW5nKi9cbnJldHVybiBlbmNvZGluZy5zbGljZSgxKTtcbiB9XG5jYXNlJyUnOntcbnJldHVybiBwYXNzYWJsZVN5bWJvbEZvck5hbWUoZW5jb2Rpbmcuc2xpY2UoMSkpO1xuIH1cbmNhc2UnIyc6e1xuc3dpdGNoKGVuY29kaW5nKXtcbmNhc2UnI3VuZGVmaW5lZCc6e1xucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG5jYXNlJyNOYU4nOntcbnJldHVybiBOYU47XG4gfVxuY2FzZScjSW5maW5pdHknOntcbnJldHVybiBJbmZpbml0eTtcbiB9XG5jYXNlJyMtSW5maW5pdHknOntcbnJldHVybi1JbmZpbml0eTtcbiB9XG5kZWZhdWx0OntcbmFzc2VydC5mYWlsKFggYHVua25vd24gY29uc3RhbnQgXCIke3EoZW5jb2RpbmcpfVwiYCxUeXBlRXJyb3IpO1xuIH19XG5cbiB9XG5jYXNlJysnOlxuY2FzZSctJzp7XG5yZXR1cm4gQmlnSW50KGVuY29kaW5nKTtcbiB9XG5jYXNlJyQnOntcbmNvbnN0IHJlc3VsdD1kZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzKFxuZW5jb2RpbmcsXG5kZWNvZGVGcm9tU21hbGxjYXBzKTtcblxuaWYocGFzc1N0eWxlT2YocmVzdWx0KSE9PSdyZW1vdGFibGUnKXtcbkZhaWwgYGludGVybmFsOiBkZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzIG9wdGlvbiBtdXN0IHJldHVybiBhIHJlbW90YWJsZTogJHtyZXN1bHR9YDtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmNhc2UnJic6e1xuY29uc3QgcmVzdWx0PWRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzKFxuZW5jb2RpbmcsXG5kZWNvZGVGcm9tU21hbGxjYXBzKTtcblxuaWYocGFzc1N0eWxlT2YocmVzdWx0KSE9PSdwcm9taXNlJyl7XG5GYWlsIGBpbnRlcm5hbDogZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMgb3B0aW9uIG11c3QgcmV0dXJuIGEgcHJvbWlzZTogJHtyZXN1bHR9YDtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgRmFpbCBgU3BlY2lhbCBjaGFyICR7cShcbmMpXG4gfSByZXNlcnZlZCBmb3IgZnV0dXJlIHVzZTogJHtlbmNvZGluZ31gO1xuIH19XG5cbiB9XG5jYXNlJ29iamVjdCc6e1xuaWYoZW5jb2Rpbmc9PT1udWxsKXtcbnJldHVybiBlbmNvZGluZztcbiB9XG5cbmlmKGlzQXJyYXkoZW5jb2RpbmcpKXtcbnJldHVybiBlbmNvZGluZy5tYXAoKHZhbCk9PmRlY29kZUZyb21TbWFsbGNhcHModmFsKSk7XG4gfVxuXG5pZihoYXNPd25Qcm9wZXJ0eU9mKGVuY29kaW5nLCcjdGFnJykpe1xuY29uc3R7JyN0YWcnOnRhZyxwYXlsb2FkLC4uLnJlc3R9PWVuY29kaW5nO1xudHlwZW9mIHRhZz09PSdzdHJpbmcnfHxcbkZhaWwgYFZhbHVlIG9mIFwiI3RhZ1wiLCB0aGUgdGFnLCBtdXN0IGJlIGEgc3RyaW5nOiAke2VuY29kaW5nfWA7XG5vd25LZXlzKHJlc3QpLmxlbmd0aD09PTB8fFxuRmFpbCBgI3RhZyByZWNvcmQgdW5leHBlY3RlZCBwcm9wZXJ0aWVzOiAke3Eob3duS2V5cyhyZXN0KSl9YDtcbnJldHVybiBtYWtlVGFnZ2VkKFxuZGVjb2RlRnJvbVNtYWxsY2Fwcyh0YWcpLFxuZGVjb2RlRnJvbVNtYWxsY2FwcyhwYXlsb2FkKSk7XG5cbiB9XG5cbmlmKGhhc093blByb3BlcnR5T2YoZW5jb2RpbmcsJyNlcnJvcicpKXtcbmNvbnN0IHJlc3VsdD1kZWNvZGVFcnJvckZyb21TbWFsbGNhcHMoXG5lbmNvZGluZyxcbmRlY29kZUZyb21TbWFsbGNhcHMpO1xuXG5wYXNzU3R5bGVPZihyZXN1bHQpPT09J2Vycm9yJ3x8XG5GYWlsIGBpbnRlcm5hbDogZGVjb2RlRXJyb3JGcm9tU21hbGxjYXBzIG9wdGlvbiBtdXN0IHJldHVybiBhbiBlcnJvcjogJHtyZXN1bHR9YDtcbnJldHVybiByZXN1bHQ7XG4gfVxuXG5jb25zdCBkZWNvZGVFbnRyeT0oW2VuY29kZWROYW1lLGVuY29kZWRWYWxdKT0+e1xudHlwZW9mIGVuY29kZWROYW1lPT09J3N0cmluZyd8fFxuRmFpbCBgUHJvcGVydHkgbmFtZSAke3EoXG5lbmNvZGVkTmFtZSlcbiB9IG9mICR7ZW5jb2Rpbmd9IG11c3QgYmUgYSBzdHJpbmdgO1xuIWVuY29kZWROYW1lLnN0YXJ0c1dpdGgoJyMnKXx8XG5GYWlsIGBVbnJlY29nbml6ZWQgcmVjb3JkIHR5cGUgJHtxKGVuY29kZWROYW1lKX06ICR7ZW5jb2Rpbmd9YDtcbmNvbnN0IG5hbWU9ZGVjb2RlRnJvbVNtYWxsY2FwcyhlbmNvZGVkTmFtZSk7XG50eXBlb2YgbmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYERlY29kZWQgcHJvcGVydHkgbmFtZSAke25hbWV9IGZyb20gJHtlbmNvZGluZ30gbXVzdCBiZSBhIHN0cmluZ2A7XG5yZXR1cm5bbmFtZSxkZWNvZGVGcm9tU21hbGxjYXBzKGVuY29kZWRWYWwpXTtcbiB9O1xuY29uc3QgZGVjb2RlZEVudHJpZXM9ZW50cmllcyhlbmNvZGluZykubWFwKGRlY29kZUVudHJ5KTtcbnJldHVybiBmcm9tRW50cmllcyhkZWNvZGVkRW50cmllcyk7XG4gfVxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChcblggYGludGVybmFsOiB1bnJlY29nbml6ZWQgSlNPTiB0eXBlb2YgJHtxKFxudHlwZW9mIGVuY29kaW5nKVxuIH06ICR7ZW5jb2Rpbmd9YCxcblR5cGVFcnJvcik7XG5cbiB9fVxuXG4gfTtcbnJldHVybiBoYXJkZW4oZGVjb2RlRnJvbVNtYWxsY2Fwcyk7XG4gfTskaOKAjV9vbmNlLm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKG1ha2VEZWNvZGVGcm9tU21hbGxjYXBzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlRW5jb2RlVG9TbWFsbGNhcHMiOlsibWFrZUVuY29kZVRvU21hbGxjYXBzIl0sIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzIjpbIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAAhCkv2sKgAArCoAACoAAABAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvbWFyc2hhbC1qdXN0aW4uanN7ImltcG9ydHMiOlsiLi9lbmNvZGVUb0NhcERhdGEuanMiLCJAZW5kby9uYXQiLCJAZW5kby9wYXNzLXN0eWxlIl0sImV4cG9ydHMiOlsiZGVjb2RlVG9KdXN0aW4iXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgTmF0LGdldEVycm9yQ29uc3RydWN0b3IsaXNPYmplY3QscGFzc2FibGVTeW1ib2xGb3JOYW1lLFFDTEFTUzskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9uYXRcIiwgW1tcIk5hdFwiLCBbJGjigI1fYSA9PiAoTmF0ID0gJGjigI1fYSldXV1dLFtcIkBlbmRvL3Bhc3Mtc3R5bGVcIiwgW1tcImdldEVycm9yQ29uc3RydWN0b3JcIiwgWyRo4oCNX2EgPT4gKGdldEVycm9yQ29uc3RydWN0b3IgPSAkaOKAjV9hKV1dLFtcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wicGFzc2FibGVTeW1ib2xGb3JOYW1lXCIsIFskaOKAjV9hID0+IChwYXNzYWJsZVN5bWJvbEZvck5hbWUgPSAkaOKAjV9hKV1dXV0sW1wiLi9lbmNvZGVUb0NhcERhdGEuanNcIiwgW1tcIlFDTEFTU1wiLCBbJGjigI1fYSA9PiAoUUNMQVNTID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5FbmNvZGluZ30gRW5jb2RpbmcgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNhcERhdGE8VD59IENhcERhdGEgKi9cblxuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXl9PUFycmF5O1xuY29uc3R7c3RyaW5naWZ5OnF1b3RlfT1KU09OO1xuY29uc3R7cXVvdGU6cSxkZXRhaWxzOlgsRmFpbH09YXNzZXJ0O1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEluZGVudGVyXG4gKiBAcHJvcGVydHkgeyhvcGVuQnJhY2tldDogc3RyaW5nKSA9PiBudW1iZXJ9IG9wZW5cbiAqIEBwcm9wZXJ0eSB7KCkgPT4gbnVtYmVyfSBsaW5lXG4gKiBAcHJvcGVydHkgeyh0b2tlbjogc3RyaW5nKSA9PiBudW1iZXJ9IG5leHRcbiAqIEBwcm9wZXJ0eSB7KGNsb3NlQnJhY2tldDogc3RyaW5nKSA9PiBudW1iZXJ9IGNsb3NlXG4gKiBAcHJvcGVydHkgeygpID0+IHN0cmluZ30gZG9uZVxuICovXG5cbi8qKlxuICogR2VuZXJvdXMgd2hpdGVzcGFjZSBmb3IgcmVhZGFiaWxpdHlcbiAqXG4gKiBAcmV0dXJucyB7SW5kZW50ZXJ9XG4gKi9cbmNvbnN0IG1ha2VZZXNJbmRlbnRlcj0oKT0+e1xuY29uc3Qgc3RyaW5ncz1bXTtcbmxldCBsZXZlbD0wO1xubGV0IG5lZWRTcGFjZT1mYWxzZTtcbmNvbnN0IGxpbmU9KCk9Pntcbm5lZWRTcGFjZT1mYWxzZTtcbnJldHVybiBzdHJpbmdzLnB1c2goJ1xcbicsJyAgJy5yZXBlYXQobGV2ZWwpKTtcbiB9O1xucmV0dXJuIGhhcmRlbih7XG5vcGVuOihvcGVuQnJhY2tldCk9PntcbmxldmVsKz0xO1xuaWYobmVlZFNwYWNlKXtcbnN0cmluZ3MucHVzaCgnICcpO1xuIH1cbm5lZWRTcGFjZT1mYWxzZTtcbnJldHVybiBzdHJpbmdzLnB1c2gob3BlbkJyYWNrZXQpO1xuIH0sXG5saW5lLFxubmV4dDoodG9rZW4pPT57XG5pZihuZWVkU3BhY2UmJnRva2VuIT09JywnKXtcbnN0cmluZ3MucHVzaCgnICcpO1xuIH1cbm5lZWRTcGFjZT10cnVlO1xucmV0dXJuIHN0cmluZ3MucHVzaCh0b2tlbik7XG4gfSxcbmNsb3NlOihjbG9zZUJyYWNrZXQpPT57XG5hc3NlcnQobGV2ZWw+PTEpO1xubGV2ZWwtPTE7XG5saW5lKCk7XG5yZXR1cm4gc3RyaW5ncy5wdXNoKGNsb3NlQnJhY2tldCk7XG4gfSxcbmRvbmU6KCk9PntcbmFzc2VydC5lcXVhbChsZXZlbCwwKTtcbnJldHVybiBzdHJpbmdzLmpvaW4oJycpO1xuIH19KTtcblxuIH07XG5cbi8qKlxuICogSWYgdGhlIGxhc3QgY2hhcmFjdGVyIG9mIG9uZSB0b2tlbiB0b2dldGhlciB3aXRoIHRoZSBmaXJzdCBjaGFyYWN0ZXJcbiAqIG9mIHRoZSBuZXh0IHRva2VuIG1hdGNoZXMgdGhpcyBwYXR0ZXJuLCB0aGVuIHRoZSB0d28gdG9rZW5zIG11c3QgYmVcbiAqIHNlcGFyYXRlZCBieSB3aGl0ZXNwYWNlIHRvIHByZXNlcnZlIHRoZWlyIG1lYW5pbmcuIE90aGVyd2lzZSB0aGVcbiAqIHdoaXRlc3BhY2UgaW4gdW5uZWNlc3NhcnkuXG4gKlxuICogVGhlIGA8IWAgYW5kIGAtPmAgY2FzZXMgcHJldmVudCB0aGUgYWNjaWRlbnRhbCBmb3JtYXRpb24gb2YgYW5cbiAqIGh0bWwtbGlrZSBjb21tZW50LiBJIGRvbid0IHRoaW5rIHRoZSBkb3VibGUgYW5nbGUgYnJhY2tldHMgYXJlIGFjdHVhbGx5XG4gKiBuZWVkZWQgYnV0IEkgaGF2ZW4ndCB0aG91Z2h0IGFib3V0IGl0IGVub3VnaCB0byByZW1vdmUgdGhlbS5cbiAqL1xuY29uc3QgYmFkUGFpclBhdHRlcm49L14oPzpcXHdcXHd8PDx8Pj58XFwrXFwrfC0tfDwhfC0+KSQvO1xuXG4vKipcbiAqIE1pbmltdW0gd2hpdGVzcGFjZSBuZWVkZWQgdG8gcHJlc2V2ZSBtZWFuaW5nLlxuICpcbiAqIEByZXR1cm5zIHtJbmRlbnRlcn1cbiAqL1xuY29uc3QgbWFrZU5vSW5kZW50ZXI9KCk9Pntcbi8qKiBAdHlwZSB7c3RyaW5nW119ICovXG5jb25zdCBzdHJpbmdzPVtdO1xucmV0dXJuIGhhcmRlbih7XG5vcGVuOihvcGVuQnJhY2tldCk9PnN0cmluZ3MucHVzaChvcGVuQnJhY2tldCksXG5saW5lOigpPT5zdHJpbmdzLmxlbmd0aCxcbm5leHQ6KHRva2VuKT0+e1xuaWYoc3RyaW5ncy5sZW5ndGg+PTEpe1xuY29uc3QgbGFzdD1zdHJpbmdzW3N0cmluZ3MubGVuZ3RoLTFdO1xuaWYobGFzdC5sZW5ndGg+PTEmJnRva2VuLmxlbmd0aD49MSl7XG5jb25zdCBwYWlyPSBgJHtsYXN0W2xhc3QubGVuZ3RoLTFdfSR7dG9rZW5bMF19YDtcbmlmKGJhZFBhaXJQYXR0ZXJuLnRlc3QocGFpcikpe1xuc3RyaW5ncy5wdXNoKCcgJyk7XG4gfVxuIH1cbiB9XG5yZXR1cm4gc3RyaW5ncy5wdXNoKHRva2VuKTtcbiB9LFxuY2xvc2U6KGNsb3NlQnJhY2tldCk9PntcbmlmKHN0cmluZ3MubGVuZ3RoPj0xJiZzdHJpbmdzW3N0cmluZ3MubGVuZ3RoLTFdPT09JywnKXtcbnN0cmluZ3MucG9wKCk7XG4gfVxucmV0dXJuIHN0cmluZ3MucHVzaChjbG9zZUJyYWNrZXQpO1xuIH0sXG5kb25lOigpPT5zdHJpbmdzLmpvaW4oJycpfSk7XG5cbiB9O1xuXG5jb25zdCBpZGVudFBhdHRlcm49L15bYS16QS1aXVxcdyokLztcbmhhcmRlbihpZGVudFBhdHRlcm4pO1xuY29uc3QgQXRBdFByZWZpeFBhdHRlcm49L15AQCguKikkLztcbmhhcmRlbihBdEF0UHJlZml4UGF0dGVybik7XG5cbi8qKlxuICogQHBhcmFtIHtFbmNvZGluZ30gZW5jb2RpbmdcbiAqIEBwYXJhbSB7Ym9vbGVhbj19IHNob3VsZEluZGVudFxuICogQHBhcmFtIHthbnlbXX0gW3Nsb3RzXVxuICogQHJldHVybnMge3N0cmluZ31cbiAqL1xuY29uc3QgZGVjb2RlVG9KdXN0aW49KGVuY29kaW5nLHNob3VsZEluZGVudD1mYWxzZSxzbG90cz1bXSk9Pntcbi8qKlxuICogVGhlIGZpcnN0IHBhc3MgZG9lcyBzb21lIGlucHV0IHZhbGlkYXRpb24uXG4gKiBJdHMgY29udHJvbCBmbG93IHNob3VsZCBtaXJyb3IgYHJlY3VyYCBhcyBjbG9zZWx5IGFzIHBvc3NpYmxlXG4gKiBhbmQgdGhlIHR3byBzaG91bGQgYmUgbWFpbnRhaW5lZCB0b2dldGhlci4gVGhleSBtdXN0IHZpc2l0IGV2ZXJ5dGhpbmdcbiAqIGluIHRoZSBzYW1lIG9yZGVyLlxuICpcbiAqIFRPRE8gbm93IHRoYXQgaWJpZHMgYXJlIGdvbmUsIHdlIHNob3VsZCBmb2xkIHRoaXMgYmFjayB0b2dldGhlciBpbnRvXG4gKiBvbmUgdmFsaWRhdGluZyBwYXNzLlxuICpcbiAqIEBwYXJhbSB7RW5jb2Rpbmd9IHJhd1RyZWVcbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5jb25zdCBwcmVwYXJlPShyYXdUcmVlKT0+e1xuaWYoIWlzT2JqZWN0KHJhd1RyZWUpKXtcbnJldHVybjtcbiB9XG4vKiBBc3NlcnRpb25zIG9mIHRoZSBhYm92ZSB0byBuYXJyb3cgdGhlIHR5cGUuKi9cbmFzc2VydC50eXBlb2YocmF3VHJlZSwnb2JqZWN0Jyk7XG5hc3NlcnQocmF3VHJlZSE9PW51bGwpO1xuaWYoUUNMQVNTIGluIHJhd1RyZWUpe1xuY29uc3QgcWNsYXNzPXJhd1RyZWVbUUNMQVNTXTtcbnR5cGVvZiBxY2xhc3M9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkIHFjbGFzcyB0eXBlb2YgJHtxKHR5cGVvZiBxY2xhc3MpfWA7XG5hc3NlcnQoIWlzQXJyYXkocmF3VHJlZSkpO1xuc3dpdGNoKHJhd1RyZWVbJ0BxY2xhc3MnXSl7XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ05hTic6XG5jYXNlJ0luZmluaXR5JzpcbmNhc2UnLUluZmluaXR5Jzp7XG5yZXR1cm47XG4gfVxuY2FzZSdiaWdpbnQnOntcbmNvbnN0e2RpZ2l0c309cmF3VHJlZTtcbnR5cGVvZiBkaWdpdHM9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkIGRpZ2l0cyB0eXBlb2YgJHtxKHR5cGVvZiBkaWdpdHMpfWA7XG5yZXR1cm47XG4gfVxuY2FzZSdAQGFzeW5jSXRlcmF0b3InOntcbnJldHVybjtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuY29uc3R7bmFtZX09cmF3VHJlZTtcbmFzc2VydC50eXBlb2YobmFtZSwnc3RyaW5nJyk7XG5jb25zdCBzeW09cGFzc2FibGVTeW1ib2xGb3JOYW1lKG5hbWUpO1xuYXNzZXJ0LnR5cGVvZihzeW0sJ3N5bWJvbCcpO1xucmV0dXJuO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG5jb25zdHt0YWcscGF5bG9hZH09cmF3VHJlZTtcbmFzc2VydC50eXBlb2YodGFnLCdzdHJpbmcnKTtcbnByZXBhcmUocGF5bG9hZCk7XG5yZXR1cm47XG4gfVxuY2FzZSdzbG90Jzp7XG5jb25zdHtpbmRleCxpZmFjZX09cmF3VHJlZTtcbmFzc2VydC50eXBlb2YoaW5kZXgsJ251bWJlcicpO1xuTmF0KGluZGV4KTtcbmlmKGlmYWNlIT09dW5kZWZpbmVkKXtcbmFzc2VydC50eXBlb2YoaWZhY2UsJ3N0cmluZycpO1xuIH1cbnJldHVybjtcbiB9XG5jYXNlJ2hpbGJlcnQnOntcbmNvbnN0e29yaWdpbmFsLHJlc3R9PXJhd1RyZWU7XG4nb3JpZ2luYWwnaW4gcmF3VHJlZXx8XG5GYWlsIGBJbnZhbGlkIEhpbGJlcnQgSG90ZWwgZW5jb2RpbmcgJHtyYXdUcmVlfWA7XG5wcmVwYXJlKG9yaWdpbmFsKTtcbmlmKCdyZXN0J2luIHJhd1RyZWUpe1xuaWYodHlwZW9mIHJlc3QhPT0nb2JqZWN0Jyl7XG50aHJvdyBGYWlsIGBSZXN0ICR7cmVzdH0gZW5jb2RpbmcgbXVzdCBiZSBhbiBvYmplY3RgO1xuIH1cbmlmKHJlc3Q9PT1udWxsKXtcbnRocm93IEZhaWwgYFJlc3QgJHtyZXN0fSBlbmNvZGluZyBtdXN0IG5vdCBiZSBudWxsYDtcbiB9XG5pZihpc0FycmF5KHJlc3QpKXtcbnRocm93IEZhaWwgYFJlc3QgJHtyZXN0fSBlbmNvZGluZyBtdXN0IG5vdCBiZSBhbiBhcnJheWA7XG4gfVxuaWYoUUNMQVNTIGluIHJlc3Qpe1xudGhyb3cgRmFpbCBgUmVzdCBlbmNvZGluZyAke3Jlc3R9IG11c3Qgbm90IGNvbnRhaW4gJHtxKFFDTEFTUyl9YDtcbiB9XG5jb25zdCBuYW1lcz1vd25LZXlzKHJlc3QpO1xuZm9yKGNvbnN0IG5hbWUgb2YgbmFtZXMpe1xudHlwZW9mIG5hbWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBQcm9wZXJ0eSBuYW1lICR7bmFtZX0gb2YgJHtyYXdUcmVlfSBtdXN0IGJlIGEgc3RyaW5nYDtcbnByZXBhcmUocmVzdFtuYW1lXSk7XG4gfVxuIH1cbnJldHVybjtcbiB9XG5jYXNlJ2Vycm9yJzp7XG5jb25zdHtuYW1lLG1lc3NhZ2V9PXJhd1RyZWU7XG50eXBlb2YgbmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgZXJyb3IgbmFtZSB0eXBlb2YgJHtxKHR5cGVvZiBuYW1lKX1gO1xuZ2V0RXJyb3JDb25zdHJ1Y3RvcihuYW1lKSE9PXVuZGVmaW5lZHx8XG5GYWlsIGBNdXN0IGJlIHRoZSBuYW1lIG9mIGFuIEVycm9yIGNvbnN0cnVjdG9yICR7bmFtZX1gO1xudHlwZW9mIG1lc3NhZ2U9PT0nc3RyaW5nJ3x8XG5GYWlsIGBpbnZhbGlkIGVycm9yIG1lc3NhZ2UgdHlwZW9mICR7cSh0eXBlb2YgbWVzc2FnZSl9YDtcbnJldHVybjtcbiB9XG5cbmRlZmF1bHQ6e1xuYXNzZXJ0LmZhaWwoWCBgdW5yZWNvZ25pemVkICR7cShRQ0xBU1MpfSAke3EocWNsYXNzKX1gLFR5cGVFcnJvcik7XG4gfX1cblxuIH1lbHNlIGlmKGlzQXJyYXkocmF3VHJlZSkpe1xuY29uc3R7bGVuZ3RofT1yYXdUcmVlO1xuZm9yKGxldCBpPTA7aTxsZW5ndGg7aSs9MSl7XG5wcmVwYXJlKHJhd1RyZWVbaV0pO1xuIH1cbiB9ZWxzZXtcbmNvbnN0IG5hbWVzPW93bktleXMocmF3VHJlZSk7XG5mb3IoY29uc3QgbmFtZSBvZiBuYW1lcyl7XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnRocm93IEZhaWwgYFByb3BlcnR5IG5hbWUgJHtuYW1lfSBvZiAke3Jhd1RyZWV9IG11c3QgYmUgYSBzdHJpbmdgO1xuIH1cbnByZXBhcmUocmF3VHJlZVtuYW1lXSk7XG4gfVxuIH1cbiB9O1xuXG5jb25zdCBtYWtlSW5kZW50ZXI9c2hvdWxkSW5kZW50P21ha2VZZXNJbmRlbnRlcjptYWtlTm9JbmRlbnRlcjtcbmxldCBvdXQ9bWFrZUluZGVudGVyKCk7XG5cbi8qKlxuICogVGhpcyBpcyB0aGUgc2Vjb25kIHBhc3MgcmVjdXJzaW9uIGFmdGVyIHRoZSBmaXJzdCBwYXNzIGBwcmVwYXJlYC5cbiAqIFRoZSBmaXJzdCBwYXNzIGRpZCBzb21lIGlucHV0IHZhbGlkYXRpb24gc29cbiAqIGhlcmUgd2UgY2FuIHNhZmVseSBhc3N1bWUgZXZlcnl0aGluZyB0aG9zZSB0aGluZ3MgYXJlIHZhbGlkYXRlZC5cbiAqXG4gKiBAcGFyYW0ge0VuY29kaW5nfSByYXdUcmVlXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCBkZWNvZGU9KHJhd1RyZWUpPT57XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIHJlY3VyKHJhd1RyZWUpO1xuIH07XG5cbmNvbnN0IGRlY29kZVByb3BlcnR5PShuYW1lLHZhbHVlKT0+e1xub3V0LmxpbmUoKTtcbmlmKG5hbWU9PT0nX19wcm90b19fJyl7XG4vKiBKYXZhU2NyaXB0IGludGVycHJldHMgYHtfX3Byb3RvX186IHgsIC4uLn1gKi9cbi8qIGFzIG1ha2luZyBhbiBvYmplY3QgaW5oZXJpdGluZyBmcm9tIGB4YCwgd2hlcmVhcyovXG4vKiBpbiBKU09OIGl0IGlzIHNpbXBseSBhIHByb3BlcnR5IG5hbWUuIFByZXNlcnZlIHRoZSovXG4vKiBKU09OIG1lYW5pbmcuKi9cbm91dC5uZXh0KCBgW1wiX19wcm90b19fXCJdOmApO1xuIH1lbHNlIGlmKGlkZW50UGF0dGVybi50ZXN0KG5hbWUpKXtcbm91dC5uZXh0KCBgJHtuYW1lfTpgKTtcbiB9ZWxzZXtcbm91dC5uZXh0KCBgJHtxdW90ZShuYW1lKX06YCk7XG4gfVxuZGVjb2RlKHZhbHVlKTtcbm91dC5uZXh0KCcsJyk7XG4gfTtcblxuLyoqXG4gKiBNb2RlbGVkIGFmdGVyIGBmdWxsUmV2aXZlYCBpbiBtYXJzaGFsLmpzXG4gKlxuICogQHBhcmFtIHtFbmNvZGluZ30gcmF3VHJlZVxuICogQHJldHVybnMge251bWJlcn1cbiAqL1xuY29uc3QgcmVjdXI9KHJhd1RyZWUpPT57XG5pZighaXNPYmplY3QocmF3VHJlZSkpe1xuLyogcHJpbWl0aXZlcyBnZXQgcXVvdGVkKi9cbnJldHVybiBvdXQubmV4dChxdW90ZShyYXdUcmVlKSk7XG4gfVxuLyogQXNzZXJ0aW9ucyBvZiB0aGUgYWJvdmUgdG8gbmFycm93IHRoZSB0eXBlLiovXG5hc3NlcnQudHlwZW9mKHJhd1RyZWUsJ29iamVjdCcpO1xuYXNzZXJ0KHJhd1RyZWUhPT1udWxsKTtcbmlmKFFDTEFTUyBpbiByYXdUcmVlKXtcbmNvbnN0IHFjbGFzcz1yYXdUcmVlW1FDTEFTU107XG5hc3NlcnQudHlwZW9mKHFjbGFzcywnc3RyaW5nJyk7XG5hc3NlcnQoIWlzQXJyYXkocmF3VHJlZSkpO1xuLyogU3dpdGNoaW5nIG9uIGBlbmNvZGVkW1FDTEFTU11gIChvciBhbnl0aGluZyBsZXNzIGRpcmVjdCwgbGlrZSovXG4vKiBgcWNsYXNzYCkgZG9lcyBub3QgZGlzY3JpbWluYXRlIHJhd1RyZWUgaW4gdHlwZXNjcmlwdEA0LjIuMyBhbmQqL1xuLyogZWFybGllci4qL1xuc3dpdGNoKHJhd1RyZWVbJ0BxY2xhc3MnXSl7XG4vKiBFbmNvZGluZyBvZiBwcmltaXRpdmVzIG5vdCBoYW5kbGVkIGJ5IEpTT04qL1xuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdOYU4nOlxuY2FzZSdJbmZpbml0eSc6XG5jYXNlJy1JbmZpbml0eSc6e1xuLyogVGhlaXIgcWNsYXNzIGlzIHRoZWlyIGV4cHJlc3Npb24gc291cmNlLiovXG5yZXR1cm4gb3V0Lm5leHQocWNsYXNzKTtcbiB9XG5jYXNlJ2JpZ2ludCc6e1xuY29uc3R7ZGlnaXRzfT1yYXdUcmVlO1xuYXNzZXJ0LnR5cGVvZihkaWdpdHMsJ3N0cmluZycpO1xucmV0dXJuIG91dC5uZXh0KCBgJHtCaWdJbnQoZGlnaXRzKX1uYCk7XG4gfVxuY2FzZSdAQGFzeW5jSXRlcmF0b3InOntcbi8qIFRPRE8gZGVwcmVjYXRlZC4gRXZlbnR1YWxseSByZW1vdmUuKi9cbnJldHVybiBvdXQubmV4dCgnU3ltYm9sLmFzeW5jSXRlcmF0b3InKTtcbiB9XG5jYXNlJ3N5bWJvbCc6e1xuY29uc3R7bmFtZX09cmF3VHJlZTtcbmFzc2VydC50eXBlb2YobmFtZSwnc3RyaW5nJyk7XG5jb25zdCBzeW09cGFzc2FibGVTeW1ib2xGb3JOYW1lKG5hbWUpO1xuYXNzZXJ0LnR5cGVvZihzeW0sJ3N5bWJvbCcpO1xuY29uc3QgcmVnaXN0ZXJlZE5hbWU9U3ltYm9sLmtleUZvcihzeW0pO1xuaWYocmVnaXN0ZXJlZE5hbWU9PT11bmRlZmluZWQpe1xuY29uc3QgbWF0Y2g9QXRBdFByZWZpeFBhdHRlcm4uZXhlYyhuYW1lKTtcbmFzc2VydChtYXRjaCE9PW51bGwpO1xuY29uc3Qgc3VmZml4PW1hdGNoWzFdO1xuYXNzZXJ0KFN5bWJvbFtzdWZmaXhdPT09c3ltKTtcbmFzc2VydChpZGVudFBhdHRlcm4udGVzdChzdWZmaXgpKTtcbnJldHVybiBvdXQubmV4dCggYFN5bWJvbC4ke3N1ZmZpeH1gKTtcbiB9XG5yZXR1cm4gb3V0Lm5leHQoIGBTeW1ib2wuZm9yKCR7cXVvdGUocmVnaXN0ZXJlZE5hbWUpfSlgKTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3R7dGFnLHBheWxvYWR9PXJhd1RyZWU7XG5vdXQubmV4dCggYG1ha2VUYWdnZWQoJHtxdW90ZSh0YWcpfSxgKTtcbmRlY29kZShwYXlsb2FkKTtcbnJldHVybiBvdXQubmV4dCgnKScpO1xuIH1cblxuY2FzZSdzbG90Jzp7XG5sZXR7aWZhY2V9PXJhd1RyZWU7XG5jb25zdCBpbmRleD1OdW1iZXIoTmF0KHJhd1RyZWUuaW5kZXgpKTtcbmNvbnN0IG5lc3RlZFJlbmRlcj0oYXJnKT0+e1xuY29uc3Qgb2xkT3V0PW91dDtcbnRyeXtcbm91dD1tYWtlTm9JbmRlbnRlcigpO1xuZGVjb2RlKGFyZyk7XG5yZXR1cm4gb3V0LmRvbmUoKTtcbiB9ZmluYWxseXtcbm91dD1vbGRPdXQ7XG4gfVxuIH07XG5pZihpbmRleDxzbG90cy5sZW5ndGgpe1xuY29uc3Qgc2xvdD1uZXN0ZWRSZW5kZXIoc2xvdHNbaW5kZXhdKTtcbmlmKGlmYWNlPT09dW5kZWZpbmVkKXtcbnJldHVybiBvdXQubmV4dCggYHNsb3RUb1ZhbCgke3Nsb3R9KWApO1xuIH1cbmlmYWNlPW5lc3RlZFJlbmRlcihpZmFjZSk7XG5yZXR1cm4gb3V0Lm5leHQoIGBzbG90VG9WYWwoJHtzbG90fSwke2lmYWNlfSlgKTtcbiB9ZWxzZSBpZihpZmFjZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gb3V0Lm5leHQoIGBzbG90KCR7aW5kZXh9KWApO1xuIH1cbmlmYWNlPW5lc3RlZFJlbmRlcihpZmFjZSk7XG5yZXR1cm4gb3V0Lm5leHQoIGBzbG90KCR7aW5kZXh9LCR7aWZhY2V9KWApO1xuIH1cblxuY2FzZSdoaWxiZXJ0Jzp7XG5jb25zdHtvcmlnaW5hbCxyZXN0fT1yYXdUcmVlO1xub3V0Lm9wZW4oJ3snKTtcbmRlY29kZVByb3BlcnR5KFFDTEFTUyxvcmlnaW5hbCk7XG5pZigncmVzdCdpbiByYXdUcmVlKXtcbmFzc2VydC50eXBlb2YocmVzdCwnb2JqZWN0Jyk7XG5hc3NlcnQocmVzdCE9PW51bGwpO1xuY29uc3QgbmFtZXM9b3duS2V5cyhyZXN0KTtcbmZvcihjb25zdCBuYW1lIG9mIG5hbWVzKXtcbmlmKHR5cGVvZiBuYW1lIT09J3N0cmluZycpe1xudGhyb3cgRmFpbCBgUHJvcGVydHkgbmFtZSAke3EoXG5uYW1lKVxuIH0gb2YgJHtyZXN0fSBtdXN0IGJlIGEgc3RyaW5nYDtcbiB9XG5kZWNvZGVQcm9wZXJ0eShuYW1lLHJlc3RbbmFtZV0pO1xuIH1cbiB9XG5yZXR1cm4gb3V0LmNsb3NlKCd9Jyk7XG4gfVxuXG5jYXNlJ2Vycm9yJzp7XG5jb25zdHtuYW1lLG1lc3NhZ2V9PXJhd1RyZWU7XG5yZXR1cm4gb3V0Lm5leHQoIGAke25hbWV9KCR7cXVvdGUobWVzc2FnZSl9KWApO1xuIH1cblxuZGVmYXVsdDp7XG5hc3NlcnQuZmFpbChYIGB1bnJlY29nbml6ZWQgJHtxKFFDTEFTUyl9ICR7cShxY2xhc3MpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfWVsc2UgaWYoaXNBcnJheShyYXdUcmVlKSl7XG5jb25zdHtsZW5ndGh9PXJhd1RyZWU7XG5pZihsZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgnW10nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCdbJyk7XG5mb3IobGV0IGk9MDtpPGxlbmd0aDtpKz0xKXtcbm91dC5saW5lKCk7XG5kZWNvZGUocmF3VHJlZVtpXSk7XG5vdXQubmV4dCgnLCcpO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ10nKTtcbiB9XG4gfWVsc2V7XG4vKiByYXdUcmVlIGlzIGFuIGBFbmNvZGluZ1JlY29yZGAgd2hpY2ggb25seSBoYXMgc3RyaW5nIGtleXMsKi9cbi8qIGJ1dCBzaW5jZSBvd25LZXlzIGlzIG5vdCBnZW5lcmljLCBpdCBjYW4ndCBwcm9wYWdhdGUgdGhhdCovXG5jb25zdCBuYW1lcz0vKiogQHR5cGUge3N0cmluZ1tdfSAqL293bktleXMocmF3VHJlZSk7XG5pZihuYW1lcy5sZW5ndGg9PT0wKXtcbnJldHVybiBvdXQubmV4dCgne30nKTtcbiB9ZWxzZXtcbm91dC5vcGVuKCd7Jyk7XG5mb3IoY29uc3QgbmFtZSBvZiBuYW1lcyl7XG5kZWNvZGVQcm9wZXJ0eShuYW1lLHJhd1RyZWVbbmFtZV0pO1xuIH1cbnJldHVybiBvdXQuY2xvc2UoJ30nKTtcbiB9XG4gfVxuIH07XG5wcmVwYXJlKGVuY29kaW5nKTtcbmRlY29kZShlbmNvZGluZyk7XG5yZXR1cm4gb3V0LmRvbmUoKTtcbiB9OyRo4oCNX29uY2UuZGVjb2RlVG9KdXN0aW4oZGVjb2RlVG9KdXN0aW4pO1xuaGFyZGVuKGRlY29kZVRvSnVzdGluKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJkZWNvZGVUb0p1c3RpbiI6WyJkZWNvZGVUb0p1c3RpbiJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAT09Ub3AYAANwGAAAtAAAAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL21hcnNoYWwtc3RyaW5naWZ5LmpzeyJpbXBvcnRzIjpbIi4vbWFyc2hhbC5qcyJdLCJleHBvcnRzIjpbInBhcnNlIiwic3RyaW5naWZ5Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IG1ha2VNYXJzaGFsOyRo4oCNX2ltcG9ydHMoW1tcIi4vbWFyc2hhbC5qc1wiLCBbW1wibWFrZU1hcnNoYWxcIiwgWyRo4oCNX2EgPT4gKG1ha2VNYXJzaGFsID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cblxuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG4vKiogQHR5cGUge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Db252ZXJ0VmFsVG9TbG90PGFueT59ICovXG5jb25zdCBkb05vdENvbnZlcnRWYWxUb1Nsb3Q9KHZhbCk9PlxuRmFpbCBgTWFyc2hhbCdzIHN0cmluZ2lmeSByZWplY3RzIHByZXNlbmNlcyBhbmQgcHJvbWlzZXMgJHt2YWx9YDtcblxuLyoqIEB0eXBlIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ29udmVydFNsb3RUb1ZhbDxhbnk+fSAqL1xuY29uc3QgZG9Ob3RDb252ZXJ0U2xvdFRvVmFsPShzbG90LF9pZmFjZSk9PlxuRmFpbCBgTWFyc2hhbCdzIHBhcnNlIG11c3Qgbm90IGVuY29kZSBhbnkgc2xvdHMgJHtzbG90fWA7XG5cbmNvbnN0IGJhZEFycmF5SGFuZGxlcj1oYXJkZW4oe1xuZ2V0OihfdGFyZ2V0LG5hbWUsX3JlY2VpdmVyKT0+e1xuaWYobmFtZT09PSdsZW5ndGgnKXtcbnJldHVybiAwO1xuIH1cbi8qIGB0aHJvd2AgaXMgbm9vcCBzaW5jZSBgRmFpbGAgdGhyb3dzLiBCdXQgbGludGVyIGNvbmZ1c2VkKi9cbnRocm93IEZhaWwgYE1hcnNoYWwncyBwYXJzZSBtdXN0IG5vdCBlbmNvZGUgYW55IHNsb3QgcG9zaXRpb25zICR7bmFtZX1gO1xuIH19KTtcblxuXG5jb25zdCBiYWRBcnJheT1oYXJkZW4obmV3IFByb3h5KGhhcmRlbihbXSksYmFkQXJyYXlIYW5kbGVyKSk7XG5cbmNvbnN0e3NlcmlhbGl6ZSx1bnNlcmlhbGl6ZX09bWFrZU1hcnNoYWwoXG5kb05vdENvbnZlcnRWYWxUb1Nsb3QsXG5kb05vdENvbnZlcnRTbG90VG9WYWwsXG57XG5lcnJvclRhZ2dpbmc6J29mZicsXG4vKiBUT0RPIGZpeCB0ZXN0cyB0byB3b3JrcyB3aXRoIHNtYWxsY2Fwcy4qL1xuc2VyaWFsaXplQm9keUZvcm1hdDonY2FwZGF0YSd9KTtcblxuXG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdmFsXG4gKiBAcmV0dXJucyB7c3RyaW5nfVxuICovXG5jb25zdCBzdHJpbmdpZnk9KHZhbCk9PnNlcmlhbGl6ZSh2YWwpLmJvZHk7JGjigI1fb25jZS5zdHJpbmdpZnkoc3RyaW5naWZ5KTtcbmhhcmRlbihzdHJpbmdpZnkpO1xuXG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBzdHJcbiAqIEByZXR1cm5zIHtQYXNzYWJsZX1cbiAqL1xuY29uc3QgcGFyc2U9KHN0cik9PlxudW5zZXJpYWxpemUoXG5oYXJkZW4oe1xuYm9keTpzdHIsXG5zbG90czpiYWRBcnJheX0pKTskaOKAjV9vbmNlLnBhcnNlKHBhcnNlKTtcblxuXG5oYXJkZW4ocGFyc2UpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InN0cmluZ2lmeSI6WyJzdHJpbmdpZnkiXSwicGFyc2UiOlsicGFyc2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAvp5pSuwyAADsMgAAIwAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9tYXJzaGFsLmpzeyJpbXBvcnRzIjpbIi4vZW5jb2RlVG9DYXBEYXRhLmpzIiwiLi9lbmNvZGVUb1NtYWxsY2Fwcy5qcyIsIkBlbmRvL25hdCIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiZXhwb3J0cyI6WyJtYWtlTWFyc2hhbCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBOYXQsYXNzZXJ0UGFzc2FibGUsZ2V0SW50ZXJmYWNlT2YsZ2V0RXJyb3JDb25zdHJ1Y3RvcixoYXNPd25Qcm9wZXJ0eU9mLFFDTEFTUyxtYWtlRW5jb2RlVG9DYXBEYXRhLG1ha2VEZWNvZGVGcm9tQ2FwRGF0YSxtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyxtYWtlRW5jb2RlVG9TbWFsbGNhcHM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vbmF0XCIsIFtbXCJOYXRcIiwgWyRo4oCNX2EgPT4gKE5hdCA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9wYXNzLXN0eWxlXCIsIFtbXCJhc3NlcnRQYXNzYWJsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaOKAjV9hKV1dLFtcImdldEludGVyZmFjZU9mXCIsIFskaOKAjV9hID0+IChnZXRJbnRlcmZhY2VPZiA9ICRo4oCNX2EpXV0sW1wiZ2V0RXJyb3JDb25zdHJ1Y3RvclwiLCBbJGjigI1fYSA9PiAoZ2V0RXJyb3JDb25zdHJ1Y3RvciA9ICRo4oCNX2EpXV0sW1wiaGFzT3duUHJvcGVydHlPZlwiLCBbJGjigI1fYSA9PiAoaGFzT3duUHJvcGVydHlPZiA9ICRo4oCNX2EpXV1dXSxbXCIuL2VuY29kZVRvQ2FwRGF0YS5qc1wiLCBbW1wiUUNMQVNTXCIsIFskaOKAjV9hID0+IChRQ0xBU1MgPSAkaOKAjV9hKV1dLFtcIm1ha2VFbmNvZGVUb0NhcERhdGFcIiwgWyRo4oCNX2EgPT4gKG1ha2VFbmNvZGVUb0NhcERhdGEgPSAkaOKAjV9hKV1dLFtcIm1ha2VEZWNvZGVGcm9tQ2FwRGF0YVwiLCBbJGjigI1fYSA9PiAobWFrZURlY29kZUZyb21DYXBEYXRhID0gJGjigI1fYSldXV1dLFtcIi4vZW5jb2RlVG9TbWFsbGNhcHMuanNcIiwgW1tcIm1ha2VEZWNvZGVGcm9tU21hbGxjYXBzXCIsIFskaOKAjV9hID0+IChtYWtlRGVjb2RlRnJvbVNtYWxsY2FwcyA9ICRo4oCNX2EpXV0sW1wibWFrZUVuY29kZVRvU21hbGxjYXBzXCIsIFskaOKAjV9hID0+IChtYWtlRW5jb2RlVG9TbWFsbGNhcHMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuTWFrZU1hcnNoYWxPcHRpb25zfSBNYWtlTWFyc2hhbE9wdGlvbnMgKi9cbi8qKiBAdGVtcGxhdGUgU2xvdCBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNvbnZlcnRTbG90VG9WYWw8U2xvdD59IENvbnZlcnRTbG90VG9WYWwgKi9cbi8qKiBAdGVtcGxhdGUgU2xvdCBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNvbnZlcnRWYWxUb1Nsb3Q8U2xvdD59IENvbnZlcnRWYWxUb1Nsb3QgKi9cbi8qKiBAdGVtcGxhdGUgU2xvdCBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlRvQ2FwRGF0YTxTbG90Pn0gVG9DYXBEYXRhICovXG4vKiogQHRlbXBsYXRlIFNsb3QgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Gcm9tQ2FwRGF0YTxTbG90Pn0gRnJvbUNhcERhdGEgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuSW50ZXJmYWNlU3BlY30gSW50ZXJmYWNlU3BlYyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRW5jb2Rpbmd9IEVuY29kaW5nICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5SZW1vdGFibGVPYmplY3R9IFJlbW90YWJsZSAqL1xuXG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e2RldGFpbHM6WCxGYWlsLHF1b3RlOnF9PWFzc2VydDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbi8qKiBAdHlwZSB7Q29udmVydFZhbFRvU2xvdDxhbnk+fSAqL1xuY29uc3QgZGVmYXVsdFZhbFRvU2xvdEZuPSh4KT0+eDtcbi8qKiBAdHlwZSB7Q29udmVydFNsb3RUb1ZhbDxhbnk+fSAqL1xuY29uc3QgZGVmYXVsdFNsb3RUb1ZhbEZuPSh4LF8pPT54O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBTbG90XG4gKiBAcGFyYW0ge0NvbnZlcnRWYWxUb1Nsb3Q8U2xvdD59IFtjb252ZXJ0VmFsVG9TbG90XVxuICogQHBhcmFtIHtDb252ZXJ0U2xvdFRvVmFsPFNsb3Q+fSBbY29udmVydFNsb3RUb1ZhbF1cbiAqIEBwYXJhbSB7TWFrZU1hcnNoYWxPcHRpb25zfSBvcHRpb25zXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlTWFyc2hhbD0oXG5jb252ZXJ0VmFsVG9TbG90PWRlZmF1bHRWYWxUb1Nsb3RGbixcbmNvbnZlcnRTbG90VG9WYWw9ZGVmYXVsdFNsb3RUb1ZhbEZuLFxue1xuZXJyb3JUYWdnaW5nPSdvbicsXG5tYXJzaGFsTmFtZT0nYW5vbi1tYXJzaGFsJyxcbi8qIFRPRE8gVGVtcG9yYXJ5IGhhY2suKi9cbi8qIFNlZSBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzI3ODAqL1xuZXJyb3JJZE51bT0xMDAwMCxcbi8qIFdlIHByZWZlciB0aGF0IHRoZSBjYWxsZXIgaW5zdGVhZCBsb2cgdG8gc29tZXdoZXJlIGhpZGRlbiovXG4vKiB0byBiZSByZXZlYWxlZCB3aGVuIGNvcnJlbGF0aW5nIHdpdGggdGhlIHJlY2VpdmVkIGVycm9yLiovXG5tYXJzaGFsU2F2ZUVycm9yPShlcnIpPT5cbmNvbnNvbGUubG9nKCdUZW1wb3JhcnkgbG9nZ2luZyBvZiBzZW50IGVycm9yJyxlcnIpLFxuLyogRGVmYXVsdCB0byAnY2FwZGF0YScgYmVjYXVzZSBpdCB3YXMgaW1wbGVtZW50ZWQgZmlyc3QuKi9cbi8qIFNvbWV0aW1lcywgb250b2dlbnkgZG9lcyByZWNhcGl0dWxhdGUgcGh5bG9nZW55IDspKi9cbnNlcmlhbGl6ZUJvZHlGb3JtYXQ9J2NhcGRhdGEnfT1cbnt9KT0+XG57XG5hc3NlcnQudHlwZW9mKG1hcnNoYWxOYW1lLCdzdHJpbmcnKTtcbmVycm9yVGFnZ2luZz09PSdvbid8fFxuZXJyb3JUYWdnaW5nPT09J29mZid8fFxuRmFpbCBgVGhlIGVycm9yVGFnZ2luZyBvcHRpb24gY2FuIG9ubHkgYmUgXCJvblwiIG9yIFwib2ZmXCIgJHtlcnJvclRhZ2dpbmd9YDtcbmNvbnN0IG5leHRFcnJvcklkPSgpPT57XG5lcnJvcklkTnVtKz0xO1xucmV0dXJuIGBlcnJvcjoke21hcnNoYWxOYW1lfSMke2Vycm9ySWROdW19YDtcbiB9O1xuXG4vKipcbiAqIEB0eXBlIHtUb0NhcERhdGE8U2xvdD59XG4gKi9cbmNvbnN0IHRvQ2FwRGF0YT0ocm9vdCk9PntcbmNvbnN0IHNsb3RzPVtdO1xuLyogbWFwcyB2YWwgKHByb21pc2Ugb3IgcmVtb3RhYmxlKSB0byBpbmRleCBvZiBzbG90c1tdKi9cbmNvbnN0IHNsb3RNYXA9bmV3IE1hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UmVtb3RhYmxlIHwgUHJvbWlzZX0gcGFzc2FibGVcbiAqIEByZXR1cm5zIHt7aW5kZXg6IG51bWJlciwgcmVwZWF0OiBib29sZWFufX1cbiAqL1xuY29uc3QgZW5jb2RlU2xvdENvbW1vbj0ocGFzc2FibGUpPT57XG5sZXQgaW5kZXg9c2xvdE1hcC5nZXQocGFzc2FibGUpO1xuaWYoaW5kZXghPT11bmRlZmluZWQpe1xuLyogVE9ETyBhc3NlcnQgdGhhdCBpdCdzIHRoZSBzYW1lIGlmYWNlIGFzIGJlZm9yZSovXG5hc3NlcnQudHlwZW9mKGluZGV4LCdudW1iZXInKTtcbnJldHVybiBoYXJkZW4oe2luZGV4LHJlcGVhdDp0cnVlfSk7XG4gfVxuXG5pbmRleD1zbG90cy5sZW5ndGg7XG5jb25zdCBzbG90PWNvbnZlcnRWYWxUb1Nsb3QocGFzc2FibGUpO1xuc2xvdHMucHVzaChzbG90KTtcbnNsb3RNYXAuc2V0KHBhc3NhYmxlLGluZGV4KTtcbnJldHVybiBoYXJkZW4oe2luZGV4LHJlcGVhdDpmYWxzZX0pO1xuIH07XG5cbi8qKlxuICogRXZlbiBpZiBhbiBFcnJvciBpcyBub3QgYWN0dWFsbHkgcGFzc2FibGUsIHdlJ2QgcmF0aGVyIHNlbmRcbiAqIGl0IGFueXdheSBiZWNhdXNlIHRoZSBkaWFnbm9zdGljIGluZm8gY2FycmllZCBieSB0aGUgZXJyb3JcbiAqIGlzIG1vcmUgdmFsdWFibGUgdGhhbiBkaWFnbm9zaW5nIHdoeSB0aGUgZXJyb3IgaXNuJ3RcbiAqIHBhc3NhYmxlLiBTZWUgY29tbWVudHMgaW4gaXNFcnJvckxpa2UuXG4gKlxuICogQHBhcmFtIHtFcnJvcn0gZXJyXG4gKiBAcGFyYW0geyhwOiBQYXNzYWJsZSkgPT4gdW5rbm93bn0gZW5jb2RlUmVjdXJcbiAqIEByZXR1cm5zIHt7ZXJyb3JJZD86IHN0cmluZywgbWVzc2FnZTogc3RyaW5nLCBuYW1lOiBzdHJpbmd9fVxuICovXG5jb25zdCBlbmNvZGVFcnJvckNvbW1vbj0oZXJyLGVuY29kZVJlY3VyKT0+e1xuY29uc3QgbWVzc2FnZT1lbmNvZGVSZWN1ciggYCR7ZXJyLm1lc3NhZ2V9YCk7XG5hc3NlcnQudHlwZW9mKG1lc3NhZ2UsJ3N0cmluZycpO1xuY29uc3QgbmFtZT1lbmNvZGVSZWN1ciggYCR7ZXJyLm5hbWV9YCk7XG5hc3NlcnQudHlwZW9mKG5hbWUsJ3N0cmluZycpO1xuLyogTXVzdCBlbmNvZGUgYGNhdXNlYCwgYGVycm9yc2AuKi9cbi8qIG5lc3RlZCBub24tcGFzc2FibGUgZXJyb3JzIG11c3QgYmUgb2sgZnJvbSBoZXJlLiovXG5pZihlcnJvclRhZ2dpbmc9PT0nb24nKXtcbi8qIFdlIGRlbGliZXJhdGVseSBkbyBub3Qgc2hhcmUgdGhlIHN0YWNrLCBidXQgaXQgd291bGQqL1xuLyogYmUgdXNlZnVsIHRvIGxvZyB0aGUgc3RhY2sgbG9jYWxseSBzbyBzb21lb25lIHdobyBoYXMqL1xuLyogcHJpdmlsZWdlZCBhY2Nlc3MgdG8gdGhlIHRocm93aW5nIFZhdCBjYW4gY29ycmVsYXRlKi9cbi8qIHRoZSBwcm9ibGVtIHdpdGggdGhlIHJlbW90ZSBWYXQgdGhhdCBnZXRzIHRoaXMqL1xuLyogc3VtbWFyeS4gSWYgd2UgZG8gdGhhdCwgd2UgY291bGQgYWxsb2NhdGUgc29tZSByYW5kb20qL1xuLyogaWRlbnRpZmllciBhbmQgaW5jbHVkZSBpdCBpbiB0aGUgbWVzc2FnZSwgdG8gaGVscCovXG4vKiB3aXRoIHRoZSBjb3JyZWxhdGlvbi4qL1xuY29uc3QgZXJyb3JJZD1lbmNvZGVSZWN1cihuZXh0RXJyb3JJZCgpKTtcbmFzc2VydC50eXBlb2YoZXJyb3JJZCwnc3RyaW5nJyk7XG5hc3NlcnQubm90ZShlcnIsWCBgU2VudCBhcyAke2Vycm9ySWR9YCk7XG5tYXJzaGFsU2F2ZUVycm9yKGVycik7XG5yZXR1cm4gaGFyZGVuKHtlcnJvcklkLG1lc3NhZ2UsbmFtZX0pO1xuIH1lbHNle1xucmV0dXJuIGhhcmRlbih7bWVzc2FnZSxuYW1lfSk7XG4gfVxuIH07XG5cbmlmKHNlcmlhbGl6ZUJvZHlGb3JtYXQ9PT0nY2FwZGF0YScpe1xuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBwYXNzYWJsZVxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBbaWZhY2VdXG4gKiBAcmV0dXJucyB7RW5jb2Rpbmd9XG4gKi9cbmNvbnN0IGVuY29kZVNsb3RUb0NhcERhdGE9KHBhc3NhYmxlLGlmYWNlPXVuZGVmaW5lZCk9PntcbmNvbnN0e2luZGV4LHJlcGVhdH09ZW5jb2RlU2xvdENvbW1vbihwYXNzYWJsZSk7XG5cbmlmKHJlcGVhdD09PXRydWV8fGlmYWNlPT09dW5kZWZpbmVkKXtcbnJldHVybiBoYXJkZW4oe1tRQ0xBU1NdOidzbG90JyxpbmRleH0pO1xuIH1lbHNle1xucmV0dXJuIGhhcmRlbih7W1FDTEFTU106J3Nsb3QnLGlmYWNlLGluZGV4fSk7XG4gfVxuIH07XG5cbmNvbnN0IGVuY29kZVJlbW90YWJsZVRvQ2FwRGF0YT0odmFsLF9lbmNvZGVSZWN1cik9PlxuZW5jb2RlU2xvdFRvQ2FwRGF0YSh2YWwsZ2V0SW50ZXJmYWNlT2YodmFsKSk7XG5cbmNvbnN0IGVuY29kZVByb21pc2VUb0NhcERhdGE9KHByb21pc2UsX2VuY29kZVJlY3VyKT0+XG5lbmNvZGVTbG90VG9DYXBEYXRhKHByb21pc2UpO1xuXG4vKipcbiAqIEV2ZW4gaWYgYW4gRXJyb3IgaXMgbm90IGFjdHVhbGx5IHBhc3NhYmxlLCB3ZSdkIHJhdGhlciBzZW5kXG4gKiBpdCBhbnl3YXkgYmVjYXVzZSB0aGUgZGlhZ25vc3RpYyBpbmZvIGNhcnJpZWQgYnkgdGhlIGVycm9yXG4gKiBpcyBtb3JlIHZhbHVhYmxlIHRoYW4gZGlhZ25vc2luZyB3aHkgdGhlIGVycm9yIGlzbid0XG4gKiBwYXNzYWJsZS4gU2VlIGNvbW1lbnRzIGluIGlzRXJyb3JMaWtlLlxuICpcbiAqIEBwYXJhbSB7RXJyb3J9IGVyclxuICogQHBhcmFtIHsocDogUGFzc2FibGUpID0+IEVuY29kaW5nfSBlbmNvZGVSZWN1clxuICogQHJldHVybnMge0VuY29kaW5nfVxuICovXG5jb25zdCBlbmNvZGVFcnJvclRvQ2FwRGF0YT0oZXJyLGVuY29kZVJlY3VyKT0+e1xuY29uc3QgZXJyRGF0YT1lbmNvZGVFcnJvckNvbW1vbihlcnIsZW5jb2RlUmVjdXIpO1xucmV0dXJuIGhhcmRlbih7W1FDTEFTU106J2Vycm9yJywuLi5lcnJEYXRhfSk7XG4gfTtcblxuY29uc3QgZW5jb2RlVG9DYXBEYXRhPW1ha2VFbmNvZGVUb0NhcERhdGEoe1xuZW5jb2RlUmVtb3RhYmxlVG9DYXBEYXRhLFxuZW5jb2RlUHJvbWlzZVRvQ2FwRGF0YSxcbmVuY29kZUVycm9yVG9DYXBEYXRhfSk7XG5cblxuY29uc3QgZW5jb2RlZD1lbmNvZGVUb0NhcERhdGEocm9vdCk7XG5jb25zdCBib2R5PUpTT04uc3RyaW5naWZ5KGVuY29kZWQpO1xucmV0dXJuIGhhcmRlbih7XG5ib2R5LFxuc2xvdHN9KTtcblxuIH1lbHNlIGlmKHNlcmlhbGl6ZUJvZHlGb3JtYXQ9PT0nc21hbGxjYXBzJyl7XG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBwcmVmaXhcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHBhc3NhYmxlXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IFtpZmFjZV1cbiAqIEByZXR1cm5zIHtzdHJpbmd9XG4gKi9cbmNvbnN0IGVuY29kZVNsb3RUb1NtYWxsY2Fwcz0ocHJlZml4LHBhc3NhYmxlLGlmYWNlPXVuZGVmaW5lZCk9PntcbmNvbnN0e2luZGV4LHJlcGVhdH09ZW5jb2RlU2xvdENvbW1vbihwYXNzYWJsZSk7XG5cbi8qIFRPRE8gZXhwbG9yZSByZW1vdmluZyB0aGlzIHNwZWNpYWwgY2FzZSovXG5pZihyZXBlYXQ9PT10cnVlfHxpZmFjZT09PXVuZGVmaW5lZCl7XG5yZXR1cm4gYCR7cHJlZml4fSR7aW5kZXh9YDtcbiB9XG5yZXR1cm4gYCR7cHJlZml4fSR7aW5kZXh9LiR7aWZhY2V9YDtcbiB9O1xuXG5jb25zdCBlbmNvZGVSZW1vdGFibGVUb1NtYWxsY2Fwcz0ocmVtb3RhYmxlLF9lbmNvZGVSZWN1cik9PlxuZW5jb2RlU2xvdFRvU21hbGxjYXBzKCckJyxyZW1vdGFibGUsZ2V0SW50ZXJmYWNlT2YocmVtb3RhYmxlKSk7XG5cbmNvbnN0IGVuY29kZVByb21pc2VUb1NtYWxsY2Fwcz0ocHJvbWlzZSxfZW5jb2RlUmVjdXIpPT5cbmVuY29kZVNsb3RUb1NtYWxsY2FwcygnJicscHJvbWlzZSk7XG5cbmNvbnN0IGVuY29kZUVycm9yVG9TbWFsbGNhcHM9KGVycixlbmNvZGVSZWN1cik9PntcbmNvbnN0IGVyckRhdGE9ZW5jb2RlRXJyb3JDb21tb24oZXJyLGVuY29kZVJlY3VyKTtcbmNvbnN0e21lc3NhZ2UsLi4ucmVzdH09ZXJyRGF0YTtcbnJldHVybiBoYXJkZW4oeycjZXJyb3InOm1lc3NhZ2UsLi4ucmVzdH0pO1xuIH07XG5cbmNvbnN0IGVuY29kZVRvU21hbGxjYXBzPW1ha2VFbmNvZGVUb1NtYWxsY2Fwcyh7XG5lbmNvZGVSZW1vdGFibGVUb1NtYWxsY2FwcyxcbmVuY29kZVByb21pc2VUb1NtYWxsY2FwcyxcbmVuY29kZUVycm9yVG9TbWFsbGNhcHN9KTtcblxuXG5jb25zdCBlbmNvZGVkPWVuY29kZVRvU21hbGxjYXBzKHJvb3QpO1xuY29uc3Qgc21hbGxjYXBzQm9keT1KU09OLnN0cmluZ2lmeShlbmNvZGVkKTtcbnJldHVybiBoYXJkZW4oe1xuLyogVmFsaWQgSlNPTiBjYW5ub3QgYmVnaW4gd2l0aCBhICcjJywgc28gdGhpcyBpcyBhIHZhbGlkIHNpZ25hbCovXG4vKiBpbmRpY2F0aW5nIHNtYWxsY2FwcyBmb3JtYXQuKi9cbmJvZHk6IGAjJHtzbWFsbGNhcHNCb2R5fWAsXG5zbG90c30pO1xuXG4gfWVsc2V7XG4vKiBUaGUgYHRocm93YCBpcyBhIG5vb3Agc2luY2UgYEZhaWxgIHRocm93cy4gQWRkZWQgZm9yIGNvbmZ1c2VkIGxpbnRlcnMuKi9cbnRocm93IEZhaWwgYFVucmVjb2duaXplZCBzZXJpYWxpemVCb2R5Rm9ybWF0OiAke3Eoc2VyaWFsaXplQm9keUZvcm1hdCl9YDtcbiB9XG4gfTtcblxuY29uc3QgbWFrZUZ1bGxSZXZpdmU9KHNsb3RzKT0+e1xuLyoqIEB0eXBlIHtNYXA8bnVtYmVyLCBQYXNzYWJsZT59ICovXG5jb25zdCB2YWxNYXA9bmV3IE1hcCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7e2lmYWNlPzogc3RyaW5nLCBpbmRleDogbnVtYmVyfX0gc2xvdERhdGFcbiAqIEByZXR1cm5zIHtSZW1vdGFibGUgfCBQcm9taXNlfVxuICovXG5jb25zdCBkZWNvZGVTbG90Q29tbW9uPShzbG90RGF0YSk9PntcbmNvbnN0e2lmYWNlPXVuZGVmaW5lZCxpbmRleCwuLi5yZXN0fT1zbG90RGF0YTtcbm93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5GYWlsIGB1bmV4cGVjdGVkIGVuY29kZWQgc2xvdCBwcm9wZXJ0aWVzICR7cShvd25LZXlzKHJlc3QpKX1gO1xuaWYodmFsTWFwLmhhcyhpbmRleCkpe1xucmV0dXJuIHZhbE1hcC5nZXQoaW5kZXgpO1xuIH1cbi8qIFRPRE8gU0VDVVJJVFkgSEFaQVJEOiBtdXN0IGVuZm9jZSB0aGF0IHJlbW90YWJsZSB2cyBwcm9taXNlKi9cbi8qIGlzIGFjY29yZGluZyB0byB0aGUgZW5jb2RlZCBzdHJpbmcuKi9cbmNvbnN0IHNsb3Q9c2xvdHNbTnVtYmVyKE5hdChpbmRleCkpXTtcbmNvbnN0IHZhbD1jb252ZXJ0U2xvdFRvVmFsKHNsb3QsaWZhY2UpO1xudmFsTWFwLnNldChpbmRleCx2YWwpO1xucmV0dXJuIHZhbDtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7e2Vycm9ySWQ/OiBzdHJpbmcsIG1lc3NhZ2U6IHN0cmluZywgbmFtZTogc3RyaW5nfX0gZXJyRGF0YVxuICogQHBhcmFtIHsoZTogdW5rbm93bikgPT4gUGFzc2FibGV9IGRlY29kZVJlY3VyXG4gKiBAcmV0dXJucyB7RXJyb3J9XG4gKi9cbmNvbnN0IGRlY29kZUVycm9yQ29tbW9uPShlcnJEYXRhLGRlY29kZVJlY3VyKT0+e1xuY29uc3R7ZXJyb3JJZD11bmRlZmluZWQsbWVzc2FnZSxuYW1lLC4uLnJlc3R9PWVyckRhdGE7XG5vd25LZXlzKHJlc3QpLmxlbmd0aD09PTB8fFxuRmFpbCBgdW5leHBlY3RlZCBlbmNvZGVkIGVycm9yIHByb3BlcnRpZXMgJHtxKG93bktleXMocmVzdCkpfWA7XG4vKiBUT0RPIE11c3QgZGVjb2RlIGBjYXVzZWAgYW5kIGBlcnJvcnNgIHByb3BlcnRpZXMqL1xuLyogY2FwRGF0YSBkb2VzIG5vdCB0cmFuc2Zvcm0gc3RyaW5ncy4gVGhlIGNhbGxzIHRvIGBkZWNvZGVSZWN1cmAqL1xuLyogYXJlIGZvciByZXVzZSBieSBvdGhlciBlbmNvZGluZ3MgdGhhdCBkbywgc3VjaCBhcyBzbWFsbGNhcHMuKi9cbmNvbnN0IGROYW1lPWRlY29kZVJlY3VyKG5hbWUpO1xuY29uc3QgZE1lc3NhZ2U9ZGVjb2RlUmVjdXIobWVzc2FnZSk7XG5jb25zdCBkRXJyb3JJZD1lcnJvcklkJiZkZWNvZGVSZWN1cihlcnJvcklkKTtcbnR5cGVvZiBkTmFtZT09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgZXJyb3IgbmFtZSB0eXBlb2YgJHtxKHR5cGVvZiBkTmFtZSl9YDtcbnR5cGVvZiBkTWVzc2FnZT09PSdzdHJpbmcnfHxcbkZhaWwgYGludmFsaWQgZXJyb3IgbWVzc2FnZSB0eXBlb2YgJHtxKHR5cGVvZiBkTWVzc2FnZSl9YDtcbmNvbnN0IEVDPWdldEVycm9yQ29uc3RydWN0b3IoZE5hbWUpfHxFcnJvcjtcbi8qIGVycm9ySWQgaXMgYSBsYXRlIGFkZGl0aW9uIHNvIGJlIHRvbGVyYW50IG9mIGl0cyBhYnNlbmNlLiovXG5jb25zdCBlcnJvck5hbWU9XG5kRXJyb3JJZD09PXVuZGVmaW5lZD9cbiBgUmVtb3RlJHtFQy5uYW1lfWA6XG4gYFJlbW90ZSR7RUMubmFtZX0oJHtkRXJyb3JJZH0pYDtcbmNvbnN0IGVycm9yPWFzc2VydC5lcnJvcihkTWVzc2FnZSxFQyx7ZXJyb3JOYW1lfSk7XG5yZXR1cm4gaGFyZGVuKGVycm9yKTtcbiB9O1xuXG4vKiBUaGUgY3VycmVudCBlbmNvZGluZyBkb2VzIG5vdCBnaXZlIHRoZSBkZWNvZGVyIGVub3VnaCBpbnRvIHRvIGRpc3Rpbmd1aXNoKi9cbi8qIHdoZXRoZXIgYSBzbG90IHJlcHJlc2VudHMgYSBwcm9taXNlIG9yIGEgcmVtb3RhYmxlLiBBcyBhbiBpbXBsZW1lbnRhdGlvbiovXG4vKiByZXN0cmljdGlvbiB1bnRpbCB0aGlzIGlzIGZpeGVkLCBpZiBlaXRoZXIgaXMgcHJvdmlkZWQsIGJvdGggbXVzdCBiZSovXG4vKiBwcm92aWRlZCBhbmQgdGhleSBtdXN0IGJlIHRoZSBzYW1lLiovXG4vKiBTZWUgaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy80MzM0Ki9cbmNvbnN0IGRlY29kZVJlbW90YWJsZU9yUHJvbWlzZUZyb21DYXBEYXRhPShyYXdUcmVlLF9kZWNvZGVSZWN1cik9PntcbmNvbnN0e1tRQ0xBU1NdOl8sLi4uc2xvdERhdGF9PXJhd1RyZWU7XG5yZXR1cm4gZGVjb2RlU2xvdENvbW1vbihzbG90RGF0YSk7XG4gfTtcblxuY29uc3QgZGVjb2RlRXJyb3JGcm9tQ2FwRGF0YT0ocmF3VHJlZSxkZWNvZGVSZWN1cik9PntcbmNvbnN0e1tRQ0xBU1NdOl8sLi4uZXJyRGF0YX09cmF3VHJlZTtcbnJldHVybiBkZWNvZGVFcnJvckNvbW1vbihlcnJEYXRhLGRlY29kZVJlY3VyKTtcbiB9O1xuXG5jb25zdCByZXZpdmVGcm9tQ2FwRGF0YT1tYWtlRGVjb2RlRnJvbUNhcERhdGEoe1xuZGVjb2RlUmVtb3RhYmxlRnJvbUNhcERhdGE6ZGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGEsXG5kZWNvZGVQcm9taXNlRnJvbUNhcERhdGE6ZGVjb2RlUmVtb3RhYmxlT3JQcm9taXNlRnJvbUNhcERhdGEsXG5kZWNvZGVFcnJvckZyb21DYXBEYXRhfSk7XG5cblxuY29uc3QgbWFrZURlY29kZVNsb3RGcm9tU21hbGxjYXBzPShwcmVmaXgpPT57XG4vKipcbiAqIEBwYXJhbSB7c3RyaW5nfSBzdHJpbmdFbmNvZGluZ1xuICogQHBhcmFtIHsoZTogdW5rbm93bikgPT4gUGFzc2FibGV9IF9kZWNvZGVSZWN1clxuICogQHJldHVybnMge1JlbW90YWJsZSB8IFByb21pc2V9XG4gKi9cbnJldHVybihzdHJpbmdFbmNvZGluZyxfZGVjb2RlUmVjdXIpPT57XG5hc3NlcnQoc3RyaW5nRW5jb2Rpbmcuc3RhcnRzV2l0aChwcmVmaXgpKTtcbi8qIHNsb3RzOiAkc2xvdEluZGV4LmlmYWNlIG9yICRzbG90SW5kZXgqL1xuY29uc3QgaT1zdHJpbmdFbmNvZGluZy5pbmRleE9mKCcuJyk7XG5jb25zdCBpbmRleD1OdW1iZXIoc3RyaW5nRW5jb2Rpbmcuc2xpY2UoMSxpPDA/dW5kZWZpbmVkOmkpKTtcbi8qIGkgPCAwIG1lYW5zIHRoZXJlIHdhcyBubyBpZmFjZSBpbmNsdWRlZC4qL1xuY29uc3QgaWZhY2U9aTwwP3VuZGVmaW5lZDpzdHJpbmdFbmNvZGluZy5zbGljZShpKzEpO1xucmV0dXJuIGRlY29kZVNsb3RDb21tb24oe2lmYWNlLGluZGV4fSk7XG4gfTtcbiB9O1xuY29uc3QgZGVjb2RlUmVtb3RhYmxlRnJvbVNtYWxsY2Fwcz1tYWtlRGVjb2RlU2xvdEZyb21TbWFsbGNhcHMoJyQnKTtcbmNvbnN0IGRlY29kZVByb21pc2VGcm9tU21hbGxjYXBzPW1ha2VEZWNvZGVTbG90RnJvbVNtYWxsY2FwcygnJicpO1xuXG5jb25zdCBkZWNvZGVFcnJvckZyb21TbWFsbGNhcHM9KGVuY29kaW5nLGRlY29kZVJlY3VyKT0+e1xuY29uc3R7JyNlcnJvcic6bWVzc2FnZSwuLi5yZXN0RXJyRGF0YX09ZW5jb2Rpbmc7XG4haGFzT3duUHJvcGVydHlPZihyZXN0RXJyRGF0YSwnbWVzc2FnZScpfHxcbkZhaWwgYHVuZXhwZWN0ZWQgZW5jb2RlZCBlcnJvciBwcm9wZXJ0eSAke3EoJ21lc3NhZ2UnKX1gO1xucmV0dXJuIGRlY29kZUVycm9yQ29tbW9uKHttZXNzYWdlLC4uLnJlc3RFcnJEYXRhfSxkZWNvZGVSZWN1cik7XG4gfTtcblxuY29uc3QgcmV2aXZlRnJvbVNtYWxsY2Fwcz1tYWtlRGVjb2RlRnJvbVNtYWxsY2Fwcyh7XG5kZWNvZGVSZW1vdGFibGVGcm9tU21hbGxjYXBzLFxuZGVjb2RlUHJvbWlzZUZyb21TbWFsbGNhcHMsXG5kZWNvZGVFcnJvckZyb21TbWFsbGNhcHN9KTtcblxuXG5yZXR1cm4gaGFyZGVuKHtyZXZpdmVGcm9tQ2FwRGF0YSxyZXZpdmVGcm9tU21hbGxjYXBzfSk7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7RnJvbUNhcERhdGE8U2xvdD59XG4gKi9cbmNvbnN0IGZyb21DYXBEYXRhPShkYXRhKT0+e1xuY29uc3R7Ym9keSxzbG90c309ZGF0YTtcbnR5cGVvZiBib2R5PT09J3N0cmluZyd8fFxuRmFpbCBgdW5zZXJpYWxpemUoKSBnaXZlbiBub24tY2FwZGF0YSAoLmJvZHkgaXMgJHtib2R5fSwgbm90IHN0cmluZylgO1xuaXNBcnJheShkYXRhLnNsb3RzKXx8XG5GYWlsIGB1bnNlcmlhbGl6ZSgpIGdpdmVuIG5vbi1jYXBkYXRhICguc2xvdHMgYXJlIG5vdCBBcnJheSlgO1xuY29uc3R7cmV2aXZlRnJvbUNhcERhdGEscmV2aXZlRnJvbVNtYWxsY2Fwc309bWFrZUZ1bGxSZXZpdmUoc2xvdHMpO1xubGV0IHJlc3VsdDtcbi8qIEpTT04gY2Fubm90IGJlZ2luIHdpdGggYSAnIycsIHNvIHRoaXMgaXMgYW4gdW5hbWJpZ3VvdXMgc2lnbmFsLiovXG5pZihib2R5LnN0YXJ0c1dpdGgoJyMnKSl7XG5jb25zdCBzbWFsbGNhcHNCb2R5PWJvZHkuc2xpY2UoMSk7XG5jb25zdCBlbmNvZGluZz1oYXJkZW4oSlNPTi5wYXJzZShzbWFsbGNhcHNCb2R5KSk7XG5yZXN1bHQ9aGFyZGVuKHJldml2ZUZyb21TbWFsbGNhcHMoZW5jb2RpbmcpKTtcbiB9ZWxzZXtcbmNvbnN0IHJhd1RyZWU9aGFyZGVuKEpTT04ucGFyc2UoYm9keSkpO1xucmVzdWx0PWhhcmRlbihyZXZpdmVGcm9tQ2FwRGF0YShyYXdUcmVlKSk7XG4gfVxuLyogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvNDMzNyovXG4vKiB3aGljaCBzaG91bGQgYmUgY29uc2lkZXJlZCBmaXhlZCBvbmNlIHdlJ3ZlIGNvbXBsZXRlZCB0aGUgc3dpdGNoKi9cbi8qIHRvIHNtYWxsY2Fwcy4qL1xuYXNzZXJ0UGFzc2FibGUocmVzdWx0KTtcbnJldHVybiByZXN1bHQ7XG4gfTtcblxucmV0dXJuIGhhcmRlbih7XG50b0NhcERhdGEsXG5mcm9tQ2FwRGF0YSxcblxuLyogZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5Ki9cbi8qKiBAZGVwcmVjYXRlZCB1c2UgdG9DYXBEYXRhICovXG5zZXJpYWxpemU6dG9DYXBEYXRhLFxuLyoqIEBkZXByZWNhdGVkIHVzZSBmcm9tQ2FwRGF0YSAqL1xudW5zZXJpYWxpemU6ZnJvbUNhcERhdGF9KTtcblxuIH07JGjigI1fb25jZS5tYWtlTWFyc2hhbChtYWtlTWFyc2hhbCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZU1hcnNoYWwiOlsibWFrZU1hcnNoYWwiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAV0RkCn5AAAB+QAAAJQAAAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9yYW5rT3JkZXIuanN7ImltcG9ydHMiOlsiLi9lbmNvZGVQYXNzYWJsZS5qcyIsIkBlbmRvL3Bhc3Mtc3R5bGUiXSwiZXhwb3J0cyI6WyJGdWxsUmFua0NvdmVyIiwiYXNzZXJ0UmFua1NvcnRlZCIsImNvbXBhcmF0b3JNaXJyb3JJbWFnZSIsImNvbXBhcmVBbnRpUmFuayIsImNvbXBhcmVSYW5rIiwiY292ZXJlZEVudHJpZXMiLCJnZXRJbmRleENvdmVyIiwiZ2V0UGFzc1N0eWxlQ292ZXIiLCJpbnRlcnNlY3RSYW5rQ292ZXJzIiwiaXNSYW5rU29ydGVkIiwibWFrZUNvbXBhcmF0b3JLaXQiLCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCIsInNvcnRCeVJhbmsiLCJ1bmlvblJhbmtDb3ZlcnMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgZ2V0VGFnLHBhc3NTdHlsZU9mLG5hbWVGb3JQYXNzYWJsZVN5bWJvbCxwYXNzU3R5bGVQcmVmaXhlcyxyZWNvcmROYW1lcyxyZWNvcmRWYWx1ZXM7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcGFzcy1zdHlsZVwiLCBbW1wiZ2V0VGFnXCIsIFskaOKAjV9hID0+IChnZXRUYWcgPSAkaOKAjV9hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV0sW1wibmFtZUZvclBhc3NhYmxlU3ltYm9sXCIsIFskaOKAjV9hID0+IChuYW1lRm9yUGFzc2FibGVTeW1ib2wgPSAkaOKAjV9hKV1dXV0sW1wiLi9lbmNvZGVQYXNzYWJsZS5qc1wiLCBbW1wicGFzc1N0eWxlUHJlZml4ZXNcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZVByZWZpeGVzID0gJGjigI1fYSldXSxbXCJyZWNvcmROYW1lc1wiLCBbJGjigI1fYSA9PiAocmVjb3JkTmFtZXMgPSAkaOKAjV9hKV1dLFtcInJlY29yZFZhbHVlc1wiLCBbJGjigI1fYSA9PiAocmVjb3JkVmFsdWVzID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SYW5rQ292ZXJ9IFJhbmtDb3ZlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmFua0NvbXBhcmlzb259IFJhbmtDb21wYXJpc29uICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SYW5rQ29tcGFyZX0gUmFua0NvbXBhcmUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkZ1bGxDb21wYXJlfSBGdWxsQ29tcGFyZSAqL1xuXG5jb25zdHtGYWlsLHF1b3RlOnF9PWFzc2VydDtcbmNvbnN0e2VudHJpZXMsZnJvbUVudHJpZXMsc2V0UHJvdG90eXBlT2YsaXN9PU9iamVjdDtcblxuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBSYW5rQ29tcGFyYXRvcktpdFxuICogQHByb3BlcnR5IHtSYW5rQ29tcGFyZX0gY29tcGFyYXRvclxuICogQHByb3BlcnR5IHtSYW5rQ29tcGFyZX0gYW50aUNvbXBhcmF0b3JcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IEZ1bGxDb21wYXJhdG9yS2l0XG4gKiBAcHJvcGVydHkge0Z1bGxDb21wYXJlfSBjb21wYXJhdG9yXG4gKiBAcHJvcGVydHkge0Z1bGxDb21wYXJlfSBhbnRpQ29tcGFyYXRvclxuICovXG5cbi8qKlxuICogQHR5cGVkZWYge1tudW1iZXIsIG51bWJlcl19IEluZGV4Q292ZXJcbiAqL1xuXG4vKipcbiAqIFRoaXMgaXMgdGhlIGVxdWFsaXR5IGNvbXBhcmlzb24gdXNlZCBieSBKYXZhU2NyaXB0J3MgTWFwIGFuZCBTZXRcbiAqIGFic3RyYWN0aW9ucywgd2hlcmUgTmFOIGlzIHRoZSBzYW1lIGFzIE5hTiBhbmQgLTAgaXMgdGhlIHNhbWUgYXNcbiAqIDAuIE1hcnNoYWwgc2VyaWFsaXplcyAtMCBhcyB6ZXJvLCBzbyB0aGUgc2VtYW50aWNzIG9mIG91ciBkaXN0cmlidXRlZFxuICogb2JqZWN0IHN5c3RlbSBkb2VzIG5vdCBkaXN0aW5ndWlzaCAwIGZyb20gLTAuXG4gKlxuICogYHNhbWVWYWx1ZVplcm9gIGlzIHRoZSBFY21hU2NyaXB0IHNwZWMgbmFtZSBmb3IgdGhpcyBlcXVhbGl0eSBjb21wYXJpc29uLFxuICogYnV0IFRPRE8gd2UgbmVlZCBhIGJldHRlciBuYW1lIGZvciB0aGUgQVBJLlxuICpcbiAqIEBwYXJhbSB7YW55fSB4XG4gKiBAcGFyYW0ge2FueX0geVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IHNhbWVWYWx1ZVplcm89KHgseSk9Png9PT15fHxpcyh4LHkpO1xuXG5jb25zdCB0cml2aWFsQ29tcGFyYXRvcj0obGVmdCxyaWdodCk9PlxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLW5lc3RlZC10ZXJuYXJ5LCBAZW5kby9yZXN0cmljdC1jb21wYXJpc29uLW9wZXJhbmRzKi9cbmxlZnQ8cmlnaHQ/LTE6bGVmdD09PXJpZ2h0PzA6MTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7UmVjb3JkPFBhc3NTdHlsZSwgeyBpbmRleDogbnVtYmVyLCBjb3ZlcjogUmFua0NvdmVyIH0+fSBQYXNzU3R5bGVSYW5rc1JlY29yZFxuICovXG5cbmNvbnN0IHBhc3NTdHlsZVJhbmtzPS8qKiBAdHlwZSB7UGFzc1N0eWxlUmFua3NSZWNvcmR9ICovXG5mcm9tRW50cmllcyhcbmVudHJpZXMocGFzc1N0eWxlUHJlZml4ZXMpXG4vKiBTb3J0IGVudHJpZXMgYnkgYXNjZW5kaW5nIHByZWZpeC4qLy5cbnNvcnQoKFtfbGVmdFN0eWxlLGxlZnRQcmVmaXhlc10sW19yaWdodFN0eWxlLHJpZ2h0UHJlZml4ZXNdKT0+e1xucmV0dXJuIHRyaXZpYWxDb21wYXJhdG9yKGxlZnRQcmVmaXhlcyxyaWdodFByZWZpeGVzKTtcbiB9KS5cbm1hcCgoW3Bhc3NTdHlsZSxwcmVmaXhlc10saW5kZXgpPT57XG4vKiBDb3ZlciBhbGwgc3RyaW5ncyB0aGF0IHN0YXJ0IHdpdGggYW55IGNoYXJhY3RlciBpbiBgcHJlZml4ZXNgLCovXG4vKiB2ZXJpZnlpbmcgdGhhdCBpdCBpcyBzb3J0ZWQgc28gdGhhdCBpcyovXG4vKiBhbGwgcyBzdWNoIHRoYXQgcHJlZml4ZXMuYXQoMCkg4omkIHMgPCBzdWNjZXNzb3IocHJlZml4ZXMuYXQoLTEpKS4qL1xucHJlZml4ZXM9PT1bLi4ucHJlZml4ZXNdLnNvcnQoKS5qb2luKCcnKXx8XG5GYWlsIGB1bnNvcnRlZCBwcmVmaXhlcyBmb3IgcGFzc1N0eWxlICR7cShwYXNzU3R5bGUpfTogJHtxKHByZWZpeGVzKX1gO1xuY29uc3QgY292ZXI9W1xucHJlZml4ZXMuY2hhckF0KDApLFxuU3RyaW5nLmZyb21DaGFyQ29kZShwcmVmaXhlcy5jaGFyQ29kZUF0KHByZWZpeGVzLmxlbmd0aC0xKSsxKV07XG5cbnJldHVybltwYXNzU3R5bGUse2luZGV4LGNvdmVyfV07XG4gfSkpO1xuXG5cbnNldFByb3RvdHlwZU9mKHBhc3NTdHlsZVJhbmtzLG51bGwpO1xuaGFyZGVuKHBhc3NTdHlsZVJhbmtzKTtcblxuLyoqXG4gKiBBc3NvY2lhdGUgd2l0aCBlYWNoIHBhc3NTdHlsZSBhIFJhbmtDb3ZlciB0aGF0IG1heSBiZSBhbiBvdmVyZXN0aW1hdGUsXG4gKiBhbmQgd2hvc2UgcmVzdWx0cyB0aGVyZWZvcmUgbmVlZCB0byBiZSBmaWx0ZXJlZCBkb3duLiBGb3IgZXhhbXBsZSwgYmVjYXVzZVxuICogdGhlcmUgaXMgbm90IGEgc21hbGxlc3Qgb3IgYmlnZ2VzdCBiaWdpbnQsIGJvdW5kIGl0IGJ5IGBOYU5gICh0aGUgbGFzdCBwbGFjZVxuICogbnVtYmVyKSBhbmQgYCcnYCAodGhlIGVtcHR5IHN0cmluZywgd2hpY2ggaXMgdGhlIGZpcnN0IHBsYWNlIHN0cmluZykuIFRodXMsXG4gKiBhIHJhbmdlIHF1ZXJ5IHVzaW5nIHRoaXMgcmFuZ2UgbWF5IGluY2x1ZGUgdGhlc2UgdmFsdWVzLCB3aGljaCB3b3VsZCB0aGVuXG4gKiBuZWVkIHRvIGJlIGZpbHRlcmVkIG91dC5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NTdHlsZX0gcGFzc1N0eWxlXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCAgICAgICAgZ2V0UGFzc1N0eWxlQ292ZXI9KHBhc3NTdHlsZSk9PnBhc3NTdHlsZVJhbmtzW3Bhc3NTdHlsZV0uY292ZXI7JGjigI1fb25jZS5nZXRQYXNzU3R5bGVDb3ZlcihnZXRQYXNzU3R5bGVDb3Zlcik7XG5oYXJkZW4oZ2V0UGFzc1N0eWxlQ292ZXIpO1xuXG4vKipcbiAqIEB0eXBlIHtXZWFrTWFwPFJhbmtDb21wYXJlLFdlYWtTZXQ8UGFzc2FibGVbXT4+fVxuICovXG5jb25zdCBtZW1vT2ZTb3J0ZWQ9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAdHlwZSB7V2Vha01hcDxSYW5rQ29tcGFyZSxSYW5rQ29tcGFyZT59XG4gKi9cbmNvbnN0IGNvbXBhcmF0b3JNaXJyb3JJbWFnZXM9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlPX0gY29tcGFyZVJlbW90YWJsZXNcbiAqIEFuIG9wdGlvbiB0byBjcmVhdGUgYSBjb21wYXJhdG9yIGluIHdoaWNoIGFuIGludGVybmFsIG9yZGVyIGlzXG4gKiBhc3NpZ25lZCB0byByZW1vdGFibGVzLiBUaGlzIGRlZmF1bHRzIHRvIGEgY29tcGFyYXRvciB0aGF0XG4gKiBhbHdheXMgcmV0dXJucyBgMGAsIG1lYW5pbmcgdGhhdCBhbGwgcmVtb3RhYmxlcyBhcmUgdGllZFxuICogZm9yIHRoZSBzYW1lIHJhbmsuXG4gKiBAcmV0dXJucyB7UmFua0NvbXBhcmF0b3JLaXR9XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29tcGFyYXRvcktpdD0oY29tcGFyZVJlbW90YWJsZXM9KF94LF95KT0+MCk9Pntcbi8qKiBAdHlwZSB7UmFua0NvbXBhcmV9ICovXG5jb25zdCBjb21wYXJhdG9yPShsZWZ0LHJpZ2h0KT0+e1xuaWYoc2FtZVZhbHVlWmVybyhsZWZ0LHJpZ2h0KSl7XG5yZXR1cm4gMDtcbiB9XG5jb25zdCBsZWZ0U3R5bGU9cGFzc1N0eWxlT2YobGVmdCk7XG5jb25zdCByaWdodFN0eWxlPXBhc3NTdHlsZU9mKHJpZ2h0KTtcbmlmKGxlZnRTdHlsZSE9PXJpZ2h0U3R5bGUpe1xucmV0dXJuIHRyaXZpYWxDb21wYXJhdG9yKFxucGFzc1N0eWxlUmFua3NbbGVmdFN0eWxlXS5pbmRleCxcbnBhc3NTdHlsZVJhbmtzW3JpZ2h0U3R5bGVdLmluZGV4KTtcblxuIH1cbi8qIGVzbGludC1kaXNhYmxlIEBlbmRvL3Jlc3RyaWN0LWNvbXBhcmlzb24tb3BlcmFuZHMgLS1cbiAqIFdlIGtub3cgYGxlZnRgIGFuZCBgcmlnaHRgIGFyZSBjb21wYXJhYmxlLlxuICovXG5zd2l0Y2gobGVmdFN0eWxlKXtcbmNhc2UncmVtb3RhYmxlJzp7XG5yZXR1cm4gY29tcGFyZVJlbW90YWJsZXMobGVmdCxyaWdodCk7XG4gfVxuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdudWxsJzpcbmNhc2UnZXJyb3InOlxuY2FzZSdwcm9taXNlJzp7XG4vKiBGb3IgZWFjaCBvZiB0aGVzZSBwYXNzU3R5bGVzLCBhbGwgbWVtYmVycyBvZiB0aGF0IHBhc3NTdHlsZSBhcmUgdGllZCovXG4vKiBmb3IgdGhlIHNhbWUgcmFuay4qL1xucmV0dXJuIDA7XG4gfVxuY2FzZSdib29sZWFuJzpcbmNhc2UnYmlnaW50JzpcbmNhc2Unc3RyaW5nJzp7XG4vKiBXaXRoaW4gZWFjaCBvZiB0aGVzZSBwYXNzU3R5bGVzLCB0aGUgcmFuayBvcmRlcmluZyBhZ3JlZXMgd2l0aCovXG4vKiBKYXZhU2NyaXB0J3MgcmVsYXRpb25hbCBvcGVyYXRvcnMgYDxgIGFuZCBgPmAuKi9cbmlmKGxlZnQ8cmlnaHQpe1xucmV0dXJuLTE7XG4gfWVsc2V7XG5hc3NlcnQobGVmdD5yaWdodCk7XG5yZXR1cm4gMTtcbiB9XG4gfVxuY2FzZSdzeW1ib2wnOntcbnJldHVybiBjb21wYXJhdG9yKFxubmFtZUZvclBhc3NhYmxlU3ltYm9sKGxlZnQpLFxubmFtZUZvclBhc3NhYmxlU3ltYm9sKHJpZ2h0KSk7XG5cbiB9XG5jYXNlJ251bWJlcic6e1xuLyogYE5hTmAncyByYW5rIGlzIGFmdGVyIGFsbCBvdGhlciBudW1iZXJzLiovXG5pZihOdW1iZXIuaXNOYU4obGVmdCkpe1xuYXNzZXJ0KCFOdW1iZXIuaXNOYU4ocmlnaHQpKTtcbnJldHVybiAxO1xuIH1lbHNlIGlmKE51bWJlci5pc05hTihyaWdodCkpe1xucmV0dXJuLTE7XG4gfVxuLyogVGhlIHJhbmsgb3JkZXJpbmcgb2Ygbm9uLU5hTiBudW1iZXJzIGFncmVlcyB3aXRoIEphdmFTY3JpcHQncyovXG4vKiByZWxhdGlvbmFsIG9wZXJhdG9ycyAnPCcgYW5kICc+Jy4qL1xuaWYobGVmdDxyaWdodCl7XG5yZXR1cm4tMTtcbiB9ZWxzZXtcbmFzc2VydChsZWZ0PnJpZ2h0KTtcbnJldHVybiAxO1xuIH1cbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbi8qIExleGljb2dyYXBoaWMgYnkgaW52ZXJzZSBzb3J0ZWQgb3JkZXIgb2YgcHJvcGVydHkgbmFtZXMsIHRoZW4qL1xuLyogbGV4aWNvZ3JhcGhpYyBieSBjb3JyZXNwb25kaW5nIHZhbHVlcyBpbiB0aGF0IHNhbWUgaW52ZXJzZSovXG4vKiBvcmRlciBvZiB0aGVpciBwcm9wZXJ0eSBuYW1lcy4gQ29tcGFyaW5nIG5hbWVzIGJ5IHRoZW1zZWx2ZXMgZmlyc3QsKi9cbi8qIGFsbCByZWNvcmRzIHdpdGggdGhlIGV4YWN0IHNhbWUgc2V0IG9mIHByb3BlcnR5IG5hbWVzIHNvcnQgbmV4dCB0byovXG4vKiBlYWNoIG90aGVyIGluIGEgcmFuay1zb3J0IG9mIGNvcHlSZWNvcmRzLiovXG5cbi8qIFRoZSBjb3B5UmVjb3JkIGludmFyaWFudHMgZW5mb3JjZWQgYnkgcGFzc1N0eWxlT2YgZW5zdXJlIHRoYXQqL1xuLyogYWxsIHRoZSBwcm9wZXJ0eSBuYW1lcyBhcmUgc3RyaW5ncy4gV2UgbmVlZCB0aGUgcmV2ZXJzZSBzb3J0ZWQgb3JkZXIqL1xuLyogb2YgdGhlc2UgbmFtZXMsIHdoaWNoIHdlIHRoZW4gY29tcGFyZSBsZXhpY29ncmFwaGljYWxseS4gVGhpcyBlbnN1cmVzKi9cbi8qIHRoYXQgaWYgdGhlIG5hbWVzIG9mIHJlY29yZCBYIGFyZSBhIHN1YnNldCBvZiB0aGUgbmFtZXMgb2YgcmVjb3JkIFksKi9cbi8qIHRoZW4gcmVjb3JkIFggd2lsbCBoYXZlIGFuIGVhcmxpZXIgcmFuayBhbmQgc29ydCB0byB0aGUgbGVmdCBvZiBZLiovXG5jb25zdCBsZWZ0TmFtZXM9cmVjb3JkTmFtZXMobGVmdCk7XG5jb25zdCByaWdodE5hbWVzPXJlY29yZE5hbWVzKHJpZ2h0KTtcblxuY29uc3QgcmVzdWx0PWNvbXBhcmF0b3IobGVmdE5hbWVzLHJpZ2h0TmFtZXMpO1xuaWYocmVzdWx0IT09MCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbnJldHVybiBjb21wYXJhdG9yKFxucmVjb3JkVmFsdWVzKGxlZnQsbGVmdE5hbWVzKSxcbnJlY29yZFZhbHVlcyhyaWdodCxyaWdodE5hbWVzKSk7XG5cbiB9XG5jYXNlJ2NvcHlBcnJheSc6e1xuLyogTGV4aWNvZ3JhcGhpYyovXG5jb25zdCBsZW49TWF0aC5taW4obGVmdC5sZW5ndGgscmlnaHQubGVuZ3RoKTtcbmZvcihsZXQgaT0wO2k8bGVuO2krPTEpe1xuY29uc3QgcmVzdWx0PWNvbXBhcmF0b3IobGVmdFtpXSxyaWdodFtpXSk7XG5pZihyZXN1bHQhPT0wKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbi8qIElmIGFsbCBtYXRjaGluZyBlbGVtZW50cyB3ZXJlIHRpZWQsIHRoZW4gYWNjb3JkaW5nIHRvIHRoZWlyIGxlbmd0aHMuKi9cbi8qIElmIGFycmF5IFggaXMgYSBwcmVmaXggb2YgYXJyYXkgWSwgdGhlbiBYIGhhcyBhbiBlYXJsaWVyIHJhbmsgdGhhbiBZLiovXG5yZXR1cm4gY29tcGFyYXRvcihsZWZ0Lmxlbmd0aCxyaWdodC5sZW5ndGgpO1xuIH1cbmNhc2UndGFnZ2VkJzp7XG4vKiBMZXhpY29ncmFwaGljIGJ5IGBbU3ltYm9sLnRvU3RyaW5nVGFnXWAgdGhlbiBgLnBheWxvYWRgLiovXG5jb25zdCBsYWJlbENvbXA9Y29tcGFyYXRvcihnZXRUYWcobGVmdCksZ2V0VGFnKHJpZ2h0KSk7XG5pZihsYWJlbENvbXAhPT0wKXtcbnJldHVybiBsYWJlbENvbXA7XG4gfVxucmV0dXJuIGNvbXBhcmF0b3IobGVmdC5wYXlsb2FkLHJpZ2h0LnBheWxvYWQpO1xuIH1cbmRlZmF1bHQ6e1xudGhyb3cgRmFpbCBgVW5yZWNvZ25pemVkIHBhc3NTdHlsZTogJHtxKGxlZnRTdHlsZSl9YDtcbiB9fVxuXG4vKiBlc2xpbnQtZW5hYmxlICovXG4gfTtcblxuLyoqIEB0eXBlIHtSYW5rQ29tcGFyZX0gKi9cbmNvbnN0IGFudGlDb21wYXJhdG9yPSh4LHkpPT5jb21wYXJhdG9yKHkseCk7XG5cbm1lbW9PZlNvcnRlZC5zZXQoY29tcGFyYXRvcixuZXcgV2Vha1NldCgpKTtcbm1lbW9PZlNvcnRlZC5zZXQoYW50aUNvbXBhcmF0b3IsbmV3IFdlYWtTZXQoKSk7XG5jb21wYXJhdG9yTWlycm9ySW1hZ2VzLnNldChjb21wYXJhdG9yLGFudGlDb21wYXJhdG9yKTtcbmNvbXBhcmF0b3JNaXJyb3JJbWFnZXMuc2V0KGFudGlDb21wYXJhdG9yLGNvbXBhcmF0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtjb21wYXJhdG9yLGFudGlDb21wYXJhdG9yfSk7XG4gfTtcbi8qKlxuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyYXRvclxuICogQHJldHVybnMge1JhbmtDb21wYXJlPX1cbiAqLyRo4oCNX29uY2UubWFrZUNvbXBhcmF0b3JLaXQobWFrZUNvbXBhcmF0b3JLaXQpO1xuY29uc3QgICAgICAgIGNvbXBhcmF0b3JNaXJyb3JJbWFnZT0oY29tcGFyYXRvcik9PlxuY29tcGFyYXRvck1pcnJvckltYWdlcy5nZXQoY29tcGFyYXRvcik7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBwYXNzYWJsZXNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjigI1fb25jZS5jb21wYXJhdG9yTWlycm9ySW1hZ2UoY29tcGFyYXRvck1pcnJvckltYWdlKTtcbmNvbnN0ICAgICAgICBpc1JhbmtTb3J0ZWQ9KHBhc3NhYmxlcyxjb21wYXJlKT0+e1xuY29uc3Qgc3ViTWVtb09mU29ydGVkPW1lbW9PZlNvcnRlZC5nZXQoY29tcGFyZSk7XG5hc3NlcnQoc3ViTWVtb09mU29ydGVkIT09dW5kZWZpbmVkKTtcbmlmKHN1Yk1lbW9PZlNvcnRlZC5oYXMocGFzc2FibGVzKSl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5hc3NlcnQocGFzc1N0eWxlT2YocGFzc2FibGVzKT09PSdjb3B5QXJyYXknKTtcbmZvcihsZXQgaT0xO2k8cGFzc2FibGVzLmxlbmd0aDtpKz0xKXtcbmlmKGNvbXBhcmUocGFzc2FibGVzW2ktMV0scGFzc2FibGVzW2ldKT49MSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuIH1cbnN1Yk1lbW9PZlNvcnRlZC5hZGQocGFzc2FibGVzKTtcbnJldHVybiB0cnVlO1xuIH07JGjigI1fb25jZS5pc1JhbmtTb3J0ZWQoaXNSYW5rU29ydGVkKTtcbmhhcmRlbihpc1JhbmtTb3J0ZWQpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRSYW5rU29ydGVkPShzb3J0ZWQsY29tcGFyZSk9PlxuaXNSYW5rU29ydGVkKHNvcnRlZCxjb21wYXJlKXx8XG4vKiBUT0RPIGFzc2VydCBvbiBidWcgY291bGQgbGVhZCB0byBpbmZpbml0ZSByZWN1cnNpb24uIEZpeC4qL1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbkZhaWwgYE11c3QgYmUgcmFuayBzb3J0ZWQ6ICR7c29ydGVkfSB2cyAke3NvcnRCeVJhbmsoc29ydGVkLGNvbXBhcmUpfWA7JGjigI1fb25jZS5hc3NlcnRSYW5rU29ydGVkKGFzc2VydFJhbmtTb3J0ZWQpO1xuaGFyZGVuKGFzc2VydFJhbmtTb3J0ZWQpO1xuXG4vKipcbiAqIFRPRE8gU0VDVVJJVFkgQlVHOiBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzQyNjBcbiAqIHNvcnRCeVJhbmsgY3VycmVudGx5IHVzZXMgYEFycmF5LnByb3RvdHlwZS5zb3J0YCBkaXJlY3RseSwgYW5kXG4gKiBzbyBvbmx5IHdvcmtzIGNvcnJlY3RseSB3aGVuIGdpdmVuIGEgYGNvbXBhcmVgIGZ1bmN0aW9uIHRoYXQgY29uc2lkZXJzXG4gKiBgdW5kZWZpbmVkYCBzdHJpY3RseSBiaWdnZXIgKGA+YCkgdGhhbiBldmVyeXRoaW5nIGVsc2UuIFRoaXMgaXNcbiAqIGJlY2F1c2UgYEFycmF5LnByb3RvdHlwZS5zb3J0YCBiaXphcnJlbHkgbW92ZXMgYWxsIGB1bmRlZmluZWRgcyB0b1xuICogdGhlIGVuZCBvZiB0aGUgYXJyYXkgcmVnYXJkbGVzcywgd2l0aG91dCBjb25zdWx0aW5nIHRoZSBgY29tcGFyZWBcbiAqIGZ1bmN0aW9uLiBUaGlzIGlzIGEgZ2VudWluZSBidWcgZm9yIHVzIE5PVyBiZWNhdXNlIHNvbWV0aW1lcyB3ZSBzb3J0XG4gKiBpbiByZXZlcnNlIG9yZGVyIGJ5IHBhc3NpbmcgYSByZXZlcnNlZCByYW5rIGNvbXBhcmlzb24gZnVuY3Rpb24uXG4gKlxuICogQHBhcmFtIHtJdGVyYWJsZTxQYXNzYWJsZT59IHBhc3NhYmxlc1xuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gY29tcGFyZVxuICogQHJldHVybnMge1Bhc3NhYmxlW119XG4gKi9cbmNvbnN0ICAgICAgICBzb3J0QnlSYW5rPShwYXNzYWJsZXMsY29tcGFyZSk9PntcbmlmKEFycmF5LmlzQXJyYXkocGFzc2FibGVzKSl7XG5oYXJkZW4ocGFzc2FibGVzKTtcbi8qIENhbGxpbmcgaXNSYW5rU29ydGVkIGdpdmVzIGl0IGEgY2hhbmNlIHRvIGdldCBtZW1vaXplZCBmb3IqL1xuLyogdGhpcyBgY29tcGFyZWAgZnVuY3Rpb24gZXZlbiBpZiBpdCB3YXMgYWxyZWFkeSBtZW1vaXplZCBmb3IgYSBkaWZmZXJlbnQqL1xuLyogYGNvbXBhcmVgIGZ1bmN0aW9uLiovXG5pZihpc1JhbmtTb3J0ZWQocGFzc2FibGVzLGNvbXBhcmUpKXtcbnJldHVybiBwYXNzYWJsZXM7XG4gfVxuIH1cbmNvbnN0IHVuc29ydGVkPVsuLi5wYXNzYWJsZXNdO1xudW5zb3J0ZWQuZm9yRWFjaChoYXJkZW4pO1xuY29uc3Qgc29ydGVkPWhhcmRlbih1bnNvcnRlZC5zb3J0KGNvbXBhcmUpKTtcbmNvbnN0IHN1Yk1lbW9PZlNvcnRlZD1tZW1vT2ZTb3J0ZWQuZ2V0KGNvbXBhcmUpO1xuYXNzZXJ0KHN1Yk1lbW9PZlNvcnRlZCE9PXVuZGVmaW5lZCk7XG5zdWJNZW1vT2ZTb3J0ZWQuYWRkKHNvcnRlZCk7XG5yZXR1cm4gc29ydGVkO1xuIH07JGjigI1fb25jZS5zb3J0QnlSYW5rKHNvcnRCeVJhbmspO1xuaGFyZGVuKHNvcnRCeVJhbmspO1xuXG4vKipcbiAqIFNlZVxuICogaHR0cHM6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvQmluYXJ5X3NlYXJjaF9hbGdvcml0aG0jUHJvY2VkdXJlX2Zvcl9maW5kaW5nX3RoZV9sZWZ0bW9zdF9lbGVtZW50XG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBzb3J0ZWRcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IGNvbXBhcmVcbiAqIEBwYXJhbSB7UGFzc2FibGV9IGtleVxuICogQHBhcmFtIHsoXCJsZWZ0TW9zdFwiIHwgXCJyaWdodE1vc3RcIik9fSBiaWFzXG4gKiBAcmV0dXJucyB7bnVtYmVyfVxuICovXG5jb25zdCByYW5rU2VhcmNoPShzb3J0ZWQsY29tcGFyZSxrZXksYmlhcz0nbGVmdE1vc3QnKT0+e1xuYXNzZXJ0UmFua1NvcnRlZChzb3J0ZWQsY29tcGFyZSk7XG5sZXQgbGVmdD0wO1xubGV0IHJpZ2h0PXNvcnRlZC5sZW5ndGg7XG53aGlsZShsZWZ0PHJpZ2h0KXtcbmNvbnN0IG09TWF0aC5mbG9vcigobGVmdCtyaWdodCkvMik7XG5jb25zdCBjb21wPWNvbXBhcmUoc29ydGVkW21dLGtleSk7XG5pZihjb21wPD0tMXx8Y29tcD09PTAmJmJpYXM9PT0ncmlnaHRNb3N0Jyl7XG5sZWZ0PW0rMTtcbiB9ZWxzZXtcbmFzc2VydChjb21wPj0xfHxjb21wPT09MCYmYmlhcz09PSdsZWZ0TW9zdCcpO1xucmlnaHQ9bTtcbiB9XG4gfVxucmV0dXJuIGJpYXM9PT0nbGVmdE1vc3QnP2xlZnQ6cmlnaHQtMTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gc29ydGVkXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1JhbmtDb3Zlcn0gcmFua0NvdmVyXG4gKiBAcmV0dXJucyB7SW5kZXhDb3Zlcn1cbiAqL1xuY29uc3QgICAgICAgIGdldEluZGV4Q292ZXI9KHNvcnRlZCxjb21wYXJlLFtsZWZ0S2V5LHJpZ2h0S2V5XSk9PntcbmFzc2VydFJhbmtTb3J0ZWQoc29ydGVkLGNvbXBhcmUpO1xuY29uc3QgbGVmdEluZGV4PXJhbmtTZWFyY2goc29ydGVkLGNvbXBhcmUsbGVmdEtleSwnbGVmdE1vc3QnKTtcbmNvbnN0IHJpZ2h0SW5kZXg9cmFua1NlYXJjaChzb3J0ZWQsY29tcGFyZSxyaWdodEtleSwncmlnaHRNb3N0Jyk7XG5yZXR1cm5bbGVmdEluZGV4LHJpZ2h0SW5kZXhdO1xuIH07JGjigI1fb25jZS5nZXRJbmRleENvdmVyKGdldEluZGV4Q292ZXIpO1xuaGFyZGVuKGdldEluZGV4Q292ZXIpO1xuXG4vKiogQHR5cGUge1JhbmtDb3Zlcn0gKi9cbmNvbnN0ICAgICAgICBGdWxsUmFua0NvdmVyPWhhcmRlbihbJycsJ3snXSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBzb3J0ZWRcbiAqIEBwYXJhbSB7SW5kZXhDb3Zlcn0gaW5kZXhDb3ZlclxuICogQHJldHVybnMge0l0ZXJhYmxlPFtudW1iZXIsIFBhc3NhYmxlXT59XG4gKi8kaOKAjV9vbmNlLkZ1bGxSYW5rQ292ZXIoRnVsbFJhbmtDb3Zlcik7XG5jb25zdCAgICAgICAgY292ZXJlZEVudHJpZXM9KHNvcnRlZCxbbGVmdEluZGV4LHJpZ2h0SW5kZXhdKT0+e1xuLyoqIEB0eXBlIHtJdGVyYWJsZTxbbnVtYmVyLCBQYXNzYWJsZV0+fSAqL1xuY29uc3QgaXRlcmFibGU9aGFyZGVuKHtcbltTeW1ib2wuaXRlcmF0b3JdOigpPT57XG5sZXQgaT1sZWZ0SW5kZXg7XG5yZXR1cm4gaGFyZGVuKHtcbm5leHQ6KCk9PntcbmlmKGk8PXJpZ2h0SW5kZXgpe1xuY29uc3QgZWxlbWVudD1zb3J0ZWRbaV07XG5pKz0xO1xucmV0dXJuIGhhcmRlbih7dmFsdWU6W2ksZWxlbWVudF0sZG9uZTpmYWxzZX0pO1xuIH1lbHNle1xucmV0dXJuIGhhcmRlbih7dmFsdWU6dW5kZWZpbmVkLGRvbmU6dHJ1ZX0pO1xuIH1cbiB9fSk7XG5cbiB9fSk7XG5cbnJldHVybiBpdGVyYWJsZTtcbiB9OyRo4oCNX29uY2UuY292ZXJlZEVudHJpZXMoY292ZXJlZEVudHJpZXMpO1xuaGFyZGVuKGNvdmVyZWRFbnRyaWVzKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBhXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBiXG4gKiBAcmV0dXJucyB7UGFzc2FibGV9XG4gKi9cbmNvbnN0IG1heFJhbms9KGNvbXBhcmUsYSxiKT0+Y29tcGFyZShhLGIpPj0wP2E6YjtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBhXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBiXG4gKiBAcmV0dXJucyB7UGFzc2FibGV9XG4gKi9cbmNvbnN0IG1pblJhbms9KGNvbXBhcmUsYSxiKT0+Y29tcGFyZShhLGIpPD0wP2E6YjtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1JhbmtDb3ZlcltdfSBjb3ZlcnNcbiAqIEByZXR1cm5zIHtSYW5rQ292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICB1bmlvblJhbmtDb3ZlcnM9KGNvbXBhcmUsY292ZXJzKT0+e1xuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb3Zlcn0gYVxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGJcbiAqIEByZXR1cm5zIHtSYW5rQ292ZXJ9XG4gKi9cbmNvbnN0IHVuaW9uUmFua0NvdmVyUGFpcj0oW2xlZnRBLHJpZ2h0QV0sW2xlZnRCLHJpZ2h0Ql0pPT5bXG5taW5SYW5rKGNvbXBhcmUsbGVmdEEsbGVmdEIpLFxubWF4UmFuayhjb21wYXJlLHJpZ2h0QSxyaWdodEIpXTtcblxucmV0dXJuIGNvdmVycy5yZWR1Y2UodW5pb25SYW5rQ292ZXJQYWlyLFsneycsJyddKTtcbiB9OyRo4oCNX29uY2UudW5pb25SYW5rQ292ZXJzKHVuaW9uUmFua0NvdmVycyk7XG5oYXJkZW4odW5pb25SYW5rQ292ZXJzKTtcblxuLyoqXG4gKiBAcGFyYW0ge1JhbmtDb21wYXJlfSBjb21wYXJlXG4gKiBAcGFyYW0ge1JhbmtDb3ZlcltdfSBjb3ZlcnNcbiAqIEByZXR1cm5zIHtSYW5rQ292ZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpbnRlcnNlY3RSYW5rQ292ZXJzPShjb21wYXJlLGNvdmVycyk9Pntcbi8qKlxuICogQHBhcmFtIHtSYW5rQ292ZXJ9IGFcbiAqIEBwYXJhbSB7UmFua0NvdmVyfSBiXG4gKiBAcmV0dXJucyB7UmFua0NvdmVyfVxuICovXG5jb25zdCBpbnRlcnNlY3RSYW5rQ292ZXJQYWlyPShbbGVmdEEscmlnaHRBXSxbbGVmdEIscmlnaHRCXSk9Pltcbm1heFJhbmsoY29tcGFyZSxsZWZ0QSxsZWZ0QiksXG5taW5SYW5rKGNvbXBhcmUscmlnaHRBLHJpZ2h0QildO1xuXG5yZXR1cm4gY292ZXJzLnJlZHVjZShpbnRlcnNlY3RSYW5rQ292ZXJQYWlyLFsnJywneyddKTtcbiB9OyRo4oCNX29uY2UuaW50ZXJzZWN0UmFua0NvdmVycyhpbnRlcnNlY3RSYW5rQ292ZXJzKTtcblxuY29uc3QgICAgICAge2NvbXBhcmF0b3I6Y29tcGFyZVJhbmssYW50aUNvbXBhcmF0b3I6Y29tcGFyZUFudGlSYW5rfT1cbm1ha2VDb21wYXJhdG9yS2l0KCk7XG5cbi8qKlxuICogQ3JlYXRlIGEgY29tcGFyYXRvciBraXQgaW4gd2hpY2ggcmVtb3RhYmxlcyBhcmUgZnVsbHkgb3JkZXJlZFxuICogYnkgdGhlIG9yZGVyIGluIHdoaWNoIHRoZXkgYXJlIGZpcnN0IHNlZW4gYnkgKnRoaXMqIGNvbXBhcmF0b3Iga2l0LlxuICogQkVXQVJFOiBUaGlzIGlzIG9ic2VydmFibGUgbXV0YWJsZSBzdGF0ZSwgc28gc3VjaCBhIGNvbXBhcmF0b3Iga2l0XG4gKiBzaG91bGQgbmV2ZXIgYmUgc2hhcmVkIGFtb25nIHN1YnN5c3RlbXMgdGhhdCBzaG91bGQgbm90IGJlIGFibGVcbiAqIHRvIGNvbW11bmljYXRlLlxuICpcbiAqIE5vdGUgdGhhdCB0aGlzIG9yZGVyIGRvZXMgbm90IG1lZXQgdGhlIHJlcXVpcmVtZW50cyBmb3Igc3RvcmVcbiAqIG9yZGVyaW5nLCBzaW5jZSBpdCBoYXMgbm8gbWVtb3J5IG9mIGRlbGV0ZWQga2V5cy5cbiAqXG4gKiBUaGVzZSBmdWxsIG9yZGVyIGNvbXBhcmF0b3Iga2l0IGlzIHN0cmljdGx5IG1vcmUgcHJlY2lzZSB0aGF0IHRoZVxuICogcmFuayBvcmRlciBjb21wYXJhdG9yIGtpdHMgYWJvdmUuIEFzIGEgcmVzdWx0LCBhbnkgYXJyYXkgd2hpY2ggaXNcbiAqIHNvcnRlZCBieSBzdWNoIGEgZnVsbCBvcmRlciB3aWxsIHBhc3MgdGhlIGlzUmFua1NvcnRlZCB0ZXN0IHdpdGhcbiAqIGEgY29ycmVzcG9uZGluZyByYW5rIG9yZGVyLlxuICpcbiAqIEFuIGFycmF5IHdoaWNoIGlzIHNvcnRlZCBieSBhICpmcmVzaCogZnVsbCBvcmRlciBjb21wYXJhdG9yLCBpLmUuLFxuICogb25lIHRoYXQgaGFzIG5vdCB5ZXQgc2VlbiBhbnkgcmVtb3RhYmxlcywgd2lsbCBvZiBjb3Vyc2UgcmVtYWluXG4gKiBzb3J0ZWQgYnkgYWNjb3JkaW5nIHRvICp0aGF0KiBmdWxsIG9yZGVyIGNvbXBhcmF0b3IuIEFuIGFycmF5ICpvZlxuICogc2NhbGFycyogc29ydGVkIGJ5IGEgZnJlc2ggZnVsbCBvcmRlciB3aWxsIHJlbWFpbiBzb3J0ZWQgZXZlblxuICogYWNjb3JkaW5nIHRvIGEgbmV3IGZyZXNoIGZ1bGwgb3JkZXIgY29tcGFyYXRvciwgc2luY2UgaXQgd2lsbCBzZWVcbiAqIHRoZSByZW1vdGFibGVzIGluIHRoZSBzYW1lIG9yZGVyIGFnYWluLiBVbmZvcnR1bmF0ZWx5LCB0aGlzIGlzXG4gKiBub3QgdHJ1ZSBvZiBhcnJheXMgb2YgcGFzc2FibGVzIGluIGdlbmVyYWwuXG4gKlxuICogQHBhcmFtIHtib29sZWFuPX0gbG9uZ0xpdmVkXG4gKiBAcmV0dXJucyB7RnVsbENvbXBhcmF0b3JLaXR9XG4gKi8kaOKAjV9vbmNlLmNvbXBhcmVSYW5rKGNvbXBhcmVSYW5rKTskaOKAjV9vbmNlLmNvbXBhcmVBbnRpUmFuayhjb21wYXJlQW50aVJhbmspO1xuY29uc3QgICAgICAgIG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0PShsb25nTGl2ZWQ9ZmFsc2UpPT57XG5sZXQgbnVtU2Vlbj0wO1xuLyogV2hlbiBkeW5hbWljYWxseSBjcmVhdGVkIHdpdGggc2hvcnQgbGlmZXRpbWVzICh0aGUgZGVmYXVsdCkgYSBXZWFrTWFwKi9cbi8qIHdvdWxkIHBlcmZvcm0gcG9vcmx5LCBhbmQgdGhlIGxlYWsgY3JlYXRlZCBieSBhIE1hcCBvbmx5IGxhc3RzIGFzIGxvbmcqL1xuLyogYXMgdGhlIE1hcC4qL1xuY29uc3QgTWFwQ29uc3RydWN0b3I9bG9uZ0xpdmVkP1dlYWtNYXA6TWFwO1xuY29uc3Qgc2Vlbj1uZXcgTWFwQ29uc3RydWN0b3IoKTtcbmNvbnN0IHRhZz0ocik9PntcbmlmKHNlZW4uaGFzKHIpKXtcbnJldHVybiBzZWVuLmdldChyKTtcbiB9XG5udW1TZWVuKz0xO1xuc2Vlbi5zZXQocixudW1TZWVuKTtcbnJldHVybiBudW1TZWVuO1xuIH07XG5jb25zdCBjb21wYXJlUmVtb3RhYmxlcz0oeCx5KT0+Y29tcGFyZVJhbmsodGFnKHgpLHRhZyh5KSk7XG5yZXR1cm4gbWFrZUNvbXBhcmF0b3JLaXQoY29tcGFyZVJlbW90YWJsZXMpO1xuIH07JGjigI1fb25jZS5tYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdChtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCk7XG5oYXJkZW4obWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImdldFBhc3NTdHlsZUNvdmVyIjpbImdldFBhc3NTdHlsZUNvdmVyIl0sIm1ha2VDb21wYXJhdG9yS2l0IjpbIm1ha2VDb21wYXJhdG9yS2l0Il0sImNvbXBhcmF0b3JNaXJyb3JJbWFnZSI6WyJjb21wYXJhdG9yTWlycm9ySW1hZ2UiXSwiaXNSYW5rU29ydGVkIjpbImlzUmFua1NvcnRlZCJdLCJhc3NlcnRSYW5rU29ydGVkIjpbImFzc2VydFJhbmtTb3J0ZWQiXSwic29ydEJ5UmFuayI6WyJzb3J0QnlSYW5rIl0sImdldEluZGV4Q292ZXIiOlsiZ2V0SW5kZXhDb3ZlciJdLCJGdWxsUmFua0NvdmVyIjpbIkZ1bGxSYW5rQ292ZXIiXSwiY292ZXJlZEVudHJpZXMiOlsiY292ZXJlZEVudHJpZXMiXSwidW5pb25SYW5rQ292ZXJzIjpbInVuaW9uUmFua0NvdmVycyJdLCJpbnRlcnNlY3RSYW5rQ292ZXJzIjpbImludGVyc2VjdFJhbmtDb3ZlcnMiXSwiY29tcGFyZVJhbmsiOlsiY29tcGFyZVJhbmsiXSwiY29tcGFyZUFudGlSYW5rIjpbImNvbXBhcmVBbnRpUmFuayJdLCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCI6WyJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACYGTuzNAEAADQBAAAhAAAAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL3R5cGVzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAACUem73PCwAAzwsAAB4AAABAZW5kby9uYXQtdjQuMS4yNy9zcmMvaW5kZXguanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbIk5hdCIsImlzTmF0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7T2JqZWN0LmRlZmluZVByb3BlcnR5KGlzTmF0LCAnbmFtZScsIHt2YWx1ZTogXCJpc05hdFwifSk7JGjigI1fb25jZS5pc05hdChpc05hdCk7T2JqZWN0LmRlZmluZVByb3BlcnR5KE5hdCwgJ25hbWUnLCB7dmFsdWU6IFwiTmF0XCJ9KTskaOKAjV9vbmNlLk5hdChOYXQpOyAgIC8qIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiovXG4vKiBDb3B5cmlnaHQgKEMpIDIwMTggQWdvcmljKi9cbi8qKi9cbi8qIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7Ki9cbi8qIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS4qL1xuLyogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0Ki9cbi8qKi9cbi8qIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCovXG4vKiovXG4vKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlKi9cbi8qIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUywqL1xuLyogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuKi9cbi8qIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmQqL1xuLyogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuKi9cblxuLyogQHRzLWNoZWNrKi9cblxuLyoqXG4gKiBJcyBgYWxsZWdlZE51bWAgYSBudW1iZXIgaW4gdGhlIFtjb250aWd1b3VzIHJhbmdlIG9mIGV4YWN0bHkgYW5kXG4gKiB1bmFtYmlndW91c2x5XG4gKiByZXByZXNlbnRhYmxlXShodHRwczovL2VzZGlzY3Vzcy5vcmcvdG9waWMvbW9yZS1udW1lcmljLWNvbnN0YW50cy1wbGVhc2UtZXNwZWNpYWxseS1lcHNpbG9uI2NvbnRlbnQtMTQpXG4gKiAgbmF0dXJhbCBudW1iZXJzIChub24tbmVnYXRpdmUgaW50ZWdlcnMpP1xuICpcbiAqIFRvIHF1YWxpZnkgYGFsbGVnZWROdW1gIG11c3QgZWl0aGVyIGJlIGFcbiAqIG5vbi1uZWdhdGl2ZSBgYmlnaW50YCwgb3IgYSBub24tbmVnYXRpdmUgYG51bWJlcmAgcmVwcmVzZW50aW5nIGFuIGludGVnZXJcbiAqIHdpdGhpbiByYW5nZSBvZiBbaW50ZWdlcnMgc2FmZWx5IHJlcHJlc2VudGFibGUgaW5cbiAqIGZsb2F0aW5nIHBvaW50XShodHRwczovL3RjMzkuZXMvZWNtYTI2Mi8jc2VjLW51bWJlci5pc3NhZmVpbnRlZ2VyKS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IGFsbGVnZWROdW1cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5mdW5jdGlvbiBpc05hdChhbGxlZ2VkTnVtKXtcbmlmKHR5cGVvZiBhbGxlZ2VkTnVtPT09J2JpZ2ludCcpe1xucmV0dXJuIGFsbGVnZWROdW0+PTA7XG4gfVxuaWYodHlwZW9mIGFsbGVnZWROdW0hPT0nbnVtYmVyJyl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuXG5yZXR1cm4gTnVtYmVyLmlzU2FmZUludGVnZXIoYWxsZWdlZE51bSkmJmFsbGVnZWROdW0+PTA7XG4gfVxuXG4vKipcbiAqIElmIGBhbGxlZ2VkTnVtYmVyYCBwYXNzZXMgdGhlIGBpc05hdGAgdGVzdCwgdGhlbiByZXR1cm4gaXQgYXMgYSBiaWdpbnQuXG4gKiBPdGhlcndpc2UgdGhyb3cgYW4gYXBwcm9wcmlhdGUgZXJyb3IuXG4gKlxuICogSWYgYGFsbGVnZWROdW1gIGlzIG5laXRoZXIgYSBiaWdpbnQgbm9yIGEgbnVtYmVyLCBgTmF0YCB0aHJvd3MgYSBgVHlwZUVycm9yYC5cbiAqIE90aGVyd2lzZSwgaWYgaXQgaXMgbm90IGEgW3NhZmVseVxuICogcmVwcmVzZW50YWJsZV0oaHR0cHM6Ly9lc2Rpc2N1c3Mub3JnL3RvcGljL21vcmUtbnVtZXJpYy1jb25zdGFudHMtcGxlYXNlLWVzcGVjaWFsbHktZXBzaWxvbiNjb250ZW50LTE0KVxuICogbm9uLW5lZ2F0aXZlIGludGVnZXIsIGBOYXRgIHRocm93cyBhIGBSYW5nZUVycm9yYC5cbiAqIE90aGVyd2lzZSwgaXQgaXMgY29udmVydGVkIHRvIGEgYmlnaW50IGlmIG5lY2Vzc2FyeSBhbmQgcmV0dXJuZWQuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBhbGxlZ2VkTnVtXG4gKiBAcmV0dXJucyB7YmlnaW50fVxuICovXG5mdW5jdGlvbiBOYXQoYWxsZWdlZE51bSl7XG5pZih0eXBlb2YgYWxsZWdlZE51bT09PSdiaWdpbnQnKXtcbmlmKGFsbGVnZWROdW08MCl7XG50aHJvdyBuZXcgUmFuZ2VFcnJvciggYCR7YWxsZWdlZE51bX0gaXMgbmVnYXRpdmVgKTtcbiB9XG5yZXR1cm4gYWxsZWdlZE51bTtcbiB9XG5cbmlmKHR5cGVvZiBhbGxlZ2VkTnVtPT09J251bWJlcicpe1xuaWYoIU51bWJlci5pc1NhZmVJbnRlZ2VyKGFsbGVnZWROdW0pKXtcbnRocm93IG5ldyBSYW5nZUVycm9yKCBgJHthbGxlZ2VkTnVtfSBub3QgYSBzYWZlIGludGVnZXJgKTtcbiB9XG5pZihhbGxlZ2VkTnVtPDApe1xudGhyb3cgbmV3IFJhbmdlRXJyb3IoIGAke2FsbGVnZWROdW19IGlzIG5lZ2F0aXZlYCk7XG4gfVxucmV0dXJuIEJpZ0ludChhbGxlZ2VkTnVtKTtcbiB9XG5cbnRocm93IG5ldyBUeXBlRXJyb3IoXG4gYCR7YWxsZWdlZE51bX0gaXMgYSAke3R5cGVvZiBhbGxlZ2VkTnVtfSBidXQgbXVzdCBiZSBhIGJpZ2ludCBvciBhIG51bWJlcmApO1xuXG4gfVxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzTmF0IjpbImlzTmF0Il0sIk5hdCI6WyJOYXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAZfKMGnwIAAB8CAAAIAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2Vycm9yLmpzIiwiLi9zcmMvaXRlci1oZWxwZXJzLmpzIiwiLi9zcmMvbWFrZS1mYXIuanMiLCIuL3NyYy9tYWtlVGFnZ2VkLmpzIiwiLi9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3NyYy9wYXNzU3R5bGVPZi5qcyIsIi4vc3JjL3JlbW90YWJsZS5qcyIsIi4vc3JjL3N5bWJvbC5qcyIsIi4vc3JjL3R5cGVHdWFyZHMuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIkZhciIsIkZhciIsImFzc2VydENvcHlBcnJheSIsImFzc2VydENvcHlBcnJheSIsImFzc2VydFBhc3NhYmxlIiwiYXNzZXJ0UGFzc2FibGUiLCJmaWx0ZXJJdGVyYWJsZSIsImZpbHRlckl0ZXJhYmxlIiwiaXNPYmplY3QiLCJpc09iamVjdCIsImlzUGFzc2FibGVTeW1ib2wiLCJpc1Bhc3NhYmxlU3ltYm9sIiwidG9QYXNzYWJsZUVycm9yIiwidG9QYXNzYWJsZUVycm9yIixudWxsLG51bGxdLCJyZWV4cG9ydHMiOlsiLi9zcmMvdHlwZXMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy9pdGVyLWhlbHBlcnMuanNcIiwgW11dLFtcIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3NyYy9lcnJvci5qc1wiLCBbXV0sW1wiLi9zcmMvcmVtb3RhYmxlLmpzXCIsIFtdXSxbXCIuL3NyYy9zeW1ib2wuanNcIiwgW11dLFtcIi4vc3JjL3Bhc3NTdHlsZU9mLmpzXCIsIFtdXSxbXCIuL3NyYy9tYWtlVGFnZ2VkLmpzXCIsIFtdXSxbXCIuL3NyYy9tYWtlLWZhci5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZUd1YXJkcy5qc1wiLCBbXV0sW1wiLi9zcmMvdHlwZXMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnsiLi9zcmMvaXRlci1oZWxwZXJzLmpzIjpbWyJtYXBJdGVyYWJsZSIsIm1hcEl0ZXJhYmxlIl0sWyJmaWx0ZXJJdGVyYWJsZSIsImZpbHRlckl0ZXJhYmxlIl1dLCIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qcyI6W1siUEFTU19TVFlMRSIsIlBBU1NfU1RZTEUiXSxbImlzT2JqZWN0IiwiaXNPYmplY3QiXSxbImFzc2VydENoZWNrZXIiLCJhc3NlcnRDaGVja2VyIl0sWyJnZXRUYWciLCJnZXRUYWciXSxbImhhc093blByb3BlcnR5T2YiLCJoYXNPd25Qcm9wZXJ0eU9mIl1dLCIuL3NyYy9lcnJvci5qcyI6W1siZ2V0RXJyb3JDb25zdHJ1Y3RvciIsImdldEVycm9yQ29uc3RydWN0b3IiXSxbInRvUGFzc2FibGVFcnJvciIsInRvUGFzc2FibGVFcnJvciJdLFsiaXNFcnJvckxpa2UiLCJpc0Vycm9yTGlrZSJdXSwiLi9zcmMvcmVtb3RhYmxlLmpzIjpbWyJnZXRJbnRlcmZhY2VPZiIsImdldEludGVyZmFjZU9mIl1dLCIuL3NyYy9zeW1ib2wuanMiOltbImFzc2VydFBhc3NhYmxlU3ltYm9sIiwiYXNzZXJ0UGFzc2FibGVTeW1ib2wiXSxbImlzUGFzc2FibGVTeW1ib2wiLCJpc1Bhc3NhYmxlU3ltYm9sIl0sWyJuYW1lRm9yUGFzc2FibGVTeW1ib2wiLCJuYW1lRm9yUGFzc2FibGVTeW1ib2wiXSxbInBhc3NhYmxlU3ltYm9sRm9yTmFtZSIsInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdXSwiLi9zcmMvcGFzc1N0eWxlT2YuanMiOltbInBhc3NTdHlsZU9mIiwicGFzc1N0eWxlT2YiXSxbImFzc2VydFBhc3NhYmxlIiwiYXNzZXJ0UGFzc2FibGUiXV0sIi4vc3JjL21ha2VUYWdnZWQuanMiOltbIm1ha2VUYWdnZWQiLCJtYWtlVGFnZ2VkIl1dLCIuL3NyYy9tYWtlLWZhci5qcyI6W1siUmVtb3RhYmxlIiwiUmVtb3RhYmxlIl0sWyJGYXIiLCJGYXIiXSxbIlRvRmFyRnVuY3Rpb24iLCJUb0ZhckZ1bmN0aW9uIl1dLCIuL3NyYy90eXBlR3VhcmRzLmpzIjpbWyJhc3NlcnRSZWNvcmQiLCJhc3NlcnRSZWNvcmQiXSxbImFzc2VydENvcHlBcnJheSIsImFzc2VydENvcHlBcnJheSJdLFsiYXNzZXJ0UmVtb3RhYmxlIiwiYXNzZXJ0UmVtb3RhYmxlIl0sWyJpc1JlbW90YWJsZSIsImlzUmVtb3RhYmxlIl0sWyJpc1JlY29yZCIsImlzUmVjb3JkIl0sWyJpc0NvcHlBcnJheSIsImlzQ29weUFycmF5Il1dfSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADeRraqkwcAAJMHAAAoAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2NvcHlBcnJheS5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiQ29weUFycmF5SGVscGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydENoZWNrZXIsY2hlY2tOb3JtYWxQcm9wZXJ0eTskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJjaGVja05vcm1hbFByb3BlcnR5XCIsIFskaOKAjV9hID0+IChjaGVja05vcm1hbFByb3BlcnR5ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5jb25zdHtkZXRhaWxzOlh9PWFzc2VydDtcbmNvbnN0e2dldFByb3RvdHlwZU9mfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheSxwcm90b3R5cGU6YXJyYXlQcm90b3R5cGV9PUFycmF5O1xuXG4vKipcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5DaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2FuQmVWYWxpZD0oY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9PlxuaXNBcnJheShjYW5kaWRhdGUpfHxcbiEhY2hlY2smJmNoZWNrKGZhbHNlLFggYEFycmF5IGV4cGVjdGVkOiAke2NhbmRpZGF0ZX1gKTtcblxuLyoqXG4gKlxuICogQHR5cGUge1hpbXBvcnQoJy4vaW50ZXJuYWwtdHlwZXMuanMnKS5QYXNzU3R5bGVIZWxwZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBDb3B5QXJyYXlIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonY29weUFycmF5JyxcblxuY2FuQmVWYWxpZCxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+e1xuY2FuQmVWYWxpZChjYW5kaWRhdGUsYXNzZXJ0Q2hlY2tlcik7XG5nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpPT09YXJyYXlQcm90b3R5cGV8fFxuYXNzZXJ0LmZhaWwoWCBgTWFsZm9ybWVkIGFycmF5OiAke2NhbmRpZGF0ZX1gLFR5cGVFcnJvcik7XG4vKiBTaW5jZSB3ZSdyZSBhbHJlYWR5IGVuc3VyZWQgY2FuZGlkYXRlIGlzIGFuIGFycmF5LCBpdCBzaG91bGQgbm90IGJlKi9cbi8qIHBvc3NpYmxlIGZvciB0aGUgZm9sbG93aW5nIHRlc3QgdG8gZmFpbCovXG5jaGVja05vcm1hbFByb3BlcnR5KGNhbmRpZGF0ZSwnbGVuZ3RoJyxmYWxzZSxhc3NlcnRDaGVja2VyKTtcbmNvbnN0IGxlbj0vKiogQHR5cGUge3Vua25vd25bXX0gKi9jYW5kaWRhdGUubGVuZ3RoO1xuZm9yKGxldCBpPTA7aTxsZW47aSs9MSl7XG5jaGVja05vcm1hbFByb3BlcnR5KGNhbmRpZGF0ZSxpLHRydWUsYXNzZXJ0Q2hlY2tlcik7XG4gfVxuLyogKzEgZm9yIHRoZSAnbGVuZ3RoJyBwcm9wZXJ0eSBpdHNlbGYuKi9cbm93bktleXMoY2FuZGlkYXRlKS5sZW5ndGg9PT1sZW4rMXx8XG5hc3NlcnQuZmFpbChYIGBBcnJheXMgbXVzdCBub3QgaGF2ZSBub24taW5kZXhlczogJHtjYW5kaWRhdGV9YCxUeXBlRXJyb3IpO1xuLyogUmVjdXJzaXZlbHkgdmFsaWRhdGUgdGhhdCBlYWNoIG1lbWJlciBpcyBwYXNzYWJsZS4qL1xuY2FuZGlkYXRlLmV2ZXJ5KCh2KT0+ISFwYXNzU3R5bGVPZlJlY3VyKHYpKTtcbiB9fSk7JGjigI1fb25jZS5Db3B5QXJyYXlIZWxwZXIoQ29weUFycmF5SGVscGVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJDb3B5QXJyYXlIZWxwZXIiOlsiQ29weUFycmF5SGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAIP12yzPBwAAzwcAACkAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvY29weVJlY29yZC5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiQ29weVJlY29yZEhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLGNhbkJlTWV0aG9kLGNoZWNrTm9ybWFsUHJvcGVydHk7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiY2FuQmVNZXRob2RcIiwgWyRo4oCNX2EgPT4gKGNhbkJlTWV0aG9kID0gJGjigI1fYSldXSxbXCJjaGVja05vcm1hbFByb3BlcnR5XCIsIFskaOKAjV9hID0+IChjaGVja05vcm1hbFByb3BlcnR5ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cbmNvbnN0e2RldGFpbHM6WH09YXNzZXJ0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2dldFByb3RvdHlwZU9mLHZhbHVlcyxwcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1PYmplY3Q7XG5cbi8qKlxuICpcbiAqIEB0eXBlIHtYaW1wb3J0KCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgQ29weVJlY29yZEhlbHBlcj1oYXJkZW4oe1xuc3R5bGVOYW1lOidjb3B5UmVjb3JkJyxcblxuY2FuQmVWYWxpZDooY2FuZGlkYXRlLGNoZWNrPXVuZGVmaW5lZCk9PntcbmNvbnN0IHJlamVjdD0hIWNoZWNrJiYoKGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKSk7XG5pZihnZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpIT09b2JqZWN0UHJvdG90eXBlKXtcbnJldHVybihcbnJlamVjdCYmXG5yZWplY3QoWCBgUmVjb3JkcyBtdXN0IGluaGVyaXQgZnJvbSBPYmplY3QucHJvdG90eXBlOiAke2NhbmRpZGF0ZX1gKSk7XG5cbiB9XG5cbnJldHVybiBvd25LZXlzKGNhbmRpZGF0ZSkuZXZlcnkoKGtleSk9PntcbnJldHVybihcbih0eXBlb2Yga2V5PT09J3N0cmluZyd8fFxuISFyZWplY3QmJlxucmVqZWN0KFxuWCBgUmVjb3JkcyBjYW4gb25seSBoYXZlIHN0cmluZy1uYW1lZCBwcm9wZXJ0aWVzOiAke2NhbmRpZGF0ZX1gKSkmJihcblxuIWNhbkJlTWV0aG9kKGNhbmRpZGF0ZVtrZXldKXx8XG4hIXJlamVjdCYmXG5yZWplY3QoXG4vKiBUT0RPOiBVcGRhdGUgbWVzc2FnZSBub3cgdGhhdCB0aGVyZSBpcyBubyBzdWNoIHRoaW5nIGFzIFwiaW1wbGljaXQgUmVtb3RhYmxlXCIuKi9cblggYFJlY29yZHMgY2Fubm90IGNvbnRhaW4gbm9uLWZhciBmdW5jdGlvbnMgYmVjYXVzZSB0aGV5IG1heSBiZSBtZXRob2RzIG9mIGFuIGltcGxpY2l0IFJlbW90YWJsZTogJHtjYW5kaWRhdGV9YCkpKTtcblxuXG4gfSk7XG4gfSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSxwYXNzU3R5bGVPZlJlY3VyKT0+e1xuQ29weVJlY29yZEhlbHBlci5jYW5CZVZhbGlkKGNhbmRpZGF0ZSxhc3NlcnRDaGVja2VyKTtcbmZvcihjb25zdCBuYW1lIG9mIG93bktleXMoY2FuZGlkYXRlKSl7XG5jaGVja05vcm1hbFByb3BlcnR5KGNhbmRpZGF0ZSxuYW1lLHRydWUsYXNzZXJ0Q2hlY2tlcik7XG4gfVxuLyogUmVjdXJzaXZlbHkgdmFsaWRhdGUgdGhhdCBlYWNoIG1lbWJlciBpcyBwYXNzYWJsZS4qL1xuZm9yKGNvbnN0IHZhbCBvZiB2YWx1ZXMoY2FuZGlkYXRlKSl7XG5wYXNzU3R5bGVPZlJlY3VyKHZhbCk7XG4gfVxuIH19KTskaOKAjV9vbmNlLkNvcHlSZWNvcmRIZWxwZXIoQ29weVJlY29yZEhlbHBlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ29weVJlY29yZEhlbHBlciI6WyJDb3B5UmVjb3JkSGVscGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAANOgOHGdEQAAnREAACQAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvZXJyb3IuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkVycm9ySGVscGVyIiwiZ2V0RXJyb3JDb25zdHJ1Y3RvciIsImlzRXJyb3JMaWtlIiwidG9QYXNzYWJsZUVycm9yIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydENoZWNrZXI7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfSBQYXNzU3R5bGVIZWxwZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IENoZWNrZXIgKi9cblxuY29uc3R7ZGV0YWlsczpYLEZhaWx9PWFzc2VydDtcbmNvbnN0e2dldFByb3RvdHlwZU9mLGdldE93blByb3BlcnR5RGVzY3JpcHRvcnN9PU9iamVjdDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbi8qIFRPRE86IE1haW50ZW5hbmNlIGhhemFyZDogQ29vcmRpbmF0ZSB3aXRoIHRoZSBsaXN0IG9mIGVycm9ycyBpbiB0aGUgU0VTKi9cbi8qIHdoaWxlbGlzdC4gQ3VycmVudGx5LCBib3RoIG9taXQgQWdncmVnYXRlRXJyb3IsIHdoaWNoIGlzIG5vdyBzdGFuZGFyZC4gQm90aCovXG4vKiBtdXN0IGV2ZW50dWFsbHkgaW5jbHVkZSBpdC4qL1xuY29uc3QgZXJyb3JDb25zdHJ1Y3RvcnM9bmV3IE1hcChbXG5bJ0Vycm9yJyxFcnJvcl0sXG5bJ0V2YWxFcnJvcicsRXZhbEVycm9yXSxcblsnUmFuZ2VFcnJvcicsUmFuZ2VFcnJvcl0sXG5bJ1JlZmVyZW5jZUVycm9yJyxSZWZlcmVuY2VFcnJvcl0sXG5bJ1N5bnRheEVycm9yJyxTeW50YXhFcnJvcl0sXG5bJ1R5cGVFcnJvcicsVHlwZUVycm9yXSxcblsnVVJJRXJyb3InLFVSSUVycm9yXV0pO1xuXG5cbmNvbnN0ICAgICAgICBnZXRFcnJvckNvbnN0cnVjdG9yPShuYW1lKT0+ZXJyb3JDb25zdHJ1Y3RvcnMuZ2V0KG5hbWUpOyRo4oCNX29uY2UuZ2V0RXJyb3JDb25zdHJ1Y3RvcihnZXRFcnJvckNvbnN0cnVjdG9yKTtcbmhhcmRlbihnZXRFcnJvckNvbnN0cnVjdG9yKTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tFcnJvckxpa2U9KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuLyogVE9ETzogTmVlZCBhIGJldHRlciB0ZXN0IHRoYW4gaW5zdGFuY2VvZiovXG5yZXR1cm4oXG5jYW5kaWRhdGUgaW5zdGFuY2VvZiBFcnJvcnx8XG5yZWplY3QmJnJlamVjdChYIGBFcnJvciBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfTtcbmhhcmRlbihjaGVja0Vycm9yTGlrZSk7XG5cbi8qKlxuICogVmFsaWRhdGluZyBlcnJvciBvYmplY3RzIGFyZSBwYXNzYWJsZSByYWlzZXMgYSB0ZW5zaW9uIGJldHdlZW4gc2VjdXJpdHlcbiAqIHZzIHByZXNlcnZpbmcgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbi4gRm9yIGVycm9ycywgd2UgbmVlZCB0byByZW1lbWJlclxuICogdGhlIGVycm9yIGl0c2VsZiBleGlzdHMgdG8gaGVscCB1cyBkaWFnbm9zZSBhIGJ1ZyB0aGF0J3MgbGlrZWx5IG1vcmVcbiAqIHByZXNzaW5nIHRoYW4gYSB2YWxpZGl0eSBidWcgaW4gdGhlIGVycm9yIGl0c2VsZi4gVGh1cywgd2hlbmV2ZXIgaXQgaXMgc2FmZVxuICogdG8gZG8gc28sIHdlIHByZWZlciB0byBsZXQgdGhlIGVycm9yLWxpa2UgdGVzdCBzdWNjZWVkIGFuZCB0byBjb3VjaCB0aGVzZVxuICogY29tcGxhaW50cyBhcyBub3RlcyBvbiB0aGUgZXJyb3IuXG4gKlxuICogVG8gcmVzb2x2ZSB0aGlzLCBzdWNoIGEgbWFsZm9ybWVkIGVycm9yIG9iamVjdCB3aWxsIHN0aWxsIHBhc3NcbiAqIGBpc0Vycm9yTGlrZWAgc28gbWFyc2hhbCBjYW4gdXNlIHRoaXMgZm9yIHRvcCBsZXZlbCBlcnJvciB0byByZXBvcnQgZnJvbSxcbiAqIGV2ZW4gaWYgaXQgd291bGQgbm90IGFjdHVhbGx5IHZhbGlkYXRlLlxuICogSW5zdGVhZCwgdGhlIGRpYWdub3N0aWNzIHRoYXQgYGFzc2VydEVycm9yYCB3b3VsZCBoYXZlIHJlcG9ydGVkIGFyZVxuICogYXR0YWNoZWQgYXMgbm90ZXMgdG8gdGhlIG1hbGZvcm1lZCBlcnJvci4gVGh1cywgYSBtYWxmb3JtZWRcbiAqIGVycm9yIGlzIHBhc3NhYmxlIGJ5IGl0c2VsZiwgYnV0IG5vdCBhcyBwYXJ0IG9mIGEgcGFzc2FibGUgc3RydWN0dXJlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gY2FuZGlkYXRlXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGlzRXJyb3JMaWtlPShjYW5kaWRhdGUpPT5jaGVja0Vycm9yTGlrZShjYW5kaWRhdGUpOyRo4oCNX29uY2UuaXNFcnJvckxpa2UoaXNFcnJvckxpa2UpO1xuaGFyZGVuKGlzRXJyb3JMaWtlKTtcblxuLyoqXG4gKiBAdHlwZSB7UGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgRXJyb3JIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonZXJyb3InLFxuXG5jYW5CZVZhbGlkOmNoZWNrRXJyb3JMaWtlLFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlKT0+e1xuRXJyb3JIZWxwZXIuY2FuQmVWYWxpZChjYW5kaWRhdGUsYXNzZXJ0Q2hlY2tlcik7XG5jb25zdCBwcm90bz1nZXRQcm90b3R5cGVPZihjYW5kaWRhdGUpO1xuY29uc3R7bmFtZX09cHJvdG87XG5jb25zdCBFQz1nZXRFcnJvckNvbnN0cnVjdG9yKG5hbWUpO1xuRUMmJkVDLnByb3RvdHlwZT09PXByb3RvfHxcbkZhaWwgYEVycm9ycyBtdXN0IGluaGVyaXQgZnJvbSBhbiBlcnJvciBjbGFzcyAucHJvdG90eXBlICR7Y2FuZGlkYXRlfWA7XG5cbmNvbnN0e1xuLyogTXVzdCBhbGxvdyBgY2F1c2VgLCBgZXJyb3JzYCovXG5tZXNzYWdlOm1EZXNjLFxuLyogQWxsb3cgYnV0IGlnbm9yZSBvbmx5IGV4dHJhbmVvdXMgb3duIGBzdGFja2AgcHJvcGVydHkuKi9cbnN0YWNrOl9vcHRTdGFja0Rlc2MsXG4uLi5yZXN0RGVzY3N9PVxuZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyhjYW5kaWRhdGUpO1xub3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aDwxfHxcbkZhaWwgYFBhc3NlZCBFcnJvciBoYXMgZXh0cmEgdW5wYXNzZWQgcHJvcGVydGllcyAke3Jlc3REZXNjc31gO1xuaWYobURlc2Mpe1xudHlwZW9mIG1EZXNjLnZhbHVlPT09J3N0cmluZyd8fFxuRmFpbCBgUGFzc2VkIEVycm9yIFwibWVzc2FnZVwiICR7bURlc2N9IG11c3QgYmUgYSBzdHJpbmctdmFsdWVkIGRhdGEgcHJvcGVydHkuYDtcbiFtRGVzYy5lbnVtZXJhYmxlfHxcbkZhaWwgYFBhc3NlZCBFcnJvciBcIm1lc3NhZ2VcIiAke21EZXNjfSBtdXN0IG5vdCBiZSBlbnVtZXJhYmxlYDtcbiB9XG5yZXR1cm4gdHJ1ZTtcbiB9fSk7XG5cblxuLyoqXG4gKiBSZXR1cm4gYSBuZXcgcGFzc2FibGUgZXJyb3IgdGhhdCBwcm9wYWdhdGVzIHRoZSBkaWFnbm9zdGljIGluZm8gb2YgdGhlXG4gKiBvcmlnaW5hbCwgYW5kIGlzIGxpbmtlZCB0byB0aGUgb3JpZ2luYWwgYXMgYSBub3RlLlxuICpcbiAqIEBwYXJhbSB7RXJyb3J9IGVyclxuICogQHJldHVybnMge0Vycm9yfVxuICovJGjigI1fb25jZS5FcnJvckhlbHBlcihFcnJvckhlbHBlcik7XG5jb25zdCAgICAgICAgdG9QYXNzYWJsZUVycm9yPShlcnIpPT57XG5jb25zdHtuYW1lLG1lc3NhZ2V9PWVycjtcblxuY29uc3QgRUM9Z2V0RXJyb3JDb25zdHJ1Y3RvciggYCR7bmFtZX1gKXx8RXJyb3I7XG5jb25zdCBuZXdFcnJvcj1oYXJkZW4obmV3IEVDKCBgJHttZXNzYWdlfWApKTtcbi8qIEV2ZW4gdGhlIGNsZWFuZWQgdXAgZXJyb3IgY29weSwgaWYgc2VudCB0byB0aGUgY29uc29sZSwgc2hvdWxkKi9cbi8qIGNhdXNlIGhpZGRlbiBkaWFnbm9zdGljIGluZm9ybWF0aW9uIG9mIHRoZSBvcmlnaW5hbCBlcnJvciovXG4vKiB0byBiZSBsb2dnZWQuKi9cbmFzc2VydC5ub3RlKG5ld0Vycm9yLFggYGNvcGllZCBmcm9tIGVycm9yICR7ZXJyfWApO1xucmV0dXJuIG5ld0Vycm9yO1xuIH07JGjigI1fb25jZS50b1Bhc3NhYmxlRXJyb3IodG9QYXNzYWJsZUVycm9yKTtcbmhhcmRlbih0b1Bhc3NhYmxlRXJyb3IpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImdldEVycm9yQ29uc3RydWN0b3IiOlsiZ2V0RXJyb3JDb25zdHJ1Y3RvciJdLCJpc0Vycm9yTGlrZSI6WyJpc0Vycm9yTGlrZSJdLCJFcnJvckhlbHBlciI6WyJFcnJvckhlbHBlciJdLCJ0b1Bhc3NhYmxlRXJyb3IiOlsidG9QYXNzYWJsZUVycm9yIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAEo7ZoNVCAAAVQgAACsAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvaXRlci1oZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4vbWFrZS1mYXIuanMiXSwiZXhwb3J0cyI6WyJmaWx0ZXJJdGVyYWJsZSIsIm1hcEl0ZXJhYmxlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEZhcjskaOKAjV9pbXBvcnRzKFtbXCIuL21ha2UtZmFyLmpzXCIsIFtbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG4vKipcbiAqIFRoZSByZXN1bHQgaXRlcmF0b3IgaGFzIGFzIG1hbnkgZWxlbWVudHMgYXMgdGhlIGBiYXNlSXRlcmF0b3JgIGFuZFxuICogaGF2ZSB0aGUgc2FtZSB0ZXJtaW5hdGlvbiAtLSB0aGUgc2FtZSBjb21wbGV0aW9uIHZhbHVlIG9yIGZhaWx1cmVcbiAqIHJlYXNvbi4gQnV0IHRoZSBub24tZmluYWwgdmFsdWVzIGFyZSB0aGUgY29ycmVzcG9uZGluZyBub24tZmluYWxcbiAqIHZhbHVlcyBmcm9tIGBiYXNlSXRlcmF0b3JgIGFzIHRyYW5zZm9ybWVkIGJ5IGBmdW5jYC5cbiAqXG4gKiBAdGVtcGxhdGUgVCxVXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFQ+fSBiYXNlSXRlcmFibGVcbiAqIEBwYXJhbSB7KHZhbHVlOiBUKSA9PiBVfSBmdW5jXG4gKiBAcmV0dXJucyB7SXRlcmFibGU8VT59XG4gKi9cbmNvbnN0ICAgICAgICBtYXBJdGVyYWJsZT0oYmFzZUl0ZXJhYmxlLGZ1bmMpPT5cbi8qKiBAdHlwZSB7SXRlcmFibGU8VT59ICovXG5GYXIoJ21hcHBlZCBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGJhc2VJdGVyYXRvcj1iYXNlSXRlcmFibGVbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIEZhcignbWFwcGVkIGl0ZXJhdG9yJyx7XG5uZXh0OigpPT57XG5jb25zdHt2YWx1ZTpiYXNlVmFsdWUsZG9uZX09YmFzZUl0ZXJhdG9yLm5leHQoKTtcbmNvbnN0IHZhbHVlPWRvbmU/YmFzZVZhbHVlOmZ1bmMoYmFzZVZhbHVlKTtcbnJldHVybiBoYXJkZW4oe3ZhbHVlLGRvbmV9KTtcbiB9fSk7XG5cbiB9fSk7JGjigI1fb25jZS5tYXBJdGVyYWJsZShtYXBJdGVyYWJsZSk7XG5cbmhhcmRlbihtYXBJdGVyYWJsZSk7XG5cbi8qKlxuICogVGhlIHJlc3VsdCBpdGVyYXRvciBoYXMgYSBzdWJzZXQgb2YgdGhlIG5vbi1maW5hbCB2YWx1ZXMgZnJvbSB0aGVcbiAqIGBiYXNlSXRlcmF0b3JgIC0tLSB0aG9zZSBmb3Igd2hpY2ggYHByZWQodmFsdWUpYCB3YXMgdHJ1dGh5LiBUaGUgcmVzdWx0XG4gKiBoYXMgdGhlIHNhbWUgdGVybWluYXRpb24gYXMgdGhlIGBiYXNlSXRlcmF0b3JgIC0tIHRoZSBzYW1lIGNvbXBsZXRpb24gdmFsdWVcbiAqIG9yIGZhaWx1cmUgcmVhc29uLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFQ+fSBiYXNlSXRlcmFibGVcbiAqIEBwYXJhbSB7KHZhbHVlOiBUKSA9PiBib29sZWFufSBwcmVkXG4gKiBAcmV0dXJucyB7SXRlcmFibGU8VD59XG4gKi9cbmNvbnN0ICAgICAgICBmaWx0ZXJJdGVyYWJsZT0oYmFzZUl0ZXJhYmxlLHByZWQpPT5cbi8qKiBAdHlwZSB7SXRlcmFibGU8VT59ICovXG5GYXIoJ2ZpbHRlcmVkIGl0ZXJhYmxlJyx7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xuY29uc3QgYmFzZUl0ZXJhdG9yPWJhc2VJdGVyYWJsZVtTeW1ib2wuaXRlcmF0b3JdKCk7XG5yZXR1cm4gRmFyKCdmaWx0ZXJlZCBpdGVyYXRvcicse1xubmV4dDooKT0+e1xuZm9yKDs7KXtcbmNvbnN0IHJlc3VsdD1iYXNlSXRlcmF0b3IubmV4dCgpO1xuY29uc3R7dmFsdWUsZG9uZX09cmVzdWx0O1xuaWYoZG9uZXx8cHJlZCh2YWx1ZSkpe1xucmV0dXJuIHJlc3VsdDtcbiB9XG4gfVxuIH19KTtcblxuIH19KTskaOKAjV9vbmNlLmZpbHRlckl0ZXJhYmxlKGZpbHRlckl0ZXJhYmxlKTtcblxuaGFyZGVuKGZpbHRlckl0ZXJhYmxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYXBJdGVyYWJsZSI6WyJtYXBJdGVyYWJsZSJdLCJmaWx0ZXJJdGVyYWJsZSI6WyJmaWx0ZXJJdGVyYWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABiTWcDThoAAE4aAAAnAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL21ha2UtZmFyLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiLCIuL3JlbW90YWJsZS5qcyJdLCJleHBvcnRzIjpbIkZhciIsIlJlbW90YWJsZSIsIlRvRmFyRnVuY3Rpb24iXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixQQVNTX1NUWUxFLGFzc2VydElmYWNlLGdldEludGVyZmFjZU9mLFJlbW90YWJsZUhlbHBlcjskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJQQVNTX1NUWUxFXCIsIFskaOKAjV9hID0+IChQQVNTX1NUWUxFID0gJGjigI1fYSldXV1dLFtcIi4vcmVtb3RhYmxlLmpzXCIsIFtbXCJhc3NlcnRJZmFjZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0SWZhY2UgPSAkaOKAjV9hKV1dLFtcImdldEludGVyZmFjZU9mXCIsIFskaOKAjV9hID0+IChnZXRJbnRlcmZhY2VPZiA9ICRo4oCNX2EpXV0sW1wiUmVtb3RhYmxlSGVscGVyXCIsIFskaOKAjV9hID0+IChSZW1vdGFibGVIZWxwZXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuSW50ZXJmYWNlU3BlY30gSW50ZXJmYWNlU3BlYyAqL1xuLyoqIEB0ZW1wbGF0ZSBMLFIgQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL2V2ZW50dWFsLXNlbmQnKS5SZW1vdGFibGVCcmFuZDxMLCBSPn0gUmVtb3RhYmxlQnJhbmQgKi9cblxuY29uc3R7cXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5cbmNvbnN0e3Byb3RvdHlwZTpmdW5jdGlvblByb3RvdHlwZX09RnVuY3Rpb247XG5jb25zdHtcbmdldFByb3RvdHlwZU9mLFxuc2V0UHJvdG90eXBlT2YsXG5jcmVhdGUsXG5pc0Zyb3plbixcbnByb3RvdHlwZTpvYmplY3RQcm90b3R5cGV9PVxuT2JqZWN0O1xuXG4vKipcbiAqIE5vdyB0aGF0IHRoZSByZW1vdGFibGVQcm90byBkb2VzIG5vdCBwcm92aWRlIGl0cyBvd24gYHRvU3RyaW5nYCBtZXRob2QsXG4gKiBlbnN1cmUgaXQgYWx3YXlzIGluaGVyaXRzIGZyb20gc29tZXRoaW5nLiBUaGUgb3JpZ2luYWwgcHJvdG90eXBlIG9mXG4gKiBgcmVtb3RhYmxlYCBpZiB0aGVyZSB3YXMgb25lLCBvciBgT2JqZWN0LnByb3RvdHlwZWAgb3RoZXJ3aXNlLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSByZW1vdGFibGVcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gaWZhY2VcbiAqIEByZXR1cm5zIHtvYmplY3R9XG4gKi9cbmNvbnN0IG1ha2VSZW1vdGFibGVQcm90bz0ocmVtb3RhYmxlLGlmYWNlKT0+e1xubGV0IG9sZFByb3RvPWdldFByb3RvdHlwZU9mKHJlbW90YWJsZSk7XG5pZih0eXBlb2YgcmVtb3RhYmxlPT09J29iamVjdCcpe1xuaWYob2xkUHJvdG89PT1udWxsKXtcbm9sZFByb3RvPW9iamVjdFByb3RvdHlwZTtcbiB9XG5vbGRQcm90bz09PW9iamVjdFByb3RvdHlwZXx8XG5GYWlsIGBGb3Igbm93LCByZW1vdGFibGVzIGNhbm5vdCBpbmhlcml0IGZyb20gYW55dGhpbmcgdW51c3VhbCwgaW4gJHtyZW1vdGFibGV9YDtcbiB9ZWxzZSBpZih0eXBlb2YgcmVtb3RhYmxlPT09J2Z1bmN0aW9uJyl7XG5vbGRQcm90byE9PW51bGx8fFxuRmFpbCBgT3JpZ2luYWwgZnVuY3Rpb24gbXVzdCBub3QgaW5oZXJpdCBmcm9tIG51bGw6ICR7cmVtb3RhYmxlfWA7XG5vbGRQcm90bz09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbmdldFByb3RvdHlwZU9mKG9sZFByb3RvKT09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbkZhaWwgYEZhciBmdW5jdGlvbnMgbXVzdCBvcmlnaW5hbGx5IGluaGVyaXQgZnJvbSBGdW5jdGlvbi5wcm90b3R5cGUsIGluICR7cmVtb3RhYmxlfWA7XG4gfWVsc2V7XG5GYWlsIGB1bnJlY29nbml6ZWQgdHlwZW9mICR7cmVtb3RhYmxlfWA7XG4gfVxucmV0dXJuIGhhcmRlbihcbmNyZWF0ZShvbGRQcm90byx7XG5bUEFTU19TVFlMRV06e3ZhbHVlOidyZW1vdGFibGUnfSxcbltTeW1ib2wudG9TdHJpbmdUYWddOnt2YWx1ZTppZmFjZX19KSk7XG5cblxuIH07XG5cbmNvbnN0IGFzc2VydENhbkJlUmVtb3RhYmxlPShjYW5kaWRhdGUpPT5cblJlbW90YWJsZUhlbHBlci5jYW5CZVZhbGlkKGNhbmRpZGF0ZSxhc3NlcnRDaGVja2VyKTtcblxuLyoqXG4gKiBDcmVhdGUgYW5kIHJlZ2lzdGVyIGEgUmVtb3RhYmxlLiAgQWZ0ZXIgdGhpcywgZ2V0SW50ZXJmYWNlT2YocmVtb3RhYmxlKVxuICogcmV0dXJucyBpZmFjZS5cbiAqXG4gKiAvLyBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvaXNzdWVzLzgwNFxuICpcbiAqIEB0ZW1wbGF0ZSB7e319IFRcbiAqIEBwYXJhbSB7SW50ZXJmYWNlU3BlY30gW2lmYWNlPSdSZW1vdGFibGUnXSBUaGUgaW50ZXJmYWNlIHNwZWNpZmljYXRpb24gZm9yXG4gKiB0aGUgcmVtb3RhYmxlLiBGb3Igbm93LCBhIHN0cmluZyBpZmFjZSBtdXN0IGJlIFwiUmVtb3RhYmxlXCIgb3IgYmVnaW4gd2l0aFxuICogXCJBbGxlZ2VkOiBcIiBvciBcIkRlYnVnTmFtZTogXCIsIHRvIHNlcnZlIGFzIHRoZSBhbGxlZ2VkIG5hbWUuIE1vcmVcbiAqIGdlbmVyYWwgaWZhY2VzIGFyZSBub3QgeWV0IGltcGxlbWVudGVkLiBUaGlzIGlzIHRlbXBvcmFyeS4gV2UgaW5jbHVkZSB0aGVcbiAqIFwiQWxsZWdlZFwiIG9yIFwiRGVidWdOYW1lXCIgYXMgYSByZW1pbmRlciB0aGF0IHdlIGRvIG5vdCB5ZXQgaGF2ZSBTd2luZ1NldFxuICogb3IgQ29tbXMgVmF0XG4gKiBzdXBwb3J0IGZvciBlbnN1cmluZyB0aGlzIGlzIGFjY29yZGluZyB0byB0aGUgdmF0IGhvc3RpbmcgdGhlIG9iamVjdC5cbiAqIEN1cnJlbnRseSwgQWxpY2UgY2FuIHRlbGwgQm9iIGFib3V0IENhcm9sLCB3aGVyZSBWYXRBIChvbiBBbGljZSdzIGJlaGFsZilcbiAqIG1pc3JlcHJlc2VudHMgQ2Fyb2wncyBgaWZhY2VgLiBWYXRCIGFuZCB0aGVyZWZvcmUgQm9iIHdpbGwgdGhlbiBzZWVcbiAqIENhcm9sJ3MgYGlmYWNlYCBhcyBtaXNyZXByZXNlbnRlZCBieSBWYXRBLlxuICogQHBhcmFtIHt1bmRlZmluZWR9IFtwcm9wcz11bmRlZmluZWRdIEN1cnJlbnRseSBtYXkgb25seSBiZSB1bmRlZmluZWQuXG4gKiBUaGF0IHBsYW4gaXMgdGhhdCBvd24tcHJvcGVydGllcyBhcmUgY29waWVkIHRvIHRoZSByZW1vdGFibGVcbiAqIEBwYXJhbSB7VH0gW3JlbW90YWJsZT17fV0gVGhlIG9iamVjdCB1c2VkIGFzIHRoZSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtUICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fSByZW1vdGFibGUsIG1vZGlmaWVkIGZvciBkZWJ1Z2dhYmlsaXR5XG4gKi9cbmNvbnN0ICAgICAgICBSZW1vdGFibGU9KFxuaWZhY2U9J1JlbW90YWJsZScsXG5wcm9wcz11bmRlZmluZWQsXG5yZW1vdGFibGU9LyoqIEB0eXBlIHtUfSAqL3t9KT0+XG57XG5hc3NlcnRJZmFjZShpZmFjZSk7XG5hc3NlcnQoaWZhY2UpO1xuLyogVE9ETzogV2hlbiBpZmFjZSBpcyByaWNoZXIgdGhhbiBqdXN0IHN0cmluZywgd2UgbmVlZCB0byBnZXQgdGhlIGFsbGVnZWROYW1lKi9cbi8qIGluIGEgZGlmZmVyZW50IHdheS4qL1xucHJvcHM9PT11bmRlZmluZWR8fEZhaWwgYFJlbW90YWJsZSBwcm9wcyBub3QgeWV0IGltcGxlbWVudGVkICR7cHJvcHN9YDtcblxuLyogRmFpbCBmYXN0OiBjaGVjayB0aGF0IHRoZSB1bm1vZGlmaWVkIG9iamVjdCBpcyBhYmxlIHRvIGJlY29tZSBhIFJlbW90YWJsZS4qL1xuYXNzZXJ0Q2FuQmVSZW1vdGFibGUocmVtb3RhYmxlKTtcblxuLyogRW5zdXJlIHRoYXQgdGhlIHJlbW90YWJsZSBpc24ndCBhbHJlYWR5IG1hcmtlZC4qL1xuIShQQVNTX1NUWUxFIGluIHJlbW90YWJsZSl8fFxuRmFpbCBgUmVtb3RhYmxlICR7cmVtb3RhYmxlfSBpcyBhbHJlYWR5IG1hcmtlZCBhcyBhICR7cShcbnJlbW90YWJsZVtQQVNTX1NUWUxFXSlcbiB9YDtcbi8qIGBpc0Zyb3plbmAgYWx3YXlzIHJldHVybnMgdHJ1ZSB3aXRoIGEgZmFrZSBgaGFyZGVuYCwgYnV0IHdlIHdhbnQgdGhhdCBjYXNlKi9cbi8qIHRvIHN1Y2NlZWQgYW55d2F5LiBGYWtpbmcgYGhhcmRlbmAgaXMgb25seSBjb3JyZWN0bmVzcyBwcmVzZXJ2aW5nKi9cbi8qIGlmIHRoZSBjb2RlIGluIHF1ZXN0aW9uIGNvbnRhaW5zIG5vIGJ1Z3MgdGhhdCB0aGUgcmVhbCBgaGFyZGVuYCB3b3VsZCovXG4vKiBoYXZlIGNhdWdodC4qL1xuLyogQHRzLWlnbm9yZSBgaXNGYWtlYCBwdXJwb3NlbHkgbm90IGluIHRoZSB0eXBlKi9cbmhhcmRlbi5pc0Zha2V8fFxuLyogRW5zdXJlIHRoYXQgdGhlIHJlbW90YWJsZSBpc24ndCBhbHJlYWR5IGZyb3plbi4qL1xuIWlzRnJvemVuKHJlbW90YWJsZSl8fFxuRmFpbCBgUmVtb3RhYmxlICR7cmVtb3RhYmxlfSBpcyBhbHJlYWR5IGZyb3plbmA7XG5jb25zdCByZW1vdGFibGVQcm90bz1tYWtlUmVtb3RhYmxlUHJvdG8ocmVtb3RhYmxlLGlmYWNlKTtcblxuLyogVGFrZSBhIHN0YXRpYyBjb3B5IG9mIHRoZSBlbnVtZXJhYmxlIG93biBwcm9wZXJ0aWVzIGFzIGRhdGEgcHJvcGVydGllcy4qL1xuLyogY29uc3QgcHJvcERlc2NzID0gZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyh7IC4uLnByb3BzIH0pOyovXG5jb25zdCBtdXRhdGVIYXJkZW5BbmRDaGVjaz0odGFyZ2V0KT0+e1xuLyogZGVmaW5lUHJvcGVydGllcyh0YXJnZXQsIHByb3BEZXNjcyk7Ki9cbnNldFByb3RvdHlwZU9mKHRhcmdldCxyZW1vdGFibGVQcm90byk7XG5oYXJkZW4odGFyZ2V0KTtcbmFzc2VydENhbkJlUmVtb3RhYmxlKHRhcmdldCk7XG4gfTtcblxuLyogRmFpbCBmYXN0OiBjaGVjayBhIGZyZXNoIHJlbW90YWJsZSB0byBzZWUgaWYgb3VyIHJ1bGVzIGZpdC4qL1xubXV0YXRlSGFyZGVuQW5kQ2hlY2soe30pO1xuXG4vKiBBY3R1YWxseSBmaW5pc2ggdGhlIG5ldyByZW1vdGFibGUuKi9cbm11dGF0ZUhhcmRlbkFuZENoZWNrKHJlbW90YWJsZSk7XG5cbi8qIENPTU1JVFRFRCEqL1xuLyogV2UncmUgY29tbWl0dGVkLCBzbyBrZWVwIHRoZSBpbnRlcmZhY2UgZm9yIGZ1dHVyZSByZWZlcmVuY2UuKi9cbmFzc2VydChpZmFjZSE9PXVuZGVmaW5lZCk7LyogVG8gbWFrZSBUeXBlU2NyaXB0IGhhcHB5Ki9cbnJldHVybiAoLyoqIEB0eXBlIHtUICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fSAqL3JlbW90YWJsZSk7XG4gfTskaOKAjV9vbmNlLlJlbW90YWJsZShSZW1vdGFibGUpO1xuaGFyZGVuKFJlbW90YWJsZSk7XG5cbi8qKlxuICogQSBjb25jaXNlIGNvbnZlbmllbmNlIGZvciB0aGUgbW9zdCBjb21tb24gYFJlbW90YWJsZWAgdXNlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7e319IFRcbiAqIEBwYXJhbSB7c3RyaW5nfSBmYXJOYW1lIFRoaXMgbmFtZSB3aWxsIGJlIHByZXBlbmRlZCB3aXRoIGBBbGxlZ2VkOiBgXG4gKiBmb3Igbm93IHRvIGZvcm0gdGhlIGBSZW1vdGFibGVgIGBpZmFjZWAgYXJndW1lbnQuXG4gKiBAcGFyYW0ge1R9IFtyZW1vdGFibGU9e31dIFRoZSBvYmplY3QgdXNlZCBhcyB0aGUgcmVtb3RhYmxlXG4gKi9cbmNvbnN0ICAgICAgICBGYXI9KGZhck5hbWUscmVtb3RhYmxlPXVuZGVmaW5lZCk9PntcbmNvbnN0IHI9cmVtb3RhYmxlPT09dW5kZWZpbmVkPy8qKiBAdHlwZSB7VH0gKi97fTpyZW1vdGFibGU7XG5yZXR1cm4gUmVtb3RhYmxlKCBgQWxsZWdlZDogJHtmYXJOYW1lfWAsdW5kZWZpbmVkLHIpO1xuIH07JGjigI1fb25jZS5GYXIoRmFyKTtcbmhhcmRlbihGYXIpO1xuXG4vKipcbiAqIENvZXJjZSBgZnVuY2AgdG8gYSBmYXIgZnVuY3Rpb24gdGhhdCBwcmVzZXJ2ZXMgaXRzIGNhbGwgYmVoYXZpb3IuXG4gKiBJZiBpdCBpcyBhbHJlYWR5IGEgZmFyIGZ1bmN0aW9uLCByZXR1cm4gaXQuIE90aGVyd2lzZSBtYWtlIGFuZCByZXR1cm4gYVxuICogbmV3IGZhciBmdW5jdGlvbiB0aGF0IHdyYXBzIGBmdW5jYCBhbmQgZm9yd2FyZHMgY2FsbHMgdG8gaXQuIFRoaXNcbiAqIHdvcmtzIGV2ZW4gaWYgYGZ1bmNgIGlzIGFscmVhZHkgZnJvemVuLiBgVG9GYXJGdW5jdGlvbmAgaXMgdG8gYmUgdXNlZFxuICogd2hlbiB0aGUgZnVuY3Rpb24gY29tZXMgZnJvbSBlbHNld2hlcmUgdW5kZXIgbGVzcyBjb250cm9sLiBGb3IgZnVuY3Rpb25zXG4gKiB5b3UgYXV0aG9yIGluIHBsYWNlLCBiZXR0ZXIgdG8gdXNlIGBGYXJgIG9uIHRoZWlyIGZ1bmN0aW9uIGxpdGVyYWwgZGlyZWN0bHkuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IGZhck5hbWUgdG8gYmUgdXNlZCBvbmx5IGlmIGBmdW5jYCBpcyBub3QgYWxyZWFkeSBhXG4gKiBmYXIgZnVuY3Rpb24uXG4gKiBAcGFyYW0geyguLi5hcmdzOiBhbnlbXSkgPT4gYW55fSBmdW5jXG4gKi9cbmNvbnN0ICAgICAgICBUb0ZhckZ1bmN0aW9uPShmYXJOYW1lLGZ1bmMpPT57XG5pZihnZXRJbnRlcmZhY2VPZihmdW5jKSE9PXVuZGVmaW5lZCl7XG5yZXR1cm4gZnVuYztcbiB9XG5yZXR1cm4gRmFyKGZhck5hbWUsKC4uLmFyZ3MpPT5mdW5jKC4uLmFyZ3MpKTtcbiB9OyRo4oCNX29uY2UuVG9GYXJGdW5jdGlvbihUb0ZhckZ1bmN0aW9uKTtcbmhhcmRlbihUb0ZhckZ1bmN0aW9uKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJSZW1vdGFibGUiOlsiUmVtb3RhYmxlIl0sIkZhciI6WyJGYXIiXSwiVG9GYXJGdW5jdGlvbiI6WyJUb0ZhckZ1bmN0aW9uIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAAKRe+UdBAAAHQQAACkAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvbWFrZVRhZ2dlZC5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbIm1ha2VUYWdnZWQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgUEFTU19TVFlMRSxhc3NlcnRQYXNzYWJsZTskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJQQVNTX1NUWUxFXCIsIFskaOKAjV9hID0+IChQQVNTX1NUWUxFID0gJGjigI1fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcImFzc2VydFBhc3NhYmxlXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXNzYWJsZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5jb25zdHtjcmVhdGUscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG5jb25zdCAgICAgICAgbWFrZVRhZ2dlZD0odGFnLHBheWxvYWQpPT57XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVGhlIHRhZyBvZiBhIHRhZ2dlZCByZWNvcmQgbXVzdCBiZSBhIHN0cmluZzogJHt0YWd9YDtcbmFzc2VydFBhc3NhYmxlKGhhcmRlbihwYXlsb2FkKSk7XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9iamVjdFByb3RvdHlwZSx7XG5bUEFTU19TVFlMRV06e3ZhbHVlOid0YWdnZWQnfSxcbltTeW1ib2wudG9TdHJpbmdUYWddOnt2YWx1ZTp0YWd9LFxucGF5bG9hZDp7dmFsdWU6cGF5bG9hZCxlbnVtZXJhYmxlOnRydWV9fSkpO1xuXG5cbiB9OyRo4oCNX29uY2UubWFrZVRhZ2dlZChtYWtlVGFnZ2VkKTtcbmhhcmRlbihtYWtlVGFnZ2VkKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlVGFnZ2VkIjpbIm1ha2VUYWdnZWQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAGUAoxvUZAAD1GQAAMAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiUEFTU19TVFlMRSIsImFzc2VydENoZWNrZXIiLCJjYW5CZU1ldGhvZCIsImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiLCJjaGVja05vcm1hbFByb3BlcnR5IiwiY2hlY2tQYXNzU3R5bGUiLCJjaGVja1RhZ1JlY29yZCIsImdldFRhZyIsImhhc093blByb3BlcnR5T2YiLCJpc09iamVjdCIsImlzVHlwZWRBcnJheSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IENoZWNrZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e3Byb3RvdHlwZTpmdW5jdGlvblByb3RvdHlwZX09RnVuY3Rpb247XG5jb25zdHtcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcixcbmdldFByb3RvdHlwZU9mLFxuaGFzT3duUHJvcGVydHk6b2JqZWN0SGFzT3duUHJvcGVydHksXG5pc0Zyb3plbixcbnByb3RvdHlwZTpvYmplY3RQcm90b3R5cGV9PVxuT2JqZWN0O1xuY29uc3R7YXBwbHl9PVJlZmxlY3Q7XG5jb25zdHt0b1N0cmluZ1RhZzp0b1N0cmluZ1RhZ1N5bWJvbH09U3ltYm9sO1xuXG5jb25zdCB0eXBlZEFycmF5UHJvdG90eXBlPWdldFByb3RvdHlwZU9mKFVpbnQ4QXJyYXkucHJvdG90eXBlKTtcbmNvbnN0IHR5cGVkQXJyYXlUb1N0cmluZ1RhZ0Rlc2M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKFxudHlwZWRBcnJheVByb3RvdHlwZSxcbnRvU3RyaW5nVGFnU3ltYm9sKTtcblxuYXNzZXJ0KHR5cGVkQXJyYXlUb1N0cmluZ1RhZ0Rlc2MpO1xuY29uc3QgZ2V0VHlwZWRBcnJheVRvU3RyaW5nVGFnPXR5cGVkQXJyYXlUb1N0cmluZ1RhZ0Rlc2MuZ2V0O1xuYXNzZXJ0KHR5cGVvZiBnZXRUeXBlZEFycmF5VG9TdHJpbmdUYWc9PT0nZnVuY3Rpb24nKTtcblxuY29uc3QgICAgICAgIGhhc093blByb3BlcnR5T2Y9KG9iaixwcm9wKT0+XG5hcHBseShvYmplY3RIYXNPd25Qcm9wZXJ0eSxvYmosW3Byb3BdKTskaOKAjV9vbmNlLmhhc093blByb3BlcnR5T2YoaGFzT3duUHJvcGVydHlPZik7XG5oYXJkZW4oaGFzT3duUHJvcGVydHlPZik7XG5cbmNvbnN0ICAgICAgICBpc09iamVjdD0odmFsKT0+T2JqZWN0KHZhbCk9PT12YWw7JGjigI1fb25jZS5pc09iamVjdChpc09iamVjdCk7XG5oYXJkZW4oaXNPYmplY3QpO1xuXG4vKipcbiAqIER1cGxpY2F0ZXMgcGFja2FnZXMvc2VzL3NyYy9tYWtlLWhhcmRlbmVyLmpzIHRvIGF2b2lkIGEgZGVwZW5kZW5jeS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IG9iamVjdFxuICovXG5jb25zdCAgICAgICAgaXNUeXBlZEFycmF5PShvYmplY3QpPT57XG4vKiBUaGUgb2JqZWN0IG11c3QgcGFzcyBhIGJyYW5kIGNoZWNrIG9yIHRvU3RyaW5nVGFnIHdpbGwgcmV0dXJuIHVuZGVmaW5lZC4qL1xuY29uc3QgdGFnPWFwcGx5KGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZyxvYmplY3QsW10pO1xucmV0dXJuIHRhZyE9PXVuZGVmaW5lZDtcbiB9OyRo4oCNX29uY2UuaXNUeXBlZEFycmF5KGlzVHlwZWRBcnJheSk7XG5oYXJkZW4oaXNUeXBlZEFycmF5KTtcblxuY29uc3QgICAgICAgIFBBU1NfU1RZTEU9U3ltYm9sLmZvcigncGFzc1N0eWxlJyk7XG5cbi8qKlxuICogRm9yIGEgZnVuY3Rpb24gdG8gYmUgYSB2YWxpZCBtZXRob2QsIGl0IG11c3Qgbm90IGJlIHBhc3NhYmxlLlxuICogT3RoZXJ3aXNlLCB3ZSByaXNrIGNvbmZ1c2luZyBwYXNzLWJ5LWNvcHkgZGF0YSBjYXJyeWluZ1xuICogZmFyIGZ1bmN0aW9ucyB3aXRoIGF0dGVtcHRzIGF0IGZhciBvYmplY3RzIHdpdGggbWV0aG9kcy5cbiAqXG4gKiBUT0RPIEhBWkFSRCBCZWNhdXNlIHdlIGNoZWNrIHRoaXMgb24gdGhlIHdheSB0byBoYXJkZW5pbmcgYSByZW1vdGFibGUsXG4gKiB3ZSBjYW5ub3QgeWV0IGNoZWNrIHRoYXQgYGZ1bmNgIGlzIGhhcmRlbmVkLiBIb3dldmVyLCB3aXRob3V0XG4gKiBkb2luZyBzbywgaXQncyBpbmhlcml0YW5jZSBtaWdodCBjaGFuZ2UgYWZ0ZXIgdGhlIGBQQVNTX1NUWUxFYFxuICogY2hlY2sgYmVsb3cuXG4gKlxuICogQHBhcmFtIHthbnl9IGZ1bmNcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjigI1fb25jZS5QQVNTX1NUWUxFKFBBU1NfU1RZTEUpO1xuY29uc3QgICAgICAgIGNhbkJlTWV0aG9kPShmdW5jKT0+XG50eXBlb2YgZnVuYz09PSdmdW5jdGlvbicmJiEoUEFTU19TVFlMRSBpbiBmdW5jKTskaOKAjV9vbmNlLmNhbkJlTWV0aG9kKGNhbkJlTWV0aG9kKTtcbmhhcmRlbihjYW5CZU1ldGhvZCk7XG5cbi8qKlxuICogQmVsb3cgd2UgaGF2ZSBhIHNlcmllcyBvZiBwcmVkaWNhdGUgZnVuY3Rpb25zIGFuZCB0aGVpciAoY3VycmllZCkgYXNzZXJ0aW9uXG4gKiBmdW5jdGlvbnMuIFRoZSBzZW1hbnRpY3Mgb2YgdGhlIGFzc2VydGlvbiBmdW5jdGlvbiBpcyBqdXN0IHRvIGFzc2VydCB0aGF0XG4gKiB0aGUgY29ycmVzcG9uZGluZyBwcmVkaWNhdGUgZnVuY3Rpb24gd291bGQgaGF2ZSByZXR1cm5lZCB0cnVlLiBCdXQgaXRcbiAqIHJlcHJvZHVjZXMgdGhlIGludGVybmFsIHRlc3RzIHNvIGZhaWx1cmVzIGNhbiBnaXZlIGEgYmV0dGVyIGVycm9yIG1lc3NhZ2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDaGVja2VyPShjb25kLGRldGFpbHMpPT57XG5hc3NlcnQoY29uZCxkZXRhaWxzKTtcbnJldHVybiB0cnVlO1xuIH07JGjigI1fb25jZS5hc3NlcnRDaGVja2VyKGFzc2VydENoZWNrZXIpO1xuaGFyZGVuKGFzc2VydENoZWNrZXIpO1xuXG4vKipcbiAqIENoZWNrcyBmb3IgdGhlIHByZXNlbmNlIGFuZCBlbnVtZXJhYmlsaXR5IG9mIGFuIG93biBkYXRhIHByb3BlcnR5LlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcnxzeW1ib2x9IHByb3BlcnR5TmFtZVxuICogQHBhcmFtIHtib29sZWFufSBzaG91bGRCZUVudW1lcmFibGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja05vcm1hbFByb3BlcnR5PShcbmNhbmRpZGF0ZSxcbnByb3BlcnR5TmFtZSxcbnNob3VsZEJlRW51bWVyYWJsZSxcbmNoZWNrKT0+XG57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuY29uc3QgZGVzYz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IoY2FuZGlkYXRlLHByb3BlcnR5TmFtZSk7XG5pZihkZXNjPT09dW5kZWZpbmVkKXtcbnJldHVybihcbnJlamVjdCYmcmVqZWN0KFggYCR7cShwcm9wZXJ0eU5hbWUpfSBwcm9wZXJ0eSBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfVxucmV0dXJuKFxuKGhhc093blByb3BlcnR5T2YoZGVzYywndmFsdWUnKXx8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgJHtxKHByb3BlcnR5TmFtZSl9IG11c3Qgbm90IGJlIGFuIGFjY2Vzc29yIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKSkmJihcblxuc2hvdWxkQmVFbnVtZXJhYmxlP1xuZGVzYy5lbnVtZXJhYmxlfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGAke3EocHJvcGVydHlOYW1lKX0gbXVzdCBiZSBhbiBlbnVtZXJhYmxlIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKTpcblxuIWRlc2MuZW51bWVyYWJsZXx8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgJHtxKFxucHJvcGVydHlOYW1lKVxuIH0gbXVzdCBub3QgYmUgYW4gZW51bWVyYWJsZSBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCkpKTtcblxuXG4gfTskaOKAjV9vbmNlLmNoZWNrTm9ybWFsUHJvcGVydHkoY2hlY2tOb3JtYWxQcm9wZXJ0eSk7XG5oYXJkZW4oY2hlY2tOb3JtYWxQcm9wZXJ0eSk7XG5cbmNvbnN0ICAgICAgICBnZXRUYWc9KHRhZ1JlY29yZCk9PnRhZ1JlY29yZFtTeW1ib2wudG9TdHJpbmdUYWddOyRo4oCNX29uY2UuZ2V0VGFnKGdldFRhZyk7XG5oYXJkZW4oZ2V0VGFnKTtcblxuY29uc3QgICAgICAgIGNoZWNrUGFzc1N0eWxlPShvYmosZXhwZWN0ZWRQYXNzU3R5bGUsY2hlY2spPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuY29uc3QgYWN0dWFsPW9ialtQQVNTX1NUWUxFXTtcbnJldHVybihcbmFjdHVhbD09PWV4cGVjdGVkUGFzc1N0eWxlfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgRXhwZWN0ZWQgJHtxKGV4cGVjdGVkUGFzc1N0eWxlKX0sIG5vdCAke3EoYWN0dWFsKX06ICR7b2JqfWApKTtcblxuIH07JGjigI1fb25jZS5jaGVja1Bhc3NTdHlsZShjaGVja1Bhc3NTdHlsZSk7XG5oYXJkZW4oY2hlY2tQYXNzU3R5bGUpO1xuXG5jb25zdCBtYWtlQ2hlY2tUYWdSZWNvcmQ9KGNoZWNrUHJvdG8pPT57XG4vKipcbiAqIEBwYXJhbSB7eyBbUEFTU19TVFlMRV06IHN0cmluZyB9fSB0YWdSZWNvcmRcbiAqIEBwYXJhbSB7UGFzc1N0eWxlfSBwYXNzU3R5bGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrVGFnUmVjb3JkPSh0YWdSZWNvcmQscGFzc1N0eWxlLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbnJldHVybihcbihpc09iamVjdCh0YWdSZWNvcmQpfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgQSBub24tb2JqZWN0IGNhbm5vdCBiZSBhIHRhZ1JlY29yZDogJHt0YWdSZWNvcmR9YCkpJiYoXG5pc0Zyb3plbih0YWdSZWNvcmQpfHxcbnJlamVjdCYmcmVqZWN0KFggYEEgdGFnUmVjb3JkIG11c3QgYmUgZnJvemVuOiAke3RhZ1JlY29yZH1gKSkmJihcbiFpc0FycmF5KHRhZ1JlY29yZCl8fFxucmVqZWN0JiZyZWplY3QoWCBgQW4gYXJyYXkgY2Fubm90IGJlIGEgdGFnUmVjb3JkOiAke3RhZ1JlY29yZH1gKSkmJlxuY2hlY2tOb3JtYWxQcm9wZXJ0eSh0YWdSZWNvcmQsUEFTU19TVFlMRSxmYWxzZSxjaGVjaykmJlxuY2hlY2tQYXNzU3R5bGUodGFnUmVjb3JkLHBhc3NTdHlsZSxjaGVjaykmJlxuY2hlY2tOb3JtYWxQcm9wZXJ0eSh0YWdSZWNvcmQsU3ltYm9sLnRvU3RyaW5nVGFnLGZhbHNlLGNoZWNrKSYmKFxudHlwZW9mIGdldFRhZyh0YWdSZWNvcmQpPT09J3N0cmluZyd8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEEgW1N5bWJvbC50b1N0cmluZ1RhZ10tbmFtZWQgcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt0YWdSZWNvcmR9YCkpJiZcblxuY2hlY2tQcm90byh0YWdSZWNvcmQsZ2V0UHJvdG90eXBlT2YodGFnUmVjb3JkKSxjaGVjaykpO1xuXG4gfTtcbnJldHVybiBoYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuIH07XG5cbmNvbnN0ICAgICAgICBjaGVja1RhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PW9iamVjdFByb3RvdHlwZXx8XG4hIWNoZWNrJiZcbmNoZWNrKGZhbHNlLFggYEEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7dmFsfWApKTskaOKAjV9vbmNlLmNoZWNrVGFnUmVjb3JkKGNoZWNrVGFnUmVjb3JkKTtcblxuaGFyZGVuKGNoZWNrVGFnUmVjb3JkKTtcblxuY29uc3QgICAgICAgIGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQ9bWFrZUNoZWNrVGFnUmVjb3JkKFxuKHZhbCxwcm90byxjaGVjayk9PlxucHJvdG89PT1mdW5jdGlvblByb3RvdHlwZXx8XG5wcm90byE9PW51bGwmJmdldFByb3RvdHlwZU9mKHByb3RvKT09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbiEhY2hlY2smJlxuY2hlY2soXG5mYWxzZSxcblggYEZvciBmdW5jdGlvbnMsIGEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIEZ1bmN0aW9uLnByb3RvdHlwZTogJHt2YWx9YCkpOyRo4oCNX29uY2UuY2hlY2tGdW5jdGlvblRhZ1JlY29yZChjaGVja0Z1bmN0aW9uVGFnUmVjb3JkKTtcblxuXG5oYXJkZW4oY2hlY2tGdW5jdGlvblRhZ1JlY29yZCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaGFzT3duUHJvcGVydHlPZiI6WyJoYXNPd25Qcm9wZXJ0eU9mIl0sImlzT2JqZWN0IjpbImlzT2JqZWN0Il0sImlzVHlwZWRBcnJheSI6WyJpc1R5cGVkQXJyYXkiXSwiUEFTU19TVFlMRSI6WyJQQVNTX1NUWUxFIl0sImNhbkJlTWV0aG9kIjpbImNhbkJlTWV0aG9kIl0sImFzc2VydENoZWNrZXIiOlsiYXNzZXJ0Q2hlY2tlciJdLCJjaGVja05vcm1hbFByb3BlcnR5IjpbImNoZWNrTm9ybWFsUHJvcGVydHkiXSwiZ2V0VGFnIjpbImdldFRhZyJdLCJjaGVja1Bhc3NTdHlsZSI6WyJjaGVja1Bhc3NTdHlsZSJdLCJjaGVja1RhZ1JlY29yZCI6WyJjaGVja1RhZ1JlY29yZCJdLCJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkIjpbImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAALm6xDYMbAACDGwAAKgAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9wYXNzU3R5bGVPZi5qc3siaW1wb3J0cyI6WyIuL2NvcHlBcnJheS5qcyIsIi4vY29weVJlY29yZC5qcyIsIi4vZXJyb3IuanMiLCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9yZW1vdGFibGUuanMiLCIuL3NhZmUtcHJvbWlzZS5qcyIsIi4vc3ltYm9sLmpzIiwiLi90YWdnZWQuanMiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbImFzc2VydFBhc3NhYmxlIiwicGFzc1N0eWxlT2YiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgaXNQcm9taXNlLGlzT2JqZWN0LGlzVHlwZWRBcnJheSxQQVNTX1NUWUxFLENvcHlBcnJheUhlbHBlcixDb3B5UmVjb3JkSGVscGVyLFRhZ2dlZEhlbHBlcixFcnJvckhlbHBlcixSZW1vdGFibGVIZWxwZXIsYXNzZXJ0UGFzc2FibGVTeW1ib2wsYXNzZXJ0U2FmZVByb21pc2U7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wiaXNUeXBlZEFycmF5XCIsIFskaOKAjV9hID0+IChpc1R5cGVkQXJyYXkgPSAkaOKAjV9hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRo4oCNX2EgPT4gKFBBU1NfU1RZTEUgPSAkaOKAjV9hKV1dXV0sW1wiLi9jb3B5QXJyYXkuanNcIiwgW1tcIkNvcHlBcnJheUhlbHBlclwiLCBbJGjigI1fYSA9PiAoQ29weUFycmF5SGVscGVyID0gJGjigI1fYSldXV1dLFtcIi4vY29weVJlY29yZC5qc1wiLCBbW1wiQ29weVJlY29yZEhlbHBlclwiLCBbJGjigI1fYSA9PiAoQ29weVJlY29yZEhlbHBlciA9ICRo4oCNX2EpXV1dXSxbXCIuL3RhZ2dlZC5qc1wiLCBbW1wiVGFnZ2VkSGVscGVyXCIsIFskaOKAjV9hID0+IChUYWdnZWRIZWxwZXIgPSAkaOKAjV9hKV1dXV0sW1wiLi9lcnJvci5qc1wiLCBbW1wiRXJyb3JIZWxwZXJcIiwgWyRo4oCNX2EgPT4gKEVycm9ySGVscGVyID0gJGjigI1fYSldXV1dLFtcIi4vcmVtb3RhYmxlLmpzXCIsIFtbXCJSZW1vdGFibGVIZWxwZXJcIiwgWyRo4oCNX2EgPT4gKFJlbW90YWJsZUhlbHBlciA9ICRo4oCNX2EpXV1dXSxbXCIuL3N5bWJvbC5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTeW1ib2xcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFBhc3NhYmxlU3ltYm9sID0gJGjigI1fYSldXV1dLFtcIi4vc2FmZS1wcm9taXNlLmpzXCIsIFtbXCJhc3NlcnRTYWZlUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0U2FmZVByb21pc2UgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfSBQYXNzU3R5bGVIZWxwZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUGFzc1N0eWxlfSBQYXNzU3R5bGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlBhc3NTdHlsZU9mfSBQYXNzU3R5bGVPZiAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUHJpbWl0aXZlU3R5bGV9IFByaW1pdGl2ZVN0eWxlICovXG5cbi8qKiBAdHlwZWRlZiB7RXhjbHVkZTxQYXNzU3R5bGUsIFByaW1pdGl2ZVN0eWxlIHwgXCJwcm9taXNlXCI+fSBIZWxwZXJQYXNzU3R5bGUgKi9cblxuY29uc3R7ZGV0YWlsczpYLEZhaWwscXVvdGU6cX09YXNzZXJ0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzRnJvemVufT1PYmplY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVyc1xuICogQHJldHVybnMge1JlY29yZDxIZWxwZXJQYXNzU3R5bGUsIFBhc3NTdHlsZUhlbHBlcj4gfVxuICovXG5cbmNvbnN0IG1ha2VIZWxwZXJUYWJsZT0ocGFzc1N0eWxlSGVscGVycyk9Pntcbi8qKiBAdHlwZSB7UmVjb3JkPEhlbHBlclBhc3NTdHlsZSwgYW55PiAmIHtfX3Byb3RvX186IG51bGx9fSAqL1xuY29uc3QgSGVscGVyVGFibGU9e1xuX19wcm90b19fOm51bGwsXG5jb3B5QXJyYXk6dW5kZWZpbmVkLFxuY29weVJlY29yZDp1bmRlZmluZWQsXG50YWdnZWQ6dW5kZWZpbmVkLFxuZXJyb3I6dW5kZWZpbmVkLFxucmVtb3RhYmxlOnVuZGVmaW5lZH07XG5cbmZvcihjb25zdCBoZWxwZXIgb2YgcGFzc1N0eWxlSGVscGVycyl7XG5jb25zdHtzdHlsZU5hbWV9PWhlbHBlcjtcbnN0eWxlTmFtZSBpbiBIZWxwZXJUYWJsZXx8RmFpbCBgVW5yZWNvZ25pemVkIGhlbHBlcjogJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09PT11bmRlZmluZWR8fFxuRmFpbCBgY29uZmxpY3RpbmcgaGVscGVycyBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV09aGVscGVyO1xuIH1cbmZvcihjb25zdCBzdHlsZU5hbWUgb2Ygb3duS2V5cyhIZWxwZXJUYWJsZSkpe1xuSGVscGVyVGFibGVbc3R5bGVOYW1lXSE9PXVuZGVmaW5lZHx8XG5GYWlsIGBtaXNzaW5nIGhlbHBlciBmb3IgJHtxKHN0eWxlTmFtZSl9YDtcbiB9XG5cbnJldHVybiBoYXJkZW4oSGVscGVyVGFibGUpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzU3R5bGVIZWxwZXJbXX0gcGFzc1N0eWxlSGVscGVycyBUaGUgcGFzc1N0eWxlSGVscGVycyB0byByZWdpc3RlcixcbiAqIGluIHByaW9yaXR5IG9yZGVyLlxuICogTk9URSBUaGVzZSBtdXN0IGFsbCBiZSBcInRydXN0ZWRcIixcbiAqIGNvbXBsZXRlLCBhbmQgbm9uLWNvbGxpZGluZy4gYG1ha2VQYXNzU3R5bGVPZmAgbWF5ICphc3N1bWUqIHRoYXQgZWFjaCBoZWxwZXJcbiAqIGRvZXMgd2hhdCBpdCBpcyBzdXBwb3NlZCB0byBkby4gYG1ha2VQYXNzU3R5bGVPZmAgaXMgbm90IHRyeWluZyB0byBkZWZlbmRcbiAqIGl0c2VsZiBhZ2FpbnN0IG1hbGljaW91cyBoZWxwZXJzLCB0aG91Z2ggaXQgZG9lcyBkZWZlbmQgYWdhaW5zdCBzb21lXG4gKiBhY2NpZGVudHMuXG4gKiBAcmV0dXJucyB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IG1ha2VQYXNzU3R5bGVPZj0ocGFzc1N0eWxlSGVscGVycyk9PntcbmNvbnN0IEhlbHBlclRhYmxlPW1ha2VIZWxwZXJUYWJsZShwYXNzU3R5bGVIZWxwZXJzKTtcbmNvbnN0IHJlbW90YWJsZUhlbHBlcj1IZWxwZXJUYWJsZS5yZW1vdGFibGU7XG5cbi8qKlxuICogUHVyZWx5IGZvciBwZXJmb3JtYW5jZS4gSG93ZXZlciBpdCBpcyBtdXRhYmxlIHN0YXRpYyBzdGF0ZSwgYW5kXG4gKiBpdCBkb2VzIGhhdmUgc29tZSBvYnNlcnZhYmlsaXR5IG9uIHByb3hpZXMuIFRPRE8gbmVlZCB0byBhc3Nlc3NcbiAqIHdoZXRoZXIgdGhpcyBjcmVhdGVzIGEgc3RhdGljIGNvbW11bmljYXRpb25zIGNoYW5uZWwuXG4gKlxuICogcGFzc1N0eWxlT2YgZG9lcyBhIGZ1bGwgcmVjdXJzaXZlIHdhbGsgb2YgcGFzcy1ieS1jb3B5XG4gKiBzdHJ1Y3R1cmVzLCBpbiBvcmRlciB0byB2YWxpZGF0ZSB0aGF0IHRoZXkgYXJlIGFjeWNsaWMuIEluIGFkZGl0aW9uXG4gKiBpdCBpcyB1c2VkIGJ5IG90aGVyIGFsZ29yaXRobXMgdG8gcmVjdXJzaXZlbHkgd2FsayB0aGVzZSBwYXNzLWJ5LWNvcHlcbiAqIHN0cnVjdHVyZXMsIHNvIHdpdGhvdXQgdGhpcyBjYWNoZSwgdGhlc2UgYWxnb3JpdGhtcyBjb3VsZCBiZVxuICogTyhOKioyKSBvciB3b3JzZS5cbiAqXG4gKiBAdHlwZSB7V2Vha01hcDxQYXNzYWJsZSwgUGFzc1N0eWxlPn1cbiAqL1xuY29uc3QgcGFzc1N0eWxlTWVtbz1uZXcgV2Vha01hcCgpO1xuXG4vKipcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqL1xuY29uc3QgcGFzc1N0eWxlT2Y9KHBhc3NhYmxlKT0+e1xuLyogRXZlbiB3aGVuIGEgV2Vha1NldCBpcyBjb3JyZWN0LCB3aGVuIHRoZSBzZXQgaGFzIGEgc2hvcnRlciBsaWZldGltZSovXG4vKiB0aGFuIGl0cyBrZXlzLCB3ZSBwcmVmZXIgYSBTZXQgZHVlIHRvIGV4cGVjdGVkIGltcGxlbWVudGF0aW9uKi9cbi8qIHRyYWRlb2Zmcy4qL1xuY29uc3QgaW5Qcm9ncmVzcz1uZXcgU2V0KCk7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZU9mfVxuICovXG5jb25zdCBwYXNzU3R5bGVPZlJlY3VyPShpbm5lcik9PntcbmNvbnN0IGlubmVySXNPYmplY3Q9aXNPYmplY3QoaW5uZXIpO1xuaWYoaW5uZXJJc09iamVjdCl7XG5pZihwYXNzU3R5bGVNZW1vLmhhcyhpbm5lcikpe1xuLyogQHRzLWlnbm9yZSBUeXBlU2NyaXB0IGRvZXNuJ3Qga25vdyB0aGF0IGBnZXRgIGFmdGVyIGBoYXNgIGlzIHNhZmUqL1xucmV0dXJuIHBhc3NTdHlsZU1lbW8uZ2V0KGlubmVyKTtcbiB9XG4haW5Qcm9ncmVzcy5oYXMoaW5uZXIpfHxcbkZhaWwgYFBhc3MtYnktY29weSBkYXRhIGNhbm5vdCBiZSBjeWNsaWMgJHtpbm5lcn1gO1xuaW5Qcm9ncmVzcy5hZGQoaW5uZXIpO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2ZJbnRlcm5hbChpbm5lcik7XG5pZihpbm5lcklzT2JqZWN0KXtcbnBhc3NTdHlsZU1lbW8uc2V0KGlubmVyLHBhc3NTdHlsZSk7XG5pblByb2dyZXNzLmRlbGV0ZShpbm5lcik7XG4gfVxucmV0dXJuIHBhc3NTdHlsZTtcbiB9O1xuXG4vKipcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqL1xuY29uc3QgcGFzc1N0eWxlT2ZJbnRlcm5hbD0oaW5uZXIpPT57XG5jb25zdCB0eXBlc3RyPXR5cGVvZiBpbm5lcjtcbnN3aXRjaCh0eXBlc3RyKXtcbmNhc2UndW5kZWZpbmVkJzpcbmNhc2Unc3RyaW5nJzpcbmNhc2UnYm9vbGVhbic6XG5jYXNlJ251bWJlcic6XG5jYXNlJ2JpZ2ludCc6e1xucmV0dXJuIHR5cGVzdHI7XG4gfVxuY2FzZSdzeW1ib2wnOntcbmFzc2VydFBhc3NhYmxlU3ltYm9sKGlubmVyKTtcbnJldHVybidzeW1ib2wnO1xuIH1cbmNhc2Unb2JqZWN0Jzp7XG5pZihpbm5lcj09PW51bGwpe1xucmV0dXJuJ251bGwnO1xuIH1cbmlmKCFpc0Zyb3plbihpbm5lcikpe1xuYXNzZXJ0LmZhaWwoXG4vKiBUeXBlZEFycmF5cyBnZXQgc3BlY2lhbCB0cmVhdG1lbnQgaW4gaGFyZGVuKCkqL1xuLyogYW5kIGEgY29ycmVzcG9uZGluZyBzcGVjaWFsIGVycm9yIG1lc3NhZ2UgaGVyZS4qL1xuaXNUeXBlZEFycmF5KGlubmVyKT9cblggYENhbm5vdCBwYXNzIG11dGFibGUgdHlwZWQgYXJyYXlzIGxpa2UgJHtpbm5lcn0uYDpcblggYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgKTtcblxuIH1cbmlmKGlzUHJvbWlzZShpbm5lcikpe1xuYXNzZXJ0U2FmZVByb21pc2UoaW5uZXIpO1xucmV0dXJuJ3Byb21pc2UnO1xuIH1cbnR5cGVvZiBpbm5lci50aGVuIT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tcHJvbWlzZSB0aGVuYWJsZXNgO1xuY29uc3QgcGFzc1N0eWxlVGFnPWlubmVyW1BBU1NfU1RZTEVdO1xuaWYocGFzc1N0eWxlVGFnIT09dW5kZWZpbmVkKXtcbmFzc2VydC50eXBlb2YocGFzc1N0eWxlVGFnLCdzdHJpbmcnKTtcbmNvbnN0IGhlbHBlcj1IZWxwZXJUYWJsZVtwYXNzU3R5bGVUYWddO1xuaGVscGVyIT09dW5kZWZpbmVkfHxcbkZhaWwgYFVucmVjb2duaXplZCBQYXNzU3R5bGU6ICR7cShwYXNzU3R5bGVUYWcpfWA7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gKC8qKiBAdHlwZSB7UGFzc1N0eWxlfSAqL3Bhc3NTdHlsZVRhZyk7XG4gfVxuZm9yKGNvbnN0IGhlbHBlciBvZiBwYXNzU3R5bGVIZWxwZXJzKXtcbmlmKGhlbHBlci5jYW5CZVZhbGlkKGlubmVyKSl7XG5oZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4gaGVscGVyLnN0eWxlTmFtZTtcbiB9XG4gfVxucmVtb3RhYmxlSGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuJ3JlbW90YWJsZSc7XG4gfVxuY2FzZSdmdW5jdGlvbic6e1xuaXNGcm96ZW4oaW5uZXIpfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7aW5uZXJ9LiBVc2UgaGFyZGVuKClgO1xudHlwZW9mIGlubmVyLnRoZW4hPT0nZnVuY3Rpb24nfHxcbkZhaWwgYENhbm5vdCBwYXNzIG5vbi1wcm9taXNlIHRoZW5hYmxlc2A7XG5yZW1vdGFibGVIZWxwZXIuYXNzZXJ0VmFsaWQoaW5uZXIscGFzc1N0eWxlT2ZSZWN1cik7XG5yZXR1cm4ncmVtb3RhYmxlJztcbiB9XG5kZWZhdWx0OntcbmFzc2VydC5mYWlsKFggYFVucmVjb2duaXplZCB0eXBlb2YgJHtxKHR5cGVzdHIpfWAsVHlwZUVycm9yKTtcbiB9fVxuXG4gfTtcblxucmV0dXJuIHBhc3NTdHlsZU9mUmVjdXIocGFzc2FibGUpO1xuIH07XG5yZXR1cm4gaGFyZGVuKHBhc3NTdHlsZU9mKTtcbiB9O1xuXG5jb25zdCAgICAgICAgcGFzc1N0eWxlT2Y9bWFrZVBhc3NTdHlsZU9mKFtcbkNvcHlBcnJheUhlbHBlcixcbkNvcHlSZWNvcmRIZWxwZXIsXG5UYWdnZWRIZWxwZXIsXG5FcnJvckhlbHBlcixcblJlbW90YWJsZUhlbHBlcl0pOyRo4oCNX29uY2UucGFzc1N0eWxlT2YocGFzc1N0eWxlT2YpO1xuXG5cbmNvbnN0ICAgICAgICBhc3NlcnRQYXNzYWJsZT0odmFsKT0+e1xucGFzc1N0eWxlT2YodmFsKTsvKiB0aHJvd3MgaWYgdmFsIGlzIG5vdCBhIHBhc3NhYmxlKi9cbiB9OyRo4oCNX29uY2UuYXNzZXJ0UGFzc2FibGUoYXNzZXJ0UGFzc2FibGUpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJwYXNzU3R5bGVPZiI6WyJwYXNzU3R5bGVPZiJdLCJhc3NlcnRQYXNzYWJsZSI6WyJhc3NlcnRQYXNzYWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAUsaJ9wyEAAMMhAAAoAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3JlbW90YWJsZS5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiUmVtb3RhYmxlSGVscGVyIiwiYXNzZXJ0SWZhY2UiLCJnZXRJbnRlcmZhY2VPZiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLGNhbkJlTWV0aG9kLGhhc093blByb3BlcnR5T2YsUEFTU19TVFlMRSxjaGVja1RhZ1JlY29yZCxjaGVja0Z1bmN0aW9uVGFnUmVjb3JkLGlzT2JqZWN0LGdldFRhZzskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJjYW5CZU1ldGhvZFwiLCBbJGjigI1fYSA9PiAoY2FuQmVNZXRob2QgPSAkaOKAjV9hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRo4oCNX2EgPT4gKGhhc093blByb3BlcnR5T2YgPSAkaOKAjV9hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRo4oCNX2EgPT4gKFBBU1NfU1RZTEUgPSAkaOKAjV9hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaOKAjV9hID0+IChjaGVja1RhZ1JlY29yZCA9ICRo4oCNX2EpXV0sW1wiY2hlY2tGdW5jdGlvblRhZ1JlY29yZFwiLCBbJGjigI1fYSA9PiAoY2hlY2tGdW5jdGlvblRhZ1JlY29yZCA9ICRo4oCNX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRo4oCNX2EgPT4gKGlzT2JqZWN0ID0gJGjigI1fYSldXSxbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuSW50ZXJmYWNlU3BlY30gSW50ZXJmYWNlU3BlYyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuTWFyc2hhbEdldEludGVyZmFjZU9mfSBNYXJzaGFsR2V0SW50ZXJmYWNlT2YgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn0gUGFzc1N0eWxlSGVscGVyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVPYmplY3R9IFJlbW90YWJsZSAqL1xuXG5jb25zdHtkZXRhaWxzOlgsRmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtcbmdldFByb3RvdHlwZU9mLFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlLFxuZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yc309XG5PYmplY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKi9cbmNvbnN0IGNoZWNrSWZhY2U9KGlmYWNlLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbnJldHVybihcbi8qIFRPRE8gb3RoZXIgcG9zc2libGUgaWZhY2VzLCBvbmNlIHdlIGhhdmUgdGhpcmQgcGFydHkgdmVyYWNpdHkqL1xuKHR5cGVvZiBpZmFjZT09PSdzdHJpbmcnfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBGb3Igbm93LCBpbnRlcmZhY2UgJHtpZmFjZX0gbXVzdCBiZSBhIHN0cmluZzsgdW5pbXBsZW1lbnRlZGApKSYmKFxuXG5pZmFjZT09PSdSZW1vdGFibGUnfHxcbmlmYWNlLnN0YXJ0c1dpdGgoJ0FsbGVnZWQ6ICcpfHxcbmlmYWNlLnN0YXJ0c1dpdGgoJ0RlYnVnTmFtZTogJyl8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEZvciBub3csIGlmYWNlICR7cShcbmlmYWNlKVxuIH0gbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGggXCJBbGxlZ2VkOiBcIiBvciBcIkRlYnVnTmFtZTogXCI7IHVuaW1wbGVtZW50ZWRgKSkpO1xuXG5cbiB9O1xuXG4vKipcbiAqIEFuIGBpZmFjZWAgbXVzdCBiZSBwdXJlLiBSaWdodCBub3cgaXQgbXVzdCBiZSBhIHN0cmluZywgd2hpY2ggaXMgcHVyZS5cbiAqIExhdGVyIHdlIGV4cGVjdCB0byBpbmNsdWRlIHNvbWUgb3RoZXIgdmFsdWVzIHRoYXQgcXVhbGlmeSBhcyBgUHVyZURhdGFgLFxuICogd2hpY2ggaXMgYSBwYXNzLWJ5LWNvcHkgc3VwZXJzdHJ1Y3R1cmUgZW5kaW5nIG9ubHkgaW4gcHJpbWl0aXZlcyBvclxuICogZW1wdHkgcGFzcy1ieS1jb3B5IGNvbXBvc2l0ZXMuIE5vIHJlbW90YWJsZXMsIHByb21pc2VzLCBvciBlcnJvcnMuXG4gKiBXZSAqYXNzdW1lKiBmb3Igbm93IHRoYXQgdGhlIHBhc3MtYnktY29weSBzdXBlcnN0cnVjdHVyZSBjb250YWlucyBub1xuICogcHJveGllcy5cbiAqXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IGlmYWNlXG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRJZmFjZT0oaWZhY2UpPT5jaGVja0lmYWNlKGlmYWNlLGFzc2VydENoZWNrZXIpOyRo4oCNX29uY2UuYXNzZXJ0SWZhY2UoYXNzZXJ0SWZhY2UpO1xuaGFyZGVuKGFzc2VydElmYWNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdCB8IEZ1bmN0aW9ufSBvcmlnaW5hbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGVQcm90b09mPShvcmlnaW5hbCxjaGVjayk9PntcbmNvbnN0IHJlamVjdD0hIWNoZWNrJiYoKGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKSk7XG5pc09iamVjdChvcmlnaW5hbCl8fFxuRmFpbCBgUmVtb3RhYmxlcyBtdXN0IGJlIG9iamVjdHMgb3IgZnVuY3Rpb25zOiAke29yaWdpbmFsfWA7XG5cbi8qIEEgdmFsaWQgcmVtb3RhYmxlIG9iamVjdCBtdXN0IGluaGVyaXQgZnJvbSBhIFwidGFnIHJlY29yZFwiIC0tIGEqL1xuLyogcGxhaW4tb2JqZWN0IHByb3RvdHlwZSBjb25zaXN0aW5nIG9mIG9ubHkqL1xuLyogYSBgUEFTU19TVFlMRWAgcHJvcGVydHkgd2l0aCB2YWx1ZSBcInJlbW90YWJsZVwiIGFuZCBhIHN1aXRhYmxlIGBTeW1ib2wudG9TdHJpbmdUYWdgKi9cbi8qIHByb3BlcnR5LiBUaGUgcmVtb3RhYmxlIGNvdWxkIGluaGVyaXQgZGlyZWN0bHkgZnJvbSBzdWNoIGEgdGFnIHJlY29yZCwgb3IqL1xuLyogaXQgY291bGQgaW5oZXJpdCBmcm9tIGFub3RoZXIgdmFsaWQgcmVtb3RhYmxlLCB0aGF0IHRoZXJlZm9yZSBpdHNlbGYqL1xuLyogaW5oZXJpdHMgZGlyZWN0bHkgb3IgaW5kaXJlY3RseSBmcm9tIHN1Y2ggYSB0YWcgcmVjb3JkLiovXG4vKiovXG4vKiBUT0RPOiBJdCB3b3VsZCBiZSBuaWNlIHRvIHR5cGVkZWYgdGhpcyBzaGFwZSwgYnV0IHdlIGNhbid0IGRlY2xhcmUgYSB0eXBlKi9cbi8qIHdpdGggUEFTU19TVFlMRSBmcm9tIEpTRG9jLiovXG4vKiovXG4vKiBAdHlwZSB7eyBbUEFTU19TVFlMRV06IHN0cmluZywqL1xuLyogW1N5bWJvbC50b1N0cmluZ1RhZ106IHN0cmluZywqL1xuLyogfX0qL1xuLyoqL1xuY29uc3QgcHJvdG89Z2V0UHJvdG90eXBlT2Yob3JpZ2luYWwpO1xuaWYocHJvdG89PT1vYmplY3RQcm90b3R5cGV8fHByb3RvPT09bnVsbCl7XG5yZXR1cm4oXG5yZWplY3QmJlxucmVqZWN0KFggYFJlbW90YWJsZXMgbXVzdCBiZSBleHBsaWNpdGx5IGRlY2xhcmVkOiAke3Eob3JpZ2luYWwpfWApKTtcblxuIH1cblxuaWYodHlwZW9mIG9yaWdpbmFsPT09J29iamVjdCcpe1xuY29uc3QgcHJvdG9Qcm90bz1nZXRQcm90b3R5cGVPZihwcm90byk7XG5pZihwcm90b1Byb3RvIT09b2JqZWN0UHJvdG90eXBlJiZwcm90b1Byb3RvIT09bnVsbCl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIGNoZWNrUmVtb3RhYmxlKHByb3RvLGNoZWNrKTtcbiB9XG5pZighY2hlY2tUYWdSZWNvcmQocHJvdG8sJ3JlbW90YWJsZScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfWVsc2UgaWYodHlwZW9mIG9yaWdpbmFsPT09J2Z1bmN0aW9uJyl7XG5pZighY2hlY2tGdW5jdGlvblRhZ1JlY29yZChwcm90bywncmVtb3RhYmxlJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTp7dmFsdWU6aWZhY2V9LFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocHJvdG8pO1xuXG5yZXR1cm4oXG4ob3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aD09PTB8fFxucmVqZWN0JiZcbnJlamVjdChcblggYFVuZXhwZWN0ZWQgcHJvcGVydGllcyBvbiBSZW1vdGFibGUgUHJvdG8gJHtvd25LZXlzKHJlc3REZXNjcyl9YCkpJiZcblxuY2hlY2tJZmFjZShpZmFjZSxjaGVjaykpO1xuXG4gfTtcblxuLyoqXG4gKiBLZWVwIGEgd2VhayBzZXQgb2YgY29uZmlybWVkIHJlbW90YWJsZXMgZm9yIG1hcnNoYWwgcGVyZm9ybWFuY2VcbiAqICh3aXRob3V0IHdoaWNoIHdlIHdvdWxkIGluY3VyIGEgcmVkdW5kYW50IHZlcmlmaWNhdGlvbiBpblxuICogZ2V0SW50ZXJmYWNlT2YpLlxuICogV2UgZG9uJ3QgcmVtZW1iZXIgcmVqZWN0aW9ucyBiZWNhdXNlIHRoZXkgYXJlIHBvc3NpYmxlIHRvIGNvcnJlY3RcbiAqIHdpdGggZS5nLiBgaGFyZGVuYC5cbiAqXG4gKiBAdHlwZSB7V2Vha1NldDxSZW1vdGFibGU+fVxuICovXG5jb25zdCBjb25maXJtZWRSZW1vdGFibGVzPW5ldyBXZWFrU2V0KCk7XG5cbi8qKlxuICogQHBhcmFtIHtSZW1vdGFibGV9IHZhbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGU9KHZhbCxjaGVjayk9PntcbmlmKGNvbmZpcm1lZFJlbW90YWJsZXMuaGFzKHZhbCkpe1xucmV0dXJuIHRydWU7XG4gfVxuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbmlmKCFpc0Zyb3plbih2YWwpKXtcbnJldHVybiByZWplY3QmJnJlamVjdChYIGBjYW5ub3Qgc2VyaWFsaXplIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7dmFsfWApO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZighUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQodmFsLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgcmVzdWx0PWNoZWNrUmVtb3RhYmxlUHJvdG9PZih2YWwsY2hlY2spO1xuaWYocmVzdWx0KXtcbmNvbmZpcm1lZFJlbW90YWJsZXMuYWRkKHZhbCk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKiogQHR5cGUge01hcnNoYWxHZXRJbnRlcmZhY2VPZn0gKi9cbmNvbnN0ICAgICAgICBnZXRJbnRlcmZhY2VPZj0odmFsKT0+e1xuaWYoXG4haXNPYmplY3QodmFsKXx8XG52YWxbUEFTU19TVFlMRV0hPT0ncmVtb3RhYmxlJ3x8XG4hY2hlY2tSZW1vdGFibGUodmFsKSlcbntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxucmV0dXJuIGdldFRhZyh2YWwpO1xuIH07JGjigI1fb25jZS5nZXRJbnRlcmZhY2VPZihnZXRJbnRlcmZhY2VPZik7XG5oYXJkZW4oZ2V0SW50ZXJmYWNlT2YpO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7UGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlSGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J3JlbW90YWJsZScsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuY29uc3QgdmFsaWRUeXBlPVxuKGlzT2JqZWN0KGNhbmRpZGF0ZSl8fFxucmVqZWN0JiZcbnJlamVjdChYIGBjYW5ub3Qgc2VyaWFsaXplIG5vbi1vYmplY3RzIGFzIFJlbW90YWJsZSAke2NhbmRpZGF0ZX1gKSkmJihcbiFpc0FycmF5KGNhbmRpZGF0ZSl8fFxucmVqZWN0JiZcbnJlamVjdChYIGBjYW5ub3Qgc2VyaWFsaXplIGFycmF5cyBhcyBSZW1vdGFibGUgJHtjYW5kaWRhdGV9YCkpO1xuaWYoIXZhbGlkVHlwZSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuXG5jb25zdCBkZXNjcz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5pZih0eXBlb2YgY2FuZGlkYXRlPT09J29iamVjdCcpe1xuLyogRXZlcnkgb3duIHByb3BlcnR5IChyZWdhcmRsZXNzIG9mIGVudW1lcmFiaWxpdHkpKi9cbi8qIG11c3QgaGF2ZSBhIGZ1bmN0aW9uIHZhbHVlLiovXG5yZXR1cm4gb3duS2V5cyhkZXNjcykuZXZlcnkoKGtleSk9PntcbnJldHVybihcbi8qIFR5cGVjYXN0IG5lZWRlZCBkdWUgdG8gaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy8xODYzKi9cbihoYXNPd25Qcm9wZXJ0eU9mKGRlc2NzWy8qKiBAdHlwZSB7c3RyaW5nfSAqL2tleV0sJ3ZhbHVlJyl8fFxucmVqZWN0JiZcbnJlamVjdChcblggYGNhbm5vdCBzZXJpYWxpemUgUmVtb3RhYmxlcyB3aXRoIGFjY2Vzc29ycyBsaWtlICR7cShcblN0cmluZyhrZXkpKVxuIH0gaW4gJHtjYW5kaWRhdGV9YCkpJiYoXG5cbmtleT09PVN5bWJvbC50b1N0cmluZ1RhZyYmY2hlY2tJZmFjZShjYW5kaWRhdGVba2V5XSxjaGVjayl8fFxuKGNhbkJlTWV0aG9kKGNhbmRpZGF0ZVtrZXldKXx8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgY2Fubm90IHNlcmlhbGl6ZSBSZW1vdGFibGVzIHdpdGggbm9uLW1ldGhvZHMgbGlrZSAke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGluICR7Y2FuZGlkYXRlfWApKSYmKFxuXG5rZXkhPT1QQVNTX1NUWUxFfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgQSBwYXNzLWJ5LXJlbW90ZSBjYW5ub3Qgc2hhZG93ICR7cShQQVNTX1NUWUxFKX1gKSkpKTtcblxuIH0pO1xuIH1lbHNlIGlmKHR5cGVvZiBjYW5kaWRhdGU9PT0nZnVuY3Rpb24nKXtcbi8qIEZhciBmdW5jdGlvbnMgY2Fubm90IGJlIG1ldGhvZHMsIGFuZCBjYW5ub3QgaGF2ZSBtZXRob2RzLiovXG4vKiBUaGV5IG11c3QgaGF2ZSBleGFjdGx5IGV4cGVjdGVkIGAubmFtZWAgYW5kIGAubGVuZ3RoYCBwcm9wZXJ0aWVzKi9cbmNvbnN0e1xubmFtZTpuYW1lRGVzYyxcbmxlbmd0aDpsZW5ndGhEZXNjLFxuLyogQHRzLWlnbm9yZSBUUyBkb2Vzbid0IGxpa2Ugc3ltYm9scyBhcyBjb21wdXRlZCBpbmRleGVzPz8qL1xuW1N5bWJvbC50b1N0cmluZ1RhZ106dG9TdHJpbmdUYWdEZXNjLFxuLi4ucmVzdERlc2NzfT1cbmRlc2NzO1xuY29uc3QgcmVzdEtleXM9b3duS2V5cyhyZXN0RGVzY3MpO1xucmV0dXJuKFxuKG5hbWVEZXNjJiZ0eXBlb2YgbmFtZURlc2MudmFsdWU9PT0nc3RyaW5nJ3x8XG5yZWplY3QmJlxucmVqZWN0KFggYEZhciBmdW5jdGlvbiBuYW1lIG11c3QgYmUgYSBzdHJpbmcsIGluICR7Y2FuZGlkYXRlfWApKSYmKFxubGVuZ3RoRGVzYyYmdHlwZW9mIGxlbmd0aERlc2MudmFsdWU9PT0nbnVtYmVyJ3x8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgRmFyIGZ1bmN0aW9uIGxlbmd0aCBtdXN0IGJlIGEgbnVtYmVyLCBpbiAke2NhbmRpZGF0ZX1gKSkmJihcblxudG9TdHJpbmdUYWdEZXNjPT09dW5kZWZpbmVkfHxcbih0eXBlb2YgdG9TdHJpbmdUYWdEZXNjLnZhbHVlPT09J3N0cmluZyd8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEZhciBmdW5jdGlvbiBAQHRvU3RyaW5nVGFnIG11c3QgYmUgYSBzdHJpbmcsIGluICR7Y2FuZGlkYXRlfWApKSYmXG5cbmNoZWNrSWZhY2UodG9TdHJpbmdUYWdEZXNjLnZhbHVlLGNoZWNrKSkmJihcbnJlc3RLZXlzLmxlbmd0aD09PTB8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEZhciBmdW5jdGlvbnMgdW5leHBlY3RlZCBwcm9wZXJ0aWVzIGJlc2lkZXMgLm5hbWUgYW5kIC5sZW5ndGggJHtyZXN0S2V5c31gKSkpO1xuXG5cbiB9XG5yZXR1cm4gcmVqZWN0JiZyZWplY3QoWCBgdW5yZWNvZ25pemVkIHR5cGVvZiAke2NhbmRpZGF0ZX1gKTtcbiB9LFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlKT0+Y2hlY2tSZW1vdGFibGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpLFxuXG5ldmVyeTooX3Bhc3NhYmxlLF9mbik9PnRydWV9KTskaOKAjV9vbmNlLlJlbW90YWJsZUhlbHBlcihSZW1vdGFibGVIZWxwZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImFzc2VydElmYWNlIjpbImFzc2VydElmYWNlIl0sImdldEludGVyZmFjZU9mIjpbImdldEludGVyZmFjZU9mIl0sIlJlbW90YWJsZUhlbHBlciI6WyJSZW1vdGFibGVIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAANeJOipoPAACaDwAAKwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9zYWZlLXByb21pc2UuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIkBlbmRvL3Byb21pc2Uta2l0Il0sImV4cG9ydHMiOlsiYXNzZXJ0U2FmZVByb21pc2UiLCJpc1NhZmVQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzUHJvbWlzZSxhc3NlcnRDaGVja2VyLGhhc093blByb3BlcnR5T2Y7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRo4oCNX2EgPT4gKGhhc093blByb3BlcnR5T2YgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuXG5jb25zdHtkZXRhaWxzOlgscXVvdGU6cX09YXNzZXJ0O1xuY29uc3R7aXNGcm96ZW4sZ2V0UHJvdG90eXBlT2Z9PU9iamVjdDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtQcm9taXNlfSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tQcm9taXNlT3duS2V5cz0ocHIsY2hlY2spPT57XG5jb25zdCByZWplY3Q9KGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKTtcbmNvbnN0IGtleXM9b3duS2V5cyhwcik7XG5cbmlmKGtleXMubGVuZ3RoPT09MCl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5cbmNvbnN0IHVua25vd25LZXlzPWtleXMuZmlsdGVyKFxuKGtleSk9PnR5cGVvZiBrZXkhPT0nc3ltYm9sJ3x8IWhhc093blByb3BlcnR5T2YoUHJvbWlzZS5wcm90b3R5cGUsa2V5KSk7XG5cblxuaWYodW5rbm93bktleXMubGVuZ3RoIT09MCl7XG5yZXR1cm4gcmVqZWN0KFxuWCBgJHtwcn0gLSBNdXN0IG5vdCBoYXZlIGFueSBvd24gcHJvcGVydGllczogJHtxKHVua25vd25LZXlzKX1gKTtcblxuIH1cblxuLyoqXG4gKiBBdCB0aGUgdGltZSBvZiB0aGlzIHdyaXRpbmcsIE5vZGUncyBhc3luY19ob29rcyBjb250YWlucyB0aGVcbiAqIGZvbGxvd2luZyBjb2RlLCB3aGljaCB3ZSBjYW4gYWxzbyBzYWZlbHkgdG9sZXJhdGVcbiAqXG4gKiBgYGBqc1xuICogZnVuY3Rpb24gZGVzdHJveVRyYWNraW5nKHByb21pc2UsIHBhcmVudCkge1xuICogdHJhY2tQcm9taXNlKHByb21pc2UsIHBhcmVudCk7XG4gKiAgIGNvbnN0IGFzeW5jSWQgPSBwcm9taXNlW2FzeW5jX2lkX3N5bWJvbF07XG4gKiAgIGNvbnN0IGRlc3Ryb3llZCA9IHsgZGVzdHJveWVkOiBmYWxzZSB9O1xuICogICBwcm9taXNlW2Rlc3Ryb3llZFN5bWJvbF0gPSBkZXN0cm95ZWQ7XG4gKiAgIHJlZ2lzdGVyRGVzdHJveUhvb2socHJvbWlzZSwgYXN5bmNJZCwgZGVzdHJveWVkKTtcbiAqIH1cbiAqIGBgYFxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfHN5bWJvbH0ga2V5XG4gKi9cbmNvbnN0IGNoZWNrU2FmZUFzeW5jSG9va3NLZXk9KGtleSk9PntcbmNvbnN0IHZhbD1wcltrZXldO1xuaWYodmFsPT09dW5kZWZpbmVkfHx0eXBlb2YgdmFsPT09J251bWJlcicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoXG50eXBlb2YgdmFsPT09J29iamVjdCcmJlxudmFsIT09bnVsbCYmXG5pc0Zyb3plbih2YWwpJiZcbmdldFByb3RvdHlwZU9mKHZhbCk9PT1PYmplY3QucHJvdG90eXBlKVxue1xuY29uc3Qgc3ViS2V5cz1vd25LZXlzKHZhbCk7XG5pZihzdWJLZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG5pZihcbnN1YktleXMubGVuZ3RoPT09MSYmXG5zdWJLZXlzWzBdPT09J2Rlc3Ryb3llZCcmJlxudmFsLmRlc3Ryb3llZD09PWZhbHNlKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiByZWplY3QoXG5YIGBVbmV4cGVjdGVkIE5vZGUgYXN5bmNfaG9va3MgYWRkaXRpb25zIHRvIHByb21pc2U6ICR7cHJ9LiR7cShcblN0cmluZyhrZXkpKVxuIH0gaXMgJHt2YWx9YCk7XG5cbiB9O1xuXG5yZXR1cm4ga2V5cy5ldmVyeShjaGVja1NhZmVBc3luY0hvb2tzS2V5KTtcbiB9O1xuXG4vKipcbiAqIFVuZGVyIEhhcmRlbmVkIEpTIGEgcHJvbWlzZSBpcyBcInNhZmVcIiBpZiBpdHMgYHRoZW5gIG1ldGhvZCBjYW4gYmUgY2FsbGVkXG4gKiBzeW5jaHJvbm91c2x5IHdpdGhvdXQgZ2l2aW5nIHRoZSBwcm9taXNlIGFuIG9wcG9ydHVuaXR5IGZvciBhXG4gKiByZWVudHJhbmN5IGF0dGFjayBkdXJpbmcgdGhhdCBjYWxsLlxuICpcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvOVxuICogcmFpc2VzIHRoZSBpc3N1ZSBvZiB0ZXN0aW5nIHRoYXQgYSBzcGVjaW1lbiBpcyBhIHNhZmUgcHJvbWlzZVxuICogc3VjaCB0aGF0IHRoZSB0ZXN0IGFsc28gZG9lcyBub3QgZ2l2ZSB0aGUgc3BlY2ltZW4gYVxuICogcmVlbnRyYW5jeSBvcHBvcnR1bml0eS4gVGhhdCBpcyB3ZWxsIGJleW9uZCB0aGUgYW1iaXRpb24gaGVyZS5cbiAqIFRPRE8gVGhvdWdoIGlmIHdlIGZpZ3VyZSBvdXQgYSBuaWNlIHNvbHV0aW9uLCBpdCBtaWdodCBiZSBnb29kIHRvXG4gKiB1c2UgaXQgaGVyZSBhcyB3ZWxsLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gcHIgVGhlIHZhbHVlIHRvIGV4YW1pbmVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtwciBpcyBQcm9taXNlfSBXaGV0aGVyIGl0IGlzIGEgc2FmZSBwcm9taXNlXG4gKi9cbmNvbnN0IGNoZWNrU2FmZVByb21pc2U9KHByLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PShkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscyk7XG5yZXR1cm4oXG4oaXNGcm96ZW4ocHIpfHxyZWplY3QoWCBgJHtwcn0gLSBNdXN0IGJlIGZyb3plbmApKSYmKFxuaXNQcm9taXNlKHByKXx8cmVqZWN0KFggYCR7cHJ9IC0gTXVzdCBiZSBhIHByb21pc2VgKSkmJihcbmdldFByb3RvdHlwZU9mKHByKT09PVByb21pc2UucHJvdG90eXBlfHxcbnJlamVjdChcblggYCR7cHJ9IC0gTXVzdCBpbmhlcml0IGZyb20gUHJvbWlzZS5wcm90b3R5cGU6ICR7cShcbmdldFByb3RvdHlwZU9mKHByKSlcbiB9YCkpJiZcblxuY2hlY2tQcm9taXNlT3duS2V5cygvKiogQHR5cGUge1Byb21pc2V9ICovcHIsY2hlY2spKTtcblxuIH07XG5oYXJkZW4oY2hlY2tTYWZlUHJvbWlzZSk7XG5cbi8qKlxuICogRGV0ZXJtaW5lIGlmIHRoZSBhcmd1bWVudCBpcyBhIFByb21pc2UuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBwcm9taXNlXG4gKi9cbmNvbnN0ICAgICAgICBpc1NhZmVQcm9taXNlPShwcik9PmNoZWNrU2FmZVByb21pc2UocHIsKHgpPT54KTskaOKAjV9vbmNlLmlzU2FmZVByb21pc2UoaXNTYWZlUHJvbWlzZSk7XG5oYXJkZW4oaXNTYWZlUHJvbWlzZSk7XG5cbmNvbnN0ICAgICAgICBhc3NlcnRTYWZlUHJvbWlzZT0ocHIpPT5jaGVja1NhZmVQcm9taXNlKHByLGFzc2VydENoZWNrZXIpOyRo4oCNX29uY2UuYXNzZXJ0U2FmZVByb21pc2UoYXNzZXJ0U2FmZVByb21pc2UpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzU2FmZVByb21pc2UiOlsiaXNTYWZlUHJvbWlzZSJdLCJhc3NlcnRTYWZlUHJvbWlzZSI6WyJhc3NlcnRTYWZlUHJvbWlzZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADHH9VQRxIAAEcSAAAlAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3N5bWJvbC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiYXNzZXJ0UGFzc2FibGVTeW1ib2wiLCJpc1Bhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwicGFzc2FibGVTeW1ib2xGb3JOYW1lIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIFRoZSB3ZWxsIGtub3duIHN5bWJvbHMgYXJlIHN0YXRpYyBzeW1ib2wgdmFsdWVzIG9uIHRoZSBgU3ltYm9sYCBjb25zdHJ1Y3Rvci5cbiAqL1xuY29uc3Qgd2VsbEtub3duU3ltYm9sTmFtZXM9bmV3IE1hcChcbm93bktleXMoU3ltYm9sKS5cbmZpbHRlcihcbihuYW1lKT0+dHlwZW9mIG5hbWU9PT0nc3RyaW5nJyYmdHlwZW9mIFN5bWJvbFtuYW1lXT09PSdzeW1ib2wnKS5cblxuZmlsdGVyKChuYW1lKT0+e1xuLyogQHRzLWV4cGVjdC1lcnJvciBJdCBkb2Vzbid0IGtub3cgbmFtZSBjYW5ub3QgYmUgYSBzeW1ib2wqL1xuIW5hbWUuc3RhcnRzV2l0aCgnQEAnKXx8XG5GYWlsIGBEaWQgbm90IGV4cGVjdCBTeW1ib2wgdG8gaGF2ZSBhIHN5bWJvbC12YWx1ZWQgcHJvcGVydHkgbmFtZSBzdGFydGluZyB3aXRoIFwiQEBcIiAke3EoXG5uYW1lKVxuIH1gO1xucmV0dXJuIHRydWU7XG4gfSlcbi8qIEB0cy1pZ25vcmUgSXQgZG9lc24ndCBrbm93IG5hbWUgY2Fubm90IGJlIGEgc3ltYm9sKi8uXG5tYXAoKG5hbWUpPT5bU3ltYm9sW25hbWVdLCBgQEAke25hbWV9YF0pKTtcblxuXG4vKipcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IHN5bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc1Bhc3NhYmxlU3ltYm9sPShzeW0pPT5cbnR5cGVvZiBzeW09PT0nc3ltYm9sJyYmKFxudHlwZW9mIFN5bWJvbC5rZXlGb3Ioc3ltKT09PSdzdHJpbmcnfHx3ZWxsS25vd25TeW1ib2xOYW1lcy5oYXMoc3ltKSk7JGjigI1fb25jZS5pc1Bhc3NhYmxlU3ltYm9sKGlzUGFzc2FibGVTeW1ib2wpO1xuaGFyZGVuKGlzUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGVTeW1ib2w9KHN5bSk9PlxuaXNQYXNzYWJsZVN5bWJvbChzeW0pfHxcbkZhaWwgYE9ubHkgcmVnaXN0ZXJlZCBzeW1ib2xzIG9yIHdlbGwta25vd24gc3ltYm9scyBhcmUgcGFzc2FibGU6ICR7cShzeW0pfWA7JGjigI1fb25jZS5hc3NlcnRQYXNzYWJsZVN5bWJvbChhc3NlcnRQYXNzYWJsZVN5bWJvbCk7XG5oYXJkZW4oYXNzZXJ0UGFzc2FibGVTeW1ib2wpO1xuXG4vKipcbiAqIElmIGBzeW1gIGlzIGEgcGFzc2FibGUgc3ltYm9sLCByZXR1cm4gYSBzdHJpbmcgdGhhdCB1bmlxdWVseSBpZGVudGlmaWVzIHRoaXNcbiAqIHN5bWJvbC4gSWYgYHN5bWAgaXMgYSBub24tcGFzc2FibGUgc3ltYm9sLCByZXR1cm4gYHVuZGVmaW5lZGAuXG4gKlxuICogVGhlIHBhc3NhYmxlIHN5bWJvbHMgYXJlIHRoZSB3ZWxsIGtub3duIHN5bWJvbHMgKHRoZSBzeW1ib2wgdmFsdWVzXG4gKiBvZiBzdGF0aWMgcHJvcGVydGllcyBvZiB0aGUgYFN5bWJvbGAgY29uc3RydWN0b3IpIGFuZCB0aGUgcmVnaXN0ZXJlZFxuICogc3ltYm9scy4gU2luY2UgdGhlIHJlZ2lzdHJhdGlvbiBzdHJpbmcgb2YgYSByZWdpc3RlcmVkIHN5bWJvbCBjYW4gYmUgYW55XG4gKiBzdHJpbmcsIGlmIHdlIHNpbXBseSB1c2VkIHRoYXQgdG8gaWRlbnRpZnkgdGhvc2Ugc3ltYm9scywgdGhlcmUgd291bGQgbm90XG4gKiBiZSBhbnkgcmVtYWluaW5nIHN0cmluZ3MgbGVmdCBvdmVyIHRvIGlkZW50aWZ5IHRoZSB3ZWxsLWtub3duIHN5bWJvbHMuXG4gKiBJbnN0ZWFkLCB3ZSByZXNlcnZlIHN0cmluZ3MgYmVnaW5uaW5nIHdpdGggYFwiQEBcImAgZm9yIHB1cnBvc2VzIG9mIHRoaXNcbiAqIGVuY29kaW5nLiBXZSBpZGVudGlmeSBhIHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXMgYFN5bWJvbC5pdGVyYXRvcmBcbiAqIGJ5IHByZWZpeGluZyB0aGUgcHJvcGVydHkgbmFtZSB3aXRoIGBcIkBAXCJgLCBzdWNoIGFzIGBcIkBAaXRlcmF0b3JcImAuXG4gKiBGb3IgcmVnaXN0ZXJlZCBzeW1ib2xzIHdob3NlIG5hbWUgaGFwcGVucyB0byBiZWdpbiB3aXRoIGBcIkBAXCJgLCBzdWNoXG4gKiBhcyBgU3ltYm9sLmZvcignQEBpdGVyYXRvcicpYCBvciBgU3ltYm9sLmZvcignQEBmb28nKWAsIHdlIGlkZW50aWZ5XG4gKiB0aGVtIGJ5IHByZWZpeGluZyB0aGVtIHdpdGggYW4gZXh0cmEgYFwiQEBcImAsIHN1Y2ggYXNcbiAqIGBcIkBAQEBpdGVyYXRvclwiYCBvciBgXCJAQEBAZm9vXCJgLiAoVGhpcyBpcyB0aGUgSGlsYmVydCBIb3RlbCBlbmNvZGluZ1xuICogdGVjaG5pcXVlLilcbiAqXG4gKiBAcGFyYW0ge3N5bWJvbH0gc3ltXG4gKiBAcmV0dXJucyB7c3RyaW5nPX1cbiAqL1xuY29uc3QgICAgICAgIG5hbWVGb3JQYXNzYWJsZVN5bWJvbD0oc3ltKT0+e1xuY29uc3QgbmFtZT1TeW1ib2wua2V5Rm9yKHN5bSk7XG5pZihuYW1lPT09dW5kZWZpbmVkKXtcbnJldHVybiB3ZWxsS25vd25TeW1ib2xOYW1lcy5nZXQoc3ltKTtcbiB9XG5pZihuYW1lLnN0YXJ0c1dpdGgoJ0BAJykpe1xucmV0dXJuIGBAQCR7bmFtZX1gO1xuIH1cbnJldHVybiBuYW1lO1xuIH07JGjigI1fb25jZS5uYW1lRm9yUGFzc2FibGVTeW1ib2wobmFtZUZvclBhc3NhYmxlU3ltYm9sKTtcbmhhcmRlbihuYW1lRm9yUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCBBdEF0UHJlZml4UGF0dGVybj0vXkBAKC4qKSQvO1xuaGFyZGVuKEF0QXRQcmVmaXhQYXR0ZXJuKTtcblxuLyoqXG4gKiBJZiBgbmFtZWAgaXMgYSBzdHJpbmcgdGhhdCBjb3VsZCBoYXZlIGJlZW4gcHJvZHVjZWQgYnlcbiAqIGBuYW1lRm9yUGFzc2FibGVTeW1ib2xgLCByZXR1cm4gdGhlIHN5bWJvbCBhcmd1bWVudCBpdCB3YXMgcHJvZHVjZWQgdG9cbiAqIHJlcHJlc2VudC5cbiAqXG4gKiAgICBJZiBgbmFtZWAgZG9lcyBub3QgYmVnaW4gd2l0aCBgXCJAQFwiYCwgdGhlbiBqdXN0IHRoZSBjb3JyZXNwb25kaW5nXG4gKiAgICAgIHJlZ2lzdGVyZWQgc3ltYm9sLCBgU3ltYm9sLmZvcihuYW1lKWAuXG4gKiAgICBJZiBgbmFtZWAgaXMgYFwiQEBcImAgZm9sbG93ZWQgYnkgYSB3ZWxsIGtub3duIHN5bWJvbCdzIHByb3BlcnR5IG5hbWUgb25cbiAqICAgICAgYFN5bWJvbGAgc3VjaCBgXCJAQGl0ZXJhdG9yXCIsIHJldHVybiB0aGF0IHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXNcbiAqICAgICAgYFN5bWJvbC5pdGVyYXRvcmBcbiAqICAgIElmIGBuYW1lYCBiZWdpbnMgd2l0aCBgXCJAQEBAXCJgIGl0IGVuY29kZXMgdGhlIHJlZ2lzdGVyZWQgc3ltYm9sIHdob3NlXG4gKiAgICAgIG5hbWUgYmVnaW5zIHdpdGggYFwiQEBcImAgaW5zdGVhZC5cbiAqICAgIE90aGVyd2lzZSwgaWYgbmFtZSBiZWdpbnMgd2l0aCBgXCJAQFwiYCBpdCBtYXkgZW5jb2RlIGEgcmVnaXN0ZXJlZCBzeW1ib2xcbiAqICAgICAgZnJvbSBhIGZ1dHVyZSB2ZXJzaW9uIG9mIEphdmFTY3JpcHQsIGJ1dCBpdCBpcyBub3Qgb25lIHdlIGNhbiBkZWNvZGVcbiAqICAgICAgeWV0LCBzbyB0aHJvdy5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge3N5bWJvbD19XG4gKi9cbmNvbnN0ICAgICAgICBwYXNzYWJsZVN5bWJvbEZvck5hbWU9KG5hbWUpPT57XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY29uc3QgbWF0Y2g9QXRBdFByZWZpeFBhdHRlcm4uZXhlYyhuYW1lKTtcbmlmKG1hdGNoKXtcbmNvbnN0IHN1ZmZpeD1tYXRjaFsxXTtcbmlmKHN1ZmZpeC5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBTeW1ib2wuZm9yKHN1ZmZpeCk7XG4gfWVsc2V7XG5jb25zdCBzeW09U3ltYm9sW3N1ZmZpeF07XG5pZih0eXBlb2Ygc3ltPT09J3N5bWJvbCcpe1xucmV0dXJuIHN5bTtcbiB9XG5GYWlsIGBSZXNlcnZlZCBmb3Igd2VsbCBrbm93biBzeW1ib2wgJHtxKHN1ZmZpeCl9OiAke3EobmFtZSl9YDtcbiB9XG4gfVxucmV0dXJuIFN5bWJvbC5mb3IobmFtZSk7XG4gfTskaOKAjV9vbmNlLnBhc3NhYmxlU3ltYm9sRm9yTmFtZShwYXNzYWJsZVN5bWJvbEZvck5hbWUpO1xuaGFyZGVuKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNQYXNzYWJsZVN5bWJvbCI6WyJpc1Bhc3NhYmxlU3ltYm9sIl0sImFzc2VydFBhc3NhYmxlU3ltYm9sIjpbImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sIm5hbWVGb3JQYXNzYWJsZVN5bWJvbCI6WyJuYW1lRm9yUGFzc2FibGVTeW1ib2wiXSwicGFzc2FibGVTeW1ib2xGb3JOYW1lIjpbInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAlvFz7/QcAAP0HAAAlAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3RhZ2dlZC5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiVGFnZ2VkSGVscGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydENoZWNrZXIsY2hlY2tUYWdSZWNvcmQsUEFTU19TVFlMRSxjaGVja05vcm1hbFByb3BlcnR5LGNoZWNrUGFzc1N0eWxlOyRo4oCNX2ltcG9ydHMoW1tcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaOKAjV9hID0+IChjaGVja1RhZ1JlY29yZCA9ICRo4oCNX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjigI1fYSA9PiAoUEFTU19TVFlMRSA9ICRo4oCNX2EpXV0sW1wiY2hlY2tOb3JtYWxQcm9wZXJ0eVwiLCBbJGjigI1fYSA9PiAoY2hlY2tOb3JtYWxQcm9wZXJ0eSA9ICRo4oCNX2EpXV0sW1wiY2hlY2tQYXNzU3R5bGVcIiwgWyRo4oCNX2EgPT4gKGNoZWNrUGFzc1N0eWxlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtGYWlsfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yc309T2JqZWN0O1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIFRhZ2dlZEhlbHBlcj1oYXJkZW4oe1xuc3R5bGVOYW1lOid0YWdnZWQnLFxuXG5jYW5CZVZhbGlkOihjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+XG5jaGVja1Bhc3NTdHlsZShjYW5kaWRhdGUsJ3RhZ2dlZCcsY2hlY2spLFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlLHBhc3NTdHlsZU9mUmVjdXIpPT57XG5jaGVja1RhZ1JlY29yZChjYW5kaWRhdGUsJ3RhZ2dlZCcsYXNzZXJ0Q2hlY2tlcik7XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTpfbGFiZWxEZXNjLFxucGF5bG9hZDpfcGF5bG9hZERlc2MsLyogdmFsdWUgY2hlY2tlZCBieSByZWN1cnNpdmUgd2FsayBhdCB0aGUgZW5kKi9cbi4uLnJlc3REZXNjc309XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5vd25LZXlzKHJlc3REZXNjcykubGVuZ3RoPT09MHx8XG5GYWlsIGBVbmV4cGVjdGVkIHByb3BlcnRpZXMgb24gdGFnZ2VkIHJlY29yZCAke293bktleXMocmVzdERlc2NzKX1gO1xuXG5jaGVja05vcm1hbFByb3BlcnR5KGNhbmRpZGF0ZSwncGF5bG9hZCcsdHJ1ZSxhc3NlcnRDaGVja2VyKTtcblxuLyogUmVjdXJzaXZlbHkgdmFsaWRhdGUgdGhhdCBlYWNoIG1lbWJlciBpcyBwYXNzYWJsZS4qL1xucGFzc1N0eWxlT2ZSZWN1cihjYW5kaWRhdGUucGF5bG9hZCk7XG4gfX0pOyRo4oCNX29uY2UuVGFnZ2VkSGVscGVyKFRhZ2dlZEhlbHBlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGFnZ2VkSGVscGVyIjpbIlRhZ2dlZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAB6oH5oEg0AABINAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbImFzc2VydENvcHlBcnJheSIsImFzc2VydFJlY29yZCIsImFzc2VydFJlbW90YWJsZSIsImlzQ29weUFycmF5IiwiaXNSZWNvcmQiLCJpc1JlbW90YWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBwYXNzU3R5bGVPZjskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZU9mLmpzXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUGFzc2FibGV9IFBhc3NhYmxlICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Db3B5QXJyYXk8VD59IENvcHlBcnJheSAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ29weVJlY29yZDxUPn0gQ29weVJlY29yZCAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVtb3RhYmxlT2JqZWN0fSBSZW1vdGFibGUgKi9cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIEFLQSBhIFwiY29weUFycmF5XCJcbiAqIGluIEBlbmRvL21hcnNoYWwgdGVybXNcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBhcnJcbiAqIEByZXR1cm5zIHthcnIgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGlzQ29weUFycmF5PShhcnIpPT5wYXNzU3R5bGVPZihhcnIpPT09J2NvcHlBcnJheSc7JGjigI1fb25jZS5pc0NvcHlBcnJheShpc0NvcHlBcnJheSk7XG5oYXJkZW4oaXNDb3B5QXJyYXkpO1xuXG4vKipcbiAqIENoZWNrIHdoZXRoZXIgdGhlIGFyZ3VtZW50IGlzIGEgcGFzcy1ieS1jb3B5IHJlY29yZCwgQUtBIGFcbiAqIFwiY29weVJlY29yZFwiIGluIEBlbmRvL21hcnNoYWwgdGVybXNcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZWNvcmRcbiAqIEByZXR1cm5zIHtyZWNvcmQgaXMgQ29weVJlY29yZDxhbnk+fVxuICovXG5jb25zdCBpc1JlY29yZD0ocmVjb3JkKT0+cGFzc1N0eWxlT2YocmVjb3JkKT09PSdjb3B5UmVjb3JkJzskaOKAjV9vbmNlLmlzUmVjb3JkKGlzUmVjb3JkKTtcbmhhcmRlbihpc1JlY29yZCk7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSByZW1vdGFibGUuXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVtb3RhYmxlXG4gKiBAcmV0dXJucyB7cmVtb3RhYmxlIGlzIFJlbW90YWJsZX1cbiAqL1xuY29uc3QgaXNSZW1vdGFibGU9KHJlbW90YWJsZSk9PnBhc3NTdHlsZU9mKHJlbW90YWJsZSk9PT0ncmVtb3RhYmxlJzskaOKAjV9vbmNlLmlzUmVtb3RhYmxlKGlzUmVtb3RhYmxlKTtcbmhhcmRlbihpc1JlbW90YWJsZSk7XG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydEFycmF5XG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBhcnJheVxuICogQHBhcmFtIHtzdHJpbmc9fSBvcHROYW1lT2ZBcnJheVxuICogQHJldHVybnMge2Fzc2VydHMgYXJyYXkgaXMgQ29weUFycmF5PGFueT59XG4gKi9cblxuLyoqIEB0eXBlIHtBc3NlcnRBcnJheX0gKi9cbmNvbnN0IGFzc2VydENvcHlBcnJheT0oYXJyYXksb3B0TmFtZU9mQXJyYXk9J0FsbGVnZWQgYXJyYXknKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKGFycmF5KTtcbnBhc3NTdHlsZT09PSdjb3B5QXJyYXknfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZBcnJheSl9ICR7YXJyYXl9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaOKAjV9vbmNlLmFzc2VydENvcHlBcnJheShhc3NlcnRDb3B5QXJyYXkpO1xuaGFyZGVuKGFzc2VydENvcHlBcnJheSk7XG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFJlY29yZFxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlY29yZFxuICogQHJldHVybnMge2Fzc2VydHMgcmVjb3JkIGlzIENvcHlSZWNvcmQ8YW55Pn1cbiAqL1xuXG4vKiogQHR5cGUge0Fzc2VydFJlY29yZH0gKi9cbmNvbnN0IGFzc2VydFJlY29yZD0ocmVjb3JkLG9wdE5hbWVPZlJlY29yZD0nQWxsZWdlZCByZWNvcmQnKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHJlY29yZCk7XG5wYXNzU3R5bGU9PT0nY29weVJlY29yZCd8fFxuRmFpbCBgJHtxKG9wdE5hbWVPZlJlY29yZCl9ICR7cmVjb3JkfSBtdXN0IGJlIGEgcGFzcy1ieS1jb3B5IHJlY29yZCwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0UmVjb3JkKGFzc2VydFJlY29yZCk7XG5oYXJkZW4oYXNzZXJ0UmVjb3JkKTtcblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0UmVtb3RhYmxlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZW1vdGFibGVcbiAqIEBwYXJhbSB7c3RyaW5nPX0gb3B0TmFtZU9mUmVtb3RhYmxlXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyByZW1vdGFibGUgaXMgUmVtb3RhYmxlfVxuICovXG5cbi8qKiBAdHlwZSB7QXNzZXJ0UmVtb3RhYmxlfSAqL1xuY29uc3QgYXNzZXJ0UmVtb3RhYmxlPShcbnJlbW90YWJsZSxcbm9wdE5hbWVPZlJlbW90YWJsZT0nQWxsZWdlZCByZW1vdGFibGUnKT0+XG57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVtb3RhYmxlKTtcbnBhc3NTdHlsZT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZSZW1vdGFibGUpfSAke3JlbW90YWJsZX0gbXVzdCBiZSBhIHJlbW90YWJsZSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0UmVtb3RhYmxlKGFzc2VydFJlbW90YWJsZSk7XG5oYXJkZW4oYXNzZXJ0UmVtb3RhYmxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJpc0NvcHlBcnJheSI6WyJpc0NvcHlBcnJheSJdLCJpc1JlY29yZCI6WyJpc1JlY29yZCJdLCJpc1JlbW90YWJsZSI6WyJpc1JlbW90YWJsZSJdLCJhc3NlcnRDb3B5QXJyYXkiOlsiYXNzZXJ0Q29weUFycmF5Il0sImFzc2VydFJlY29yZCI6WyJhc3NlcnRSZWNvcmQiXSwiYXNzZXJ0UmVtb3RhYmxlIjpbImFzc2VydFJlbW90YWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACYGTuzNAEAADQBAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3R5cGVzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGXyjBp8CAAAfAgAACAAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuNy9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9lcnJvci5qcyIsIi4vc3JjL2l0ZXItaGVscGVycy5qcyIsIi4vc3JjL21ha2UtZmFyLmpzIiwiLi9zcmMvbWFrZVRhZ2dlZC5qcyIsIi4vc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9zcmMvcGFzc1N0eWxlT2YuanMiLCIuL3NyYy9yZW1vdGFibGUuanMiLCIuL3NyYy9zeW1ib2wuanMiLCIuL3NyYy90eXBlR3VhcmRzLmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiZXhwb3J0cyI6WyJGYXIiLCJGYXIiLCJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIiwiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSIsImlzT2JqZWN0IiwiaXNPYmplY3QiLCJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCIsInRvUGFzc2FibGVFcnJvciIsInRvUGFzc2FibGVFcnJvciIsbnVsbCxudWxsXSwicmVleHBvcnRzIjpbIi4vc3JjL3R5cGVzLmpzIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiLi9zcmMvaXRlci1oZWxwZXJzLmpzXCIsIFtdXSxbXCIuL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbXV0sW1wiLi9zcmMvZXJyb3IuanNcIiwgW11dLFtcIi4vc3JjL3JlbW90YWJsZS5qc1wiLCBbXV0sW1wiLi9zcmMvc3ltYm9sLmpzXCIsIFtdXSxbXCIuL3NyYy9wYXNzU3R5bGVPZi5qc1wiLCBbXV0sW1wiLi9zcmMvbWFrZVRhZ2dlZC5qc1wiLCBbXV0sW1wiLi9zcmMvbWFrZS1mYXIuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVHdWFyZHMuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2l0ZXItaGVscGVycy5qcyI6W1sibWFwSXRlcmFibGUiLCJtYXBJdGVyYWJsZSJdLFsiZmlsdGVySXRlcmFibGUiLCJmaWx0ZXJJdGVyYWJsZSJdXSwiLi9zcmMvcGFzc1N0eWxlLWhlbHBlcnMuanMiOltbIlBBU1NfU1RZTEUiLCJQQVNTX1NUWUxFIl0sWyJpc09iamVjdCIsImlzT2JqZWN0Il0sWyJhc3NlcnRDaGVja2VyIiwiYXNzZXJ0Q2hlY2tlciJdLFsiZ2V0VGFnIiwiZ2V0VGFnIl0sWyJoYXNPd25Qcm9wZXJ0eU9mIiwiaGFzT3duUHJvcGVydHlPZiJdXSwiLi9zcmMvZXJyb3IuanMiOltbImdldEVycm9yQ29uc3RydWN0b3IiLCJnZXRFcnJvckNvbnN0cnVjdG9yIl0sWyJ0b1Bhc3NhYmxlRXJyb3IiLCJ0b1Bhc3NhYmxlRXJyb3IiXSxbImlzRXJyb3JMaWtlIiwiaXNFcnJvckxpa2UiXV0sIi4vc3JjL3JlbW90YWJsZS5qcyI6W1siZ2V0SW50ZXJmYWNlT2YiLCJnZXRJbnRlcmZhY2VPZiJdXSwiLi9zcmMvc3ltYm9sLmpzIjpbWyJhc3NlcnRQYXNzYWJsZVN5bWJvbCIsImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sWyJpc1Bhc3NhYmxlU3ltYm9sIiwiaXNQYXNzYWJsZVN5bWJvbCJdLFsibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIl0sWyJwYXNzYWJsZVN5bWJvbEZvck5hbWUiLCJwYXNzYWJsZVN5bWJvbEZvck5hbWUiXV0sIi4vc3JjL3Bhc3NTdHlsZU9mLmpzIjpbWyJwYXNzU3R5bGVPZiIsInBhc3NTdHlsZU9mIl0sWyJhc3NlcnRQYXNzYWJsZSIsImFzc2VydFBhc3NhYmxlIl1dLCIuL3NyYy9tYWtlVGFnZ2VkLmpzIjpbWyJtYWtlVGFnZ2VkIiwibWFrZVRhZ2dlZCJdXSwiLi9zcmMvbWFrZS1mYXIuanMiOltbIlJlbW90YWJsZSIsIlJlbW90YWJsZSJdLFsiRmFyIiwiRmFyIl0sWyJUb0ZhckZ1bmN0aW9uIiwiVG9GYXJGdW5jdGlvbiJdXSwiLi9zcmMvdHlwZUd1YXJkcy5qcyI6W1siYXNzZXJ0UmVjb3JkIiwiYXNzZXJ0UmVjb3JkIl0sWyJhc3NlcnRDb3B5QXJyYXkiLCJhc3NlcnRDb3B5QXJyYXkiXSxbImFzc2VydFJlbW90YWJsZSIsImFzc2VydFJlbW90YWJsZSJdLFsiaXNSZW1vdGFibGUiLCJpc1JlbW90YWJsZSJdLFsiaXNSZWNvcmQiLCJpc1JlY29yZCJdLFsiaXNDb3B5QXJyYXkiLCJpc0NvcHlBcnJheSJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA3ka2qpMHAACTBwAAKAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy9jb3B5QXJyYXkuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlBcnJheUhlbHBlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLGNoZWNrTm9ybWFsUHJvcGVydHk7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiY2hlY2tOb3JtYWxQcm9wZXJ0eVwiLCBbJGjigI1fYSA9PiAoY2hlY2tOb3JtYWxQcm9wZXJ0eSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3R7ZGV0YWlsczpYfT1hc3NlcnQ7XG5jb25zdHtnZXRQcm90b3R5cGVPZn09T2JqZWN0O1xuY29uc3R7b3duS2V5c309UmVmbGVjdDtcbmNvbnN0e2lzQXJyYXkscHJvdG90eXBlOmFycmF5UHJvdG90eXBlfT1BcnJheTtcblxuLyoqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNhbkJlVmFsaWQ9KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT5cbmlzQXJyYXkoY2FuZGlkYXRlKXx8XG4hIWNoZWNrJiZjaGVjayhmYWxzZSxYIGBBcnJheSBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCk7XG5cbi8qKlxuICpcbiAqIEB0eXBlIHtYaW1wb3J0KCcuL2ludGVybmFsLXR5cGVzLmpzJykuUGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgQ29weUFycmF5SGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2NvcHlBcnJheScsXG5cbmNhbkJlVmFsaWQsXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKT09PWFycmF5UHJvdG90eXBlfHxcbmFzc2VydC5mYWlsKFggYE1hbGZvcm1lZCBhcnJheTogJHtjYW5kaWRhdGV9YCxUeXBlRXJyb3IpO1xuLyogU2luY2Ugd2UncmUgYWxyZWFkeSBlbnN1cmVkIGNhbmRpZGF0ZSBpcyBhbiBhcnJheSwgaXQgc2hvdWxkIG5vdCBiZSovXG4vKiBwb3NzaWJsZSBmb3IgdGhlIGZvbGxvd2luZyB0ZXN0IHRvIGZhaWwqL1xuY2hlY2tOb3JtYWxQcm9wZXJ0eShjYW5kaWRhdGUsJ2xlbmd0aCcsZmFsc2UsYXNzZXJ0Q2hlY2tlcik7XG5jb25zdCBsZW49LyoqIEB0eXBlIHt1bmtub3duW119ICovY2FuZGlkYXRlLmxlbmd0aDtcbmZvcihsZXQgaT0wO2k8bGVuO2krPTEpe1xuY2hlY2tOb3JtYWxQcm9wZXJ0eShjYW5kaWRhdGUsaSx0cnVlLGFzc2VydENoZWNrZXIpO1xuIH1cbi8qICsxIGZvciB0aGUgJ2xlbmd0aCcgcHJvcGVydHkgaXRzZWxmLiovXG5vd25LZXlzKGNhbmRpZGF0ZSkubGVuZ3RoPT09bGVuKzF8fFxuYXNzZXJ0LmZhaWwoWCBgQXJyYXlzIG11c3Qgbm90IGhhdmUgbm9uLWluZGV4ZXM6ICR7Y2FuZGlkYXRlfWAsVHlwZUVycm9yKTtcbi8qIFJlY3Vyc2l2ZWx5IHZhbGlkYXRlIHRoYXQgZWFjaCBtZW1iZXIgaXMgcGFzc2FibGUuKi9cbmNhbmRpZGF0ZS5ldmVyeSgodik9PiEhcGFzc1N0eWxlT2ZSZWN1cih2KSk7XG4gfX0pOyRo4oCNX29uY2UuQ29weUFycmF5SGVscGVyKENvcHlBcnJheUhlbHBlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiQ29weUFycmF5SGVscGVyIjpbIkNvcHlBcnJheUhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACD9dsszwcAAM8HAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL2NvcHlSZWNvcmQuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyJdLCJleHBvcnRzIjpbIkNvcHlSZWNvcmRIZWxwZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixjYW5CZU1ldGhvZCxjaGVja05vcm1hbFByb3BlcnR5OyRo4oCNX2ltcG9ydHMoW1tcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcImNhbkJlTWV0aG9kXCIsIFskaOKAjV9hID0+IChjYW5CZU1ldGhvZCA9ICRo4oCNX2EpXV0sW1wiY2hlY2tOb3JtYWxQcm9wZXJ0eVwiLCBbJGjigI1fYSA9PiAoY2hlY2tOb3JtYWxQcm9wZXJ0eSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5jb25zdHtkZXRhaWxzOlh9PWFzc2VydDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtnZXRQcm90b3R5cGVPZix2YWx1ZXMscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIENvcHlSZWNvcmRIZWxwZXI9aGFyZGVuKHtcbnN0eWxlTmFtZTonY29weVJlY29yZCcsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuaWYoZ2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKSE9PW9iamVjdFByb3RvdHlwZSl7XG5yZXR1cm4oXG5yZWplY3QmJlxucmVqZWN0KFggYFJlY29yZHMgbXVzdCBpbmhlcml0IGZyb20gT2JqZWN0LnByb3RvdHlwZTogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfVxuXG5yZXR1cm4gb3duS2V5cyhjYW5kaWRhdGUpLmV2ZXJ5KChrZXkpPT57XG5yZXR1cm4oXG4odHlwZW9mIGtleT09PSdzdHJpbmcnfHxcbiEhcmVqZWN0JiZcbnJlamVjdChcblggYFJlY29yZHMgY2FuIG9ubHkgaGF2ZSBzdHJpbmctbmFtZWQgcHJvcGVydGllczogJHtjYW5kaWRhdGV9YCkpJiYoXG5cbiFjYW5CZU1ldGhvZChjYW5kaWRhdGVba2V5XSl8fFxuISFyZWplY3QmJlxucmVqZWN0KFxuLyogVE9ETzogVXBkYXRlIG1lc3NhZ2Ugbm93IHRoYXQgdGhlcmUgaXMgbm8gc3VjaCB0aGluZyBhcyBcImltcGxpY2l0IFJlbW90YWJsZVwiLiovXG5YIGBSZWNvcmRzIGNhbm5vdCBjb250YWluIG5vbi1mYXIgZnVuY3Rpb25zIGJlY2F1c2UgdGhleSBtYXkgYmUgbWV0aG9kcyBvZiBhbiBpbXBsaWNpdCBSZW1vdGFibGU6ICR7Y2FuZGlkYXRlfWApKSk7XG5cblxuIH0pO1xuIH0sXG5cbmFzc2VydFZhbGlkOihjYW5kaWRhdGUscGFzc1N0eWxlT2ZSZWN1cik9PntcbkNvcHlSZWNvcmRIZWxwZXIuY2FuQmVWYWxpZChjYW5kaWRhdGUsYXNzZXJ0Q2hlY2tlcik7XG5mb3IoY29uc3QgbmFtZSBvZiBvd25LZXlzKGNhbmRpZGF0ZSkpe1xuY2hlY2tOb3JtYWxQcm9wZXJ0eShjYW5kaWRhdGUsbmFtZSx0cnVlLGFzc2VydENoZWNrZXIpO1xuIH1cbi8qIFJlY3Vyc2l2ZWx5IHZhbGlkYXRlIHRoYXQgZWFjaCBtZW1iZXIgaXMgcGFzc2FibGUuKi9cbmZvcihjb25zdCB2YWwgb2YgdmFsdWVzKGNhbmRpZGF0ZSkpe1xucGFzc1N0eWxlT2ZSZWN1cih2YWwpO1xuIH1cbiB9fSk7JGjigI1fb25jZS5Db3B5UmVjb3JkSGVscGVyKENvcHlSZWNvcmRIZWxwZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkNvcHlSZWNvcmRIZWxwZXIiOlsiQ29weVJlY29yZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABqd7sZSxIAAEsSAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL2Vycm9yLmpzeyJpbXBvcnRzIjpbIi4vcGFzc1N0eWxlLWhlbHBlcnMuanMiXSwiZXhwb3J0cyI6WyJFcnJvckhlbHBlciIsImdldEVycm9yQ29uc3RydWN0b3IiLCJpc0Vycm9yTGlrZSIsInRvUGFzc2FibGVFcnJvciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyOyRo4oCNX2ltcG9ydHMoW1tcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn0gUGFzc1N0eWxlSGVscGVyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5DaGVja2VyfSBDaGVja2VyICovXG5cbmNvbnN0e2RldGFpbHM6WCxGYWlsfT1hc3NlcnQ7XG5jb25zdHtnZXRQcm90b3R5cGVPZixnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzfT1PYmplY3Q7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKiBUT0RPOiBNYWludGVuYW5jZSBoYXphcmQ6IENvb3JkaW5hdGUgd2l0aCB0aGUgbGlzdCBvZiBlcnJvcnMgaW4gdGhlIFNFUyovXG4vKiB3aGlsZWxpc3QuIEN1cnJlbnRseSwgYm90aCBvbWl0IEFnZ3JlZ2F0ZUVycm9yLCB3aGljaCBpcyBub3cgc3RhbmRhcmQuIEJvdGgqL1xuLyogbXVzdCBldmVudHVhbGx5IGluY2x1ZGUgaXQuKi9cbmNvbnN0IGVycm9yQ29uc3RydWN0b3JzPW5ldyBNYXAoW1xuWydFcnJvcicsRXJyb3JdLFxuWydFdmFsRXJyb3InLEV2YWxFcnJvcl0sXG5bJ1JhbmdlRXJyb3InLFJhbmdlRXJyb3JdLFxuWydSZWZlcmVuY2VFcnJvcicsUmVmZXJlbmNlRXJyb3JdLFxuWydTeW50YXhFcnJvcicsU3ludGF4RXJyb3JdLFxuWydUeXBlRXJyb3InLFR5cGVFcnJvcl0sXG5bJ1VSSUVycm9yJyxVUklFcnJvcl1dKTtcblxuXG5jb25zdCAgICAgICAgZ2V0RXJyb3JDb25zdHJ1Y3Rvcj0obmFtZSk9PmVycm9yQ29uc3RydWN0b3JzLmdldChuYW1lKTskaOKAjV9vbmNlLmdldEVycm9yQ29uc3RydWN0b3IoZ2V0RXJyb3JDb25zdHJ1Y3Rvcik7XG5oYXJkZW4oZ2V0RXJyb3JDb25zdHJ1Y3Rvcik7XG5cbi8qKlxuICogQHBhcmFtIHt1bmtub3dufSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrRXJyb3JMaWtlPShjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbi8qIFRPRE86IE5lZWQgYSBiZXR0ZXIgdGVzdCB0aGFuIGluc3RhbmNlb2YqL1xucmV0dXJuKFxuY2FuZGlkYXRlIGluc3RhbmNlb2YgRXJyb3J8fFxucmVqZWN0JiZyZWplY3QoWCBgRXJyb3IgZXhwZWN0ZWQ6ICR7Y2FuZGlkYXRlfWApKTtcblxuIH07XG5oYXJkZW4oY2hlY2tFcnJvckxpa2UpO1xuXG4vKipcbiAqIFZhbGlkYXRpbmcgZXJyb3Igb2JqZWN0cyBhcmUgcGFzc2FibGUgcmFpc2VzIGEgdGVuc2lvbiBiZXR3ZWVuIHNlY3VyaXR5XG4gKiB2cyBwcmVzZXJ2aW5nIGRpYWdub3N0aWMgaW5mb3JtYXRpb24uIEZvciBlcnJvcnMsIHdlIG5lZWQgdG8gcmVtZW1iZXJcbiAqIHRoZSBlcnJvciBpdHNlbGYgZXhpc3RzIHRvIGhlbHAgdXMgZGlhZ25vc2UgYSBidWcgdGhhdCdzIGxpa2VseSBtb3JlXG4gKiBwcmVzc2luZyB0aGFuIGEgdmFsaWRpdHkgYnVnIGluIHRoZSBlcnJvciBpdHNlbGYuIFRodXMsIHdoZW5ldmVyIGl0IGlzIHNhZmVcbiAqIHRvIGRvIHNvLCB3ZSBwcmVmZXIgdG8gbGV0IHRoZSBlcnJvci1saWtlIHRlc3Qgc3VjY2VlZCBhbmQgdG8gY291Y2ggdGhlc2VcbiAqIGNvbXBsYWludHMgYXMgbm90ZXMgb24gdGhlIGVycm9yLlxuICpcbiAqIFRvIHJlc29sdmUgdGhpcywgc3VjaCBhIG1hbGZvcm1lZCBlcnJvciBvYmplY3Qgd2lsbCBzdGlsbCBwYXNzXG4gKiBgaXNFcnJvckxpa2VgIHNvIG1hcnNoYWwgY2FuIHVzZSB0aGlzIGZvciB0b3AgbGV2ZWwgZXJyb3IgdG8gcmVwb3J0IGZyb20sXG4gKiBldmVuIGlmIGl0IHdvdWxkIG5vdCBhY3R1YWxseSB2YWxpZGF0ZS5cbiAqIEluc3RlYWQsIHRoZSBkaWFnbm9zdGljcyB0aGF0IGBhc3NlcnRFcnJvcmAgd291bGQgaGF2ZSByZXBvcnRlZCBhcmVcbiAqIGF0dGFjaGVkIGFzIG5vdGVzIHRvIHRoZSBtYWxmb3JtZWQgZXJyb3IuIFRodXMsIGEgbWFsZm9ybWVkXG4gKiBlcnJvciBpcyBwYXNzYWJsZSBieSBpdHNlbGYsIGJ1dCBub3QgYXMgcGFydCBvZiBhIHBhc3NhYmxlIHN0cnVjdHVyZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IGNhbmRpZGF0ZVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc0Vycm9yTGlrZT0oY2FuZGlkYXRlKT0+Y2hlY2tFcnJvckxpa2UoY2FuZGlkYXRlKTskaOKAjV9vbmNlLmlzRXJyb3JMaWtlKGlzRXJyb3JMaWtlKTtcbmhhcmRlbihpc0Vycm9yTGlrZSk7XG5cbi8qKlxuICogQHR5cGUge1Bhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIEVycm9ySGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J2Vycm9yJyxcblxuY2FuQmVWYWxpZDpjaGVja0Vycm9yTGlrZSxcblxuYXNzZXJ0VmFsaWQ6KGNhbmRpZGF0ZSk9PntcbkVycm9ySGVscGVyLmNhbkJlVmFsaWQoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpO1xuY29uc3QgcHJvdG89Z2V0UHJvdG90eXBlT2YoY2FuZGlkYXRlKTtcbmNvbnN0e25hbWV9PXByb3RvO1xuY29uc3QgRUM9Z2V0RXJyb3JDb25zdHJ1Y3RvcihuYW1lKTtcbkVDJiZFQy5wcm90b3R5cGU9PT1wcm90b3x8XG5GYWlsIGBFcnJvcnMgbXVzdCBpbmhlcml0IGZyb20gYW4gZXJyb3IgY2xhc3MgLnByb3RvdHlwZSAke2NhbmRpZGF0ZX1gO1xuXG5jb25zdHtcbi8qIFRPRE8gTXVzdCBhbGxvdyBgY2F1c2VgLCBgZXJyb3JzYCovXG5tZXNzYWdlOm1EZXNjLFxuc3RhY2s6c3RhY2tEZXNjLFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMoY2FuZGlkYXRlKTtcbm93bktleXMocmVzdERlc2NzKS5sZW5ndGg8MXx8XG5GYWlsIGBQYXNzZWQgRXJyb3IgaGFzIGV4dHJhIHVucGFzc2VkIHByb3BlcnRpZXMgJHtyZXN0RGVzY3N9YDtcbmlmKG1EZXNjKXtcbnR5cGVvZiBtRGVzYy52YWx1ZT09PSdzdHJpbmcnfHxcbkZhaWwgYFBhc3NlZCBFcnJvciBcIm1lc3NhZ2VcIiAke21EZXNjfSBtdXN0IGJlIGEgc3RyaW5nLXZhbHVlZCBkYXRhIHByb3BlcnR5LmA7XG4hbURlc2MuZW51bWVyYWJsZXx8XG5GYWlsIGBQYXNzZWQgRXJyb3IgXCJtZXNzYWdlXCIgJHttRGVzY30gbXVzdCBub3QgYmUgZW51bWVyYWJsZWA7XG4gfVxuaWYoc3RhY2tEZXNjKXtcbnR5cGVvZiBzdGFja0Rlc2MudmFsdWU9PT0nc3RyaW5nJ3x8XG5GYWlsIGBQYXNzZWQgRXJyb3IgXCJzdGFja1wiICR7c3RhY2tEZXNjfSBtdXN0IGJlIGEgc3RyaW5nLXZhbHVlZCBkYXRhIHByb3BlcnR5LmA7XG4hc3RhY2tEZXNjLmVudW1lcmFibGV8fFxuRmFpbCBgUGFzc2VkIEVycm9yIFwic3RhY2tcIiAke3N0YWNrRGVzY30gbXVzdCBub3QgYmUgZW51bWVyYWJsZWA7XG4gfVxucmV0dXJuIHRydWU7XG4gfX0pO1xuXG5cbi8qKlxuICogUmV0dXJuIGEgbmV3IHBhc3NhYmxlIGVycm9yIHRoYXQgcHJvcGFnYXRlcyB0aGUgZGlhZ25vc3RpYyBpbmZvIG9mIHRoZVxuICogb3JpZ2luYWwsIGFuZCBpcyBsaW5rZWQgdG8gdGhlIG9yaWdpbmFsIGFzIGEgbm90ZS5cbiAqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJcbiAqIEByZXR1cm5zIHtFcnJvcn1cbiAqLyRo4oCNX29uY2UuRXJyb3JIZWxwZXIoRXJyb3JIZWxwZXIpO1xuY29uc3QgICAgICAgIHRvUGFzc2FibGVFcnJvcj0oZXJyKT0+e1xuY29uc3R7bmFtZSxtZXNzYWdlfT1lcnI7XG5cbmNvbnN0IEVDPWdldEVycm9yQ29uc3RydWN0b3IoIGAke25hbWV9YCl8fEVycm9yO1xuY29uc3QgbmV3RXJyb3I9aGFyZGVuKG5ldyBFQyggYCR7bWVzc2FnZX1gKSk7XG4vKiBFdmVuIHRoZSBjbGVhbmVkIHVwIGVycm9yIGNvcHksIGlmIHNlbnQgdG8gdGhlIGNvbnNvbGUsIHNob3VsZCovXG4vKiBjYXVzZSBoaWRkZW4gZGlhZ25vc3RpYyBpbmZvcm1hdGlvbiBvZiB0aGUgb3JpZ2luYWwgZXJyb3IqL1xuLyogdG8gYmUgbG9nZ2VkLiovXG5hc3NlcnQubm90ZShuZXdFcnJvcixYIGBjb3BpZWQgZnJvbSBlcnJvciAke2Vycn1gKTtcbnJldHVybiBuZXdFcnJvcjtcbiB9OyRo4oCNX29uY2UudG9QYXNzYWJsZUVycm9yKHRvUGFzc2FibGVFcnJvcik7XG5oYXJkZW4odG9QYXNzYWJsZUVycm9yKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJnZXRFcnJvckNvbnN0cnVjdG9yIjpbImdldEVycm9yQ29uc3RydWN0b3IiXSwiaXNFcnJvckxpa2UiOlsiaXNFcnJvckxpa2UiXSwiRXJyb3JIZWxwZXIiOlsiRXJyb3JIZWxwZXIiXSwidG9QYXNzYWJsZUVycm9yIjpbInRvUGFzc2FibGVFcnJvciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABKO2aDVQgAAFUIAAArAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL2l0ZXItaGVscGVycy5qc3siaW1wb3J0cyI6WyIuL21ha2UtZmFyLmpzIl0sImV4cG9ydHMiOlsiZmlsdGVySXRlcmFibGUiLCJtYXBJdGVyYWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBGYXI7JGjigI1faW1wb3J0cyhbW1wiLi9tYWtlLWZhci5qc1wiLCBbW1wiRmFyXCIsIFskaOKAjV9hID0+IChGYXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuLyoqXG4gKiBUaGUgcmVzdWx0IGl0ZXJhdG9yIGhhcyBhcyBtYW55IGVsZW1lbnRzIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCBhbmRcbiAqIGhhdmUgdGhlIHNhbWUgdGVybWluYXRpb24gLS0gdGhlIHNhbWUgY29tcGxldGlvbiB2YWx1ZSBvciBmYWlsdXJlXG4gKiByZWFzb24uIEJ1dCB0aGUgbm9uLWZpbmFsIHZhbHVlcyBhcmUgdGhlIGNvcnJlc3BvbmRpbmcgbm9uLWZpbmFsXG4gKiB2YWx1ZXMgZnJvbSBgYmFzZUl0ZXJhdG9yYCBhcyB0cmFuc2Zvcm1lZCBieSBgZnVuY2AuXG4gKlxuICogQHRlbXBsYXRlIFQsVVxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gVX0gZnVuY1xuICogQHJldHVybnMge0l0ZXJhYmxlPFU+fVxuICovXG5jb25zdCAgICAgICAgbWFwSXRlcmFibGU9KGJhc2VJdGVyYWJsZSxmdW5jKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdtYXBwZWQgaXRlcmFibGUnLHtcbltTeW1ib2wuaXRlcmF0b3JdOigpPT57XG5jb25zdCBiYXNlSXRlcmF0b3I9YmFzZUl0ZXJhYmxlW1N5bWJvbC5pdGVyYXRvcl0oKTtcbnJldHVybiBGYXIoJ21hcHBlZCBpdGVyYXRvcicse1xubmV4dDooKT0+e1xuY29uc3R7dmFsdWU6YmFzZVZhbHVlLGRvbmV9PWJhc2VJdGVyYXRvci5uZXh0KCk7XG5jb25zdCB2YWx1ZT1kb25lP2Jhc2VWYWx1ZTpmdW5jKGJhc2VWYWx1ZSk7XG5yZXR1cm4gaGFyZGVuKHt2YWx1ZSxkb25lfSk7XG4gfX0pO1xuXG4gfX0pOyRo4oCNX29uY2UubWFwSXRlcmFibGUobWFwSXRlcmFibGUpO1xuXG5oYXJkZW4obWFwSXRlcmFibGUpO1xuXG4vKipcbiAqIFRoZSByZXN1bHQgaXRlcmF0b3IgaGFzIGEgc3Vic2V0IG9mIHRoZSBub24tZmluYWwgdmFsdWVzIGZyb20gdGhlXG4gKiBgYmFzZUl0ZXJhdG9yYCAtLS0gdGhvc2UgZm9yIHdoaWNoIGBwcmVkKHZhbHVlKWAgd2FzIHRydXRoeS4gVGhlIHJlc3VsdFxuICogaGFzIHRoZSBzYW1lIHRlcm1pbmF0aW9uIGFzIHRoZSBgYmFzZUl0ZXJhdG9yYCAtLSB0aGUgc2FtZSBjb21wbGV0aW9uIHZhbHVlXG4gKiBvciBmYWlsdXJlIHJlYXNvbi5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gYmFzZUl0ZXJhYmxlXG4gKiBAcGFyYW0geyh2YWx1ZTogVCkgPT4gYm9vbGVhbn0gcHJlZFxuICogQHJldHVybnMge0l0ZXJhYmxlPFQ+fVxuICovXG5jb25zdCAgICAgICAgZmlsdGVySXRlcmFibGU9KGJhc2VJdGVyYWJsZSxwcmVkKT0+XG4vKiogQHR5cGUge0l0ZXJhYmxlPFU+fSAqL1xuRmFyKCdmaWx0ZXJlZCBpdGVyYWJsZScse1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9PntcbmNvbnN0IGJhc2VJdGVyYXRvcj1iYXNlSXRlcmFibGVbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIEZhcignZmlsdGVyZWQgaXRlcmF0b3InLHtcbm5leHQ6KCk9PntcbmZvcig7Oyl7XG5jb25zdCByZXN1bHQ9YmFzZUl0ZXJhdG9yLm5leHQoKTtcbmNvbnN0e3ZhbHVlLGRvbmV9PXJlc3VsdDtcbmlmKGRvbmV8fHByZWQodmFsdWUpKXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbiB9fSk7XG5cbiB9fSk7JGjigI1fb25jZS5maWx0ZXJJdGVyYWJsZShmaWx0ZXJJdGVyYWJsZSk7XG5cbmhhcmRlbihmaWx0ZXJJdGVyYWJsZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFwSXRlcmFibGUiOlsibWFwSXRlcmFibGUiXSwiZmlsdGVySXRlcmFibGUiOlsiZmlsdGVySXRlcmFibGUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA+lX/zTIaAAAyGgAAJwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy9tYWtlLWZhci5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9yZW1vdGFibGUuanMiXSwiZXhwb3J0cyI6WyJGYXIiLCJSZW1vdGFibGUiLCJUb0ZhckZ1bmN0aW9uIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydENoZWNrZXIsUEFTU19TVFlMRSxhc3NlcnRJZmFjZSxnZXRJbnRlcmZhY2VPZixSZW1vdGFibGVIZWxwZXI7JGjigI1faW1wb3J0cyhbW1wiLi9wYXNzU3R5bGUtaGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjigI1fYSA9PiAoUEFTU19TVFlMRSA9ICRo4oCNX2EpXV1dXSxbXCIuL3JlbW90YWJsZS5qc1wiLCBbW1wiYXNzZXJ0SWZhY2VcIiwgWyRo4oCNX2EgPT4gKGFzc2VydElmYWNlID0gJGjigI1fYSldXSxbXCJnZXRJbnRlcmZhY2VPZlwiLCBbJGjigI1fYSA9PiAoZ2V0SW50ZXJmYWNlT2YgPSAkaOKAjV9hKV1dLFtcIlJlbW90YWJsZUhlbHBlclwiLCBbJGjigI1fYSA9PiAoUmVtb3RhYmxlSGVscGVyID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkludGVyZmFjZVNwZWN9IEludGVyZmFjZVNwZWMgKi9cbi8qKiBAdGVtcGxhdGUgTCxSIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9ldmVudHVhbC1zZW5kJykuUmVtb3RhYmxlQnJhbmQ8TCwgUj59IFJlbW90YWJsZUJyYW5kICovXG5cbmNvbnN0e3F1b3RlOnEsRmFpbH09YXNzZXJ0O1xuXG5jb25zdHtwcm90b3R5cGU6ZnVuY3Rpb25Qcm90b3R5cGV9PUZ1bmN0aW9uO1xuY29uc3R7XG5nZXRQcm90b3R5cGVPZixcbnNldFByb3RvdHlwZU9mLFxuY3JlYXRlLFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlfT1cbk9iamVjdDtcblxuLyoqXG4gKiBOb3cgdGhhdCB0aGUgcmVtb3RhYmxlUHJvdG8gZG9lcyBub3QgcHJvdmlkZSBpdHMgb3duIGB0b1N0cmluZ2AgbWV0aG9kLFxuICogZW5zdXJlIGl0IGFsd2F5cyBpbmhlcml0cyBmcm9tIHNvbWV0aGluZy4gVGhlIG9yaWdpbmFsIHByb3RvdHlwZSBvZlxuICogYHJlbW90YWJsZWAgaWYgdGhlcmUgd2FzIG9uZSwgb3IgYE9iamVjdC5wcm90b3R5cGVgIG90aGVyd2lzZS5cbiAqXG4gKiBAcGFyYW0ge29iamVjdH0gcmVtb3RhYmxlXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IGlmYWNlXG4gKiBAcmV0dXJucyB7b2JqZWN0fVxuICovXG5jb25zdCBtYWtlUmVtb3RhYmxlUHJvdG89KHJlbW90YWJsZSxpZmFjZSk9PntcbmxldCBvbGRQcm90bz1nZXRQcm90b3R5cGVPZihyZW1vdGFibGUpO1xuaWYodHlwZW9mIHJlbW90YWJsZT09PSdvYmplY3QnKXtcbmlmKG9sZFByb3RvPT09bnVsbCl7XG5vbGRQcm90bz1vYmplY3RQcm90b3R5cGU7XG4gfVxub2xkUHJvdG89PT1vYmplY3RQcm90b3R5cGV8fFxuRmFpbCBgRm9yIG5vdywgcmVtb3RhYmxlcyBjYW5ub3QgaW5oZXJpdCBmcm9tIGFueXRoaW5nIHVudXN1YWwsIGluICR7cmVtb3RhYmxlfWA7XG4gfWVsc2UgaWYodHlwZW9mIHJlbW90YWJsZT09PSdmdW5jdGlvbicpe1xub2xkUHJvdG8hPT1udWxsfHxcbkZhaWwgYE9yaWdpbmFsIGZ1bmN0aW9uIG11c3Qgbm90IGluaGVyaXQgZnJvbSBudWxsOiAke3JlbW90YWJsZX1gO1xub2xkUHJvdG89PT1mdW5jdGlvblByb3RvdHlwZXx8XG5nZXRQcm90b3R5cGVPZihvbGRQcm90byk9PT1mdW5jdGlvblByb3RvdHlwZXx8XG5GYWlsIGBGYXIgZnVuY3Rpb25zIG11c3Qgb3JpZ2luYWxseSBpbmhlcml0IGZyb20gRnVuY3Rpb24ucHJvdG90eXBlLCBpbiAke3JlbW90YWJsZX1gO1xuIH1lbHNle1xuRmFpbCBgdW5yZWNvZ25pemVkIHR5cGVvZiAke3JlbW90YWJsZX1gO1xuIH1cbnJldHVybiBoYXJkZW4oXG5jcmVhdGUob2xkUHJvdG8se1xuW1BBU1NfU1RZTEVdOnt2YWx1ZToncmVtb3RhYmxlJ30sXG5bU3ltYm9sLnRvU3RyaW5nVGFnXTp7dmFsdWU6aWZhY2V9fSkpO1xuXG5cbiB9O1xuXG5jb25zdCBhc3NlcnRDYW5CZVJlbW90YWJsZT0oY2FuZGlkYXRlKT0+XG5SZW1vdGFibGVIZWxwZXIuY2FuQmVWYWxpZChjYW5kaWRhdGUsYXNzZXJ0Q2hlY2tlcik7XG5cbi8qKlxuICogQ3JlYXRlIGFuZCByZWdpc3RlciBhIFJlbW90YWJsZS4gIEFmdGVyIHRoaXMsIGdldEludGVyZmFjZU9mKHJlbW90YWJsZSlcbiAqIHJldHVybnMgaWZhY2UuXG4gKlxuICogLy8gaHR0cHM6Ly9naXRodWIuY29tL0Fnb3JpYy9hZ29yaWMtc2RrL2lzc3Vlcy84MDRcbiAqXG4gKiBAdGVtcGxhdGUge3t9fSBUXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IFtpZmFjZV0gVGhlIGludGVyZmFjZSBzcGVjaWZpY2F0aW9uIGZvclxuICogdGhlIHJlbW90YWJsZS4gRm9yIG5vdywgYSBzdHJpbmcgaWZhY2UgbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGhcbiAqIFwiQWxsZWdlZDogXCIgb3IgXCJEZWJ1Z05hbWU6IFwiLCB0byBzZXJ2ZSBhcyB0aGUgYWxsZWdlZCBuYW1lLiBNb3JlXG4gKiBnZW5lcmFsIGlmYWNlcyBhcmUgbm90IHlldCBpbXBsZW1lbnRlZC4gVGhpcyBpcyB0ZW1wb3JhcnkuIFdlIGluY2x1ZGUgdGhlXG4gKiBcIkFsbGVnZWRcIiBvciBcIkRlYnVnTmFtZVwiIGFzIGEgcmVtaW5kZXIgdGhhdCB3ZSBkbyBub3QgeWV0IGhhdmUgU3dpbmdTZXRcbiAqIG9yIENvbW1zIFZhdFxuICogc3VwcG9ydCBmb3IgZW5zdXJpbmcgdGhpcyBpcyBhY2NvcmRpbmcgdG8gdGhlIHZhdCBob3N0aW5nIHRoZSBvYmplY3QuXG4gKiBDdXJyZW50bHksIEFsaWNlIGNhbiB0ZWxsIEJvYiBhYm91dCBDYXJvbCwgd2hlcmUgVmF0QSAob24gQWxpY2UncyBiZWhhbGYpXG4gKiBtaXNyZXByZXNlbnRzIENhcm9sJ3MgYGlmYWNlYC4gVmF0QiBhbmQgdGhlcmVmb3JlIEJvYiB3aWxsIHRoZW4gc2VlXG4gKiBDYXJvbCdzIGBpZmFjZWAgYXMgbWlzcmVwcmVzZW50ZWQgYnkgVmF0QS5cbiAqIEBwYXJhbSB7dW5kZWZpbmVkfSBbcHJvcHNdIEN1cnJlbnRseSBtYXkgb25seSBiZSB1bmRlZmluZWQuXG4gKiBUaGF0IHBsYW4gaXMgdGhhdCBvd24tcHJvcGVydGllcyBhcmUgY29waWVkIHRvIHRoZSByZW1vdGFibGVcbiAqIEBwYXJhbSB7VH0gW3JlbW90YWJsZV0gVGhlIG9iamVjdCB1c2VkIGFzIHRoZSByZW1vdGFibGVcbiAqIEByZXR1cm5zIHtUICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fSByZW1vdGFibGUsIG1vZGlmaWVkIGZvciBkZWJ1Z2dhYmlsaXR5XG4gKi9cbmNvbnN0ICAgICAgICBSZW1vdGFibGU9KFxuaWZhY2U9J1JlbW90YWJsZScsXG5wcm9wcz11bmRlZmluZWQsXG5yZW1vdGFibGU9LyoqIEB0eXBlIHtUfSAqL3t9KT0+XG57XG5hc3NlcnRJZmFjZShpZmFjZSk7XG5hc3NlcnQoaWZhY2UpO1xuLyogVE9ETzogV2hlbiBpZmFjZSBpcyByaWNoZXIgdGhhbiBqdXN0IHN0cmluZywgd2UgbmVlZCB0byBnZXQgdGhlIGFsbGVnZWROYW1lKi9cbi8qIGluIGEgZGlmZmVyZW50IHdheS4qL1xucHJvcHM9PT11bmRlZmluZWR8fEZhaWwgYFJlbW90YWJsZSBwcm9wcyBub3QgeWV0IGltcGxlbWVudGVkICR7cHJvcHN9YDtcblxuLyogRmFpbCBmYXN0OiBjaGVjayB0aGF0IHRoZSB1bm1vZGlmaWVkIG9iamVjdCBpcyBhYmxlIHRvIGJlY29tZSBhIFJlbW90YWJsZS4qL1xuYXNzZXJ0Q2FuQmVSZW1vdGFibGUocmVtb3RhYmxlKTtcblxuLyogRW5zdXJlIHRoYXQgdGhlIHJlbW90YWJsZSBpc24ndCBhbHJlYWR5IG1hcmtlZC4qL1xuIShQQVNTX1NUWUxFIGluIHJlbW90YWJsZSl8fFxuRmFpbCBgUmVtb3RhYmxlICR7cmVtb3RhYmxlfSBpcyBhbHJlYWR5IG1hcmtlZCBhcyBhICR7cShcbnJlbW90YWJsZVtQQVNTX1NUWUxFXSlcbiB9YDtcbi8qIGBpc0Zyb3plbmAgYWx3YXlzIHJldHVybnMgdHJ1ZSB3aXRoIGEgZmFrZSBgaGFyZGVuYCwgYnV0IHdlIHdhbnQgdGhhdCBjYXNlKi9cbi8qIHRvIHN1Y2NlZWQgYW55d2F5LiBGYWtpbmcgYGhhcmRlbmAgaXMgb25seSBjb3JyZWN0bmVzcyBwcmVzZXJ2aW5nKi9cbi8qIGlmIHRoZSBjb2RlIGluIHF1ZXN0aW9uIGNvbnRhaW5zIG5vIGJ1Z3MgdGhhdCB0aGUgcmVhbCBgaGFyZGVuYCB3b3VsZCovXG4vKiBoYXZlIGNhdWdodC4qL1xuLyogQHRzLWlnbm9yZSBgaXNGYWtlYCBwdXJwb3NlbHkgbm90IGluIHRoZSB0eXBlKi9cbmhhcmRlbi5pc0Zha2V8fFxuLyogRW5zdXJlIHRoYXQgdGhlIHJlbW90YWJsZSBpc24ndCBhbHJlYWR5IGZyb3plbi4qL1xuIWlzRnJvemVuKHJlbW90YWJsZSl8fFxuRmFpbCBgUmVtb3RhYmxlICR7cmVtb3RhYmxlfSBpcyBhbHJlYWR5IGZyb3plbmA7XG5jb25zdCByZW1vdGFibGVQcm90bz1tYWtlUmVtb3RhYmxlUHJvdG8ocmVtb3RhYmxlLGlmYWNlKTtcblxuLyogVGFrZSBhIHN0YXRpYyBjb3B5IG9mIHRoZSBlbnVtZXJhYmxlIG93biBwcm9wZXJ0aWVzIGFzIGRhdGEgcHJvcGVydGllcy4qL1xuLyogY29uc3QgcHJvcERlc2NzID0gZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9ycyh7IC4uLnByb3BzIH0pOyovXG5jb25zdCBtdXRhdGVIYXJkZW5BbmRDaGVjaz0odGFyZ2V0KT0+e1xuLyogZGVmaW5lUHJvcGVydGllcyh0YXJnZXQsIHByb3BEZXNjcyk7Ki9cbnNldFByb3RvdHlwZU9mKHRhcmdldCxyZW1vdGFibGVQcm90byk7XG5oYXJkZW4odGFyZ2V0KTtcbmFzc2VydENhbkJlUmVtb3RhYmxlKHRhcmdldCk7XG4gfTtcblxuLyogRmFpbCBmYXN0OiBjaGVjayBhIGZyZXNoIHJlbW90YWJsZSB0byBzZWUgaWYgb3VyIHJ1bGVzIGZpdC4qL1xubXV0YXRlSGFyZGVuQW5kQ2hlY2soe30pO1xuXG4vKiBBY3R1YWxseSBmaW5pc2ggdGhlIG5ldyByZW1vdGFibGUuKi9cbm11dGF0ZUhhcmRlbkFuZENoZWNrKHJlbW90YWJsZSk7XG5cbi8qIENPTU1JVFRFRCEqL1xuLyogV2UncmUgY29tbWl0dGVkLCBzbyBrZWVwIHRoZSBpbnRlcmZhY2UgZm9yIGZ1dHVyZSByZWZlcmVuY2UuKi9cbmFzc2VydChpZmFjZSE9PXVuZGVmaW5lZCk7LyogVG8gbWFrZSBUeXBlU2NyaXB0IGhhcHB5Ki9cbnJldHVybiAoLyoqIEB0eXBlIHtUICYgUmVtb3RhYmxlQnJhbmQ8e30sIFQ+fSAqL3JlbW90YWJsZSk7XG4gfTskaOKAjV9vbmNlLlJlbW90YWJsZShSZW1vdGFibGUpO1xuaGFyZGVuKFJlbW90YWJsZSk7XG5cbi8qKlxuICogQSBjb25jaXNlIGNvbnZlbmllbmNlIGZvciB0aGUgbW9zdCBjb21tb24gYFJlbW90YWJsZWAgdXNlLlxuICpcbiAqIEB0ZW1wbGF0ZSB7e319IFRcbiAqIEBwYXJhbSB7c3RyaW5nfSBmYXJOYW1lIFRoaXMgbmFtZSB3aWxsIGJlIHByZXBlbmRlZCB3aXRoIGBBbGxlZ2VkOiBgXG4gKiBmb3Igbm93IHRvIGZvcm0gdGhlIGBSZW1vdGFibGVgIGBpZmFjZWAgYXJndW1lbnQuXG4gKiBAcGFyYW0ge1R9IFtyZW1vdGFibGVdIFRoZSBvYmplY3QgdXNlZCBhcyB0aGUgcmVtb3RhYmxlXG4gKi9cbmNvbnN0ICAgICAgICBGYXI9KGZhck5hbWUscmVtb3RhYmxlPXVuZGVmaW5lZCk9PntcbmNvbnN0IHI9cmVtb3RhYmxlPT09dW5kZWZpbmVkPy8qKiBAdHlwZSB7VH0gKi97fTpyZW1vdGFibGU7XG5yZXR1cm4gUmVtb3RhYmxlKCBgQWxsZWdlZDogJHtmYXJOYW1lfWAsdW5kZWZpbmVkLHIpO1xuIH07JGjigI1fb25jZS5GYXIoRmFyKTtcbmhhcmRlbihGYXIpO1xuXG4vKipcbiAqIENvZXJjZSBgZnVuY2AgdG8gYSBmYXIgZnVuY3Rpb24gdGhhdCBwcmVzZXJ2ZXMgaXRzIGNhbGwgYmVoYXZpb3IuXG4gKiBJZiBpdCBpcyBhbHJlYWR5IGEgZmFyIGZ1bmN0aW9uLCByZXR1cm4gaXQuIE90aGVyd2lzZSBtYWtlIGFuZCByZXR1cm4gYVxuICogbmV3IGZhciBmdW5jdGlvbiB0aGF0IHdyYXBzIGBmdW5jYCBhbmQgZm9yd2FyZHMgY2FsbHMgdG8gaXQuIFRoaXNcbiAqIHdvcmtzIGV2ZW4gaWYgYGZ1bmNgIGlzIGFscmVhZHkgZnJvemVuLiBgVG9GYXJGdW5jdGlvbmAgaXMgdG8gYmUgdXNlZFxuICogd2hlbiB0aGUgZnVuY3Rpb24gY29tZXMgZnJvbSBlbHNld2hlcmUgdW5kZXIgbGVzcyBjb250cm9sLiBGb3IgZnVuY3Rpb25zXG4gKiB5b3UgYXV0aG9yIGluIHBsYWNlLCBiZXR0ZXIgdG8gdXNlIGBGYXJgIG9uIHRoZWlyIGZ1bmN0aW9uIGxpdGVyYWwgZGlyZWN0bHkuXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IGZhck5hbWUgdG8gYmUgdXNlZCBvbmx5IGlmIGBmdW5jYCBpcyBub3QgYWxyZWFkeSBhXG4gKiBmYXIgZnVuY3Rpb24uXG4gKiBAcGFyYW0geyguLi5hcmdzOiBhbnlbXSkgPT4gYW55fSBmdW5jXG4gKi9cbmNvbnN0ICAgICAgICBUb0ZhckZ1bmN0aW9uPShmYXJOYW1lLGZ1bmMpPT57XG5pZihnZXRJbnRlcmZhY2VPZihmdW5jKSE9PXVuZGVmaW5lZCl7XG5yZXR1cm4gZnVuYztcbiB9XG5yZXR1cm4gRmFyKGZhck5hbWUsKC4uLmFyZ3MpPT5mdW5jKC4uLmFyZ3MpKTtcbiB9OyRo4oCNX29uY2UuVG9GYXJGdW5jdGlvbihUb0ZhckZ1bmN0aW9uKTtcbmhhcmRlbihUb0ZhckZ1bmN0aW9uKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJSZW1vdGFibGUiOlsiUmVtb3RhYmxlIl0sIkZhciI6WyJGYXIiXSwiVG9GYXJGdW5jdGlvbiI6WyJUb0ZhckZ1bmN0aW9uIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAAKRe+UdBAAAHQQAACkAAABAZW5kby9wYXNzLXN0eWxlLXYwLjEuNy9zcmMvbWFrZVRhZ2dlZC5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbIm1ha2VUYWdnZWQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgUEFTU19TVFlMRSxhc3NlcnRQYXNzYWJsZTskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJQQVNTX1NUWUxFXCIsIFskaOKAjV9hID0+IChQQVNTX1NUWUxFID0gJGjigI1fYSldXV1dLFtcIi4vcGFzc1N0eWxlT2YuanNcIiwgW1tcImFzc2VydFBhc3NhYmxlXCIsIFskaOKAjV9hID0+IChhc3NlcnRQYXNzYWJsZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5jb25zdHtjcmVhdGUscHJvdG90eXBlOm9iamVjdFByb3RvdHlwZX09T2JqZWN0O1xuY29uc3R7RmFpbH09YXNzZXJ0O1xuXG5jb25zdCAgICAgICAgbWFrZVRhZ2dlZD0odGFnLHBheWxvYWQpPT57XG50eXBlb2YgdGFnPT09J3N0cmluZyd8fFxuRmFpbCBgVGhlIHRhZyBvZiBhIHRhZ2dlZCByZWNvcmQgbXVzdCBiZSBhIHN0cmluZzogJHt0YWd9YDtcbmFzc2VydFBhc3NhYmxlKGhhcmRlbihwYXlsb2FkKSk7XG5yZXR1cm4gaGFyZGVuKFxuY3JlYXRlKG9iamVjdFByb3RvdHlwZSx7XG5bUEFTU19TVFlMRV06e3ZhbHVlOid0YWdnZWQnfSxcbltTeW1ib2wudG9TdHJpbmdUYWddOnt2YWx1ZTp0YWd9LFxucGF5bG9hZDp7dmFsdWU6cGF5bG9hZCxlbnVtZXJhYmxlOnRydWV9fSkpO1xuXG5cbiB9OyRo4oCNX29uY2UubWFrZVRhZ2dlZChtYWtlVGFnZ2VkKTtcbmhhcmRlbihtYWtlVGFnZ2VkKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlVGFnZ2VkIjpbIm1ha2VUYWdnZWQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAGUAoxvUZAAD1GQAAMAAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy9wYXNzU3R5bGUtaGVscGVycy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiUEFTU19TVFlMRSIsImFzc2VydENoZWNrZXIiLCJjYW5CZU1ldGhvZCIsImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiLCJjaGVja05vcm1hbFByb3BlcnR5IiwiY2hlY2tQYXNzU3R5bGUiLCJjaGVja1RhZ1JlY29yZCIsImdldFRhZyIsImhhc093blByb3BlcnR5T2YiLCJpc09iamVjdCIsImlzVHlwZWRBcnJheSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLkNoZWNrZXJ9IENoZWNrZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtpc0FycmF5fT1BcnJheTtcbmNvbnN0e3Byb3RvdHlwZTpmdW5jdGlvblByb3RvdHlwZX09RnVuY3Rpb247XG5jb25zdHtcbmdldE93blByb3BlcnR5RGVzY3JpcHRvcixcbmdldFByb3RvdHlwZU9mLFxuaGFzT3duUHJvcGVydHk6b2JqZWN0SGFzT3duUHJvcGVydHksXG5pc0Zyb3plbixcbnByb3RvdHlwZTpvYmplY3RQcm90b3R5cGV9PVxuT2JqZWN0O1xuY29uc3R7YXBwbHl9PVJlZmxlY3Q7XG5jb25zdHt0b1N0cmluZ1RhZzp0b1N0cmluZ1RhZ1N5bWJvbH09U3ltYm9sO1xuXG5jb25zdCB0eXBlZEFycmF5UHJvdG90eXBlPWdldFByb3RvdHlwZU9mKFVpbnQ4QXJyYXkucHJvdG90eXBlKTtcbmNvbnN0IHR5cGVkQXJyYXlUb1N0cmluZ1RhZ0Rlc2M9Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKFxudHlwZWRBcnJheVByb3RvdHlwZSxcbnRvU3RyaW5nVGFnU3ltYm9sKTtcblxuYXNzZXJ0KHR5cGVkQXJyYXlUb1N0cmluZ1RhZ0Rlc2MpO1xuY29uc3QgZ2V0VHlwZWRBcnJheVRvU3RyaW5nVGFnPXR5cGVkQXJyYXlUb1N0cmluZ1RhZ0Rlc2MuZ2V0O1xuYXNzZXJ0KHR5cGVvZiBnZXRUeXBlZEFycmF5VG9TdHJpbmdUYWc9PT0nZnVuY3Rpb24nKTtcblxuY29uc3QgICAgICAgIGhhc093blByb3BlcnR5T2Y9KG9iaixwcm9wKT0+XG5hcHBseShvYmplY3RIYXNPd25Qcm9wZXJ0eSxvYmosW3Byb3BdKTskaOKAjV9vbmNlLmhhc093blByb3BlcnR5T2YoaGFzT3duUHJvcGVydHlPZik7XG5oYXJkZW4oaGFzT3duUHJvcGVydHlPZik7XG5cbmNvbnN0ICAgICAgICBpc09iamVjdD0odmFsKT0+T2JqZWN0KHZhbCk9PT12YWw7JGjigI1fb25jZS5pc09iamVjdChpc09iamVjdCk7XG5oYXJkZW4oaXNPYmplY3QpO1xuXG4vKipcbiAqIER1cGxpY2F0ZXMgcGFja2FnZXMvc2VzL3NyYy9tYWtlLWhhcmRlbmVyLmpzIHRvIGF2b2lkIGEgZGVwZW5kZW5jeS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IG9iamVjdFxuICovXG5jb25zdCAgICAgICAgaXNUeXBlZEFycmF5PShvYmplY3QpPT57XG4vKiBUaGUgb2JqZWN0IG11c3QgcGFzcyBhIGJyYW5kIGNoZWNrIG9yIHRvU3RyaW5nVGFnIHdpbGwgcmV0dXJuIHVuZGVmaW5lZC4qL1xuY29uc3QgdGFnPWFwcGx5KGdldFR5cGVkQXJyYXlUb1N0cmluZ1RhZyxvYmplY3QsW10pO1xucmV0dXJuIHRhZyE9PXVuZGVmaW5lZDtcbiB9OyRo4oCNX29uY2UuaXNUeXBlZEFycmF5KGlzVHlwZWRBcnJheSk7XG5oYXJkZW4oaXNUeXBlZEFycmF5KTtcblxuY29uc3QgICAgICAgIFBBU1NfU1RZTEU9U3ltYm9sLmZvcigncGFzc1N0eWxlJyk7XG5cbi8qKlxuICogRm9yIGEgZnVuY3Rpb24gdG8gYmUgYSB2YWxpZCBtZXRob2QsIGl0IG11c3Qgbm90IGJlIHBhc3NhYmxlLlxuICogT3RoZXJ3aXNlLCB3ZSByaXNrIGNvbmZ1c2luZyBwYXNzLWJ5LWNvcHkgZGF0YSBjYXJyeWluZ1xuICogZmFyIGZ1bmN0aW9ucyB3aXRoIGF0dGVtcHRzIGF0IGZhciBvYmplY3RzIHdpdGggbWV0aG9kcy5cbiAqXG4gKiBUT0RPIEhBWkFSRCBCZWNhdXNlIHdlIGNoZWNrIHRoaXMgb24gdGhlIHdheSB0byBoYXJkZW5pbmcgYSByZW1vdGFibGUsXG4gKiB3ZSBjYW5ub3QgeWV0IGNoZWNrIHRoYXQgYGZ1bmNgIGlzIGhhcmRlbmVkLiBIb3dldmVyLCB3aXRob3V0XG4gKiBkb2luZyBzbywgaXQncyBpbmhlcml0YW5jZSBtaWdodCBjaGFuZ2UgYWZ0ZXIgdGhlIGBQQVNTX1NUWUxFYFxuICogY2hlY2sgYmVsb3cuXG4gKlxuICogQHBhcmFtIHthbnl9IGZ1bmNcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjigI1fb25jZS5QQVNTX1NUWUxFKFBBU1NfU1RZTEUpO1xuY29uc3QgICAgICAgIGNhbkJlTWV0aG9kPShmdW5jKT0+XG50eXBlb2YgZnVuYz09PSdmdW5jdGlvbicmJiEoUEFTU19TVFlMRSBpbiBmdW5jKTskaOKAjV9vbmNlLmNhbkJlTWV0aG9kKGNhbkJlTWV0aG9kKTtcbmhhcmRlbihjYW5CZU1ldGhvZCk7XG5cbi8qKlxuICogQmVsb3cgd2UgaGF2ZSBhIHNlcmllcyBvZiBwcmVkaWNhdGUgZnVuY3Rpb25zIGFuZCB0aGVpciAoY3VycmllZCkgYXNzZXJ0aW9uXG4gKiBmdW5jdGlvbnMuIFRoZSBzZW1hbnRpY3Mgb2YgdGhlIGFzc2VydGlvbiBmdW5jdGlvbiBpcyBqdXN0IHRvIGFzc2VydCB0aGF0XG4gKiB0aGUgY29ycmVzcG9uZGluZyBwcmVkaWNhdGUgZnVuY3Rpb24gd291bGQgaGF2ZSByZXR1cm5lZCB0cnVlLiBCdXQgaXRcbiAqIHJlcHJvZHVjZXMgdGhlIGludGVybmFsIHRlc3RzIHNvIGZhaWx1cmVzIGNhbiBnaXZlIGEgYmV0dGVyIGVycm9yIG1lc3NhZ2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDaGVja2VyPShjb25kLGRldGFpbHMpPT57XG5hc3NlcnQoY29uZCxkZXRhaWxzKTtcbnJldHVybiB0cnVlO1xuIH07JGjigI1fb25jZS5hc3NlcnRDaGVja2VyKGFzc2VydENoZWNrZXIpO1xuaGFyZGVuKGFzc2VydENoZWNrZXIpO1xuXG4vKipcbiAqIENoZWNrcyBmb3IgdGhlIHByZXNlbmNlIGFuZCBlbnVtZXJhYmlsaXR5IG9mIGFuIG93biBkYXRhIHByb3BlcnR5LlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBjYW5kaWRhdGVcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcnxzeW1ib2x9IHByb3BlcnR5TmFtZVxuICogQHBhcmFtIHtib29sZWFufSBzaG91bGRCZUVudW1lcmFibGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja05vcm1hbFByb3BlcnR5PShcbmNhbmRpZGF0ZSxcbnByb3BlcnR5TmFtZSxcbnNob3VsZEJlRW51bWVyYWJsZSxcbmNoZWNrKT0+XG57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuY29uc3QgZGVzYz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IoY2FuZGlkYXRlLHByb3BlcnR5TmFtZSk7XG5pZihkZXNjPT09dW5kZWZpbmVkKXtcbnJldHVybihcbnJlamVjdCYmcmVqZWN0KFggYCR7cShwcm9wZXJ0eU5hbWUpfSBwcm9wZXJ0eSBleHBlY3RlZDogJHtjYW5kaWRhdGV9YCkpO1xuXG4gfVxucmV0dXJuKFxuKGhhc093blByb3BlcnR5T2YoZGVzYywndmFsdWUnKXx8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgJHtxKHByb3BlcnR5TmFtZSl9IG11c3Qgbm90IGJlIGFuIGFjY2Vzc29yIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKSkmJihcblxuc2hvdWxkQmVFbnVtZXJhYmxlP1xuZGVzYy5lbnVtZXJhYmxlfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGAke3EocHJvcGVydHlOYW1lKX0gbXVzdCBiZSBhbiBlbnVtZXJhYmxlIHByb3BlcnR5OiAke2NhbmRpZGF0ZX1gKTpcblxuIWRlc2MuZW51bWVyYWJsZXx8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgJHtxKFxucHJvcGVydHlOYW1lKVxuIH0gbXVzdCBub3QgYmUgYW4gZW51bWVyYWJsZSBwcm9wZXJ0eTogJHtjYW5kaWRhdGV9YCkpKTtcblxuXG4gfTskaOKAjV9vbmNlLmNoZWNrTm9ybWFsUHJvcGVydHkoY2hlY2tOb3JtYWxQcm9wZXJ0eSk7XG5oYXJkZW4oY2hlY2tOb3JtYWxQcm9wZXJ0eSk7XG5cbmNvbnN0ICAgICAgICBnZXRUYWc9KHRhZ1JlY29yZCk9PnRhZ1JlY29yZFtTeW1ib2wudG9TdHJpbmdUYWddOyRo4oCNX29uY2UuZ2V0VGFnKGdldFRhZyk7XG5oYXJkZW4oZ2V0VGFnKTtcblxuY29uc3QgICAgICAgIGNoZWNrUGFzc1N0eWxlPShvYmosZXhwZWN0ZWRQYXNzU3R5bGUsY2hlY2spPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuY29uc3QgYWN0dWFsPW9ialtQQVNTX1NUWUxFXTtcbnJldHVybihcbmFjdHVhbD09PWV4cGVjdGVkUGFzc1N0eWxlfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgRXhwZWN0ZWQgJHtxKGV4cGVjdGVkUGFzc1N0eWxlKX0sIG5vdCAke3EoYWN0dWFsKX06ICR7b2JqfWApKTtcblxuIH07JGjigI1fb25jZS5jaGVja1Bhc3NTdHlsZShjaGVja1Bhc3NTdHlsZSk7XG5oYXJkZW4oY2hlY2tQYXNzU3R5bGUpO1xuXG5jb25zdCBtYWtlQ2hlY2tUYWdSZWNvcmQ9KGNoZWNrUHJvdG8pPT57XG4vKipcbiAqIEBwYXJhbSB7eyBbUEFTU19TVFlMRV06IHN0cmluZyB9fSB0YWdSZWNvcmRcbiAqIEBwYXJhbSB7UGFzc1N0eWxlfSBwYXNzU3R5bGVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrVGFnUmVjb3JkPSh0YWdSZWNvcmQscGFzc1N0eWxlLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbnJldHVybihcbihpc09iamVjdCh0YWdSZWNvcmQpfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgQSBub24tb2JqZWN0IGNhbm5vdCBiZSBhIHRhZ1JlY29yZDogJHt0YWdSZWNvcmR9YCkpJiYoXG5pc0Zyb3plbih0YWdSZWNvcmQpfHxcbnJlamVjdCYmcmVqZWN0KFggYEEgdGFnUmVjb3JkIG11c3QgYmUgZnJvemVuOiAke3RhZ1JlY29yZH1gKSkmJihcbiFpc0FycmF5KHRhZ1JlY29yZCl8fFxucmVqZWN0JiZyZWplY3QoWCBgQW4gYXJyYXkgY2Fubm90IGJlIGEgdGFnUmVjb3JkOiAke3RhZ1JlY29yZH1gKSkmJlxuY2hlY2tOb3JtYWxQcm9wZXJ0eSh0YWdSZWNvcmQsUEFTU19TVFlMRSxmYWxzZSxjaGVjaykmJlxuY2hlY2tQYXNzU3R5bGUodGFnUmVjb3JkLHBhc3NTdHlsZSxjaGVjaykmJlxuY2hlY2tOb3JtYWxQcm9wZXJ0eSh0YWdSZWNvcmQsU3ltYm9sLnRvU3RyaW5nVGFnLGZhbHNlLGNoZWNrKSYmKFxudHlwZW9mIGdldFRhZyh0YWdSZWNvcmQpPT09J3N0cmluZyd8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEEgW1N5bWJvbC50b1N0cmluZ1RhZ10tbmFtZWQgcHJvcGVydHkgbXVzdCBiZSBhIHN0cmluZzogJHt0YWdSZWNvcmR9YCkpJiZcblxuY2hlY2tQcm90byh0YWdSZWNvcmQsZ2V0UHJvdG90eXBlT2YodGFnUmVjb3JkKSxjaGVjaykpO1xuXG4gfTtcbnJldHVybiBoYXJkZW4oY2hlY2tUYWdSZWNvcmQpO1xuIH07XG5cbmNvbnN0ICAgICAgICBjaGVja1RhZ1JlY29yZD1tYWtlQ2hlY2tUYWdSZWNvcmQoXG4odmFsLHByb3RvLGNoZWNrKT0+XG5wcm90bz09PW9iamVjdFByb3RvdHlwZXx8XG4hIWNoZWNrJiZcbmNoZWNrKGZhbHNlLFggYEEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIE9iamVjdC5wcm90b3R5cGU6ICR7dmFsfWApKTskaOKAjV9vbmNlLmNoZWNrVGFnUmVjb3JkKGNoZWNrVGFnUmVjb3JkKTtcblxuaGFyZGVuKGNoZWNrVGFnUmVjb3JkKTtcblxuY29uc3QgICAgICAgIGNoZWNrRnVuY3Rpb25UYWdSZWNvcmQ9bWFrZUNoZWNrVGFnUmVjb3JkKFxuKHZhbCxwcm90byxjaGVjayk9PlxucHJvdG89PT1mdW5jdGlvblByb3RvdHlwZXx8XG5wcm90byE9PW51bGwmJmdldFByb3RvdHlwZU9mKHByb3RvKT09PWZ1bmN0aW9uUHJvdG90eXBlfHxcbiEhY2hlY2smJlxuY2hlY2soXG5mYWxzZSxcblggYEZvciBmdW5jdGlvbnMsIGEgdGFnUmVjb3JkIG11c3QgaW5oZXJpdCBmcm9tIEZ1bmN0aW9uLnByb3RvdHlwZTogJHt2YWx9YCkpOyRo4oCNX29uY2UuY2hlY2tGdW5jdGlvblRhZ1JlY29yZChjaGVja0Z1bmN0aW9uVGFnUmVjb3JkKTtcblxuXG5oYXJkZW4oY2hlY2tGdW5jdGlvblRhZ1JlY29yZCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaGFzT3duUHJvcGVydHlPZiI6WyJoYXNPd25Qcm9wZXJ0eU9mIl0sImlzT2JqZWN0IjpbImlzT2JqZWN0Il0sImlzVHlwZWRBcnJheSI6WyJpc1R5cGVkQXJyYXkiXSwiUEFTU19TVFlMRSI6WyJQQVNTX1NUWUxFIl0sImNhbkJlTWV0aG9kIjpbImNhbkJlTWV0aG9kIl0sImFzc2VydENoZWNrZXIiOlsiYXNzZXJ0Q2hlY2tlciJdLCJjaGVja05vcm1hbFByb3BlcnR5IjpbImNoZWNrTm9ybWFsUHJvcGVydHkiXSwiZ2V0VGFnIjpbImdldFRhZyJdLCJjaGVja1Bhc3NTdHlsZSI6WyJjaGVja1Bhc3NTdHlsZSJdLCJjaGVja1RhZ1JlY29yZCI6WyJjaGVja1RhZ1JlY29yZCJdLCJjaGVja0Z1bmN0aW9uVGFnUmVjb3JkIjpbImNoZWNrRnVuY3Rpb25UYWdSZWNvcmQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAed/NzNceAADXHgAAKgAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy9wYXNzU3R5bGVPZi5qc3siaW1wb3J0cyI6WyIuL2NvcHlBcnJheS5qcyIsIi4vY29weVJlY29yZC5qcyIsIi4vZXJyb3IuanMiLCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIiwiLi9yZW1vdGFibGUuanMiLCIuL3NhZmUtcHJvbWlzZS5qcyIsIi4vc3ltYm9sLmpzIiwiLi90YWdnZWQuanMiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbImFzc2VydFBhc3NhYmxlIiwicGFzc1N0eWxlT2YiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgaXNQcm9taXNlLGlzT2JqZWN0LGlzVHlwZWRBcnJheSxQQVNTX1NUWUxFLENvcHlBcnJheUhlbHBlcixDb3B5UmVjb3JkSGVscGVyLFRhZ2dlZEhlbHBlcixFcnJvckhlbHBlcixSZW1vdGFibGVIZWxwZXIsYXNzZXJ0UGFzc2FibGVTeW1ib2wsYXNzZXJ0U2FmZVByb21pc2U7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImlzT2JqZWN0XCIsIFskaOKAjV9hID0+IChpc09iamVjdCA9ICRo4oCNX2EpXV0sW1wiaXNUeXBlZEFycmF5XCIsIFskaOKAjV9hID0+IChpc1R5cGVkQXJyYXkgPSAkaOKAjV9hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRo4oCNX2EgPT4gKFBBU1NfU1RZTEUgPSAkaOKAjV9hKV1dXV0sW1wiLi9jb3B5QXJyYXkuanNcIiwgW1tcIkNvcHlBcnJheUhlbHBlclwiLCBbJGjigI1fYSA9PiAoQ29weUFycmF5SGVscGVyID0gJGjigI1fYSldXV1dLFtcIi4vY29weVJlY29yZC5qc1wiLCBbW1wiQ29weVJlY29yZEhlbHBlclwiLCBbJGjigI1fYSA9PiAoQ29weVJlY29yZEhlbHBlciA9ICRo4oCNX2EpXV1dXSxbXCIuL3RhZ2dlZC5qc1wiLCBbW1wiVGFnZ2VkSGVscGVyXCIsIFskaOKAjV9hID0+IChUYWdnZWRIZWxwZXIgPSAkaOKAjV9hKV1dXV0sW1wiLi9lcnJvci5qc1wiLCBbW1wiRXJyb3JIZWxwZXJcIiwgWyRo4oCNX2EgPT4gKEVycm9ySGVscGVyID0gJGjigI1fYSldXV1dLFtcIi4vcmVtb3RhYmxlLmpzXCIsIFtbXCJSZW1vdGFibGVIZWxwZXJcIiwgWyRo4oCNX2EgPT4gKFJlbW90YWJsZUhlbHBlciA9ICRo4oCNX2EpXV1dXSxbXCIuL3N5bWJvbC5qc1wiLCBbW1wiYXNzZXJ0UGFzc2FibGVTeW1ib2xcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFBhc3NhYmxlU3ltYm9sID0gJGjigI1fYSldXV1dLFtcIi4vc2FmZS1wcm9taXNlLmpzXCIsIFtbXCJhc3NlcnRTYWZlUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0U2FmZVByb21pc2UgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn0gUGFzc1N0eWxlSGVscGVyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlBhc3NTdHlsZX0gUGFzc1N0eWxlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5QYXNzU3R5bGVPZn0gUGFzc1N0eWxlT2YgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi90eXBlcy5qcycpLlByaW1pdGl2ZVN0eWxlfSBQcmltaXRpdmVTdHlsZSAqL1xuXG4vKiogQHR5cGVkZWYge0V4Y2x1ZGU8UGFzc1N0eWxlLCBQcmltaXRpdmVTdHlsZSB8IFwicHJvbWlzZVwiPn0gSGVscGVyUGFzc1N0eWxlICovXG5cbmNvbnN0e2RldGFpbHM6WCxGYWlsLHF1b3RlOnF9PWFzc2VydDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5jb25zdHtpc0Zyb3plbn09T2JqZWN0O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc1N0eWxlSGVscGVyW119IHBhc3NTdHlsZUhlbHBlcnNcbiAqIEByZXR1cm5zIHtSZWNvcmQ8SGVscGVyUGFzc1N0eWxlLCBQYXNzU3R5bGVIZWxwZXI+IH1cbiAqL1xuXG5jb25zdCBtYWtlSGVscGVyVGFibGU9KHBhc3NTdHlsZUhlbHBlcnMpPT57XG4vKiogQHR5cGUge1JlY29yZDxIZWxwZXJQYXNzU3R5bGUsIGFueT4gJiB7X19wcm90b19fOiBudWxsfX0gKi9cbmNvbnN0IEhlbHBlclRhYmxlPXtcbl9fcHJvdG9fXzpudWxsLFxuY29weUFycmF5OnVuZGVmaW5lZCxcbmNvcHlSZWNvcmQ6dW5kZWZpbmVkLFxudGFnZ2VkOnVuZGVmaW5lZCxcbmVycm9yOnVuZGVmaW5lZCxcbnJlbW90YWJsZTp1bmRlZmluZWR9O1xuXG5mb3IoY29uc3QgaGVscGVyIG9mIHBhc3NTdHlsZUhlbHBlcnMpe1xuY29uc3R7c3R5bGVOYW1lfT1oZWxwZXI7XG5zdHlsZU5hbWUgaW4gSGVscGVyVGFibGV8fEZhaWwgYFVucmVjb2duaXplZCBoZWxwZXI6ICR7cShzdHlsZU5hbWUpfWA7XG5IZWxwZXJUYWJsZVtzdHlsZU5hbWVdPT09dW5kZWZpbmVkfHxcbkZhaWwgYGNvbmZsaWN0aW5nIGhlbHBlcnMgZm9yICR7cShzdHlsZU5hbWUpfWA7XG5IZWxwZXJUYWJsZVtzdHlsZU5hbWVdPWhlbHBlcjtcbiB9XG5mb3IoY29uc3Qgc3R5bGVOYW1lIG9mIG93bktleXMoSGVscGVyVGFibGUpKXtcbkhlbHBlclRhYmxlW3N0eWxlTmFtZV0hPT11bmRlZmluZWR8fFxuRmFpbCBgbWlzc2luZyBoZWxwZXIgZm9yICR7cShzdHlsZU5hbWUpfWA7XG4gfVxuXG5yZXR1cm4gaGFyZGVuKEhlbHBlclRhYmxlKTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc1N0eWxlSGVscGVyW119IHBhc3NTdHlsZUhlbHBlcnMgVGhlIHBhc3NTdHlsZUhlbHBlcnMgdG8gcmVnaXN0ZXIsXG4gKiBpbiBwcmlvcml0eSBvcmRlci5cbiAqIE5PVEUgVGhlc2UgbXVzdCBhbGwgYmUgXCJ0cnVzdGVkXCIsXG4gKiBjb21wbGV0ZSwgYW5kIG5vbi1jb2xsaWRpbmcuIGBtYWtlUGFzc1N0eWxlT2ZgIG1heSAqYXNzdW1lKiB0aGF0IGVhY2ggaGVscGVyXG4gKiBkb2VzIHdoYXQgaXQgaXMgc3VwcG9zZWQgdG8gZG8uIGBtYWtlUGFzc1N0eWxlT2ZgIGlzIG5vdCB0cnlpbmcgdG8gZGVmZW5kXG4gKiBpdHNlbGYgYWdhaW5zdCBtYWxpY2lvdXMgaGVscGVycywgdGhvdWdoIGl0IGRvZXMgZGVmZW5kIGFnYWluc3Qgc29tZVxuICogYWNjaWRlbnRzLlxuICogQHJldHVybnMge1Bhc3NTdHlsZU9mfVxuICovXG5jb25zdCBtYWtlUGFzc1N0eWxlT2Y9KHBhc3NTdHlsZUhlbHBlcnMpPT57XG5jb25zdCBIZWxwZXJUYWJsZT1tYWtlSGVscGVyVGFibGUocGFzc1N0eWxlSGVscGVycyk7XG5jb25zdCByZW1vdGFibGVIZWxwZXI9SGVscGVyVGFibGUucmVtb3RhYmxlO1xuXG4vKipcbiAqIFB1cmVseSBmb3IgcGVyZm9ybWFuY2UuIEhvd2V2ZXIgaXQgaXMgbXV0YWJsZSBzdGF0aWMgc3RhdGUsIGFuZFxuICogaXQgZG9lcyBoYXZlIHNvbWUgb2JzZXJ2YWJpbGl0eSBvbiBwcm94aWVzLiBUT0RPIG5lZWQgdG8gYXNzZXNzXG4gKiB3aGV0aGVyIHRoaXMgY3JlYXRlcyBhIHN0YXRpYyBjb21tdW5pY2F0aW9ucyBjaGFubmVsLlxuICpcbiAqIHBhc3NTdHlsZU9mIGRvZXMgYSBmdWxsIHJlY3Vyc2l2ZSB3YWxrIG9mIHBhc3MtYnktY29weVxuICogc3RydWN0dXJlcywgaW4gb3JkZXIgdG8gdmFsaWRhdGUgdGhhdCB0aGV5IGFyZSBhY3ljbGljLiBJbiBhZGRpdGlvblxuICogaXQgaXMgdXNlZCBieSBvdGhlciBhbGdvcml0aG1zIHRvIHJlY3Vyc2l2ZWx5IHdhbGsgdGhlc2UgcGFzcy1ieS1jb3B5XG4gKiBzdHJ1Y3R1cmVzLCBzbyB3aXRob3V0IHRoaXMgY2FjaGUsIHRoZXNlIGFsZ29yaXRobXMgY291bGQgYmVcbiAqIE8oTioqMikgb3Igd29yc2UuXG4gKlxuICogQHR5cGUge1dlYWtNYXA8UGFzc2FibGUsIFBhc3NTdHlsZT59XG4gKi9cbmNvbnN0IHBhc3NTdHlsZU1lbW89bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAdHlwZSB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IHBhc3NTdHlsZU9mPShwYXNzYWJsZSk9Pntcbi8qIEV2ZW4gd2hlbiBhIFdlYWtTZXQgaXMgY29ycmVjdCwgd2hlbiB0aGUgc2V0IGhhcyBhIHNob3J0ZXIgbGlmZXRpbWUqL1xuLyogdGhhbiBpdHMga2V5cywgd2UgcHJlZmVyIGEgU2V0IGR1ZSB0byBleHBlY3RlZCBpbXBsZW1lbnRhdGlvbiovXG4vKiB0cmFkZW9mZnMuKi9cbmNvbnN0IGluUHJvZ3Jlc3M9bmV3IFNldCgpO1xuXG4vKipcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqL1xuY29uc3QgcGFzc1N0eWxlT2ZSZWN1cj0oaW5uZXIpPT57XG5jb25zdCBpbm5lcklzT2JqZWN0PWlzT2JqZWN0KGlubmVyKTtcbmlmKGlubmVySXNPYmplY3Qpe1xuaWYocGFzc1N0eWxlTWVtby5oYXMoaW5uZXIpKXtcbi8qIEB0cy1pZ25vcmUgVHlwZVNjcmlwdCBkb2Vzbid0IGtub3cgdGhhdCBgZ2V0YCBhZnRlciBgaGFzYCBpcyBzYWZlKi9cbnJldHVybiBwYXNzU3R5bGVNZW1vLmdldChpbm5lcik7XG4gfVxuIWluUHJvZ3Jlc3MuaGFzKGlubmVyKXx8XG5GYWlsIGBQYXNzLWJ5LWNvcHkgZGF0YSBjYW5ub3QgYmUgY3ljbGljICR7aW5uZXJ9YDtcbmluUHJvZ3Jlc3MuYWRkKGlubmVyKTtcbiB9XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mSW50ZXJuYWwoaW5uZXIpO1xuaWYoaW5uZXJJc09iamVjdCl7XG5wYXNzU3R5bGVNZW1vLnNldChpbm5lcixwYXNzU3R5bGUpO1xuaW5Qcm9ncmVzcy5kZWxldGUoaW5uZXIpO1xuIH1cbnJldHVybiBwYXNzU3R5bGU7XG4gfTtcblxuLyoqXG4gKiBAdHlwZSB7UGFzc1N0eWxlT2Z9XG4gKi9cbmNvbnN0IHBhc3NTdHlsZU9mSW50ZXJuYWw9KGlubmVyKT0+e1xuY29uc3QgdHlwZXN0cj10eXBlb2YgaW5uZXI7XG5zd2l0Y2godHlwZXN0cil7XG5jYXNlJ3VuZGVmaW5lZCc6XG5jYXNlJ3N0cmluZyc6XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdudW1iZXInOlxuY2FzZSdiaWdpbnQnOntcbnJldHVybiB0eXBlc3RyO1xuIH1cbmNhc2Unc3ltYm9sJzp7XG5hc3NlcnRQYXNzYWJsZVN5bWJvbChpbm5lcik7XG5yZXR1cm4nc3ltYm9sJztcbiB9XG5jYXNlJ29iamVjdCc6e1xuaWYoaW5uZXI9PT1udWxsKXtcbnJldHVybidudWxsJztcbiB9XG5pZighaXNGcm96ZW4oaW5uZXIpKXtcbmFzc2VydC5mYWlsKFxuLyogVHlwZWRBcnJheXMgZ2V0IHNwZWNpYWwgdHJlYXRtZW50IGluIGhhcmRlbigpKi9cbi8qIGFuZCBhIGNvcnJlc3BvbmRpbmcgc3BlY2lhbCBlcnJvciBtZXNzYWdlIGhlcmUuKi9cbmlzVHlwZWRBcnJheShpbm5lcik/XG5YIGBDYW5ub3QgcGFzcyBtdXRhYmxlIHR5cGVkIGFycmF5cyBsaWtlICR7aW5uZXJ9LmA6XG5YIGBDYW5ub3QgcGFzcyBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke2lubmVyfS4gVXNlIGhhcmRlbigpYCk7XG5cbiB9XG5pZihpc1Byb21pc2UoaW5uZXIpKXtcbmFzc2VydFNhZmVQcm9taXNlKGlubmVyKTtcbnJldHVybidwcm9taXNlJztcbiB9XG50eXBlb2YgaW5uZXIudGhlbiE9PSdmdW5jdGlvbid8fFxuRmFpbCBgQ2Fubm90IHBhc3Mgbm9uLXByb21pc2UgdGhlbmFibGVzYDtcbmNvbnN0IHBhc3NTdHlsZVRhZz1pbm5lcltQQVNTX1NUWUxFXTtcbmlmKHBhc3NTdHlsZVRhZyE9PXVuZGVmaW5lZCl7XG5hc3NlcnQudHlwZW9mKHBhc3NTdHlsZVRhZywnc3RyaW5nJyk7XG5jb25zdCBoZWxwZXI9SGVscGVyVGFibGVbcGFzc1N0eWxlVGFnXTtcbmhlbHBlciE9PXVuZGVmaW5lZHx8XG5GYWlsIGBVbnJlY29nbml6ZWQgUGFzc1N0eWxlOiAke3EocGFzc1N0eWxlVGFnKX1gO1xuaGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuICgvKiogQHR5cGUge1Bhc3NTdHlsZX0gKi9wYXNzU3R5bGVUYWcpO1xuIH1cbmZvcihjb25zdCBoZWxwZXIgb2YgcGFzc1N0eWxlSGVscGVycyl7XG5pZihoZWxwZXIuY2FuQmVWYWxpZChpbm5lcikpe1xuaGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuIGhlbHBlci5zdHlsZU5hbWU7XG4gfVxuIH1cbnJlbW90YWJsZUhlbHBlci5hc3NlcnRWYWxpZChpbm5lcixwYXNzU3R5bGVPZlJlY3VyKTtcbnJldHVybidyZW1vdGFibGUnO1xuIH1cbmNhc2UnZnVuY3Rpb24nOntcbmlzRnJvemVuKGlubmVyKXx8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tZnJvemVuIG9iamVjdHMgbGlrZSAke2lubmVyfS4gVXNlIGhhcmRlbigpYDtcbnR5cGVvZiBpbm5lci50aGVuIT09J2Z1bmN0aW9uJ3x8XG5GYWlsIGBDYW5ub3QgcGFzcyBub24tcHJvbWlzZSB0aGVuYWJsZXNgO1xucmVtb3RhYmxlSGVscGVyLmFzc2VydFZhbGlkKGlubmVyLHBhc3NTdHlsZU9mUmVjdXIpO1xucmV0dXJuJ3JlbW90YWJsZSc7XG4gfVxuZGVmYXVsdDp7XG50aHJvdyBhc3NlcnQuZmFpbChYIGBVbnJlY29nbml6ZWQgdHlwZW9mICR7cSh0eXBlc3RyKX1gLFR5cGVFcnJvcik7XG4gfX1cblxuIH07XG5cbnJldHVybiBwYXNzU3R5bGVPZlJlY3VyKHBhc3NhYmxlKTtcbiB9O1xucmV0dXJuIGhhcmRlbihwYXNzU3R5bGVPZik7XG4gfTtcblxuLyoqXG4gKiBJZiB0aGVyZSBpcyBhbHJlYWR5IGEgYFZhdGFEYXRhYCBnbG9iYWwgY29udGFpbmluZyBhIGBwYXNzU3R5bGVPZmAsXG4gKiB0aGVuIHByZXN1bWFibHkgaXQgd2FzIGVuZG93ZWQgZm9yIHVzIGJ5IGxpdmVzbG90cywgc28gd2Ugc2hvdWxkIHVzZVxuICogYW5kIGV4cG9ydCB0aGF0IG9uZSBpbnN0ZWFkLiBPdGhlciBzb2Z0d2FyZSBtYXkgaGF2ZSBsZWZ0IGl0IGZvciB1cyBoZXJlLFxuICogYnV0IGl0IHdvdWxkIHJlcXVpcmUgd3JpdGUgYWNjZXNzIHRvIG91ciBnbG9iYWwsIG9yIHRoZSBhYmlsaXR5IHRvXG4gKiBwcm92aWRlIGVuZG93bWVudHMgdG8gb3VyIGdsb2JhbCwgYm90aCBvZiB3aGljaCBzZWVtcyBhZGVxdWF0ZSBhcyBhIHRlc3Qgb2ZcbiAqIHdoZXRoZXIgaXQgaXMgYXV0aG9yaXplZCB0byBzZXJ2ZSB0aGUgc2FtZSByb2xlIGFzIGxpdmVzbG90cy5cbiAqXG4gKiBOT1RFIEhBWkFSRDogVGhpcyB1c2UgYnkgbGl2ZXNsb3RzIGRvZXMgcmVseSBvbiBgcGFzc1N0eWxlT2ZgIGJlaW5nXG4gKiBkZXRlcm1pbmlzdGljLiBJZiBpdCBpcyBub3QsIHRoZW4gaW4gYSBsaXZlc2xvdC1saWtlIHZpcnR1YWxpemVkXG4gKiBlbnZpcm9ubWVudCwgaXQgY2FuIGJlIHVzZWQgdG8gZGV0ZWN0IEdDLlxuICpcbiAqIEB0eXBlIHtQYXNzU3R5bGVPZn1cbiAqL1xuY29uc3QgICAgICAgIHBhc3NTdHlsZU9mPVxuLyogVU5USUwgaHR0cHM6Ly9naXRodWIuY29tL2VuZG9qcy9lbmRvL2lzc3Vlcy8xNTE0Ki9cbi8qIFByZWZlcjogZ2xvYmFsVGhpcz8uVmF0RGF0YT8ucGFzc1N0eWxlT2YgfHwqL1xuZ2xvYmFsVGhpcyYmZ2xvYmFsVGhpcy5WYXREYXRhJiZnbG9iYWxUaGlzLlZhdERhdGEucGFzc1N0eWxlT2Z8fFxubWFrZVBhc3NTdHlsZU9mKFtcbkNvcHlBcnJheUhlbHBlcixcbkNvcHlSZWNvcmRIZWxwZXIsXG5UYWdnZWRIZWxwZXIsXG5FcnJvckhlbHBlcixcblJlbW90YWJsZUhlbHBlcl0pOyRo4oCNX29uY2UucGFzc1N0eWxlT2YocGFzc1N0eWxlT2YpO1xuXG5cbmNvbnN0ICAgICAgICBhc3NlcnRQYXNzYWJsZT0odmFsKT0+e1xucGFzc1N0eWxlT2YodmFsKTsvKiB0aHJvd3MgaWYgdmFsIGlzIG5vdCBhIHBhc3NhYmxlKi9cbiB9OyRo4oCNX29uY2UuYXNzZXJ0UGFzc2FibGUoYXNzZXJ0UGFzc2FibGUpO1xuaGFyZGVuKGFzc2VydFBhc3NhYmxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJwYXNzU3R5bGVPZiI6WyJwYXNzU3R5bGVPZiJdLCJhc3NlcnRQYXNzYWJsZSI6WyJhc3NlcnRQYXNzYWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAUsaJ9wyEAAMMhAAAoAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL3JlbW90YWJsZS5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiUmVtb3RhYmxlSGVscGVyIiwiYXNzZXJ0SWZhY2UiLCJnZXRJbnRlcmZhY2VPZiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLGNhbkJlTWV0aG9kLGhhc093blByb3BlcnR5T2YsUEFTU19TVFlMRSxjaGVja1RhZ1JlY29yZCxjaGVja0Z1bmN0aW9uVGFnUmVjb3JkLGlzT2JqZWN0LGdldFRhZzskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJjYW5CZU1ldGhvZFwiLCBbJGjigI1fYSA9PiAoY2FuQmVNZXRob2QgPSAkaOKAjV9hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRo4oCNX2EgPT4gKGhhc093blByb3BlcnR5T2YgPSAkaOKAjV9hKV1dLFtcIlBBU1NfU1RZTEVcIiwgWyRo4oCNX2EgPT4gKFBBU1NfU1RZTEUgPSAkaOKAjV9hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaOKAjV9hID0+IChjaGVja1RhZ1JlY29yZCA9ICRo4oCNX2EpXV0sW1wiY2hlY2tGdW5jdGlvblRhZ1JlY29yZFwiLCBbJGjigI1fYSA9PiAoY2hlY2tGdW5jdGlvblRhZ1JlY29yZCA9ICRo4oCNX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRo4oCNX2EgPT4gKGlzT2JqZWN0ID0gJGjigI1fYSldXSxbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuSW50ZXJmYWNlU3BlY30gSW50ZXJmYWNlU3BlYyAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuTWFyc2hhbEdldEludGVyZmFjZU9mfSBNYXJzaGFsR2V0SW50ZXJmYWNlT2YgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn0gUGFzc1N0eWxlSGVscGVyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZW1vdGFibGVPYmplY3R9IFJlbW90YWJsZSAqL1xuXG5jb25zdHtkZXRhaWxzOlgsRmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7aXNBcnJheX09QXJyYXk7XG5jb25zdHtcbmdldFByb3RvdHlwZU9mLFxuaXNGcm96ZW4sXG5wcm90b3R5cGU6b2JqZWN0UHJvdG90eXBlLFxuZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yc309XG5PYmplY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtJbnRlcmZhY2VTcGVjfSBpZmFjZVxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKi9cbmNvbnN0IGNoZWNrSWZhY2U9KGlmYWNlLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbnJldHVybihcbi8qIFRPRE8gb3RoZXIgcG9zc2libGUgaWZhY2VzLCBvbmNlIHdlIGhhdmUgdGhpcmQgcGFydHkgdmVyYWNpdHkqL1xuKHR5cGVvZiBpZmFjZT09PSdzdHJpbmcnfHxcbnJlamVjdCYmXG5yZWplY3QoXG5YIGBGb3Igbm93LCBpbnRlcmZhY2UgJHtpZmFjZX0gbXVzdCBiZSBhIHN0cmluZzsgdW5pbXBsZW1lbnRlZGApKSYmKFxuXG5pZmFjZT09PSdSZW1vdGFibGUnfHxcbmlmYWNlLnN0YXJ0c1dpdGgoJ0FsbGVnZWQ6ICcpfHxcbmlmYWNlLnN0YXJ0c1dpdGgoJ0RlYnVnTmFtZTogJyl8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEZvciBub3csIGlmYWNlICR7cShcbmlmYWNlKVxuIH0gbXVzdCBiZSBcIlJlbW90YWJsZVwiIG9yIGJlZ2luIHdpdGggXCJBbGxlZ2VkOiBcIiBvciBcIkRlYnVnTmFtZTogXCI7IHVuaW1wbGVtZW50ZWRgKSkpO1xuXG5cbiB9O1xuXG4vKipcbiAqIEFuIGBpZmFjZWAgbXVzdCBiZSBwdXJlLiBSaWdodCBub3cgaXQgbXVzdCBiZSBhIHN0cmluZywgd2hpY2ggaXMgcHVyZS5cbiAqIExhdGVyIHdlIGV4cGVjdCB0byBpbmNsdWRlIHNvbWUgb3RoZXIgdmFsdWVzIHRoYXQgcXVhbGlmeSBhcyBgUHVyZURhdGFgLFxuICogd2hpY2ggaXMgYSBwYXNzLWJ5LWNvcHkgc3VwZXJzdHJ1Y3R1cmUgZW5kaW5nIG9ubHkgaW4gcHJpbWl0aXZlcyBvclxuICogZW1wdHkgcGFzcy1ieS1jb3B5IGNvbXBvc2l0ZXMuIE5vIHJlbW90YWJsZXMsIHByb21pc2VzLCBvciBlcnJvcnMuXG4gKiBXZSAqYXNzdW1lKiBmb3Igbm93IHRoYXQgdGhlIHBhc3MtYnktY29weSBzdXBlcnN0cnVjdHVyZSBjb250YWlucyBub1xuICogcHJveGllcy5cbiAqXG4gKiBAcGFyYW0ge0ludGVyZmFjZVNwZWN9IGlmYWNlXG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRJZmFjZT0oaWZhY2UpPT5jaGVja0lmYWNlKGlmYWNlLGFzc2VydENoZWNrZXIpOyRo4oCNX29uY2UuYXNzZXJ0SWZhY2UoYXNzZXJ0SWZhY2UpO1xuaGFyZGVuKGFzc2VydElmYWNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge29iamVjdCB8IEZ1bmN0aW9ufSBvcmlnaW5hbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGVQcm90b09mPShvcmlnaW5hbCxjaGVjayk9PntcbmNvbnN0IHJlamVjdD0hIWNoZWNrJiYoKGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKSk7XG5pc09iamVjdChvcmlnaW5hbCl8fFxuRmFpbCBgUmVtb3RhYmxlcyBtdXN0IGJlIG9iamVjdHMgb3IgZnVuY3Rpb25zOiAke29yaWdpbmFsfWA7XG5cbi8qIEEgdmFsaWQgcmVtb3RhYmxlIG9iamVjdCBtdXN0IGluaGVyaXQgZnJvbSBhIFwidGFnIHJlY29yZFwiIC0tIGEqL1xuLyogcGxhaW4tb2JqZWN0IHByb3RvdHlwZSBjb25zaXN0aW5nIG9mIG9ubHkqL1xuLyogYSBgUEFTU19TVFlMRWAgcHJvcGVydHkgd2l0aCB2YWx1ZSBcInJlbW90YWJsZVwiIGFuZCBhIHN1aXRhYmxlIGBTeW1ib2wudG9TdHJpbmdUYWdgKi9cbi8qIHByb3BlcnR5LiBUaGUgcmVtb3RhYmxlIGNvdWxkIGluaGVyaXQgZGlyZWN0bHkgZnJvbSBzdWNoIGEgdGFnIHJlY29yZCwgb3IqL1xuLyogaXQgY291bGQgaW5oZXJpdCBmcm9tIGFub3RoZXIgdmFsaWQgcmVtb3RhYmxlLCB0aGF0IHRoZXJlZm9yZSBpdHNlbGYqL1xuLyogaW5oZXJpdHMgZGlyZWN0bHkgb3IgaW5kaXJlY3RseSBmcm9tIHN1Y2ggYSB0YWcgcmVjb3JkLiovXG4vKiovXG4vKiBUT0RPOiBJdCB3b3VsZCBiZSBuaWNlIHRvIHR5cGVkZWYgdGhpcyBzaGFwZSwgYnV0IHdlIGNhbid0IGRlY2xhcmUgYSB0eXBlKi9cbi8qIHdpdGggUEFTU19TVFlMRSBmcm9tIEpTRG9jLiovXG4vKiovXG4vKiBAdHlwZSB7eyBbUEFTU19TVFlMRV06IHN0cmluZywqL1xuLyogW1N5bWJvbC50b1N0cmluZ1RhZ106IHN0cmluZywqL1xuLyogfX0qL1xuLyoqL1xuY29uc3QgcHJvdG89Z2V0UHJvdG90eXBlT2Yob3JpZ2luYWwpO1xuaWYocHJvdG89PT1vYmplY3RQcm90b3R5cGV8fHByb3RvPT09bnVsbCl7XG5yZXR1cm4oXG5yZWplY3QmJlxucmVqZWN0KFggYFJlbW90YWJsZXMgbXVzdCBiZSBleHBsaWNpdGx5IGRlY2xhcmVkOiAke3Eob3JpZ2luYWwpfWApKTtcblxuIH1cblxuaWYodHlwZW9mIG9yaWdpbmFsPT09J29iamVjdCcpe1xuY29uc3QgcHJvdG9Qcm90bz1nZXRQcm90b3R5cGVPZihwcm90byk7XG5pZihwcm90b1Byb3RvIT09b2JqZWN0UHJvdG90eXBlJiZwcm90b1Byb3RvIT09bnVsbCl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xucmV0dXJuIGNoZWNrUmVtb3RhYmxlKHByb3RvLGNoZWNrKTtcbiB9XG5pZighY2hlY2tUYWdSZWNvcmQocHJvdG8sJ3JlbW90YWJsZScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG4gfWVsc2UgaWYodHlwZW9mIG9yaWdpbmFsPT09J2Z1bmN0aW9uJyl7XG5pZighY2hlY2tGdW5jdGlvblRhZ1JlY29yZChwcm90bywncmVtb3RhYmxlJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTp7dmFsdWU6aWZhY2V9LFxuLi4ucmVzdERlc2NzfT1cbmdldE93blByb3BlcnR5RGVzY3JpcHRvcnMocHJvdG8pO1xuXG5yZXR1cm4oXG4ob3duS2V5cyhyZXN0RGVzY3MpLmxlbmd0aD09PTB8fFxucmVqZWN0JiZcbnJlamVjdChcblggYFVuZXhwZWN0ZWQgcHJvcGVydGllcyBvbiBSZW1vdGFibGUgUHJvdG8gJHtvd25LZXlzKHJlc3REZXNjcyl9YCkpJiZcblxuY2hlY2tJZmFjZShpZmFjZSxjaGVjaykpO1xuXG4gfTtcblxuLyoqXG4gKiBLZWVwIGEgd2VhayBzZXQgb2YgY29uZmlybWVkIHJlbW90YWJsZXMgZm9yIG1hcnNoYWwgcGVyZm9ybWFuY2VcbiAqICh3aXRob3V0IHdoaWNoIHdlIHdvdWxkIGluY3VyIGEgcmVkdW5kYW50IHZlcmlmaWNhdGlvbiBpblxuICogZ2V0SW50ZXJmYWNlT2YpLlxuICogV2UgZG9uJ3QgcmVtZW1iZXIgcmVqZWN0aW9ucyBiZWNhdXNlIHRoZXkgYXJlIHBvc3NpYmxlIHRvIGNvcnJlY3RcbiAqIHdpdGggZS5nLiBgaGFyZGVuYC5cbiAqXG4gKiBAdHlwZSB7V2Vha1NldDxSZW1vdGFibGU+fVxuICovXG5jb25zdCBjb25maXJtZWRSZW1vdGFibGVzPW5ldyBXZWFrU2V0KCk7XG5cbi8qKlxuICogQHBhcmFtIHtSZW1vdGFibGV9IHZhbFxuICogQHBhcmFtIHtDaGVja2VyfSBbY2hlY2tdXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tSZW1vdGFibGU9KHZhbCxjaGVjayk9PntcbmlmKGNvbmZpcm1lZFJlbW90YWJsZXMuaGFzKHZhbCkpe1xucmV0dXJuIHRydWU7XG4gfVxuY29uc3QgcmVqZWN0PSEhY2hlY2smJigoZGV0YWlscyk9PmNoZWNrKGZhbHNlLGRldGFpbHMpKTtcbmlmKCFpc0Zyb3plbih2YWwpKXtcbnJldHVybiByZWplY3QmJnJlamVjdChYIGBjYW5ub3Qgc2VyaWFsaXplIG5vbi1mcm96ZW4gb2JqZWN0cyBsaWtlICR7dmFsfWApO1xuIH1cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZighUmVtb3RhYmxlSGVscGVyLmNhbkJlVmFsaWQodmFsLGNoZWNrKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuY29uc3QgcmVzdWx0PWNoZWNrUmVtb3RhYmxlUHJvdG9PZih2YWwsY2hlY2spO1xuaWYocmVzdWx0KXtcbmNvbmZpcm1lZFJlbW90YWJsZXMuYWRkKHZhbCk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKiogQHR5cGUge01hcnNoYWxHZXRJbnRlcmZhY2VPZn0gKi9cbmNvbnN0ICAgICAgICBnZXRJbnRlcmZhY2VPZj0odmFsKT0+e1xuaWYoXG4haXNPYmplY3QodmFsKXx8XG52YWxbUEFTU19TVFlMRV0hPT0ncmVtb3RhYmxlJ3x8XG4hY2hlY2tSZW1vdGFibGUodmFsKSlcbntcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxucmV0dXJuIGdldFRhZyh2YWwpO1xuIH07JGjigI1fb25jZS5nZXRJbnRlcmZhY2VPZihnZXRJbnRlcmZhY2VPZik7XG5oYXJkZW4oZ2V0SW50ZXJmYWNlT2YpO1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7UGFzc1N0eWxlSGVscGVyfVxuICovXG5jb25zdCAgICAgICAgUmVtb3RhYmxlSGVscGVyPWhhcmRlbih7XG5zdHlsZU5hbWU6J3JlbW90YWJsZScsXG5cbmNhbkJlVmFsaWQ6KGNhbmRpZGF0ZSxjaGVjaz11bmRlZmluZWQpPT57XG5jb25zdCByZWplY3Q9ISFjaGVjayYmKChkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscykpO1xuY29uc3QgdmFsaWRUeXBlPVxuKGlzT2JqZWN0KGNhbmRpZGF0ZSl8fFxucmVqZWN0JiZcbnJlamVjdChYIGBjYW5ub3Qgc2VyaWFsaXplIG5vbi1vYmplY3RzIGFzIFJlbW90YWJsZSAke2NhbmRpZGF0ZX1gKSkmJihcbiFpc0FycmF5KGNhbmRpZGF0ZSl8fFxucmVqZWN0JiZcbnJlamVjdChYIGBjYW5ub3Qgc2VyaWFsaXplIGFycmF5cyBhcyBSZW1vdGFibGUgJHtjYW5kaWRhdGV9YCkpO1xuaWYoIXZhbGlkVHlwZSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuXG5jb25zdCBkZXNjcz1nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5pZih0eXBlb2YgY2FuZGlkYXRlPT09J29iamVjdCcpe1xuLyogRXZlcnkgb3duIHByb3BlcnR5IChyZWdhcmRsZXNzIG9mIGVudW1lcmFiaWxpdHkpKi9cbi8qIG11c3QgaGF2ZSBhIGZ1bmN0aW9uIHZhbHVlLiovXG5yZXR1cm4gb3duS2V5cyhkZXNjcykuZXZlcnkoKGtleSk9PntcbnJldHVybihcbi8qIFR5cGVjYXN0IG5lZWRlZCBkdWUgdG8gaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy8xODYzKi9cbihoYXNPd25Qcm9wZXJ0eU9mKGRlc2NzWy8qKiBAdHlwZSB7c3RyaW5nfSAqL2tleV0sJ3ZhbHVlJyl8fFxucmVqZWN0JiZcbnJlamVjdChcblggYGNhbm5vdCBzZXJpYWxpemUgUmVtb3RhYmxlcyB3aXRoIGFjY2Vzc29ycyBsaWtlICR7cShcblN0cmluZyhrZXkpKVxuIH0gaW4gJHtjYW5kaWRhdGV9YCkpJiYoXG5cbmtleT09PVN5bWJvbC50b1N0cmluZ1RhZyYmY2hlY2tJZmFjZShjYW5kaWRhdGVba2V5XSxjaGVjayl8fFxuKGNhbkJlTWV0aG9kKGNhbmRpZGF0ZVtrZXldKXx8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgY2Fubm90IHNlcmlhbGl6ZSBSZW1vdGFibGVzIHdpdGggbm9uLW1ldGhvZHMgbGlrZSAke3EoXG5TdHJpbmcoa2V5KSlcbiB9IGluICR7Y2FuZGlkYXRlfWApKSYmKFxuXG5rZXkhPT1QQVNTX1NUWUxFfHxcbnJlamVjdCYmXG5yZWplY3QoWCBgQSBwYXNzLWJ5LXJlbW90ZSBjYW5ub3Qgc2hhZG93ICR7cShQQVNTX1NUWUxFKX1gKSkpKTtcblxuIH0pO1xuIH1lbHNlIGlmKHR5cGVvZiBjYW5kaWRhdGU9PT0nZnVuY3Rpb24nKXtcbi8qIEZhciBmdW5jdGlvbnMgY2Fubm90IGJlIG1ldGhvZHMsIGFuZCBjYW5ub3QgaGF2ZSBtZXRob2RzLiovXG4vKiBUaGV5IG11c3QgaGF2ZSBleGFjdGx5IGV4cGVjdGVkIGAubmFtZWAgYW5kIGAubGVuZ3RoYCBwcm9wZXJ0aWVzKi9cbmNvbnN0e1xubmFtZTpuYW1lRGVzYyxcbmxlbmd0aDpsZW5ndGhEZXNjLFxuLyogQHRzLWlnbm9yZSBUUyBkb2Vzbid0IGxpa2Ugc3ltYm9scyBhcyBjb21wdXRlZCBpbmRleGVzPz8qL1xuW1N5bWJvbC50b1N0cmluZ1RhZ106dG9TdHJpbmdUYWdEZXNjLFxuLi4ucmVzdERlc2NzfT1cbmRlc2NzO1xuY29uc3QgcmVzdEtleXM9b3duS2V5cyhyZXN0RGVzY3MpO1xucmV0dXJuKFxuKG5hbWVEZXNjJiZ0eXBlb2YgbmFtZURlc2MudmFsdWU9PT0nc3RyaW5nJ3x8XG5yZWplY3QmJlxucmVqZWN0KFggYEZhciBmdW5jdGlvbiBuYW1lIG11c3QgYmUgYSBzdHJpbmcsIGluICR7Y2FuZGlkYXRlfWApKSYmKFxubGVuZ3RoRGVzYyYmdHlwZW9mIGxlbmd0aERlc2MudmFsdWU9PT0nbnVtYmVyJ3x8XG5yZWplY3QmJlxucmVqZWN0KFxuWCBgRmFyIGZ1bmN0aW9uIGxlbmd0aCBtdXN0IGJlIGEgbnVtYmVyLCBpbiAke2NhbmRpZGF0ZX1gKSkmJihcblxudG9TdHJpbmdUYWdEZXNjPT09dW5kZWZpbmVkfHxcbih0eXBlb2YgdG9TdHJpbmdUYWdEZXNjLnZhbHVlPT09J3N0cmluZyd8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEZhciBmdW5jdGlvbiBAQHRvU3RyaW5nVGFnIG11c3QgYmUgYSBzdHJpbmcsIGluICR7Y2FuZGlkYXRlfWApKSYmXG5cbmNoZWNrSWZhY2UodG9TdHJpbmdUYWdEZXNjLnZhbHVlLGNoZWNrKSkmJihcbnJlc3RLZXlzLmxlbmd0aD09PTB8fFxucmVqZWN0JiZcbnJlamVjdChcblggYEZhciBmdW5jdGlvbnMgdW5leHBlY3RlZCBwcm9wZXJ0aWVzIGJlc2lkZXMgLm5hbWUgYW5kIC5sZW5ndGggJHtyZXN0S2V5c31gKSkpO1xuXG5cbiB9XG5yZXR1cm4gcmVqZWN0JiZyZWplY3QoWCBgdW5yZWNvZ25pemVkIHR5cGVvZiAke2NhbmRpZGF0ZX1gKTtcbiB9LFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlKT0+Y2hlY2tSZW1vdGFibGUoY2FuZGlkYXRlLGFzc2VydENoZWNrZXIpLFxuXG5ldmVyeTooX3Bhc3NhYmxlLF9mbik9PnRydWV9KTskaOKAjV9vbmNlLlJlbW90YWJsZUhlbHBlcihSZW1vdGFibGVIZWxwZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImFzc2VydElmYWNlIjpbImFzc2VydElmYWNlIl0sImdldEludGVyZmFjZU9mIjpbImdldEludGVyZmFjZU9mIl0sIlJlbW90YWJsZUhlbHBlciI6WyJSZW1vdGFibGVIZWxwZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAANeJOipoPAACaDwAAKwAAAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy9zYWZlLXByb21pc2UuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGUtaGVscGVycy5qcyIsIkBlbmRvL3Byb21pc2Uta2l0Il0sImV4cG9ydHMiOlsiYXNzZXJ0U2FmZVByb21pc2UiLCJpc1NhZmVQcm9taXNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGlzUHJvbWlzZSxhc3NlcnRDaGVja2VyLGhhc093blByb3BlcnR5T2Y7JGjigI1faW1wb3J0cyhbW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dLFtcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcImhhc093blByb3BlcnR5T2ZcIiwgWyRo4oCNX2EgPT4gKGhhc093blByb3BlcnR5T2YgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuXG5jb25zdHtkZXRhaWxzOlgscXVvdGU6cX09YXNzZXJ0O1xuY29uc3R7aXNGcm96ZW4sZ2V0UHJvdG90eXBlT2Z9PU9iamVjdDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbi8qKlxuICogQHBhcmFtIHtQcm9taXNlfSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBzYWZlIHByb21pc2VcbiAqL1xuY29uc3QgY2hlY2tQcm9taXNlT3duS2V5cz0ocHIsY2hlY2spPT57XG5jb25zdCByZWplY3Q9KGRldGFpbHMpPT5jaGVjayhmYWxzZSxkZXRhaWxzKTtcbmNvbnN0IGtleXM9b3duS2V5cyhwcik7XG5cbmlmKGtleXMubGVuZ3RoPT09MCl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5cbmNvbnN0IHVua25vd25LZXlzPWtleXMuZmlsdGVyKFxuKGtleSk9PnR5cGVvZiBrZXkhPT0nc3ltYm9sJ3x8IWhhc093blByb3BlcnR5T2YoUHJvbWlzZS5wcm90b3R5cGUsa2V5KSk7XG5cblxuaWYodW5rbm93bktleXMubGVuZ3RoIT09MCl7XG5yZXR1cm4gcmVqZWN0KFxuWCBgJHtwcn0gLSBNdXN0IG5vdCBoYXZlIGFueSBvd24gcHJvcGVydGllczogJHtxKHVua25vd25LZXlzKX1gKTtcblxuIH1cblxuLyoqXG4gKiBBdCB0aGUgdGltZSBvZiB0aGlzIHdyaXRpbmcsIE5vZGUncyBhc3luY19ob29rcyBjb250YWlucyB0aGVcbiAqIGZvbGxvd2luZyBjb2RlLCB3aGljaCB3ZSBjYW4gYWxzbyBzYWZlbHkgdG9sZXJhdGVcbiAqXG4gKiBgYGBqc1xuICogZnVuY3Rpb24gZGVzdHJveVRyYWNraW5nKHByb21pc2UsIHBhcmVudCkge1xuICogdHJhY2tQcm9taXNlKHByb21pc2UsIHBhcmVudCk7XG4gKiAgIGNvbnN0IGFzeW5jSWQgPSBwcm9taXNlW2FzeW5jX2lkX3N5bWJvbF07XG4gKiAgIGNvbnN0IGRlc3Ryb3llZCA9IHsgZGVzdHJveWVkOiBmYWxzZSB9O1xuICogICBwcm9taXNlW2Rlc3Ryb3llZFN5bWJvbF0gPSBkZXN0cm95ZWQ7XG4gKiAgIHJlZ2lzdGVyRGVzdHJveUhvb2socHJvbWlzZSwgYXN5bmNJZCwgZGVzdHJveWVkKTtcbiAqIH1cbiAqIGBgYFxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfHN5bWJvbH0ga2V5XG4gKi9cbmNvbnN0IGNoZWNrU2FmZUFzeW5jSG9va3NLZXk9KGtleSk9PntcbmNvbnN0IHZhbD1wcltrZXldO1xuaWYodmFsPT09dW5kZWZpbmVkfHx0eXBlb2YgdmFsPT09J251bWJlcicpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoXG50eXBlb2YgdmFsPT09J29iamVjdCcmJlxudmFsIT09bnVsbCYmXG5pc0Zyb3plbih2YWwpJiZcbmdldFByb3RvdHlwZU9mKHZhbCk9PT1PYmplY3QucHJvdG90eXBlKVxue1xuY29uc3Qgc3ViS2V5cz1vd25LZXlzKHZhbCk7XG5pZihzdWJLZXlzLmxlbmd0aD09PTApe1xucmV0dXJuIHRydWU7XG4gfVxuXG5pZihcbnN1YktleXMubGVuZ3RoPT09MSYmXG5zdWJLZXlzWzBdPT09J2Rlc3Ryb3llZCcmJlxudmFsLmRlc3Ryb3llZD09PWZhbHNlKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiByZWplY3QoXG5YIGBVbmV4cGVjdGVkIE5vZGUgYXN5bmNfaG9va3MgYWRkaXRpb25zIHRvIHByb21pc2U6ICR7cHJ9LiR7cShcblN0cmluZyhrZXkpKVxuIH0gaXMgJHt2YWx9YCk7XG5cbiB9O1xuXG5yZXR1cm4ga2V5cy5ldmVyeShjaGVja1NhZmVBc3luY0hvb2tzS2V5KTtcbiB9O1xuXG4vKipcbiAqIFVuZGVyIEhhcmRlbmVkIEpTIGEgcHJvbWlzZSBpcyBcInNhZmVcIiBpZiBpdHMgYHRoZW5gIG1ldGhvZCBjYW4gYmUgY2FsbGVkXG4gKiBzeW5jaHJvbm91c2x5IHdpdGhvdXQgZ2l2aW5nIHRoZSBwcm9taXNlIGFuIG9wcG9ydHVuaXR5IGZvciBhXG4gKiByZWVudHJhbmN5IGF0dGFjayBkdXJpbmcgdGhhdCBjYWxsLlxuICpcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9BZ29yaWMvYWdvcmljLXNkay9pc3N1ZXMvOVxuICogcmFpc2VzIHRoZSBpc3N1ZSBvZiB0ZXN0aW5nIHRoYXQgYSBzcGVjaW1lbiBpcyBhIHNhZmUgcHJvbWlzZVxuICogc3VjaCB0aGF0IHRoZSB0ZXN0IGFsc28gZG9lcyBub3QgZ2l2ZSB0aGUgc3BlY2ltZW4gYVxuICogcmVlbnRyYW5jeSBvcHBvcnR1bml0eS4gVGhhdCBpcyB3ZWxsIGJleW9uZCB0aGUgYW1iaXRpb24gaGVyZS5cbiAqIFRPRE8gVGhvdWdoIGlmIHdlIGZpZ3VyZSBvdXQgYSBuaWNlIHNvbHV0aW9uLCBpdCBtaWdodCBiZSBnb29kIHRvXG4gKiB1c2UgaXQgaGVyZSBhcyB3ZWxsLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gcHIgVGhlIHZhbHVlIHRvIGV4YW1pbmVcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtwciBpcyBQcm9taXNlfSBXaGV0aGVyIGl0IGlzIGEgc2FmZSBwcm9taXNlXG4gKi9cbmNvbnN0IGNoZWNrU2FmZVByb21pc2U9KHByLGNoZWNrKT0+e1xuY29uc3QgcmVqZWN0PShkZXRhaWxzKT0+Y2hlY2soZmFsc2UsZGV0YWlscyk7XG5yZXR1cm4oXG4oaXNGcm96ZW4ocHIpfHxyZWplY3QoWCBgJHtwcn0gLSBNdXN0IGJlIGZyb3plbmApKSYmKFxuaXNQcm9taXNlKHByKXx8cmVqZWN0KFggYCR7cHJ9IC0gTXVzdCBiZSBhIHByb21pc2VgKSkmJihcbmdldFByb3RvdHlwZU9mKHByKT09PVByb21pc2UucHJvdG90eXBlfHxcbnJlamVjdChcblggYCR7cHJ9IC0gTXVzdCBpbmhlcml0IGZyb20gUHJvbWlzZS5wcm90b3R5cGU6ICR7cShcbmdldFByb3RvdHlwZU9mKHByKSlcbiB9YCkpJiZcblxuY2hlY2tQcm9taXNlT3duS2V5cygvKiogQHR5cGUge1Byb21pc2V9ICovcHIsY2hlY2spKTtcblxuIH07XG5oYXJkZW4oY2hlY2tTYWZlUHJvbWlzZSk7XG5cbi8qKlxuICogRGV0ZXJtaW5lIGlmIHRoZSBhcmd1bWVudCBpcyBhIFByb21pc2UuXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBwciBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHJldHVybnMge3ByIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBwcm9taXNlXG4gKi9cbmNvbnN0ICAgICAgICBpc1NhZmVQcm9taXNlPShwcik9PmNoZWNrU2FmZVByb21pc2UocHIsKHgpPT54KTskaOKAjV9vbmNlLmlzU2FmZVByb21pc2UoaXNTYWZlUHJvbWlzZSk7XG5oYXJkZW4oaXNTYWZlUHJvbWlzZSk7XG5cbmNvbnN0ICAgICAgICBhc3NlcnRTYWZlUHJvbWlzZT0ocHIpPT5jaGVja1NhZmVQcm9taXNlKHByLGFzc2VydENoZWNrZXIpOyRo4oCNX29uY2UuYXNzZXJ0U2FmZVByb21pc2UoYXNzZXJ0U2FmZVByb21pc2UpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImlzU2FmZVByb21pc2UiOlsiaXNTYWZlUHJvbWlzZSJdLCJhc3NlcnRTYWZlUHJvbWlzZSI6WyJhc3NlcnRTYWZlUHJvbWlzZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADHH9VQRxIAAEcSAAAlAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL3N5bWJvbC5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOlsiYXNzZXJ0UGFzc2FibGVTeW1ib2wiLCJpc1Bhc3NhYmxlU3ltYm9sIiwibmFtZUZvclBhc3NhYmxlU3ltYm9sIiwicGFzc2FibGVTeW1ib2xGb3JOYW1lIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuXG4vKipcbiAqIFRoZSB3ZWxsIGtub3duIHN5bWJvbHMgYXJlIHN0YXRpYyBzeW1ib2wgdmFsdWVzIG9uIHRoZSBgU3ltYm9sYCBjb25zdHJ1Y3Rvci5cbiAqL1xuY29uc3Qgd2VsbEtub3duU3ltYm9sTmFtZXM9bmV3IE1hcChcbm93bktleXMoU3ltYm9sKS5cbmZpbHRlcihcbihuYW1lKT0+dHlwZW9mIG5hbWU9PT0nc3RyaW5nJyYmdHlwZW9mIFN5bWJvbFtuYW1lXT09PSdzeW1ib2wnKS5cblxuZmlsdGVyKChuYW1lKT0+e1xuLyogQHRzLWV4cGVjdC1lcnJvciBJdCBkb2Vzbid0IGtub3cgbmFtZSBjYW5ub3QgYmUgYSBzeW1ib2wqL1xuIW5hbWUuc3RhcnRzV2l0aCgnQEAnKXx8XG5GYWlsIGBEaWQgbm90IGV4cGVjdCBTeW1ib2wgdG8gaGF2ZSBhIHN5bWJvbC12YWx1ZWQgcHJvcGVydHkgbmFtZSBzdGFydGluZyB3aXRoIFwiQEBcIiAke3EoXG5uYW1lKVxuIH1gO1xucmV0dXJuIHRydWU7XG4gfSlcbi8qIEB0cy1pZ25vcmUgSXQgZG9lc24ndCBrbm93IG5hbWUgY2Fubm90IGJlIGEgc3ltYm9sKi8uXG5tYXAoKG5hbWUpPT5bU3ltYm9sW25hbWVdLCBgQEAke25hbWV9YF0pKTtcblxuXG4vKipcbiAqIFRoZSBwYXNzYWJsZSBzeW1ib2xzIGFyZSB0aGUgd2VsbCBrbm93biBzeW1ib2xzICh0aGUgc3ltYm9sIHZhbHVlc1xuICogb2Ygc3RhdGljIHByb3BlcnRpZXMgb2YgdGhlIGBTeW1ib2xgIGNvbnN0cnVjdG9yKSBhbmQgdGhlIHJlZ2lzdGVyZWRcbiAqIHN5bWJvbHMuXG4gKlxuICogQHBhcmFtIHthbnl9IHN5bVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc1Bhc3NhYmxlU3ltYm9sPShzeW0pPT5cbnR5cGVvZiBzeW09PT0nc3ltYm9sJyYmKFxudHlwZW9mIFN5bWJvbC5rZXlGb3Ioc3ltKT09PSdzdHJpbmcnfHx3ZWxsS25vd25TeW1ib2xOYW1lcy5oYXMoc3ltKSk7JGjigI1fb25jZS5pc1Bhc3NhYmxlU3ltYm9sKGlzUGFzc2FibGVTeW1ib2wpO1xuaGFyZGVuKGlzUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0UGFzc2FibGVTeW1ib2w9KHN5bSk9PlxuaXNQYXNzYWJsZVN5bWJvbChzeW0pfHxcbkZhaWwgYE9ubHkgcmVnaXN0ZXJlZCBzeW1ib2xzIG9yIHdlbGwta25vd24gc3ltYm9scyBhcmUgcGFzc2FibGU6ICR7cShzeW0pfWA7JGjigI1fb25jZS5hc3NlcnRQYXNzYWJsZVN5bWJvbChhc3NlcnRQYXNzYWJsZVN5bWJvbCk7XG5oYXJkZW4oYXNzZXJ0UGFzc2FibGVTeW1ib2wpO1xuXG4vKipcbiAqIElmIGBzeW1gIGlzIGEgcGFzc2FibGUgc3ltYm9sLCByZXR1cm4gYSBzdHJpbmcgdGhhdCB1bmlxdWVseSBpZGVudGlmaWVzIHRoaXNcbiAqIHN5bWJvbC4gSWYgYHN5bWAgaXMgYSBub24tcGFzc2FibGUgc3ltYm9sLCByZXR1cm4gYHVuZGVmaW5lZGAuXG4gKlxuICogVGhlIHBhc3NhYmxlIHN5bWJvbHMgYXJlIHRoZSB3ZWxsIGtub3duIHN5bWJvbHMgKHRoZSBzeW1ib2wgdmFsdWVzXG4gKiBvZiBzdGF0aWMgcHJvcGVydGllcyBvZiB0aGUgYFN5bWJvbGAgY29uc3RydWN0b3IpIGFuZCB0aGUgcmVnaXN0ZXJlZFxuICogc3ltYm9scy4gU2luY2UgdGhlIHJlZ2lzdHJhdGlvbiBzdHJpbmcgb2YgYSByZWdpc3RlcmVkIHN5bWJvbCBjYW4gYmUgYW55XG4gKiBzdHJpbmcsIGlmIHdlIHNpbXBseSB1c2VkIHRoYXQgdG8gaWRlbnRpZnkgdGhvc2Ugc3ltYm9scywgdGhlcmUgd291bGQgbm90XG4gKiBiZSBhbnkgcmVtYWluaW5nIHN0cmluZ3MgbGVmdCBvdmVyIHRvIGlkZW50aWZ5IHRoZSB3ZWxsLWtub3duIHN5bWJvbHMuXG4gKiBJbnN0ZWFkLCB3ZSByZXNlcnZlIHN0cmluZ3MgYmVnaW5uaW5nIHdpdGggYFwiQEBcImAgZm9yIHB1cnBvc2VzIG9mIHRoaXNcbiAqIGVuY29kaW5nLiBXZSBpZGVudGlmeSBhIHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXMgYFN5bWJvbC5pdGVyYXRvcmBcbiAqIGJ5IHByZWZpeGluZyB0aGUgcHJvcGVydHkgbmFtZSB3aXRoIGBcIkBAXCJgLCBzdWNoIGFzIGBcIkBAaXRlcmF0b3JcImAuXG4gKiBGb3IgcmVnaXN0ZXJlZCBzeW1ib2xzIHdob3NlIG5hbWUgaGFwcGVucyB0byBiZWdpbiB3aXRoIGBcIkBAXCJgLCBzdWNoXG4gKiBhcyBgU3ltYm9sLmZvcignQEBpdGVyYXRvcicpYCBvciBgU3ltYm9sLmZvcignQEBmb28nKWAsIHdlIGlkZW50aWZ5XG4gKiB0aGVtIGJ5IHByZWZpeGluZyB0aGVtIHdpdGggYW4gZXh0cmEgYFwiQEBcImAsIHN1Y2ggYXNcbiAqIGBcIkBAQEBpdGVyYXRvclwiYCBvciBgXCJAQEBAZm9vXCJgLiAoVGhpcyBpcyB0aGUgSGlsYmVydCBIb3RlbCBlbmNvZGluZ1xuICogdGVjaG5pcXVlLilcbiAqXG4gKiBAcGFyYW0ge3N5bWJvbH0gc3ltXG4gKiBAcmV0dXJucyB7c3RyaW5nPX1cbiAqL1xuY29uc3QgICAgICAgIG5hbWVGb3JQYXNzYWJsZVN5bWJvbD0oc3ltKT0+e1xuY29uc3QgbmFtZT1TeW1ib2wua2V5Rm9yKHN5bSk7XG5pZihuYW1lPT09dW5kZWZpbmVkKXtcbnJldHVybiB3ZWxsS25vd25TeW1ib2xOYW1lcy5nZXQoc3ltKTtcbiB9XG5pZihuYW1lLnN0YXJ0c1dpdGgoJ0BAJykpe1xucmV0dXJuIGBAQCR7bmFtZX1gO1xuIH1cbnJldHVybiBuYW1lO1xuIH07JGjigI1fb25jZS5uYW1lRm9yUGFzc2FibGVTeW1ib2wobmFtZUZvclBhc3NhYmxlU3ltYm9sKTtcbmhhcmRlbihuYW1lRm9yUGFzc2FibGVTeW1ib2wpO1xuXG5jb25zdCBBdEF0UHJlZml4UGF0dGVybj0vXkBAKC4qKSQvO1xuaGFyZGVuKEF0QXRQcmVmaXhQYXR0ZXJuKTtcblxuLyoqXG4gKiBJZiBgbmFtZWAgaXMgYSBzdHJpbmcgdGhhdCBjb3VsZCBoYXZlIGJlZW4gcHJvZHVjZWQgYnlcbiAqIGBuYW1lRm9yUGFzc2FibGVTeW1ib2xgLCByZXR1cm4gdGhlIHN5bWJvbCBhcmd1bWVudCBpdCB3YXMgcHJvZHVjZWQgdG9cbiAqIHJlcHJlc2VudC5cbiAqXG4gKiAgICBJZiBgbmFtZWAgZG9lcyBub3QgYmVnaW4gd2l0aCBgXCJAQFwiYCwgdGhlbiBqdXN0IHRoZSBjb3JyZXNwb25kaW5nXG4gKiAgICAgIHJlZ2lzdGVyZWQgc3ltYm9sLCBgU3ltYm9sLmZvcihuYW1lKWAuXG4gKiAgICBJZiBgbmFtZWAgaXMgYFwiQEBcImAgZm9sbG93ZWQgYnkgYSB3ZWxsIGtub3duIHN5bWJvbCdzIHByb3BlcnR5IG5hbWUgb25cbiAqICAgICAgYFN5bWJvbGAgc3VjaCBgXCJAQGl0ZXJhdG9yXCIsIHJldHVybiB0aGF0IHdlbGwga25vd24gc3ltYm9sIHN1Y2ggYXNcbiAqICAgICAgYFN5bWJvbC5pdGVyYXRvcmBcbiAqICAgIElmIGBuYW1lYCBiZWdpbnMgd2l0aCBgXCJAQEBAXCJgIGl0IGVuY29kZXMgdGhlIHJlZ2lzdGVyZWQgc3ltYm9sIHdob3NlXG4gKiAgICAgIG5hbWUgYmVnaW5zIHdpdGggYFwiQEBcImAgaW5zdGVhZC5cbiAqICAgIE90aGVyd2lzZSwgaWYgbmFtZSBiZWdpbnMgd2l0aCBgXCJAQFwiYCBpdCBtYXkgZW5jb2RlIGEgcmVnaXN0ZXJlZCBzeW1ib2xcbiAqICAgICAgZnJvbSBhIGZ1dHVyZSB2ZXJzaW9uIG9mIEphdmFTY3JpcHQsIGJ1dCBpdCBpcyBub3Qgb25lIHdlIGNhbiBkZWNvZGVcbiAqICAgICAgeWV0LCBzbyB0aHJvdy5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICogQHJldHVybnMge3N5bWJvbD19XG4gKi9cbmNvbnN0ICAgICAgICBwYXNzYWJsZVN5bWJvbEZvck5hbWU9KG5hbWUpPT57XG5pZih0eXBlb2YgbmFtZSE9PSdzdHJpbmcnKXtcbnJldHVybiB1bmRlZmluZWQ7XG4gfVxuY29uc3QgbWF0Y2g9QXRBdFByZWZpeFBhdHRlcm4uZXhlYyhuYW1lKTtcbmlmKG1hdGNoKXtcbmNvbnN0IHN1ZmZpeD1tYXRjaFsxXTtcbmlmKHN1ZmZpeC5zdGFydHNXaXRoKCdAQCcpKXtcbnJldHVybiBTeW1ib2wuZm9yKHN1ZmZpeCk7XG4gfWVsc2V7XG5jb25zdCBzeW09U3ltYm9sW3N1ZmZpeF07XG5pZih0eXBlb2Ygc3ltPT09J3N5bWJvbCcpe1xucmV0dXJuIHN5bTtcbiB9XG5GYWlsIGBSZXNlcnZlZCBmb3Igd2VsbCBrbm93biBzeW1ib2wgJHtxKHN1ZmZpeCl9OiAke3EobmFtZSl9YDtcbiB9XG4gfVxucmV0dXJuIFN5bWJvbC5mb3IobmFtZSk7XG4gfTskaOKAjV9vbmNlLnBhc3NhYmxlU3ltYm9sRm9yTmFtZShwYXNzYWJsZVN5bWJvbEZvck5hbWUpO1xuaGFyZGVuKHBhc3NhYmxlU3ltYm9sRm9yTmFtZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNQYXNzYWJsZVN5bWJvbCI6WyJpc1Bhc3NhYmxlU3ltYm9sIl0sImFzc2VydFBhc3NhYmxlU3ltYm9sIjpbImFzc2VydFBhc3NhYmxlU3ltYm9sIl0sIm5hbWVGb3JQYXNzYWJsZVN5bWJvbCI6WyJuYW1lRm9yUGFzc2FibGVTeW1ib2wiXSwicGFzc2FibGVTeW1ib2xGb3JOYW1lIjpbInBhc3NhYmxlU3ltYm9sRm9yTmFtZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAlvFz7/QcAAP0HAAAlAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL3RhZ2dlZC5qc3siaW1wb3J0cyI6WyIuL3Bhc3NTdHlsZS1oZWxwZXJzLmpzIl0sImV4cG9ydHMiOlsiVGFnZ2VkSGVscGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IGFzc2VydENoZWNrZXIsY2hlY2tUYWdSZWNvcmQsUEFTU19TVFlMRSxjaGVja05vcm1hbFByb3BlcnR5LGNoZWNrUGFzc1N0eWxlOyRo4oCNX2ltcG9ydHMoW1tcIi4vcGFzc1N0eWxlLWhlbHBlcnMuanNcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcImNoZWNrVGFnUmVjb3JkXCIsIFskaOKAjV9hID0+IChjaGVja1RhZ1JlY29yZCA9ICRo4oCNX2EpXV0sW1wiUEFTU19TVFlMRVwiLCBbJGjigI1fYSA9PiAoUEFTU19TVFlMRSA9ICRo4oCNX2EpXV0sW1wiY2hlY2tOb3JtYWxQcm9wZXJ0eVwiLCBbJGjigI1fYSA9PiAoY2hlY2tOb3JtYWxQcm9wZXJ0eSA9ICRo4oCNX2EpXV0sW1wiY2hlY2tQYXNzU3R5bGVcIiwgWyRo4oCNX2EgPT4gKGNoZWNrUGFzc1N0eWxlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5jb25zdHtGYWlsfT1hc3NlcnQ7XG5jb25zdHtvd25LZXlzfT1SZWZsZWN0O1xuY29uc3R7Z2V0T3duUHJvcGVydHlEZXNjcmlwdG9yc309T2JqZWN0O1xuXG4vKipcbiAqXG4gKiBAdHlwZSB7WGltcG9ydCgnLi9pbnRlcm5hbC10eXBlcy5qcycpLlBhc3NTdHlsZUhlbHBlcn1cbiAqL1xuY29uc3QgICAgICAgIFRhZ2dlZEhlbHBlcj1oYXJkZW4oe1xuc3R5bGVOYW1lOid0YWdnZWQnLFxuXG5jYW5CZVZhbGlkOihjYW5kaWRhdGUsY2hlY2s9dW5kZWZpbmVkKT0+XG5jaGVja1Bhc3NTdHlsZShjYW5kaWRhdGUsJ3RhZ2dlZCcsY2hlY2spLFxuXG5hc3NlcnRWYWxpZDooY2FuZGlkYXRlLHBhc3NTdHlsZU9mUmVjdXIpPT57XG5jaGVja1RhZ1JlY29yZChjYW5kaWRhdGUsJ3RhZ2dlZCcsYXNzZXJ0Q2hlY2tlcik7XG5cbi8qIFR5cGVjYXN0cyBuZWVkZWQgZHVlIHRvIGh0dHBzOi8vZ2l0aHViLmNvbS9taWNyb3NvZnQvVHlwZVNjcmlwdC9pc3N1ZXMvMTg2MyovXG5jb25zdCBwYXNzU3R5bGVLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1BBU1NfU1RZTEU7XG5jb25zdCB0YWdLZXk9LyoqIEB0eXBlIHt1bmtub3dufSAqL1N5bWJvbC50b1N0cmluZ1RhZztcbmNvbnN0e1xuLyogY2hlY2tUYWdSZWNvcmQgYWxyZWFkeSB2ZXJpZmllZCBQQVNTX1NUWUxFIGFuZCBTeW1ib2wudG9TdHJpbmdUYWcgb3duIGRhdGEgcHJvcGVydGllcy4qL1xuWy8qKiBAdHlwZSB7c3RyaW5nfSAqL3Bhc3NTdHlsZUtleV06X3Bhc3NTdHlsZURlc2MsXG5bLyoqIEB0eXBlIHtzdHJpbmd9ICovdGFnS2V5XTpfbGFiZWxEZXNjLFxucGF5bG9hZDpfcGF5bG9hZERlc2MsLyogdmFsdWUgY2hlY2tlZCBieSByZWN1cnNpdmUgd2FsayBhdCB0aGUgZW5kKi9cbi4uLnJlc3REZXNjc309XG5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzKGNhbmRpZGF0ZSk7XG5vd25LZXlzKHJlc3REZXNjcykubGVuZ3RoPT09MHx8XG5GYWlsIGBVbmV4cGVjdGVkIHByb3BlcnRpZXMgb24gdGFnZ2VkIHJlY29yZCAke293bktleXMocmVzdERlc2NzKX1gO1xuXG5jaGVja05vcm1hbFByb3BlcnR5KGNhbmRpZGF0ZSwncGF5bG9hZCcsdHJ1ZSxhc3NlcnRDaGVja2VyKTtcblxuLyogUmVjdXJzaXZlbHkgdmFsaWRhdGUgdGhhdCBlYWNoIG1lbWJlciBpcyBwYXNzYWJsZS4qL1xucGFzc1N0eWxlT2ZSZWN1cihjYW5kaWRhdGUucGF5bG9hZCk7XG4gfX0pOyRo4oCNX29uY2UuVGFnZ2VkSGVscGVyKFRhZ2dlZEhlbHBlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiVGFnZ2VkSGVscGVyIjpbIlRhZ2dlZEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAB6oH5oEg0AABINAAApAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiLi9wYXNzU3R5bGVPZi5qcyJdLCJleHBvcnRzIjpbImFzc2VydENvcHlBcnJheSIsImFzc2VydFJlY29yZCIsImFzc2VydFJlbW90YWJsZSIsImlzQ29weUFycmF5IiwiaXNSZWNvcmQiLCJpc1JlbW90YWJsZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBwYXNzU3R5bGVPZjskaOKAjV9pbXBvcnRzKFtbXCIuL3Bhc3NTdHlsZU9mLmpzXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUGFzc2FibGV9IFBhc3NhYmxlICovXG4vKiogQHRlbXBsYXRlIFQgQHR5cGVkZWYge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Db3B5QXJyYXk8VD59IENvcHlBcnJheSAqL1xuLyoqIEB0ZW1wbGF0ZSBUIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ29weVJlY29yZDxUPn0gQ29weVJlY29yZCAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVtb3RhYmxlT2JqZWN0fSBSZW1vdGFibGUgKi9cblxuY29uc3R7RmFpbCxxdW90ZTpxfT1hc3NlcnQ7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIEFLQSBhIFwiY29weUFycmF5XCJcbiAqIGluIEBlbmRvL21hcnNoYWwgdGVybXNcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBhcnJcbiAqIEByZXR1cm5zIHthcnIgaXMgQ29weUFycmF5PGFueT59XG4gKi9cbmNvbnN0IGlzQ29weUFycmF5PShhcnIpPT5wYXNzU3R5bGVPZihhcnIpPT09J2NvcHlBcnJheSc7JGjigI1fb25jZS5pc0NvcHlBcnJheShpc0NvcHlBcnJheSk7XG5oYXJkZW4oaXNDb3B5QXJyYXkpO1xuXG4vKipcbiAqIENoZWNrIHdoZXRoZXIgdGhlIGFyZ3VtZW50IGlzIGEgcGFzcy1ieS1jb3B5IHJlY29yZCwgQUtBIGFcbiAqIFwiY29weVJlY29yZFwiIGluIEBlbmRvL21hcnNoYWwgdGVybXNcbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZWNvcmRcbiAqIEByZXR1cm5zIHtyZWNvcmQgaXMgQ29weVJlY29yZDxhbnk+fVxuICovXG5jb25zdCBpc1JlY29yZD0ocmVjb3JkKT0+cGFzc1N0eWxlT2YocmVjb3JkKT09PSdjb3B5UmVjb3JkJzskaOKAjV9vbmNlLmlzUmVjb3JkKGlzUmVjb3JkKTtcbmhhcmRlbihpc1JlY29yZCk7XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB0aGUgYXJndW1lbnQgaXMgYSByZW1vdGFibGUuXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVtb3RhYmxlXG4gKiBAcmV0dXJucyB7cmVtb3RhYmxlIGlzIFJlbW90YWJsZX1cbiAqL1xuY29uc3QgaXNSZW1vdGFibGU9KHJlbW90YWJsZSk9PnBhc3NTdHlsZU9mKHJlbW90YWJsZSk9PT0ncmVtb3RhYmxlJzskaOKAjV9vbmNlLmlzUmVtb3RhYmxlKGlzUmVtb3RhYmxlKTtcbmhhcmRlbihpc1JlbW90YWJsZSk7XG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydEFycmF5XG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBhcnJheVxuICogQHBhcmFtIHtzdHJpbmc9fSBvcHROYW1lT2ZBcnJheVxuICogQHJldHVybnMge2Fzc2VydHMgYXJyYXkgaXMgQ29weUFycmF5PGFueT59XG4gKi9cblxuLyoqIEB0eXBlIHtBc3NlcnRBcnJheX0gKi9cbmNvbnN0IGFzc2VydENvcHlBcnJheT0oYXJyYXksb3B0TmFtZU9mQXJyYXk9J0FsbGVnZWQgYXJyYXknKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKGFycmF5KTtcbnBhc3NTdHlsZT09PSdjb3B5QXJyYXknfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZBcnJheSl9ICR7YXJyYXl9IG11c3QgYmUgYSBwYXNzLWJ5LWNvcHkgYXJyYXksIG5vdCAke3EoXG5wYXNzU3R5bGUpXG4gfWA7XG4gfTskaOKAjV9vbmNlLmFzc2VydENvcHlBcnJheShhc3NlcnRDb3B5QXJyYXkpO1xuaGFyZGVuKGFzc2VydENvcHlBcnJheSk7XG5cbi8qKlxuICogQGNhbGxiYWNrIEFzc2VydFJlY29yZFxuICogQHBhcmFtIHtQYXNzYWJsZX0gcmVjb3JkXG4gKiBAcGFyYW0ge3N0cmluZz19IG9wdE5hbWVPZlJlY29yZFxuICogQHJldHVybnMge2Fzc2VydHMgcmVjb3JkIGlzIENvcHlSZWNvcmQ8YW55Pn1cbiAqL1xuXG4vKiogQHR5cGUge0Fzc2VydFJlY29yZH0gKi9cbmNvbnN0IGFzc2VydFJlY29yZD0ocmVjb3JkLG9wdE5hbWVPZlJlY29yZD0nQWxsZWdlZCByZWNvcmQnKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHJlY29yZCk7XG5wYXNzU3R5bGU9PT0nY29weVJlY29yZCd8fFxuRmFpbCBgJHtxKG9wdE5hbWVPZlJlY29yZCl9ICR7cmVjb3JkfSBtdXN0IGJlIGEgcGFzcy1ieS1jb3B5IHJlY29yZCwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0UmVjb3JkKGFzc2VydFJlY29yZCk7XG5oYXJkZW4oYXNzZXJ0UmVjb3JkKTtcblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0UmVtb3RhYmxlXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSByZW1vdGFibGVcbiAqIEBwYXJhbSB7c3RyaW5nPX0gb3B0TmFtZU9mUmVtb3RhYmxlXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyByZW1vdGFibGUgaXMgUmVtb3RhYmxlfVxuICovXG5cbi8qKiBAdHlwZSB7QXNzZXJ0UmVtb3RhYmxlfSAqL1xuY29uc3QgYXNzZXJ0UmVtb3RhYmxlPShcbnJlbW90YWJsZSxcbm9wdE5hbWVPZlJlbW90YWJsZT0nQWxsZWdlZCByZW1vdGFibGUnKT0+XG57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmVtb3RhYmxlKTtcbnBhc3NTdHlsZT09PSdyZW1vdGFibGUnfHxcbkZhaWwgYCR7cShvcHROYW1lT2ZSZW1vdGFibGUpfSAke3JlbW90YWJsZX0gbXVzdCBiZSBhIHJlbW90YWJsZSwgbm90ICR7cShcbnBhc3NTdHlsZSlcbiB9YDtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0UmVtb3RhYmxlKGFzc2VydFJlbW90YWJsZSk7XG5oYXJkZW4oYXNzZXJ0UmVtb3RhYmxlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJpc0NvcHlBcnJheSI6WyJpc0NvcHlBcnJheSJdLCJpc1JlY29yZCI6WyJpc1JlY29yZCJdLCJpc1JlbW90YWJsZSI6WyJpc1JlbW90YWJsZSJdLCJhc3NlcnRDb3B5QXJyYXkiOlsiYXNzZXJ0Q29weUFycmF5Il0sImFzc2VydFJlY29yZCI6WyJhc3NlcnRSZWNvcmQiXSwiYXNzZXJ0UmVtb3RhYmxlIjpbImFzc2VydFJlbW90YWJsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACYGTuzNAEAADQBAAAkAAAAQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL3R5cGVzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAALCcQn7iCgAA4goAAB4AAABAZW5kby9wYXR0ZXJucy12MC4yLjIvaW5kZXguanN7ImltcG9ydHMiOlsiLi9zcmMva2V5cy9jaGVja0tleS5qcyIsIi4vc3JjL2tleXMvY29tcGFyZUtleXMuanMiLCIuL3NyYy9rZXlzL2NvcHlCYWcuanMiLCIuL3NyYy9rZXlzL2NvcHlTZXQuanMiLCIuL3NyYy9rZXlzL21lcmdlLWJhZy1vcGVyYXRvcnMuanMiLCIuL3NyYy9rZXlzL21lcmdlLXNldC1vcGVyYXRvcnMuanMiLCIuL3NyYy9wYXR0ZXJucy9wYXR0ZXJuTWF0Y2hlcnMuanMiLCIuL3NyYy90eXBlcy5qcyIsIi4vc3JjL3V0aWxzLmpzIl0sImV4cG9ydHMiOlsiYXNzZXJ0S2V5IiwiYXNzZXJ0S2V5IiwiYmFnQ29tcGFyZSIsImJhZ0NvbXBhcmUiLCJlbGVtZW50c0lzRGlzam9pbnQiLCJlbGVtZW50c0lzRGlzam9pbnQiLCJnZXRSYW5rQ292ZXIiLCJnZXRSYW5rQ292ZXIiLCJrZXlMVCIsImtleUxUIiwib2JqZWN0TWFwIiwib2JqZWN0TWFwIixudWxsLG51bGxdLCJyZWV4cG9ydHMiOlsiLi9zcmMvdHlwZXMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3NyYy9rZXlzL2NoZWNrS2V5LmpzXCIsIFtdXSxbXCIuL3NyYy9rZXlzL2NvcHlTZXQuanNcIiwgW11dLFtcIi4vc3JjL2tleXMvY29weUJhZy5qc1wiLCBbXV0sW1wiLi9zcmMva2V5cy9jb21wYXJlS2V5cy5qc1wiLCBbXV0sW1wiLi9zcmMva2V5cy9tZXJnZS1zZXQtb3BlcmF0b3JzLmpzXCIsIFtdXSxbXCIuL3NyYy9rZXlzL21lcmdlLWJhZy1vcGVyYXRvcnMuanNcIiwgW11dLFtcIi4vc3JjL3BhdHRlcm5zL3BhdHRlcm5NYXRjaGVycy5qc1wiLCBbXV0sW1wiLi9zcmMvdXRpbHMuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7Ii4vc3JjL2tleXMvY2hlY2tLZXkuanMiOltbImlzS2V5IiwiaXNLZXkiXSxbImFzc2VydEtleSIsImFzc2VydEtleSJdLFsiYXNzZXJ0U2NhbGFyS2V5IiwiYXNzZXJ0U2NhbGFyS2V5Il0sWyJtYWtlQ29weVNldCIsIm1ha2VDb3B5U2V0Il0sWyJnZXRDb3B5U2V0S2V5cyIsImdldENvcHlTZXRLZXlzIl0sWyJtYWtlQ29weUJhZyIsIm1ha2VDb3B5QmFnIl0sWyJtYWtlQ29weUJhZ0Zyb21FbGVtZW50cyIsIm1ha2VDb3B5QmFnRnJvbUVsZW1lbnRzIl0sWyJnZXRDb3B5QmFnRW50cmllcyIsImdldENvcHlCYWdFbnRyaWVzIl0sWyJtYWtlQ29weU1hcCIsIm1ha2VDb3B5TWFwIl0sWyJnZXRDb3B5TWFwRW50cmllcyIsImdldENvcHlNYXBFbnRyaWVzIl1dLCIuL3NyYy9rZXlzL2NvcHlTZXQuanMiOltbImNvZXJjZVRvRWxlbWVudHMiLCJjb2VyY2VUb0VsZW1lbnRzIl1dLCIuL3NyYy9rZXlzL2NvcHlCYWcuanMiOltbImNvZXJjZVRvQmFnRW50cmllcyIsImNvZXJjZVRvQmFnRW50cmllcyJdXSwiLi9zcmMva2V5cy9jb21wYXJlS2V5cy5qcyI6W1siY29tcGFyZUtleXMiLCJjb21wYXJlS2V5cyJdLFsia2V5TFQiLCJrZXlMVCJdLFsia2V5TFRFIiwia2V5TFRFIl0sWyJrZXlFUSIsImtleUVRIl0sWyJrZXlHVEUiLCJrZXlHVEUiXSxbImtleUdUIiwia2V5R1QiXV0sIi4vc3JjL2tleXMvbWVyZ2Utc2V0LW9wZXJhdG9ycy5qcyI6W1siZWxlbWVudHNJc1N1cGVyc2V0IiwiZWxlbWVudHNJc1N1cGVyc2V0Il0sWyJlbGVtZW50c0lzRGlzam9pbnQiLCJlbGVtZW50c0lzRGlzam9pbnQiXSxbImVsZW1lbnRzQ29tcGFyZSIsImVsZW1lbnRzQ29tcGFyZSJdLFsiZWxlbWVudHNVbmlvbiIsImVsZW1lbnRzVW5pb24iXSxbImVsZW1lbnRzRGlzam9pbnRVbmlvbiIsImVsZW1lbnRzRGlzam9pbnRVbmlvbiJdLFsiZWxlbWVudHNJbnRlcnNlY3Rpb24iLCJlbGVtZW50c0ludGVyc2VjdGlvbiJdLFsiZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0IiwiZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0Il0sWyJzZXRJc1N1cGVyc2V0Iiwic2V0SXNTdXBlcnNldCJdLFsic2V0SXNEaXNqb2ludCIsInNldElzRGlzam9pbnQiXSxbInNldENvbXBhcmUiLCJzZXRDb21wYXJlIl0sWyJzZXRVbmlvbiIsInNldFVuaW9uIl0sWyJzZXREaXNqb2ludFVuaW9uIiwic2V0RGlzam9pbnRVbmlvbiJdLFsic2V0SW50ZXJzZWN0aW9uIiwic2V0SW50ZXJzZWN0aW9uIl0sWyJzZXREaXNqb2ludFN1YnRyYWN0Iiwic2V0RGlzam9pbnRTdWJ0cmFjdCJdXSwiLi9zcmMva2V5cy9tZXJnZS1iYWctb3BlcmF0b3JzLmpzIjpbWyJiYWdJc1N1cGVyYmFnIiwiYmFnSXNTdXBlcmJhZyJdLFsiYmFnQ29tcGFyZSIsImJhZ0NvbXBhcmUiXSxbImJhZ1VuaW9uIiwiYmFnVW5pb24iXSxbImJhZ0ludGVyc2VjdGlvbiIsImJhZ0ludGVyc2VjdGlvbiJdLFsiYmFnRGlzam9pbnRTdWJ0cmFjdCIsImJhZ0Rpc2pvaW50U3VidHJhY3QiXV0sIi4vc3JjL3BhdHRlcm5zL3BhdHRlcm5NYXRjaGVycy5qcyI6W1siTSIsIk0iXSxbImdldFJhbmtDb3ZlciIsImdldFJhbmtDb3ZlciJdLFsiaXNQYXR0ZXJuIiwiaXNQYXR0ZXJuIl0sWyJhc3NlcnRQYXR0ZXJuIiwiYXNzZXJ0UGF0dGVybiJdLFsibWF0Y2hlcyIsIm1hdGNoZXMiXSxbIm11c3RNYXRjaCIsIm11c3RNYXRjaCJdXSwiLi9zcmMvdXRpbHMuanMiOltbImxpc3REaWZmZXJlbmNlIiwibGlzdERpZmZlcmVuY2UiXSxbIm9iamVjdE1hcCIsIm9iamVjdE1hcCJdXX0sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAyxcZ4KRGAACkRgAAKgAAAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMva2V5cy9jaGVja0tleS5qc3siaW1wb3J0cyI6WyIuLi91dGlscy5qcyIsIi4vY29weUJhZy5qcyIsIi4vY29weVNldC5qcyIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJhc3NlcnRDb3B5QmFnIiwiYXNzZXJ0Q29weU1hcCIsImFzc2VydENvcHlTZXQiLCJhc3NlcnRLZXkiLCJhc3NlcnRQcmltaXRpdmVLZXkiLCJhc3NlcnRTY2FsYXJLZXkiLCJjaGVja0NvcHlCYWciLCJjaGVja0NvcHlNYXAiLCJjaGVja0NvcHlTZXQiLCJjaGVja0tleSIsImNoZWNrU2NhbGFyS2V5IiwiY29weU1hcEtleVNldCIsImV2ZXJ5Q29weUJhZ0VudHJ5IiwiZXZlcnlDb3B5TWFwS2V5IiwiZXZlcnlDb3B5TWFwVmFsdWUiLCJldmVyeUNvcHlTZXRLZXkiLCJnZXRDb3B5QmFnRW50cmllcyIsImdldENvcHlNYXBFbnRyaWVzIiwiZ2V0Q29weU1hcEtleXMiLCJnZXRDb3B5TWFwVmFsdWVzIiwiZ2V0Q29weVNldEtleXMiLCJpc0NvcHlCYWciLCJpc0NvcHlNYXAiLCJpc0NvcHlTZXQiLCJpc0tleSIsImlzUHJpbWl0aXZlS2V5IiwiaXNTY2FsYXJLZXkiLCJtYWtlQ29weUJhZyIsIm1ha2VDb3B5QmFnRnJvbUVsZW1lbnRzIiwibWFrZUNvcHlNYXAiLCJtYWtlQ29weVNldCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLGFzc2VydFBhc3NhYmxlLEZhcixnZXRUYWcsaXNPYmplY3QsbWFrZVRhZ2dlZCxwYXNzU3R5bGVPZixjb21wYXJlQW50aVJhbmssbWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQsc29ydEJ5UmFuayxpZGVudENoZWNrZXIsY2hlY2tFbGVtZW50cyxtYWtlU2V0T2ZFbGVtZW50cyxjaGVja0JhZ0VudHJpZXMsbWFrZUJhZ09mRW50cmllczskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJhc3NlcnRQYXNzYWJsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UGFzc2FibGUgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXSxbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV0sW1wiaXNPYmplY3RcIiwgWyRo4oCNX2EgPT4gKGlzT2JqZWN0ID0gJGjigI1fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaOKAjV9hID0+IChtYWtlVGFnZ2VkID0gJGjigI1fYSldXSxbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcImNvbXBhcmVBbnRpUmFua1wiLCBbJGjigI1fYSA9PiAoY29tcGFyZUFudGlSYW5rID0gJGjigI1fYSldXSxbXCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdFwiLCBbJGjigI1fYSA9PiAobWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQgPSAkaOKAjV9hKV1dLFtcInNvcnRCeVJhbmtcIiwgWyRo4oCNX2EgPT4gKHNvcnRCeVJhbmsgPSAkaOKAjV9hKV1dXV0sW1wiLi4vdXRpbHMuanNcIiwgW1tcImlkZW50Q2hlY2tlclwiLCBbJGjigI1fYSA9PiAoaWRlbnRDaGVja2VyID0gJGjigI1fYSldXV1dLFtcIi4vY29weVNldC5qc1wiLCBbW1wiY2hlY2tFbGVtZW50c1wiLCBbJGjigI1fYSA9PiAoY2hlY2tFbGVtZW50cyA9ICRo4oCNX2EpXV0sW1wibWFrZVNldE9mRWxlbWVudHNcIiwgWyRo4oCNX2EgPT4gKG1ha2VTZXRPZkVsZW1lbnRzID0gJGjigI1fYSldXV1dLFtcIi4vY29weUJhZy5qc1wiLCBbW1wiY2hlY2tCYWdFbnRyaWVzXCIsIFskaOKAjV9hID0+IChjaGVja0JhZ0VudHJpZXMgPSAkaOKAjV9hKV1dLFtcIm1ha2VCYWdPZkVudHJpZXNcIiwgWyRo4oCNX2EgPT4gKG1ha2VCYWdPZkVudHJpZXMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWx9PWFzc2VydDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNoZWNrZXJ9IENoZWNrZXIgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vcGFzcy1zdHlsZScpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLktleUNvbXBhcmlzb259IEtleUNvbXBhcmlzb24gKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXl9IEtleSAqL1xuLyoqIEB0ZW1wbGF0ZSB7S2V5fSBbSz1LZXldIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkNvcHlCYWc8Sz59IENvcHlCYWcgKi9cbi8qKiBAdGVtcGxhdGUge0tleX0gW0s9S2V5XSBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5Db3B5U2V0PEs+fSBDb3B5U2V0ICovXG4vKiogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV0gQHRlbXBsYXRlIHtQYXNzYWJsZX0gW1Y9UGFzc2FibGVdIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkNvcHlNYXA8SywgVj59IENvcHlNYXAgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXlDb21wYXJlfSBLZXlDb21wYXJlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuRnVsbENvbXBhcmV9IEZ1bGxDb21wYXJlICovXG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLyBQcmltaXRpdmUgYW5kIFNjYWxhciBrZXlzIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB2YWxcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja1ByaW1pdGl2ZUtleT0odmFsLGNoZWNrKT0+e1xuaWYoaXNPYmplY3QodmFsKSl7XG5yZXR1cm4oXG5jaGVjayE9PWlkZW50Q2hlY2tlciYmXG5jaGVjayhmYWxzZSxYIGBBICR7cSh0eXBlb2YgdmFsKX0gY2Fubm90IGJlIGEgcHJpbWl0aXZlOiAke3ZhbH1gKSk7XG5cbiB9XG4vKiBUT0RPIFRoZXJlIGlzIG5vdCB5ZXQgYSBjaGVja1Bhc3NhYmxlLCBidXQgcGVyaGFwcyB0aGVyZSBzaG91bGQgYmUuKi9cbi8qIElmIHRoYXQgaGFwcGVucywgd2Ugc2hvdWxkIGNhbGwgaXQgaGVyZSBpbnN0ZWFkLiovXG5hc3NlcnRQYXNzYWJsZSh2YWwpO1xucmV0dXJuIHRydWU7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB2YWxcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCAgICAgICAgaXNQcmltaXRpdmVLZXk9KHZhbCk9PmNoZWNrUHJpbWl0aXZlS2V5KHZhbCxpZGVudENoZWNrZXIpOyRo4oCNX29uY2UuaXNQcmltaXRpdmVLZXkoaXNQcmltaXRpdmVLZXkpO1xuaGFyZGVuKGlzUHJpbWl0aXZlS2V5KTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB2YWxcbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0UHJpbWl0aXZlS2V5PSh2YWwpPT57XG5jaGVja1ByaW1pdGl2ZUtleSh2YWwsYXNzZXJ0Q2hlY2tlcik7XG4gfTskaOKAjV9vbmNlLmFzc2VydFByaW1pdGl2ZUtleShhc3NlcnRQcmltaXRpdmVLZXkpO1xuaGFyZGVuKGFzc2VydFByaW1pdGl2ZUtleSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdmFsXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGNoZWNrU2NhbGFyS2V5PSh2YWwsY2hlY2spPT57XG5pZihpc1ByaW1pdGl2ZUtleSh2YWwpKXtcbnJldHVybiB0cnVlO1xuIH1cbmNvbnN0IHBhc3NTdHlsZT1wYXNzU3R5bGVPZih2YWwpO1xuaWYocGFzc1N0eWxlPT09J3JlbW90YWJsZScpe1xucmV0dXJuIHRydWU7XG4gfVxucmV0dXJuIGNoZWNrKGZhbHNlLFggYEEgJHtxKHBhc3NTdHlsZSl9IGNhbm5vdCBiZSBhIHNjYWxhciBrZXk6ICR7dmFsfWApO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdmFsXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqLyRo4oCNX29uY2UuY2hlY2tTY2FsYXJLZXkoY2hlY2tTY2FsYXJLZXkpO1xuY29uc3QgICAgICAgIGlzU2NhbGFyS2V5PSh2YWwpPT5jaGVja1NjYWxhcktleSh2YWwsaWRlbnRDaGVja2VyKTskaOKAjV9vbmNlLmlzU2NhbGFyS2V5KGlzU2NhbGFyS2V5KTtcbmhhcmRlbihpc1NjYWxhcktleSk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gdmFsXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydFNjYWxhcktleT0odmFsKT0+e1xuY2hlY2tTY2FsYXJLZXkodmFsLGFzc2VydENoZWNrZXIpO1xuIH07JGjigI1fb25jZS5hc3NlcnRTY2FsYXJLZXkoYXNzZXJ0U2NhbGFyS2V5KTtcbmhhcmRlbihhc3NlcnRTY2FsYXJLZXkpO1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gS2V5cyAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKiBAdHlwZSB7V2Vha1NldDxLZXk+fSAqL1xuY29uc3Qga2V5TWVtbz1uZXcgV2Vha1NldCgpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja0tleT0odmFsLGNoZWNrKT0+e1xuaWYoIWlzT2JqZWN0KHZhbCkpe1xuLyogVE9ETyBUaGVyZSBpcyBub3QgeWV0IGEgY2hlY2tQYXNzYWJsZSwgYnV0IHBlcmhhcHMgdGhlcmUgc2hvdWxkIGJlLiovXG4vKiBJZiB0aGF0IGhhcHBlbnMsIHdlIHNob3VsZCBjYWxsIGl0IGhlcmUgaW5zdGVhZC4qL1xuYXNzZXJ0UGFzc2FibGUodmFsKTtcbnJldHVybiB0cnVlO1xuIH1cbmlmKGtleU1lbW8uaGFzKHZhbCkpe1xucmV0dXJuIHRydWU7XG4gfVxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbmNvbnN0IHJlc3VsdD1jaGVja0tleUludGVybmFsKHZhbCxjaGVjayk7XG5pZihyZXN1bHQpe1xuLyogRG9uJ3QgY2FjaGUgdGhlIHVuZGVmaW5lZCBjYXNlcywgc28gdGhhdCBpZiBpdCBpcyB0cmllZCBhZ2FpbiovXG4vKiB3aXRoIGBhc3NlcnRDaGVja2VyYCBpdCdsbCB0aHJvdyBhIGRpYWdub3N0aWMgYWdhaW4qL1xua2V5TWVtby5hZGQodmFsKTtcbiB9XG4vKiBOb3RlIHRoYXQgd2UgZG8gbm90IG1lbW9pemUgYSBuZWdhdGl2ZSBqdWRnZW1lbnQsIHNvIHRoYXQgaWYgaXQgaXMgdHJpZWQqL1xuLyogYWdhaW4gd2l0aCBhIGNoZWNrZXIsIGl0IHdpbGwgc3RpbGwgcHJvZHVjZSBhIHVzZWZ1bCBkaWFnbm9zdGljLiovXG5yZXR1cm4gcmVzdWx0O1xuIH07JGjigI1fb25jZS5jaGVja0tleShjaGVja0tleSk7XG5oYXJkZW4oY2hlY2tLZXkpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBpc0tleT0odmFsKT0+Y2hlY2tLZXkodmFsLGlkZW50Q2hlY2tlcik7JGjigI1fb25jZS5pc0tleShpc0tleSk7XG5oYXJkZW4oaXNLZXkpO1xuXG4vKipcbiAqIEBwYXJhbSB7S2V5fSB2YWxcbiAqL1xuY29uc3QgICAgICAgIGFzc2VydEtleT0odmFsKT0+e1xuY2hlY2tLZXkodmFsLGFzc2VydENoZWNrZXIpO1xuIH07JGjigI1fb25jZS5hc3NlcnRLZXkoYXNzZXJ0S2V5KTtcbmhhcmRlbihhc3NlcnRLZXkpO1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIENvcHlTZXQgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qIE1vdmVkIHRvIGhlcmUgc28gdGhleSBjYW4gY2hlY2sgdGhhdCB0aGUgY29weVNldCBjb250YWlucyBvbmx5IGtleXMqL1xuLyogd2l0aG91dCBjcmVhdGluZyBhbiBpbXBvcnQgY3ljbGUuKi9cblxuLyoqIEB0eXBlIHtXZWFrU2V0PENvcHlTZXQ+fSAqL1xuY29uc3QgY29weVNldE1lbW89bmV3IFdlYWtTZXQoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBzXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGNoZWNrQ29weVNldD0ocyxjaGVjayk9PntcbmlmKGNvcHlTZXRNZW1vLmhhcyhzKSl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5jb25zdCByZXN1bHQ9XG4ocGFzc1N0eWxlT2Yocyk9PT0ndGFnZ2VkJyYmZ2V0VGFnKHMpPT09J2NvcHlTZXQnfHxcbmNoZWNrKGZhbHNlLFggYE5vdCBhIGNvcHlTZXQ6ICR7c31gKSkmJlxuY2hlY2tFbGVtZW50cyhzLnBheWxvYWQsY2hlY2spJiZcbmNoZWNrS2V5KHMucGF5bG9hZCxjaGVjayk7XG5pZihyZXN1bHQpe1xuY29weVNldE1lbW8uYWRkKHMpO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfTskaOKAjV9vbmNlLmNoZWNrQ29weVNldChjaGVja0NvcHlTZXQpO1xuaGFyZGVuKGNoZWNrQ29weVNldCk7XG5cbi8qKlxuICogQGNhbGxiYWNrIElzQ29weVNldFxuICogQHBhcmFtIHtQYXNzYWJsZX0gc1xuICogQHJldHVybnMge3MgaXMgQ29weVNldH1cbiAqL1xuXG4vKiogQHR5cGUge0lzQ29weVNldH0gKi9cbmNvbnN0ICAgICAgICBpc0NvcHlTZXQ9KHMpPT5jaGVja0NvcHlTZXQocyxpZGVudENoZWNrZXIpOyRo4oCNX29uY2UuaXNDb3B5U2V0KGlzQ29weVNldCk7XG5oYXJkZW4oaXNDb3B5U2V0KTtcblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0Q29weVNldFxuICogQHBhcmFtIHtQYXNzYWJsZX0gc1xuICogQHJldHVybnMge2Fzc2VydHMgcyBpcyBDb3B5U2V0fVxuICovXG5cbi8qKiBAdHlwZSB7QXNzZXJ0Q29weVNldH0gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDb3B5U2V0PShzKT0+e1xuY2hlY2tDb3B5U2V0KHMsYXNzZXJ0Q2hlY2tlcik7XG4gfTskaOKAjV9vbmNlLmFzc2VydENvcHlTZXQoYXNzZXJ0Q29weVNldCk7XG5oYXJkZW4oYXNzZXJ0Q29weVNldCk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7Q29weVNldDxLPn0gc1xuICogQHJldHVybnMge0tbXX1cbiAqL1xuY29uc3QgICAgICAgIGdldENvcHlTZXRLZXlzPShzKT0+e1xuYXNzZXJ0Q29weVNldChzKTtcbnJldHVybiBzLnBheWxvYWQ7XG4gfTskaOKAjV9vbmNlLmdldENvcHlTZXRLZXlzKGdldENvcHlTZXRLZXlzKTtcbmhhcmRlbihnZXRDb3B5U2V0S2V5cyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7Q29weVNldDxLPn0gc1xuICogQHBhcmFtIHsoa2V5OiBLLCBpbmRleDogbnVtYmVyKSA9PiBib29sZWFufSBmblxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBldmVyeUNvcHlTZXRLZXk9KHMsZm4pPT5cbmdldENvcHlTZXRLZXlzKHMpLmV2ZXJ5KChrZXksaW5kZXgpPT5mbihrZXksaW5kZXgpKTskaOKAjV9vbmNlLmV2ZXJ5Q29weVNldEtleShldmVyeUNvcHlTZXRLZXkpO1xuaGFyZGVuKGV2ZXJ5Q29weVNldEtleSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7SXRlcmFibGU8Sz59IGVsZW1lbnRJdGVyXG4gKiBAcmV0dXJucyB7Q29weVNldDxLPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VDb3B5U2V0PShlbGVtZW50SXRlcik9PntcbmNvbnN0IHJlc3VsdD1tYWtlU2V0T2ZFbGVtZW50cyhlbGVtZW50SXRlcik7XG5hc3NlcnRDb3B5U2V0KHJlc3VsdCk7XG5yZXR1cm4gcmVzdWx0O1xuIH07JGjigI1fb25jZS5tYWtlQ29weVNldChtYWtlQ29weVNldCk7XG5oYXJkZW4obWFrZUNvcHlTZXQpO1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIENvcHlCYWcgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qIE1vdmVkIHRvIGhlcmUgc28gdGhleSBjYW4gY2hlY2sgdGhhdCB0aGUgY29weUJhZyBjb250YWlucyBvbmx5IGtleXMqL1xuLyogd2l0aG91dCBjcmVhdGluZyBhbiBpbXBvcnQgY3ljbGUuKi9cblxuLyoqIEB0eXBlIHtXZWFrU2V0PENvcHlCYWc+fSAqL1xuY29uc3QgY29weUJhZ01lbW89bmV3IFdlYWtTZXQoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBiXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGNoZWNrQ29weUJhZz0oYixjaGVjayk9PntcbmlmKGNvcHlCYWdNZW1vLmhhcyhiKSl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5jb25zdCByZXN1bHQ9XG4ocGFzc1N0eWxlT2YoYik9PT0ndGFnZ2VkJyYmZ2V0VGFnKGIpPT09J2NvcHlCYWcnfHxcbmNoZWNrKGZhbHNlLFggYE5vdCBhIGNvcHlCYWc6ICR7Yn1gKSkmJlxuY2hlY2tCYWdFbnRyaWVzKGIucGF5bG9hZCxjaGVjaykmJlxuY2hlY2tLZXkoYi5wYXlsb2FkLGNoZWNrKTtcbmlmKHJlc3VsdCl7XG5jb3B5QmFnTWVtby5hZGQoYik7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9OyRo4oCNX29uY2UuY2hlY2tDb3B5QmFnKGNoZWNrQ29weUJhZyk7XG5oYXJkZW4oY2hlY2tDb3B5QmFnKTtcblxuLyoqXG4gKiBAY2FsbGJhY2sgSXNDb3B5QmFnXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBiXG4gKiBAcmV0dXJucyB7YiBpcyBDb3B5QmFnfVxuICovXG5cbi8qKiBAdHlwZSB7SXNDb3B5QmFnfSAqL1xuY29uc3QgICAgICAgIGlzQ29weUJhZz0oYik9PmNoZWNrQ29weUJhZyhiLGlkZW50Q2hlY2tlcik7JGjigI1fb25jZS5pc0NvcHlCYWcoaXNDb3B5QmFnKTtcbmhhcmRlbihpc0NvcHlCYWcpO1xuXG4vKipcbiAqIEBjYWxsYmFjayBBc3NlcnRDb3B5QmFnXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBiXG4gKiBAcmV0dXJucyB7YXNzZXJ0cyBiIGlzIENvcHlCYWd9XG4gKi9cblxuLyoqIEB0eXBlIHtBc3NlcnRDb3B5QmFnfSAqL1xuY29uc3QgICAgICAgIGFzc2VydENvcHlCYWc9KGIpPT57XG5jaGVja0NvcHlCYWcoYixhc3NlcnRDaGVja2VyKTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0Q29weUJhZyhhc3NlcnRDb3B5QmFnKTtcbmhhcmRlbihhc3NlcnRDb3B5QmFnKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgS1xuICogQHBhcmFtIHtDb3B5QmFnPEs+fSBiXG4gKiBAcmV0dXJucyB7Q29weUJhZzxLPlsncGF5bG9hZCddfVxuICovXG5jb25zdCAgICAgICAgZ2V0Q29weUJhZ0VudHJpZXM9KGIpPT57XG5hc3NlcnRDb3B5QmFnKGIpO1xucmV0dXJuIGIucGF5bG9hZDtcbiB9OyRo4oCNX29uY2UuZ2V0Q29weUJhZ0VudHJpZXMoZ2V0Q29weUJhZ0VudHJpZXMpO1xuaGFyZGVuKGdldENvcHlCYWdFbnRyaWVzKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgS1xuICogQHBhcmFtIHtDb3B5QmFnPEs+fSBiXG4gKiBAcGFyYW0geyhlbnRyeTogW0ssIGJpZ2ludF0sIGluZGV4OiBudW1iZXIpID0+IGJvb2xlYW59IGZuXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGV2ZXJ5Q29weUJhZ0VudHJ5PShiLGZuKT0+XG5nZXRDb3B5QmFnRW50cmllcyhiKS5ldmVyeSgoZW50cnksaW5kZXgpPT5mbihlbnRyeSxpbmRleCkpOyRo4oCNX29uY2UuZXZlcnlDb3B5QmFnRW50cnkoZXZlcnlDb3B5QmFnRW50cnkpO1xuaGFyZGVuKGV2ZXJ5Q29weUJhZ0VudHJ5KTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgS1xuICogQHBhcmFtIHtJdGVyYWJsZTxbSyxiaWdpbnRdPn0gYmFnRW50cnlJdGVyXG4gKiBAcmV0dXJucyB7Q29weUJhZzxLPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VDb3B5QmFnPShiYWdFbnRyeUl0ZXIpPT57XG5jb25zdCByZXN1bHQ9bWFrZUJhZ09mRW50cmllcyhiYWdFbnRyeUl0ZXIpO1xuYXNzZXJ0Q29weUJhZyhyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9OyRo4oCNX29uY2UubWFrZUNvcHlCYWcobWFrZUNvcHlCYWcpO1xuaGFyZGVuKG1ha2VDb3B5QmFnKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgS1xuICogQHBhcmFtIHtJdGVyYWJsZTxLPn0gZWxlbWVudEl0ZXJcbiAqIEByZXR1cm5zIHtDb3B5QmFnPEs+fVxuICovXG5jb25zdCAgICAgICAgbWFrZUNvcHlCYWdGcm9tRWxlbWVudHM9KGVsZW1lbnRJdGVyKT0+e1xuLyogVGhpcyBmdWxsT3JkZXIgY29udGFpbnMgaGlzdG9yeSBkZXBlbmRlbnQgc3RhdGUuIEl0IGlzIHNwZWNpZmljKi9cbi8qIHRvIHRoaXMgb25lIGNhbGwgYW5kIGRvZXMgbm90IHN1cnZpdmUgaXQuKi9cbmNvbnN0IGZ1bGxDb21wYXJlPW1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0KCkuYW50aUNvbXBhcmF0b3I7XG5jb25zdCBzb3J0ZWQ9c29ydEJ5UmFuayhlbGVtZW50SXRlcixmdWxsQ29tcGFyZSk7XG4vKiogQHR5cGUge1tLLGJpZ2ludF1bXX0gKi9cbmNvbnN0IGVudHJpZXM9W107XG5mb3IobGV0IGk9MDtpPHNvcnRlZC5sZW5ndGg7KXtcbmNvbnN0IGs9c29ydGVkW2ldO1xubGV0IGo9aSsxO1xud2hpbGUoajxzb3J0ZWQubGVuZ3RoJiZmdWxsQ29tcGFyZShrLHNvcnRlZFtqXSk9PT0wKXtcbmorPTE7XG4gfVxuZW50cmllcy5wdXNoKFtrLEJpZ0ludChqLWkpXSk7XG5pPWo7XG4gfVxucmV0dXJuIG1ha2VDb3B5QmFnKGVudHJpZXMpO1xuIH07JGjigI1fb25jZS5tYWtlQ29weUJhZ0Zyb21FbGVtZW50cyhtYWtlQ29weUJhZ0Zyb21FbGVtZW50cyk7XG5oYXJkZW4obWFrZUNvcHlCYWdGcm9tRWxlbWVudHMpO1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIENvcHlNYXAgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qIE1vdmVkIHRvIGhlcmUgc28gdGhleSBjYW4gY2hlY2sgdGhhdCB0aGUgY29weU1hcCdzIGtleXMgY29udGFpbnMgb25seSBrZXlzKi9cbi8qIHdpdGhvdXQgY3JlYXRpbmcgYW4gaW1wb3J0IGN5Y2xlLiovXG5cbi8qKiBAdHlwZSB7V2Vha1NldDxDb3B5TWFwPn0gKi9cbmNvbnN0IGNvcHlNYXBNZW1vPW5ldyBXZWFrU2V0KCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gbVxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBjaGVja0NvcHlNYXA9KG0sY2hlY2spPT57XG5pZihjb3B5TWFwTWVtby5oYXMobSkpe1xucmV0dXJuIHRydWU7XG4gfVxuaWYoIShwYXNzU3R5bGVPZihtKT09PSd0YWdnZWQnJiZnZXRUYWcobSk9PT0nY29weU1hcCcpKXtcbnJldHVybiBjaGVjayhmYWxzZSxYIGBOb3QgYSBjb3B5TWFwOiAke219YCk7XG4gfVxuY29uc3R7cGF5bG9hZH09bTtcbmlmKHBhc3NTdHlsZU9mKHBheWxvYWQpIT09J2NvcHlSZWNvcmQnKXtcbnJldHVybiBjaGVjayhmYWxzZSxYIGBBIGNvcHlNYXAncyBwYXlsb2FkIG11c3QgYmUgYSByZWNvcmQ6ICR7bX1gKTtcbiB9XG5jb25zdHtrZXlzLHZhbHVlcywuLi5yZXN0fT1wYXlsb2FkO1xuY29uc3QgcmVzdWx0PVxuKG93bktleXMocmVzdCkubGVuZ3RoPT09MHx8XG5jaGVjayhcbmZhbHNlLFxuWCBgQSBjb3B5TWFwJ3MgcGF5bG9hZCBtdXN0IG9ubHkgaGF2ZSAua2V5cyBhbmQgLnZhbHVlczogJHttfWApKSYmXG5cbmNoZWNrRWxlbWVudHMoa2V5cyxjaGVjaykmJlxuY2hlY2tLZXkoa2V5cyxjaGVjaykmJihcbnBhc3NTdHlsZU9mKHZhbHVlcyk9PT0nY29weUFycmF5J3x8XG5jaGVjayhmYWxzZSxYIGBBIGNvcHlNYXAncyAudmFsdWVzIG11c3QgYmUgYSBjb3B5QXJyYXk6ICR7bX1gKSkmJihcbmtleXMubGVuZ3RoPT09dmFsdWVzLmxlbmd0aHx8XG5jaGVjayhcbmZhbHNlLFxuWCBgQSBjb3B5TWFwIG11c3QgaGF2ZSB0aGUgc2FtZSBudW1iZXIgb2Yga2V5cyBhbmQgdmFsdWVzOiAke219YCkpO1xuXG5pZihyZXN1bHQpe1xuY29weU1hcE1lbW8uYWRkKG0pO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfTskaOKAjV9vbmNlLmNoZWNrQ29weU1hcChjaGVja0NvcHlNYXApO1xuaGFyZGVuKGNoZWNrQ29weU1hcCk7XG5cbi8qKlxuICogQGNhbGxiYWNrIElzQ29weU1hcFxuICogQHBhcmFtIHtQYXNzYWJsZX0gbVxuICogQHJldHVybnMge20gaXMgQ29weU1hcDxLZXksIFBhc3NhYmxlPn1cbiAqL1xuXG4vKiogQHR5cGUge0lzQ29weU1hcH0gKi9cbmNvbnN0ICAgICAgICBpc0NvcHlNYXA9KG0pPT5jaGVja0NvcHlNYXAobSxpZGVudENoZWNrZXIpOyRo4oCNX29uY2UuaXNDb3B5TWFwKGlzQ29weU1hcCk7XG5oYXJkZW4oaXNDb3B5TWFwKTtcblxuLyoqXG4gKiBAY2FsbGJhY2sgQXNzZXJ0Q29weU1hcFxuICogQHBhcmFtIHtQYXNzYWJsZX0gbVxuICogQHJldHVybnMge2Fzc2VydHMgbSBpcyBDb3B5TWFwPEtleSwgUGFzc2FibGU+fVxuICovXG5cbi8qKiBAdHlwZSB7QXNzZXJ0Q29weU1hcH0gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRDb3B5TWFwPShtKT0+e1xuY2hlY2tDb3B5TWFwKG0sYXNzZXJ0Q2hlY2tlcik7XG4gfTskaOKAjV9vbmNlLmFzc2VydENvcHlNYXAoYXNzZXJ0Q29weU1hcCk7XG5oYXJkZW4oYXNzZXJ0Q29weU1hcCk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IEtcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFZcbiAqIEBwYXJhbSB7Q29weU1hcDxLLFY+fSBtXG4gKiBAcmV0dXJucyB7S1tdfVxuICovXG5jb25zdCAgICAgICAgZ2V0Q29weU1hcEtleXM9KG0pPT57XG5hc3NlcnRDb3B5TWFwKG0pO1xucmV0dXJuIG0ucGF5bG9hZC5rZXlzO1xuIH07JGjigI1fb25jZS5nZXRDb3B5TWFwS2V5cyhnZXRDb3B5TWFwS2V5cyk7XG5oYXJkZW4oZ2V0Q29weU1hcEtleXMpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7S2V5fSBLXG4gKiBAdGVtcGxhdGUge1Bhc3NhYmxlfSBWXG4gKiBAcGFyYW0ge0NvcHlNYXA8SyxWPn0gbVxuICogQHJldHVybnMge1ZbXX1cbiAqL1xuY29uc3QgICAgICAgIGdldENvcHlNYXBWYWx1ZXM9KG0pPT57XG5hc3NlcnRDb3B5TWFwKG0pO1xucmV0dXJuIG0ucGF5bG9hZC52YWx1ZXM7XG4gfTskaOKAjV9vbmNlLmdldENvcHlNYXBWYWx1ZXMoZ2V0Q29weU1hcFZhbHVlcyk7XG5oYXJkZW4oZ2V0Q29weU1hcFZhbHVlcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IEtcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFZcbiAqIEBwYXJhbSB7Q29weU1hcDxLLFY+fSBtXG4gKiBAcmV0dXJucyB7SXRlcmFibGU8W0ssVl0+fVxuICovXG5jb25zdCAgICAgICAgZ2V0Q29weU1hcEVudHJpZXM9KG0pPT57XG5hc3NlcnRDb3B5TWFwKG0pO1xuY29uc3R7XG5wYXlsb2FkOntrZXlzLHZhbHVlc319PVxubTtcbmNvbnN0e2xlbmd0aH09LyoqIEB0eXBlIHtBcnJheX0gKi9rZXlzO1xucmV0dXJuIEZhcignQ29weU1hcCBlbnRyaWVzIGl0ZXJhYmxlJyx7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xubGV0IGk9MDtcbnJldHVybiBGYXIoJ0NvcHlNYXAgZW50cmllcyBpdGVyYXRvcicse1xubmV4dDooKT0+e1xuLyoqIEB0eXBlIHtJdGVyYXRvclJlc3VsdDxbSyxWXSx2b2lkPn0gKi9cbmxldCByZXN1bHQ7XG5pZihpPGxlbmd0aCl7XG5yZXN1bHQ9aGFyZGVuKHtkb25lOmZhbHNlLHZhbHVlOltrZXlzW2ldLHZhbHVlc1tpXV19KTtcbmkrPTE7XG5yZXR1cm4gcmVzdWx0O1xuIH1lbHNle1xucmVzdWx0PWhhcmRlbih7ZG9uZTp0cnVlLHZhbHVlOnVuZGVmaW5lZH0pO1xuIH1cbnJldHVybiByZXN1bHQ7XG4gfX0pO1xuXG4gfX0pO1xuXG4gfTskaOKAjV9vbmNlLmdldENvcHlNYXBFbnRyaWVzKGdldENvcHlNYXBFbnRyaWVzKTtcbmhhcmRlbihnZXRDb3B5TWFwRW50cmllcyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIHtLZXl9IEtcbiAqIEB0ZW1wbGF0ZSB7UGFzc2FibGV9IFZcbiAqIEBwYXJhbSB7Q29weU1hcDxLLFY+fSBtXG4gKiBAcGFyYW0geyhrZXk6IEssIGluZGV4OiBudW1iZXIpID0+IGJvb2xlYW59IGZuXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgICAgICAgIGV2ZXJ5Q29weU1hcEtleT0obSxmbik9PlxuZ2V0Q29weU1hcEtleXMobSkuZXZlcnkoKGtleSxpbmRleCk9PmZuKGtleSxpbmRleCkpOyRo4oCNX29uY2UuZXZlcnlDb3B5TWFwS2V5KGV2ZXJ5Q29weU1hcEtleSk7XG5oYXJkZW4oZXZlcnlDb3B5TWFwS2V5KTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gS1xuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVlxuICogQHBhcmFtIHtDb3B5TWFwPEssVj59IG1cbiAqIEBwYXJhbSB7KHZhbHVlOiBWLCBpbmRleDogbnVtYmVyKSA9PiBib29sZWFufSBmblxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0ICAgICAgICBldmVyeUNvcHlNYXBWYWx1ZT0obSxmbik9PlxuZ2V0Q29weU1hcFZhbHVlcyhtKS5ldmVyeSgodmFsdWUsaW5kZXgpPT5mbih2YWx1ZSxpbmRleCkpOyRo4oCNX29uY2UuZXZlcnlDb3B5TWFwVmFsdWUoZXZlcnlDb3B5TWFwVmFsdWUpO1xuaGFyZGVuKGV2ZXJ5Q29weU1hcFZhbHVlKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUge0tleX0gS1xuICogQHRlbXBsYXRlIHtQYXNzYWJsZX0gVlxuICogQHBhcmFtIHtDb3B5TWFwPEssVj59IG1cbiAqIEByZXR1cm5zIHtDb3B5U2V0PEs+fVxuICovXG5jb25zdCAgICAgICAgY29weU1hcEtleVNldD0obSk9PlxuLyogQSBjb3B5TWFwJ3Mga2V5cyBhcmUgYWxyZWFkeSBpbiB0aGUgaW50ZXJuYWwgZm9ybSB1c2VkIGJ5IGNvcHlTZXRzLiovXG5tYWtlVGFnZ2VkKCdjb3B5U2V0JyxtLnBheWxvYWQua2V5cyk7JGjigI1fb25jZS5jb3B5TWFwS2V5U2V0KGNvcHlNYXBLZXlTZXQpO1xuaGFyZGVuKGNvcHlNYXBLZXlTZXQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSB7S2V5fSBLXG4gKiBAdGVtcGxhdGUge1Bhc3NhYmxlfSBWXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtLLCBWXT59IGVudHJpZXNcbiAqIEByZXR1cm5zIHtDb3B5TWFwPEssVj59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ29weU1hcD0oZW50cmllcyk9Pntcbi8qIFRoaXMgaXMgd2VpcmQsIGJ1dCByZXZlcnNlIHJhbmsgc29ydGluZyB0aGUgZW50cmllcyBpcyBhIGdvb2QgZmlyc3Qgc3RlcCovXG4vKiBmb3IgZ2V0dGluZyB0aGUgcmFuayBzb3J0ZWQga2V5cyB0b2dldGhlciB3aXRoIHRoZSB2YWx1ZXMqL1xuLyogb3JnYW5pemVkIGJ5IHRob3NlIGtleXMuIEFsc28sIGFtb25nIHZhbHVlcyBhc3NvY2lhdGVkIHdpdGgqL1xuLyoga2V5cyBpbiB0aGUgc2FtZSBlcXVpdmFsZW5jZSBjbGFzcywgdGhvc2UgYXJlIHJhbmsgc29ydGVkLiovXG4vKiBUT0RPIFRoaXMqL1xuLyogY291bGQgc29sdmUgdGhlIGNvcHlNYXAgY292ZXIgaXNzdWUgZXhwbGFpbmVkIGluIHBhdHRlcm5NYXRjaGVycy5qcy4qL1xuLyogQnV0IG9ubHkgaWYgd2UgaW5jbHVkZSB0aGlzIGNyaXRlcmlhIGluIG91ciB2YWxpZGF0aW9uIG9mIGNvcHlNYXBzLCovXG4vKiB3aGljaCB3ZSBjdXJyZW50bHkgZG8gbm90LiovXG5jb25zdCBzb3J0ZWRFbnRyaWVzPXNvcnRCeVJhbmsoZW50cmllcyxjb21wYXJlQW50aVJhbmspO1xuY29uc3Qga2V5cz1zb3J0ZWRFbnRyaWVzLm1hcCgoW2ssX3ZdKT0+ayk7XG5jb25zdCB2YWx1ZXM9c29ydGVkRW50cmllcy5tYXAoKFtfayx2XSk9PnYpO1xuY29uc3QgcmVzdWx0PW1ha2VUYWdnZWQoJ2NvcHlNYXAnLHtrZXlzLHZhbHVlc30pO1xuYXNzZXJ0Q29weU1hcChyZXN1bHQpO1xucmV0dXJuIHJlc3VsdDtcbiB9OyRo4oCNX29uY2UubWFrZUNvcHlNYXAobWFrZUNvcHlNYXApO1xuaGFyZGVuKG1ha2VDb3B5TWFwKTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIEtleXMgUmVjdXIgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHZhbFxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrS2V5SW50ZXJuYWw9KHZhbCxjaGVjayk9PntcbmNvbnN0IGNoZWNrSXQ9KGNoaWxkKT0+Y2hlY2tLZXkoY2hpbGQsY2hlY2spO1xuXG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YodmFsKTtcbnN3aXRjaChwYXNzU3R5bGUpe1xuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBBIGNvcHlSZWNvcmQgaXMgYSBrZXkgaWZmIGFsbCBpdHMgY2hpbGRyZW4gYXJlIGtleXMqL1xucmV0dXJuIE9iamVjdC52YWx1ZXModmFsKS5ldmVyeShjaGVja0l0KTtcbiB9XG5jYXNlJ2NvcHlBcnJheSc6e1xuLyogQSBjb3B5QXJyYXkgaXMgYSBrZXkgaWZmIGFsbCBpdHMgY2hpbGRyZW4gYXJlIGtleXMqL1xucmV0dXJuIHZhbC5ldmVyeShjaGVja0l0KTtcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3QgdGFnPWdldFRhZyh2YWwpO1xuc3dpdGNoKHRhZyl7XG5jYXNlJ2NvcHlTZXQnOntcbnJldHVybiBjaGVja0NvcHlTZXQodmFsLGNoZWNrKTtcbiB9XG5jYXNlJ2NvcHlCYWcnOntcbnJldHVybiBjaGVja0NvcHlCYWcodmFsLGNoZWNrKTtcbiB9XG5jYXNlJ2NvcHlNYXAnOntcbnJldHVybihcbmNoZWNrQ29weU1hcCh2YWwsY2hlY2spJiZcbi8qIEZvciBhIGNvcHlNYXAgdG8gYmUgYSBrZXksIGFsbCBpdHMga2V5cyBhbmQgdmFsdWVzIG11c3QqL1xuLyogYmUga2V5cy4gS2V5cyBhbHJlYWR5IGNoZWNrZWQgYnkgYGNoZWNrQ29weU1hcGAgc2luY2UqL1xuLyogdGhhdCdzIGEgY29weU1hcCByZXF1aXJlbWVudCBpbiBnZW5lcmFsLiovXG5ldmVyeUNvcHlNYXBWYWx1ZSh2YWwsY2hlY2tJdCkpO1xuXG4gfVxuZGVmYXVsdDp7XG5yZXR1cm4oXG5jaGVjayE9PWlkZW50Q2hlY2tlciYmXG5jaGVjayhmYWxzZSxYIGBBIHBhc3NhYmxlIHRhZ2dlZCAke3EodGFnKX0gaXMgbm90IGEga2V5OiAke3ZhbH1gKSk7XG5cbiB9fVxuXG4gfVxuY2FzZSdyZW1vdGFibGUnOntcbi8qIEFsbCByZW1vdGFibGVzIGFyZSBrZXlzLiovXG5yZXR1cm4gdHJ1ZTtcbiB9XG5jYXNlJ2Vycm9yJzpcbmNhc2UncHJvbWlzZSc6e1xucmV0dXJuIGNoZWNrKGZhbHNlLFggYEEgJHtxKHBhc3NTdHlsZSl9IGNhbm5vdCBiZSBhIGtleWApO1xuIH1cbmRlZmF1bHQ6e1xuLyogVW5leHBlY3RlZCB0YWdzIGFyZSBqdXN0IG5vbi1rZXlzLCBidXQgYW4gdW5leHBlY3RlZCBwYXNzU3R5bGUqL1xuLyogaXMgYWx3YXlzIGFuIGVycm9yLiovXG50aHJvdyBGYWlsIGB1bmV4cGVjdGVkIHBhc3NTdHlsZSAke3EocGFzc1N0eWxlKX06ICR7dmFsfWA7XG4gfX1cblxuIH07XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNQcmltaXRpdmVLZXkiOlsiaXNQcmltaXRpdmVLZXkiXSwiYXNzZXJ0UHJpbWl0aXZlS2V5IjpbImFzc2VydFByaW1pdGl2ZUtleSJdLCJjaGVja1NjYWxhcktleSI6WyJjaGVja1NjYWxhcktleSJdLCJpc1NjYWxhcktleSI6WyJpc1NjYWxhcktleSJdLCJhc3NlcnRTY2FsYXJLZXkiOlsiYXNzZXJ0U2NhbGFyS2V5Il0sImNoZWNrS2V5IjpbImNoZWNrS2V5Il0sImlzS2V5IjpbImlzS2V5Il0sImFzc2VydEtleSI6WyJhc3NlcnRLZXkiXSwiY2hlY2tDb3B5U2V0IjpbImNoZWNrQ29weVNldCJdLCJpc0NvcHlTZXQiOlsiaXNDb3B5U2V0Il0sImFzc2VydENvcHlTZXQiOlsiYXNzZXJ0Q29weVNldCJdLCJnZXRDb3B5U2V0S2V5cyI6WyJnZXRDb3B5U2V0S2V5cyJdLCJldmVyeUNvcHlTZXRLZXkiOlsiZXZlcnlDb3B5U2V0S2V5Il0sIm1ha2VDb3B5U2V0IjpbIm1ha2VDb3B5U2V0Il0sImNoZWNrQ29weUJhZyI6WyJjaGVja0NvcHlCYWciXSwiaXNDb3B5QmFnIjpbImlzQ29weUJhZyJdLCJhc3NlcnRDb3B5QmFnIjpbImFzc2VydENvcHlCYWciXSwiZ2V0Q29weUJhZ0VudHJpZXMiOlsiZ2V0Q29weUJhZ0VudHJpZXMiXSwiZXZlcnlDb3B5QmFnRW50cnkiOlsiZXZlcnlDb3B5QmFnRW50cnkiXSwibWFrZUNvcHlCYWciOlsibWFrZUNvcHlCYWciXSwibWFrZUNvcHlCYWdGcm9tRWxlbWVudHMiOlsibWFrZUNvcHlCYWdGcm9tRWxlbWVudHMiXSwiY2hlY2tDb3B5TWFwIjpbImNoZWNrQ29weU1hcCJdLCJpc0NvcHlNYXAiOlsiaXNDb3B5TWFwIl0sImFzc2VydENvcHlNYXAiOlsiYXNzZXJ0Q29weU1hcCJdLCJnZXRDb3B5TWFwS2V5cyI6WyJnZXRDb3B5TWFwS2V5cyJdLCJnZXRDb3B5TWFwVmFsdWVzIjpbImdldENvcHlNYXBWYWx1ZXMiXSwiZ2V0Q29weU1hcEVudHJpZXMiOlsiZ2V0Q29weU1hcEVudHJpZXMiXSwiZXZlcnlDb3B5TWFwS2V5IjpbImV2ZXJ5Q29weU1hcEtleSJdLCJldmVyeUNvcHlNYXBWYWx1ZSI6WyJldmVyeUNvcHlNYXBWYWx1ZSJdLCJjb3B5TWFwS2V5U2V0IjpbImNvcHlNYXBLZXlTZXQiXSwibWFrZUNvcHlNYXAiOlsibWFrZUNvcHlNYXAiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA9+bCUXcaAAB3GgAALQAAAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMva2V5cy9jb21wYXJlS2V5cy5qc3siaW1wb3J0cyI6WyIuL2NoZWNrS2V5LmpzIiwiLi9tZXJnZS1iYWctb3BlcmF0b3JzLmpzIiwiLi9tZXJnZS1zZXQtb3BlcmF0b3JzLmpzIiwiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbImNvbXBhcmVLZXlzIiwia2V5RVEiLCJrZXlHVCIsImtleUdURSIsImtleUxUIiwia2V5TFRFIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHBhc3NTdHlsZU9mLGdldFRhZyxjb21wYXJlUmFuayxyZWNvcmROYW1lcyxyZWNvcmRWYWx1ZXMsYXNzZXJ0S2V5LGJhZ0NvbXBhcmUsc2V0Q29tcGFyZTskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcImdldFRhZ1wiLCBbJGjigI1fYSA9PiAoZ2V0VGFnID0gJGjigI1fYSldXSxbXCJjb21wYXJlUmFua1wiLCBbJGjigI1fYSA9PiAoY29tcGFyZVJhbmsgPSAkaOKAjV9hKV1dLFtcInJlY29yZE5hbWVzXCIsIFskaOKAjV9hID0+IChyZWNvcmROYW1lcyA9ICRo4oCNX2EpXV0sW1wicmVjb3JkVmFsdWVzXCIsIFskaOKAjV9hID0+IChyZWNvcmRWYWx1ZXMgPSAkaOKAjV9hKV1dXV0sW1wiLi9jaGVja0tleS5qc1wiLCBbW1wiYXNzZXJ0S2V5XCIsIFskaOKAjV9hID0+IChhc3NlcnRLZXkgPSAkaOKAjV9hKV1dXV0sW1wiLi9tZXJnZS1iYWctb3BlcmF0b3JzLmpzXCIsIFtbXCJiYWdDb21wYXJlXCIsIFskaOKAjV9hID0+IChiYWdDb21wYXJlID0gJGjigI1fYSldXV1dLFtcIi4vbWVyZ2Utc2V0LW9wZXJhdG9ycy5qc1wiLCBbW1wic2V0Q29tcGFyZVwiLCBbJGjigI1fYSA9PiAoc2V0Q29tcGFyZSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuY29uc3R7cXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5cbi8qKiBAdHlwZSB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXlDb21wYXJlfSAqL1xuY29uc3QgICAgICAgIGNvbXBhcmVLZXlzPShsZWZ0LHJpZ2h0KT0+e1xuYXNzZXJ0S2V5KGxlZnQpO1xuYXNzZXJ0S2V5KHJpZ2h0KTtcbmNvbnN0IGxlZnRTdHlsZT1wYXNzU3R5bGVPZihsZWZ0KTtcbmNvbnN0IHJpZ2h0U3R5bGU9cGFzc1N0eWxlT2YocmlnaHQpO1xuaWYobGVmdFN0eWxlIT09cmlnaHRTdHlsZSl7XG4vKiBEaWZmZXJlbnQgcGFzc1N0eWxlcyBhcmUgaW5jb21tZW5zdXJhdGUqL1xucmV0dXJuIE5hTjtcbiB9XG5zd2l0Y2gobGVmdFN0eWxlKXtcbmNhc2UndW5kZWZpbmVkJzpcbmNhc2UnbnVsbCc6XG5jYXNlJ2Jvb2xlYW4nOlxuY2FzZSdiaWdpbnQnOlxuY2FzZSdzdHJpbmcnOlxuY2FzZSdzeW1ib2wnOntcbi8qIGZvciB0aGVzZSwga2V5cyBjb21wYXJlIHRoZSBzYW1lIGFzIHJhbmsqL1xucmV0dXJuIGNvbXBhcmVSYW5rKGxlZnQscmlnaHQpO1xuIH1cbmNhc2UnbnVtYmVyJzp7XG5jb25zdCByYW5rQ29tcD1jb21wYXJlUmFuayhsZWZ0LHJpZ2h0KTtcbmlmKHJhbmtDb21wPT09MCl7XG5yZXR1cm4gMDtcbiB9XG5pZihOdW1iZXIuaXNOYU4obGVmdCl8fE51bWJlci5pc05hTihyaWdodCkpe1xuLyogTmFOIGlzIGVxdWFsIHRvIGl0c2VsZiwgYnV0IGluY29tbWVuc3VyYXRlIHdpdGggZXZlcnl0aGluZyBlbHNlKi9cbmFzc2VydCghTnVtYmVyLmlzTmFOKGxlZnQpfHwhTnVtYmVyLmlzTmFOKHJpZ2h0KSk7XG5yZXR1cm4gTmFOO1xuIH1cbi8qIEFtb25nIG5vbi1OYU4gbnVtYmVycywga2V5IG9yZGVyIGlzIHRoZSBzYW1lIGFzIHJhbmsgb3JkZXIuIE5vdGUgdGhhdCovXG4vKiBpbiBib3RoIG9yZGVycywgYC0wYCBpcyBpbiB0aGUgc2FtZSBlcXVpdmFsZW5jZSBjbGFzcyBhcyBgMGAuKi9cbnJldHVybiByYW5rQ29tcDtcbiB9XG5jYXNlJ3JlbW90YWJsZSc6e1xuaWYobGVmdD09PXJpZ2h0KXtcbnJldHVybiAwO1xuIH1cbi8qIElmIHR3byByZW1vdGFibGVzIGFyZSBub3QgaWRlbnRpY2FsLCB0aGVuIGFzIGtleXMgdGhleSBhcmUqL1xuLyogaW5jb21tZW5zdXJhdGUuKi9cbnJldHVybiBOYU47XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIExleGljb2dyYXBoaWMgYnkga2V5IG9yZGVyLiBSYW5rIG9yZGVyIG9mIGFycmF5cyBpcyBsZXhpY29ncmFwaGljIGJ5Ki9cbi8qIHJhbmsgb3JkZXIuKi9cbi8qIEJlY2F1c2UgdGhlIGludmFyaWFudHMgYWJvdmUgYXBwbHkgdG8gdGhlIGVsZW1lbnRzIG9mIHRoZSBhcnJheSwqL1xuLyogdGhleSBhcHBseSB0byB0aGUgYXJyYXkgYXMgYSB3aG9sZS4qL1xuY29uc3QgbGVuPU1hdGgubWluKGxlZnQubGVuZ3RoLHJpZ2h0Lmxlbmd0aCk7XG5mb3IobGV0IGk9MDtpPGxlbjtpKz0xKXtcbmNvbnN0IHJlc3VsdD1jb21wYXJlS2V5cyhsZWZ0W2ldLHJpZ2h0W2ldKTtcbmlmKHJlc3VsdCE9PTApe1xucmV0dXJuIHJlc3VsdDtcbiB9XG4gfVxuLyogSWYgYWxsIG1hdGNoaW5nIGVsZW1lbnRzIGFyZSBrZXlFUSwgdGhlbiBhY2NvcmRpbmcgdG8gdGhlaXIgbGVuZ3Rocy4qL1xuLyogVGh1cywgaWYgYXJyYXkgWCBpcyBhIHByZWZpeCBvZiBhcnJheSBZLCB0aGVuIFggaXMgc21hbGxlciB0aGFuIFkuKi9cbnJldHVybiBjb21wYXJlUmFuayhsZWZ0Lmxlbmd0aCxyaWdodC5sZW5ndGgpO1xuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuLyogUGFyZXRvIHBhcnRpYWwgb3JkZXIgY29tcGFyaXNvbi4qL1xuY29uc3QgbGVmdE5hbWVzPXJlY29yZE5hbWVzKGxlZnQpO1xuY29uc3QgcmlnaHROYW1lcz1yZWNvcmROYW1lcyhyaWdodCk7XG5cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11c2UtYmVmb3JlLWRlZmluZSovXG5pZigha2V5RVEobGVmdE5hbWVzLHJpZ2h0TmFtZXMpKXtcbi8qIElmIHRoZXkgZG8gbm90IGhhdmUgZXhhY3RseSB0aGUgc2FtZSBwcm9wZXJ0aWVzLCovXG4vKiB0aGV5IGFyZSBpbmNvbW1lbnN1cmF0ZS4qL1xuLyogTm90ZSB0aGF0IHJhbmsgc29ydGluZyBvZiBjb3B5UmVjb3JkcyBncm91cHMgYWxsIGNvcHlSZWNvcmRzIHdpdGgqL1xuLyogdGhlIHNhbWUga2V5cyB0b2dldGhlciwgZW5hYmxpbmcgcmFuZ2Ugc2VhcmNoaW5nIG92ZXIgY29weVJlY29yZHMqL1xuLyogdG8gYXZvaWQgbW9yZSBpcnJlbGV2YW50IG9uZXMuKi9cbnJldHVybiBOYU47XG4gfVxuY29uc3QgbGVmdFZhbHVlcz1yZWNvcmRWYWx1ZXMobGVmdCxsZWZ0TmFtZXMpO1xuY29uc3QgcmlnaHRWYWx1ZXM9cmVjb3JkVmFsdWVzKHJpZ2h0LHJpZ2h0TmFtZXMpO1xuLyogUHJlc3VtZSB0aGF0IGJvdGggY29weVJlY29yZHMgaGF2ZSB0aGUgc2FtZSBrZXkgb3JkZXIqL1xuLyogdW50aWwgZW5jb3VudGVyaW5nIGEgcHJvcGVydHkgZGlzcHJvdmluZyB0aGF0IGh5cG90aGVzaXMuKi9cbmxldCByZXN1bHQ9MDtcbmZvcihsZXQgaT0wO2k8bGVmdFZhbHVlcy5sZW5ndGg7aSs9MSl7XG5jb25zdCBjb21wPWNvbXBhcmVLZXlzKGxlZnRWYWx1ZXNbaV0scmlnaHRWYWx1ZXNbaV0pO1xuaWYoTnVtYmVyLmlzTmFOKGNvbXApKXtcbnJldHVybiBOYU47XG4gfVxuaWYocmVzdWx0IT09Y29tcCYmY29tcCE9PTApe1xuaWYocmVzdWx0PT09MCl7XG5yZXN1bHQ9Y29tcDtcbiB9ZWxzZXtcbmFzc2VydChcbnJlc3VsdD09PS0xJiZjb21wPT09MXx8cmVzdWx0PT09MSYmY29tcD09PS0xKTtcblxucmV0dXJuIE5hTjtcbiB9XG4gfVxuIH1cbi8qIElmIGNvcHlSZWNvcmQgWCBpcyBzbWFsbGVyIHRoYW4gY29weVJlY29yZCBZLCB0aGVuIHRoZXkgbXVzdCBoYXZlIHRoZSovXG4vKiBzYW1lIHByb3BlcnR5IG5hbWVzIGFuZCBldmVyeSB2YWx1ZSBpbiBYIG11c3QgYmUgc21hbGxlciBvciBlcXVhbCB0byovXG4vKiB0aGUgY29ycmVzcG9uZGluZyB2YWx1ZSBpbiBZICh3aXRoIGF0IGxlYXN0IG9uZSB2YWx1ZSBzbWFsbGVyKS4qL1xuLyogVGhlIHJhbmsgb3JkZXIgb2YgWCBhbmQgWSBpcyBiYXNlZCBvbiBsZXhpY29ncmFwaGljIHJhbmsgb3JkZXIgb2YqL1xuLyogdGhlaXIgdmFsdWVzLCBhcyBvcmdhbml6ZWQgYnkgcmV2ZXJzZSBsZXhpY29ncmFwaGljIG9yZGVyIG9mIHRoZWlyKi9cbi8qIHByb3BlcnR5IG5hbWVzLiovXG4vKiBUaHVzIGlmIGNvbXBhcmVLZXlzKFgsWSkgPCAwIHRoZW4gY29tcGFyZVJhbmsoWCxZKSA8IDAuKi9cbnJldHVybiByZXN1bHQ7XG4gfVxuY2FzZSd0YWdnZWQnOntcbmNvbnN0IGxlZnRUYWc9Z2V0VGFnKGxlZnQpO1xuY29uc3QgcmlnaHRUYWc9Z2V0VGFnKHJpZ2h0KTtcbmlmKGxlZnRUYWchPT1yaWdodFRhZyl7XG4vKiBkaWZmZXJlbnQgdGFncyBhcmUgaW5jb21tZW5zdXJhdGUqL1xucmV0dXJuIE5hTjtcbiB9XG5zd2l0Y2gobGVmdFRhZyl7XG5jYXNlJ2NvcHlTZXQnOntcbi8qIGNvcHlTZXQgWCBpcyBzbWFsbGVyIHRoYW4gY29weVNldCBZIHdoZW4gZXZlcnkgZWxlbWVudCBvZiBYKi9cbi8qIGlzIGtleUVRIHRvIHNvbWUgZWxlbWVudCBvZiBZIGFuZCBzb21lIGVsZW1lbnQgb2YgWSBpcyovXG4vKiBub3Qga2V5RVEgdG8gYW55IGVsZW1lbnQgb2YgWC4qL1xucmV0dXJuIHNldENvbXBhcmUobGVmdCxyaWdodCk7XG4gfVxuY2FzZSdjb3B5QmFnJzp7XG4vKiBjb3B5QmFnIFggaXMgc21hbGxlciB0aGFuIGNvcHlCYWcgWSB3aGVuIGV2ZXJ5IGVsZW1lbnQgb2YgWCovXG4vKiBvY2N1cnMgbm8gbW9yZSB0aGFuIHRoZSBrZXlFUSBlbGVtZW50IG9mIFksIGFuZCBzb21lIGVsZW1lbnQqL1xuLyogb2YgWSBvY2N1cnMgbW9yZSB0aGFuIHNvbWUgZWxlbWVudCBvZiBYLCB3aGVyZSBiZWluZyBhYnNlbnQqL1xuLyogZnJvbSBYIGNvdW50cyBhcyBvY2N1cnJpbmcgemVybyB0aW1lcy4qL1xucmV0dXJuIGJhZ0NvbXBhcmUobGVmdCxyaWdodCk7XG4gfVxuY2FzZSdjb3B5TWFwJzp7XG4vKiBUd28gY29weU1hcHMgdGhhdCBoYXZlIGRpZmZlcmVudCBrZXlzIChhY2NvcmRpbmcgdG8ga2V5RVEpIGFyZSovXG4vKiBpbmNvbW1lbnN1cmF0ZS4gVGhlIHJlcHJlc2VudGF0aW9uIG9mIGNvcHlNYXBzIGluY2x1ZGVzIHRoZSBrZXlzKi9cbi8qIGZpcnN0LCBpbiB0aGUgc2FtZSByZXZlcnNlIHJhbmsgb3JkZXIgdXNlZCBieSBzZXRzLiBUaHVzLCBhbGwqL1xuLyogY29weU1hcHMgd2l0aCBrZXlzIG9mIHRoZSBzYW1lIHJhbmsgKHdoaWNoIGlzKi9cbi8qIGxlc3MgcHJlY2lzZSEpIHdpbGwgYmUgZ3JvdXBlZCB0b2dldGhlciB3aGVuIGNvcHlNYXBzIGFyZSBzb3J0ZWQqL1xuLyogYnkgcmFuaywgbWluaW1pemluZyB0aGUgbnVtYmVyIG9mIG1pc3NlcyB3aGVuIHJhbmdlIHNlYXJjaGluZy4qL1xuLyoqL1xuLyogQW1vbmcgY29weU1hcHMgd2l0aCB0aGUgc2FtZSBrZXlzIChhY2NvcmRpbmcgdG8ga2V5RVEpLCB0aGV5Ki9cbi8qIGNvbXBhcmUgYnkgYSBjb3JyZXNwb25kaW5nIGNvbXBhcmlzb24gb2YgdGhlaXIgdmFsdWVzLiBUaHVzLCBhcyovXG4vKiB3aXRoIHJlY29yZHMsIGZvciB0d28gY29weU1hcHMgWCBhbmQgWSwgaWYgYGNvbXBhcmVLZXlzKFgsWSkgPCovXG4vKiAwYCB0aGVuLCBiZWNhdXNlIHRoZXNlIHZhbHVlcyBvYmV5IHRoZSBhYm92ZSBpbnZhcmlhbnRzLCBub25lIG9mKi9cbi8qIHRoZSB2YWx1ZXMgaW4gWCBoYXZlIGEgbGF0ZXIgcmFuayB0aGFuIHRoZSBjb3JyZXNwb25kaW5nIHZhbHVlKi9cbi8qIG9mIFkuIFRodXMsIGBjb21wYXJlUmFuayhYLFkpIDw9IDBgLiBUT0RPIGltcGxlbWVudCovXG50aHJvdyBGYWlsIGBNYXAgY29tcGFyaXNvbiBub3QgeWV0IGltcGxlbWVudGVkOiAke2xlZnR9IHZzICR7cmlnaHR9YDtcbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYHVuZXhwZWN0ZWQgdGFnICR7cShsZWZ0VGFnKX06ICR7bGVmdH1gO1xuIH19XG5cbiB9XG5kZWZhdWx0OntcbnRocm93IEZhaWwgYHVuZXhwZWN0ZWQgcGFzc1N0eWxlICR7cShsZWZ0U3R5bGUpfTogJHtsZWZ0fWA7XG4gfX1cblxuIH07JGjigI1fb25jZS5jb21wYXJlS2V5cyhjb21wYXJlS2V5cyk7XG5oYXJkZW4oY29tcGFyZUtleXMpO1xuXG5jb25zdCAgICAgICAga2V5TFQ9KGxlZnQscmlnaHQpPT5jb21wYXJlS2V5cyhsZWZ0LHJpZ2h0KTwwOyRo4oCNX29uY2Uua2V5TFQoa2V5TFQpO1xuaGFyZGVuKGtleUxUKTtcblxuY29uc3QgICAgICAgIGtleUxURT0obGVmdCxyaWdodCk9PmNvbXBhcmVLZXlzKGxlZnQscmlnaHQpPD0wOyRo4oCNX29uY2Uua2V5TFRFKGtleUxURSk7XG5oYXJkZW4oa2V5TFRFKTtcblxuY29uc3QgICAgICAgIGtleUVRPShsZWZ0LHJpZ2h0KT0+Y29tcGFyZUtleXMobGVmdCxyaWdodCk9PT0wOyRo4oCNX29uY2Uua2V5RVEoa2V5RVEpO1xuaGFyZGVuKGtleUVRKTtcblxuY29uc3QgICAgICAgIGtleUdURT0obGVmdCxyaWdodCk9PmNvbXBhcmVLZXlzKGxlZnQscmlnaHQpPj0wOyRo4oCNX29uY2Uua2V5R1RFKGtleUdURSk7XG5oYXJkZW4oa2V5R1RFKTtcblxuY29uc3QgICAgICAgIGtleUdUPShsZWZ0LHJpZ2h0KT0+Y29tcGFyZUtleXMobGVmdCxyaWdodCk+MDskaOKAjV9vbmNlLmtleUdUKGtleUdUKTtcbmhhcmRlbihrZXlHVCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiY29tcGFyZUtleXMiOlsiY29tcGFyZUtleXMiXSwia2V5TFQiOlsia2V5TFQiXSwia2V5TFRFIjpbImtleUxURSJdLCJrZXlFUSI6WyJrZXlFUSJdLCJrZXlHVEUiOlsia2V5R1RFIl0sImtleUdUIjpbImtleUdUIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAFUgwv0qFAAAKhQAACkAAABAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvY29weUJhZy5qc3siaW1wb3J0cyI6WyJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiYXNzZXJ0QmFnRW50cmllcyIsImFzc2VydE5vRHVwbGljYXRlS2V5cyIsImNoZWNrQmFnRW50cmllcyIsImNvZXJjZVRvQmFnRW50cmllcyIsIm1ha2VCYWdPZkVudHJpZXMiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0Q2hlY2tlcixtYWtlVGFnZ2VkLHBhc3NTdHlsZU9mLGNvbXBhcmVBbnRpUmFuayxpc1JhbmtTb3J0ZWQsbWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQsc29ydEJ5UmFuazskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRDaGVja2VyXCIsIFskaOKAjV9hID0+IChhc3NlcnRDaGVja2VyID0gJGjigI1fYSldXSxbXCJtYWtlVGFnZ2VkXCIsIFskaOKAjV9hID0+IChtYWtlVGFnZ2VkID0gJGjigI1fYSldXSxbXCJwYXNzU3R5bGVPZlwiLCBbJGjigI1fYSA9PiAocGFzc1N0eWxlT2YgPSAkaOKAjV9hKV1dLFtcImNvbXBhcmVBbnRpUmFua1wiLCBbJGjigI1fYSA9PiAoY29tcGFyZUFudGlSYW5rID0gJGjigI1fYSldXSxbXCJpc1JhbmtTb3J0ZWRcIiwgWyRo4oCNX2EgPT4gKGlzUmFua1NvcnRlZCA9ICRo4oCNX2EpXV0sW1wibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0ID0gJGjigI1fYSldXSxbXCJzb3J0QnlSYW5rXCIsIFskaOKAjV9hID0+IChzb3J0QnlSYW5rID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG4vKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG5jb25zdHtkZXRhaWxzOlh9PWFzc2VydDtcblxuLyoqIEB0ZW1wbGF0ZSB7S2V5fSBbSz1LZXldIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkNvcHlCYWc8Sz59IENvcHlCYWcgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXl9IEtleSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkZ1bGxDb21wYXJlfSBGdWxsQ29tcGFyZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuQ2hlY2tlcn0gQ2hlY2tlciAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9wYXNzLXN0eWxlJykuUGFzc2FibGV9IFBhc3NhYmxlICovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7W1QsYmlnaW50XVtdfSBiYWdFbnRyaWVzXG4gKiBAcGFyYW0ge0Z1bGxDb21wYXJlIHwgdW5kZWZpbmVkfSBmdWxsQ29tcGFyZSBJZiBwcm92aWRlZCBhbmQgYGJhZ0VudHJpZXNgIGlzIGFscmVhZHlcbiAqIGtub3duIHRvIGJlIHNvcnRlZCBieSB0aGlzIGBmdWxsQ29tcGFyZWAsIHRoZW4gd2Ugc2hvdWxkIGdldCBhIG1lbW8gaGl0XG4gKiByYXRoZXIgdGhhbiBhIHJlc29ydGluZy4gSG93ZXZlciwgY3VycmVudGx5LCB3ZSBzdGlsbCBlbnVtZXJhdGUgdGhlIGVudGlyZVxuICogYXJyYXkgZWFjaCB0aW1lLlxuICpcbiAqIFRPRE86IElmIGRvaW5nIHRoaXMgcmVkdW50YW50bHkgdHVybnMgb3V0IHRvIGJlIGV4cGVuc2l2ZSwgd2VcbiAqIGNvdWxkIG1lbW9pemUgdGhpcyBuby1kdXBsaWNhdGUta2V5cyBmaW5kaW5nIGFzIHdlbGwsIGluZGVwZW5kZW50XG4gKiBvZiB0aGUgYGZ1bGxPcmRlcmAgdXNlIHRvIHJlYWNoIHRoaXMgZmluZGluZy5cbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja05vRHVwbGljYXRlS2V5cz0oYmFnRW50cmllcyxmdWxsQ29tcGFyZSxjaGVjayk9Pntcbi8qIFRoaXMgZnVsbE9yZGVyIGNvbnRhaW5zIGhpc3RvcnkgZGVwZW5kZW50IHN0YXRlLiBJdCBpcyBzcGVjaWZpYyovXG4vKiB0byB0aGlzIG9uZSBjYWxsIGFuZCBkb2VzIG5vdCBzdXJ2aXZlIGl0LiovXG4vKiBUT0RPIE9uY2UgYWxsIG91ciB0b29saW5nIGlzIHJlYWR5IGZvciBgJiY9YCwgdGhlIGZvbGxvd2luZyovXG4vKiBsaW5lIHNob3VsZCBiZSByZXdyaXR0ZW4gdXNpbmcgaXQuKi9cbmZ1bGxDb21wYXJlPWZ1bGxDb21wYXJlfHxtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCgpLmFudGlDb21wYXJhdG9yO1xuXG4vKiBTaW5jZSB0aGUga2V5IGlzIG1vcmUgc2lnbmlmaWNhbnQgdGhhbiB0aGUgdmFsdWUgKHRoZSBjb3VudCksKi9cbi8qIHNvcnRpbmcgYnkgZnVsbE9yZGVyIGlzIGd1YXJhbnRlZWQgdG8gbWFrZSBkdXBsaWNhdGUga2V5cyovXG4vKiBhZGphY2VudCBpbmRlcGVuZGVudCBvZiB0aGVpciBjb3VudHMuKi9cbmJhZ0VudHJpZXM9c29ydEJ5UmFuayhiYWdFbnRyaWVzLGZ1bGxDb21wYXJlKTtcbmNvbnN0e2xlbmd0aH09YmFnRW50cmllcztcbmZvcihsZXQgaT0xO2k8bGVuZ3RoO2krPTEpe1xuY29uc3QgazA9YmFnRW50cmllc1tpLTFdWzBdO1xuY29uc3QgazE9YmFnRW50cmllc1tpXVswXTtcbmlmKGZ1bGxDb21wYXJlKGswLGsxKT09PTApe1xucmV0dXJuIGNoZWNrKGZhbHNlLFggYHZhbHVlIGhhcyBkdXBsaWNhdGUga2V5czogJHtrMH1gKTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtbVCxiaWdpbnRdW119IGJhZ0VudHJpZXNcbiAqIEBwYXJhbSB7RnVsbENvbXBhcmV9IFtmdWxsQ29tcGFyZV1cbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzPShiYWdFbnRyaWVzLGZ1bGxDb21wYXJlPXVuZGVmaW5lZCk9PntcbmNoZWNrTm9EdXBsaWNhdGVLZXlzKGJhZ0VudHJpZXMsZnVsbENvbXBhcmUsYXNzZXJ0Q2hlY2tlcik7XG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1tQYXNzYWJsZSxiaWdpbnRdW119IGJhZ0VudHJpZXNcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjigI1fb25jZS5hc3NlcnROb0R1cGxpY2F0ZUtleXMoYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzKTtcbmNvbnN0ICAgICAgICBjaGVja0JhZ0VudHJpZXM9KGJhZ0VudHJpZXMsY2hlY2spPT57XG5pZihwYXNzU3R5bGVPZihiYWdFbnRyaWVzKSE9PSdjb3B5QXJyYXknKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgVGhlIGVudHJpZXMgb2YgYSBjb3B5QmFnIG11c3QgYmUgYSBjb3B5QXJyYXk6ICR7YmFnRW50cmllc31gKTtcblxuIH1cbmlmKCFpc1JhbmtTb3J0ZWQoYmFnRW50cmllcyxjb21wYXJlQW50aVJhbmspKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgVGhlIGVudHJpZXMgb2YgYSBjb3B5QmFnIG11c3QgYmUgc29ydGVkIGluIHJldmVyc2UgcmFuayBvcmRlcjogJHtiYWdFbnRyaWVzfWApO1xuXG4gfVxuZm9yKGNvbnN0IGVudHJ5IG9mIGJhZ0VudHJpZXMpe1xuaWYoXG5wYXNzU3R5bGVPZihlbnRyeSkhPT0nY29weUFycmF5J3x8XG5lbnRyeS5sZW5ndGghPT0yfHxcbnR5cGVvZiBlbnRyeVsxXSE9PSdiaWdpbnQnKVxue1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGBFYWNoIGVudHJ5IG9mIGEgY29weUJhZyBtdXN0IGJlIHBhaXIgb2YgYSBrZXkgYW5kIGEgYmlnaW50IHJlcHJlc2VudGluZyBhIGNvdW50OiAke2VudHJ5fWApO1xuXG4gfVxuaWYoZW50cnlbMV08MSl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYEVhY2ggZW50cnkgb2YgYSBjb3B5QmFnIG11c3QgaGF2ZSBhIHBvc2l0aXZlIGNvdW50OiAke2VudHJ5fWApO1xuXG4gfVxuIH1cbnJldHVybiBjaGVja05vRHVwbGljYXRlS2V5cyhiYWdFbnRyaWVzLHVuZGVmaW5lZCxjaGVjayk7XG4gfTskaOKAjV9vbmNlLmNoZWNrQmFnRW50cmllcyhjaGVja0JhZ0VudHJpZXMpO1xuaGFyZGVuKGNoZWNrQmFnRW50cmllcyk7XG5cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBqc2RvYy9yZXF1aXJlLXJldHVybnMtY2hlY2sgLS0gZG9lc24ndCB1bmRlcnN0YW5kIGFzc2VydHMqL1xuLyoqXG4gKiBAcGFyYW0ge1tQYXNzYWJsZSxiaWdpbnRdW119IGJhZ0VudHJpZXNcbiAqIEByZXR1cm5zIHthc3NlcnRzIGJhZ0VudHJpZXMgaXMgW1Bhc3NhYmxlLGJpZ2ludF1bXX1cbiAqL1xuY29uc3QgICAgICAgIGFzc2VydEJhZ0VudHJpZXM9KGJhZ0VudHJpZXMpPT57XG5jaGVja0JhZ0VudHJpZXMoYmFnRW50cmllcyxhc3NlcnRDaGVja2VyKTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0QmFnRW50cmllcyhhc3NlcnRCYWdFbnRyaWVzKTtcbmhhcmRlbihhc3NlcnRCYWdFbnRyaWVzKTtcblxuY29uc3QgICAgICAgIGNvZXJjZVRvQmFnRW50cmllcz0oYmFnRW50cmllc0xpc3QpPT57XG5jb25zdCBiYWdFbnRyaWVzPXNvcnRCeVJhbmsoYmFnRW50cmllc0xpc3QsY29tcGFyZUFudGlSYW5rKTtcbmFzc2VydEJhZ0VudHJpZXMoYmFnRW50cmllcyk7XG5yZXR1cm4gYmFnRW50cmllcztcbiB9OyRo4oCNX29uY2UuY29lcmNlVG9CYWdFbnRyaWVzKGNvZXJjZVRvQmFnRW50cmllcyk7XG5oYXJkZW4oY29lcmNlVG9CYWdFbnRyaWVzKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgS1xuICogQHBhcmFtIHtJdGVyYWJsZTxbSywgYmlnaW50XT59IGJhZ0VudHJ5SXRlclxuICogQHJldHVybnMge0NvcHlCYWc8Sz59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQmFnT2ZFbnRyaWVzPShiYWdFbnRyeUl0ZXIpPT5cbm1ha2VUYWdnZWQoJ2NvcHlCYWcnLGNvZXJjZVRvQmFnRW50cmllcyhiYWdFbnRyeUl0ZXIpKTskaOKAjV9vbmNlLm1ha2VCYWdPZkVudHJpZXMobWFrZUJhZ09mRW50cmllcyk7XG5oYXJkZW4obWFrZUJhZ09mRW50cmllcyk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzIjpbImFzc2VydE5vRHVwbGljYXRlS2V5cyJdLCJjaGVja0JhZ0VudHJpZXMiOlsiY2hlY2tCYWdFbnRyaWVzIl0sImFzc2VydEJhZ0VudHJpZXMiOlsiYXNzZXJ0QmFnRW50cmllcyJdLCJjb2VyY2VUb0JhZ0VudHJpZXMiOlsiY29lcmNlVG9CYWdFbnRyaWVzIl0sIm1ha2VCYWdPZkVudHJpZXMiOlsibWFrZUJhZ09mRW50cmllcyJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAKHf6/oxAAAKMQAAApAAAAQGVuZG8vcGF0dGVybnMtdjAuMi4yL3NyYy9rZXlzL2NvcHlTZXQuanN7ImltcG9ydHMiOlsiQGVuZG8vbWFyc2hhbCJdLCJleHBvcnRzIjpbImFzc2VydEVsZW1lbnRzIiwiYXNzZXJ0Tm9EdXBsaWNhdGVzIiwiY2hlY2tFbGVtZW50cyIsImNvZXJjZVRvRWxlbWVudHMiLCJtYWtlU2V0T2ZFbGVtZW50cyJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLG1ha2VUYWdnZWQscGFzc1N0eWxlT2YsY29tcGFyZUFudGlSYW5rLGlzUmFua1NvcnRlZCxtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCxzb3J0QnlSYW5rOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL21hcnNoYWxcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcIm1ha2VUYWdnZWRcIiwgWyRo4oCNX2EgPT4gKG1ha2VUYWdnZWQgPSAkaOKAjV9hKV1dLFtcInBhc3NTdHlsZU9mXCIsIFskaOKAjV9hID0+IChwYXNzU3R5bGVPZiA9ICRo4oCNX2EpXV0sW1wiY29tcGFyZUFudGlSYW5rXCIsIFskaOKAjV9hID0+IChjb21wYXJlQW50aVJhbmsgPSAkaOKAjV9hKV1dLFtcImlzUmFua1NvcnRlZFwiLCBbJGjigI1fYSA9PiAoaXNSYW5rU29ydGVkID0gJGjigI1fYSldXSxbXCJtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdFwiLCBbJGjigI1fYSA9PiAobWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQgPSAkaOKAjV9hKV1dLFtcInNvcnRCeVJhbmtcIiwgWyRo4oCNX2EgPT4gKHNvcnRCeVJhbmsgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cbi8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbmNvbnN0e2RldGFpbHM6WH09YXNzZXJ0O1xuXG4vKiogQHRlbXBsYXRlIHtLZXl9IFtLPUtleV0gQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuQ29weVNldDxLPn0gQ29weVNldCAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLktleX0gS2V5ICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuRnVsbENvbXBhcmV9IEZ1bGxDb21wYXJlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5DaGVja2VyfSBDaGVja2VyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL3Bhc3Mtc3R5bGUnKS5QYXNzYWJsZX0gUGFzc2FibGUgKi9cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUW119IGVsZW1lbnRzXG4gKiBAcGFyYW0ge0Z1bGxDb21wYXJlIHwgdW5kZWZpbmVkfSBmdWxsQ29tcGFyZSBJZiBwcm92aWRlZCBhbmQgYGVsZW1lbnRzYCBpcyBhbHJlYWR5IGtub3duXG4gKiB0byBiZSBzb3J0ZWQgYnkgdGhpcyBgZnVsbENvbXBhcmVgLCB0aGVuIHdlIHNob3VsZCBnZXQgYSBtZW1vIGhpdCByYXRoZXJcbiAqIHRoYW4gYSByZXNvcnRpbmcuIEhvd2V2ZXIsIGN1cnJlbnRseSwgd2Ugc3RpbGwgZW51bWVyYXRlIHRoZSBlbnRpcmUgYXJyYXlcbiAqIGVhY2ggdGltZS5cbiAqXG4gKiBUT0RPOiBJZiBkb2luZyB0aGlzIHJlZHVudGFudGx5IHR1cm5zIG91dCB0byBiZSBleHBlbnNpdmUsIHdlXG4gKiBjb3VsZCBtZW1vaXplIHRoaXMgbm8tZHVwbGljYXRlIGZpbmRpbmcgYXMgd2VsbCwgaW5kZXBlbmRlbnRcbiAqIG9mIHRoZSBgZnVsbE9yZGVyYCB1c2UgdG8gcmVhY2ggdGhpcyBmaW5kaW5nLlxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrTm9EdXBsaWNhdGVzPShlbGVtZW50cyxmdWxsQ29tcGFyZSxjaGVjayk9Pntcbi8qIFRoaXMgZnVsbE9yZGVyIGNvbnRhaW5zIGhpc3RvcnkgZGVwZW5kZW50IHN0YXRlLiBJdCBpcyBzcGVjaWZpYyovXG4vKiB0byB0aGlzIG9uZSBjYWxsIGFuZCBkb2VzIG5vdCBzdXJ2aXZlIGl0LiovXG4vKiBUT0RPIE9uY2UgYWxsIG91ciB0b29saW5nIGlzIHJlYWR5IGZvciBgJiY9YCwgdGhlIGZvbGxvd2luZyovXG4vKiBsaW5lIHNob3VsZCBiZSByZXdyaXR0ZW4gdXNpbmcgaXQuKi9cbmZ1bGxDb21wYXJlPWZ1bGxDb21wYXJlfHxtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCgpLmFudGlDb21wYXJhdG9yO1xuXG5lbGVtZW50cz1zb3J0QnlSYW5rKGVsZW1lbnRzLGZ1bGxDb21wYXJlKTtcbmNvbnN0e2xlbmd0aH09ZWxlbWVudHM7XG5mb3IobGV0IGk9MTtpPGxlbmd0aDtpKz0xKXtcbmNvbnN0IGswPWVsZW1lbnRzW2ktMV07XG5jb25zdCBrMT1lbGVtZW50c1tpXTtcbmlmKGZ1bGxDb21wYXJlKGswLGsxKT09PTApe1xucmV0dXJuIGNoZWNrKGZhbHNlLFggYHZhbHVlIGhhcyBkdXBsaWNhdGVzOiAke2swfWApO1xuIH1cbiB9XG5yZXR1cm4gdHJ1ZTtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1RbXX0gZWxlbWVudHNcbiAqIEBwYXJhbSB7RnVsbENvbXBhcmV9IFtmdWxsQ29tcGFyZV1cbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5jb25zdCAgICAgICAgYXNzZXJ0Tm9EdXBsaWNhdGVzPShlbGVtZW50cyxmdWxsQ29tcGFyZT11bmRlZmluZWQpPT57XG5jaGVja05vRHVwbGljYXRlcyhlbGVtZW50cyxmdWxsQ29tcGFyZSxhc3NlcnRDaGVja2VyKTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gZWxlbWVudHNcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovJGjigI1fb25jZS5hc3NlcnROb0R1cGxpY2F0ZXMoYXNzZXJ0Tm9EdXBsaWNhdGVzKTtcbmNvbnN0ICAgICAgICBjaGVja0VsZW1lbnRzPShlbGVtZW50cyxjaGVjayk9PntcbmlmKHBhc3NTdHlsZU9mKGVsZW1lbnRzKSE9PSdjb3B5QXJyYXknKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgVGhlIGtleXMgb2YgYSBjb3B5U2V0IG9yIGNvcHlNYXAgbXVzdCBiZSBhIGNvcHlBcnJheTogJHtlbGVtZW50c31gKTtcblxuIH1cbmlmKCFpc1JhbmtTb3J0ZWQoZWxlbWVudHMsY29tcGFyZUFudGlSYW5rKSl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYFRoZSBrZXlzIG9mIGEgY29weVNldCBvciBjb3B5TWFwIG11c3QgYmUgc29ydGVkIGluIHJldmVyc2UgcmFuayBvcmRlcjogJHtlbGVtZW50c31gKTtcblxuIH1cbnJldHVybiBjaGVja05vRHVwbGljYXRlcyhlbGVtZW50cyx1bmRlZmluZWQsY2hlY2spO1xuIH07JGjigI1fb25jZS5jaGVja0VsZW1lbnRzKGNoZWNrRWxlbWVudHMpO1xuaGFyZGVuKGNoZWNrRWxlbWVudHMpO1xuXG5jb25zdCAgICAgICAgYXNzZXJ0RWxlbWVudHM9KGVsZW1lbnRzKT0+e1xuY2hlY2tFbGVtZW50cyhlbGVtZW50cyxhc3NlcnRDaGVja2VyKTtcbiB9OyRo4oCNX29uY2UuYXNzZXJ0RWxlbWVudHMoYXNzZXJ0RWxlbWVudHMpO1xuaGFyZGVuKGFzc2VydEVsZW1lbnRzKTtcblxuY29uc3QgICAgICAgIGNvZXJjZVRvRWxlbWVudHM9KGVsZW1lbnRzTGlzdCk9PntcbmNvbnN0IGVsZW1lbnRzPXNvcnRCeVJhbmsoZWxlbWVudHNMaXN0LGNvbXBhcmVBbnRpUmFuayk7XG5hc3NlcnRFbGVtZW50cyhlbGVtZW50cyk7XG5yZXR1cm4gZWxlbWVudHM7XG4gfTskaOKAjV9vbmNlLmNvZXJjZVRvRWxlbWVudHMoY29lcmNlVG9FbGVtZW50cyk7XG5oYXJkZW4oY29lcmNlVG9FbGVtZW50cyk7XG5cbi8qKlxuICogQHRlbXBsYXRlIEtcbiAqIEBwYXJhbSB7SXRlcmFibGU8Sz59IGVsZW1lbnRJdGVyXG4gKiBAcmV0dXJucyB7Q29weVNldDxLPn1cbiAqL1xuY29uc3QgICAgICAgIG1ha2VTZXRPZkVsZW1lbnRzPShlbGVtZW50SXRlcik9PlxubWFrZVRhZ2dlZCgnY29weVNldCcsY29lcmNlVG9FbGVtZW50cyhlbGVtZW50SXRlcikpOyRo4oCNX29uY2UubWFrZVNldE9mRWxlbWVudHMobWFrZVNldE9mRWxlbWVudHMpO1xuaGFyZGVuKG1ha2VTZXRPZkVsZW1lbnRzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJhc3NlcnROb0R1cGxpY2F0ZXMiOlsiYXNzZXJ0Tm9EdXBsaWNhdGVzIl0sImNoZWNrRWxlbWVudHMiOlsiY2hlY2tFbGVtZW50cyJdLCJhc3NlcnRFbGVtZW50cyI6WyJhc3NlcnRFbGVtZW50cyJdLCJjb2VyY2VUb0VsZW1lbnRzIjpbImNvZXJjZVRvRWxlbWVudHMiXSwibWFrZVNldE9mRWxlbWVudHMiOlsibWFrZVNldE9mRWxlbWVudHMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAACyiebXklAAB5JQAANQAAAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMva2V5cy9tZXJnZS1iYWctb3BlcmF0b3JzLmpzeyJpbXBvcnRzIjpbIi4vY29weUJhZy5qcyIsIkBlbmRvL21hcnNoYWwiXSwiZXhwb3J0cyI6WyJiYWdDb21wYXJlIiwiYmFnRGlzam9pbnRTdWJ0cmFjdCIsImJhZ0ludGVyc2VjdGlvbiIsImJhZ0lzRGlzam9pbnQiLCJiYWdJc1N1cGVyYmFnIiwiYmFnVW5pb24iXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgYXNzZXJ0UmFua1NvcnRlZCxjb21wYXJlQW50aVJhbmssbWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQsc29ydEJ5UmFuayxhc3NlcnROb0R1cGxpY2F0ZUtleXMsbWFrZUJhZ09mRW50cmllczskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRSYW5rU29ydGVkXCIsIFskaOKAjV9hID0+IChhc3NlcnRSYW5rU29ydGVkID0gJGjigI1fYSldXSxbXCJjb21wYXJlQW50aVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVBbnRpUmFuayA9ICRo4oCNX2EpXV0sW1wibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0ID0gJGjigI1fYSldXSxbXCJzb3J0QnlSYW5rXCIsIFskaOKAjV9hID0+IChzb3J0QnlSYW5rID0gJGjigI1fYSldXV1dLFtcIi4vY29weUJhZy5qc1wiLCBbW1wiYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzXCIsIFskaOKAjV9hID0+IChhc3NlcnROb0R1cGxpY2F0ZUtleXMgPSAkaOKAjV9hKV1dLFtcIm1ha2VCYWdPZkVudHJpZXNcIiwgWyRo4oCNX2EgPT4gKG1ha2VCYWdPZkVudHJpZXMgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuY29uc3R7cXVvdGU6cSxGYWlsfT1hc3NlcnQ7XG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5LZXlDb21wYXJpc29ufSBLZXlDb21wYXJpc29uICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuRnVsbENvbXBhcmV9IEZ1bGxDb21wYXJlICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5SYW5rQ29tcGFyZX0gUmFua0NvbXBhcmUgKi9cblxuLyogQmFzZWQgb24gbWVyZ2Utc2V0LW9wZXJhdG9ycy5qcywgYnV0IGFsdGVyZWQgZm9yIHRoZSBiYWcgcmVwcmVzZW50YXRpb24uKi9cbi8qIFRPRE8gc2hhcmUgbW9yZSBjb2RlIHdpdGggbWVyZ2Utc2V0LW9wZXJhdG9ycy5qcywgcmF0aGVyIHRoYW4qL1xuLyogZHVwbGljYXRpbmcgd2l0aCBjaGFuZ2VzLiovXG5cbi8qKlxuICogQXNzZXJ0cyB0aGF0IGBiYWdFbnRyaWVzYCBpcyBhbHJlYWR5IHJhbmsgc29ydGVkIGJ5IGByYW5rQ29tcGFyZWAsIHdoZXJlXG4gKiB0aGVyZVxuICogbWF5IGJlIGNvbnRpZ3VvdXMgcmVnaW9ucyBvZiBiYWdFbnRyaWVzIHdob3NlIGtleXMgYXJlIHRpZWQgZm9yIHRoZSBzYW1lXG4gKiByYW5rLlxuICogUmV0dXJucyBhbiBpdGVyYWJsZSB0aGF0IHdpbGwgZW51bWVyYXRlIGFsbCB0aGUgYmFnRW50cmllcyBpbiBvcmRlclxuICogYWNjb3JkaW5nIHRvIGBmdWxsT3JkZXJgLCB3aGljaCBzaG91bGQgZGlmZmVyIGZyb20gYHJhbmtPcmRlcmAgb25seVxuICogYnkgYmVpbmcgbW9yZSBwcmVjaXNlLlxuICpcbiAqIFRoaXMgc2hvdWxkIGJlIGVxdWl2YWxlbnQgdG8gcmVzb3J0aW5nIHRoZSBlbnRpcmUgYGJhZ0VudHJpZXNgIGFycmF5XG4gKiBhY2NvcmRpbmdcbiAqIHRvIGBmdWxsT3JkZXJgLiBIb3dldmVyLCBpdCBvcHRpbWl6ZXMgZm9yIHRoZSBjYXNlIHdoZXJlIHRoZXNlIGNvbnRpZ3VvdXNcbiAqIHJ1bnMgdGhhdCBuZWVkIHRvIGJlIHJlc29ydGVkIGFyZSBlaXRoZXIgYWJzZW50IG9yIHNtYWxsLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1tULGJpZ2ludF1bXX0gYmFnRW50cmllc1xuICogQHBhcmFtIHtSYW5rQ29tcGFyZX0gcmFua0NvbXBhcmVcbiAqIEBwYXJhbSB7RnVsbENvbXBhcmV9IGZ1bGxDb21wYXJlXG4gKiBAcmV0dXJucyB7SXRlcmFibGU8W1QsYmlnaW50XT59XG4gKi9cbmNvbnN0IGJhZ1dpbmRvd1Jlc29ydD0oYmFnRW50cmllcyxyYW5rQ29tcGFyZSxmdWxsQ29tcGFyZSk9PntcbmFzc2VydFJhbmtTb3J0ZWQoYmFnRW50cmllcyxyYW5rQ29tcGFyZSk7XG5jb25zdHtsZW5ndGh9PWJhZ0VudHJpZXM7XG5sZXQgaT0wO1xubGV0IG9wdElubmVySXRlcmF0b3I7XG5yZXR1cm4gaGFyZGVuKHtcbltTeW1ib2wuaXRlcmF0b3JdOigpPT5cbmhhcmRlbih7XG5uZXh0OigpPT57XG5pZihvcHRJbm5lckl0ZXJhdG9yKXtcbmNvbnN0IHJlc3VsdD1vcHRJbm5lckl0ZXJhdG9yLm5leHQoKTtcbmlmKHJlc3VsdC5kb25lKXtcbm9wdElubmVySXRlcmF0b3I9dW5kZWZpbmVkO1xuLyogZmFsbCB0aHJvdWdoKi9cbiB9ZWxzZXtcbnJldHVybiByZXN1bHQ7XG4gfVxuIH1cbmlmKGk8bGVuZ3RoKXtcbmNvbnN0IGVudHJ5PWJhZ0VudHJpZXNbaV07XG5sZXQgaj1pKzE7XG53aGlsZShcbmo8bGVuZ3RoJiZcbnJhbmtDb21wYXJlKGVudHJ5WzBdLGJhZ0VudHJpZXNbal1bMF0pPT09MClcbntcbmorPTE7XG4gfVxuaWYoaj09PWkrMSl7XG5pPWo7XG5yZXR1cm4gaGFyZGVuKHtkb25lOmZhbHNlLHZhbHVlOmVudHJ5fSk7XG4gfVxuY29uc3Qgc2ltaWxhclJ1bj1iYWdFbnRyaWVzLnNsaWNlKGksaik7XG5pPWo7XG5jb25zdCByZXNvcnRlZD1zb3J0QnlSYW5rKHNpbWlsYXJSdW4sZnVsbENvbXBhcmUpO1xuLyogUHJvdmlkaW5nIHRoZSBzYW1lIGBmdWxsQ29tcGFyZWAgc2hvdWxkIGNhdXNlIGEgbWVtbyBoaXQqL1xuLyogd2l0aGluIGBhc3NlcnROb0R1cGxpY2F0ZXNgIGVuYWJsaW5nIGl0IHRvIGF2b2lkIGEqL1xuLyogcmVkdW5kYW50IHJlc29ydGluZy4qL1xuYXNzZXJ0Tm9EdXBsaWNhdGVLZXlzKHJlc29ydGVkLGZ1bGxDb21wYXJlKTtcbi8qIFRoaXMgaXMgdGhlIHJhdyBKUyBhcnJheSBpdGVyYXRvciB3aG9zZSBgLm5leHQoKWAgbWV0aG9kKi9cbi8qIGRvZXMgbm90IGhhcmRlbiB0aGUgSXRlcmF0b3JSZXN1bHQsIGluIHZpb2xhdGlvbiBvZiBvdXIqL1xuLyogY29udmVudGlvbnMuIEZpeGluZyB0aGlzIGlzIGV4cGVuc2l2ZSBhbmQgSSdtIGNvbmZpZGVudCB0aGUqL1xuLyogdW5mcm96ZW4gdmFsdWUgZG9lcyBub3QgZXNjYXBlIHRoaXMgZmlsZSwgc28gSSdtIGxlYXZpbmcgdGhpcyovXG4vKiBhcyBpcy4qL1xub3B0SW5uZXJJdGVyYXRvcj1yZXNvcnRlZFtTeW1ib2wuaXRlcmF0b3JdKCk7XG5yZXR1cm4gb3B0SW5uZXJJdGVyYXRvci5uZXh0KCk7XG4gfWVsc2V7XG5yZXR1cm4gaGFyZGVuKHtkb25lOnRydWUsdmFsdWU6W251bGwsMG5dfSk7XG4gfVxuIH19KX0pO1xuXG5cbiB9O1xuXG4vKipcbiAqIFJldHVybnMgYW4gaXRlcmFibGUgd2hvc2UgaXRlcmF0aW9uIHJlc3VsdHMgYXJlIFtrZXksIHhDb3VudCwgeUNvdW50XSB0dXBsZXNcbiAqIHJlcHJlc2VudGluZyB0aGUgbmV4dCBrZXkgaW4gdGhlIGxvY2FsIGZ1bGwgb3JkZXIsIGFzIHdlbGwgYXMgaG93IG1hbnlcbiAqIHRpbWVzIGl0IG9jY3VycmVkIGluIHRoZSB4IGlucHV0IGl0ZXJhdG9yIGFuZCB0aGUgeSBpbnB1dCBpdGVyYXRvci5cbiAqXG4gKiBGb3Igc2V0cywgdGhlc2UgY291bnRzIGFyZSBhbHdheXMgMCBvciAxLCBidXQgdGhpcyByZXByZXNlbnRhdGlvblxuICogZ2VuZXJhbGl6ZXMgbmljZWx5IGZvciBiYWdzLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1tULGJpZ2ludF1bXX0geGJhZ0VudHJpZXNcbiAqIEBwYXJhbSB7W1QsYmlnaW50XVtdfSB5YmFnRW50cmllc1xuICogQHJldHVybnMge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn1cbiAqL1xuY29uc3QgbWVyZ2U9KHhiYWdFbnRyaWVzLHliYWdFbnRyaWVzKT0+e1xuLyogVGhpcyBmdWxsT3JkZXIgY29udGFpbnMgaGlzdG9yeSBkZXBlbmRlbnQgc3RhdGUuIEl0IGlzIHNwZWNpZmljKi9cbi8qIHRvIHRoaXMgb25lIGBtZXJnZWAgY2FsbCBhbmQgZG9lcyBub3Qgc3Vydml2ZSBpdC4qL1xuY29uc3QgZnVsbENvbXBhcmU9bWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQoKS5hbnRpQ29tcGFyYXRvcjtcblxuY29uc3QgeHM9YmFnV2luZG93UmVzb3J0KHhiYWdFbnRyaWVzLGNvbXBhcmVBbnRpUmFuayxmdWxsQ29tcGFyZSk7XG5jb25zdCB5cz1iYWdXaW5kb3dSZXNvcnQoeWJhZ0VudHJpZXMsY29tcGFyZUFudGlSYW5rLGZ1bGxDb21wYXJlKTtcbnJldHVybiBoYXJkZW4oe1xuW1N5bWJvbC5pdGVyYXRvcl06KCk9Pntcbi8qIFRoZXNlIHNpeCBgbGV0YCB2YXJpYWJsZXMgYXJlIGJ1ZmZlcmluZyBvbmUgYWhlYWQgZnJvbSB0aGUgdW5kZXJseWluZyovXG4vKiBpdGVyYXRvcnMuIEVhY2ggaXRlcmF0aW9uIHJlcG9ydHMgb25lIG9yIHRoZSBvdGhlciBvciBib3RoLCBhbmQqL1xuLyogdGhlbiByZWZpbGxzIHRoZSBidWZmZXJzIG9mIHRob3NlIGl0IGFkdmFuY2VkLiovXG4vKiogQHR5cGUge1R9ICovXG5sZXQgeDtcbmxldCB4YztcbmxldCB4RG9uZTtcbi8qKiBAdHlwZSB7VH0gKi9cbmxldCB5O1xubGV0IHljO1xubGV0IHlEb25lO1xuXG5jb25zdCB4aT14c1tTeW1ib2wuaXRlcmF0b3JdKCk7XG5jb25zdCBuZXh0WD0oKT0+e1xuIXhEb25lfHxGYWlsIGBJbnRlcm5hbDogbmV4dFggc2hvdWxkIG5vdCBiZSBjYWxsZWQgb25jZSBkb25lYDtcbih7XG5kb25lOnhEb25lLFxudmFsdWU6W3gseGNdfT1cbnhpLm5leHQoKSk7XG4gfTtcbm5leHRYKCk7XG5cbmNvbnN0IHlpPXlzW1N5bWJvbC5pdGVyYXRvcl0oKTtcbmNvbnN0IG5leHRZPSgpPT57XG4heURvbmV8fEZhaWwgYEludGVybmFsOiBuZXh0WSBzaG91bGQgbm90IGJlIGNhbGxlZCBvbmNlIGRvbmVgO1xuKHtcbmRvbmU6eURvbmUsXG52YWx1ZTpbeSx5Y119PVxueWkubmV4dCgpKTtcbiB9O1xubmV4dFkoKTtcblxucmV0dXJuIGhhcmRlbih7XG5uZXh0OigpPT57XG4vKiogQHR5cGUge2Jvb2xlYW59ICovXG5sZXQgZG9uZT1mYWxzZTtcbi8qKiBAdHlwZSB7W1QsYmlnaW50LGJpZ2ludF19ICovXG5sZXQgdmFsdWU7XG5pZih4RG9uZSYmeURvbmUpe1xuZG9uZT10cnVlO1xuLyogQHRzLWV4cGVjdC1lcnJvciBCZWNhdXNlIHRoZSB0ZXJtaW5hdGluZyB2YWx1ZSBkb2VzIG5vdCBtYXR0ZXIqL1xudmFsdWU9W251bGwsMG4sMG5dO1xuIH1lbHNlIGlmKHhEb25lKXtcbi8qIG9ubHkgeXMgYXJlIGxlZnQqL1xudmFsdWU9W3ksMG4seWNdO1xubmV4dFkoKTtcbiB9ZWxzZSBpZih5RG9uZSl7XG4vKiBvbmx5IHhzIGFyZSBsZWZ0Ki9cbnZhbHVlPVt4LHhjLDBuXTtcbm5leHRYKCk7XG4gfWVsc2V7XG5jb25zdCBjb21wPWZ1bGxDb21wYXJlKHgseSk7XG5pZihjb21wPT09MCl7XG4vKiB4IGFuZCB5IGFyZSBlcXVpdmFsZW50LCBzbyByZXBvcnQgYm90aCovXG52YWx1ZT1beCx4Yyx5Y107XG5uZXh0WCgpO1xubmV4dFkoKTtcbiB9ZWxzZSBpZihjb21wPDApe1xuLyogeCBpcyBlYXJsaWVyLCBzbyByZXBvcnQgaXQqL1xudmFsdWU9W3gseGMsMG5dO1xubmV4dFgoKTtcbiB9ZWxzZXtcbi8qIHkgaXMgZWFybGllciwgc28gcmVwb3J0IGl0Ki9cbmNvbXA+MHx8RmFpbCBgSW50ZXJuYWw6IFVuZXhwZWN0ZWQgY29tcCAke3EoY29tcCl9YDtcbnZhbHVlPVt5LDBuLHljXTtcbm5leHRZKCk7XG4gfVxuIH1cbnJldHVybiBoYXJkZW4oe2RvbmUsdmFsdWV9KTtcbiB9fSk7XG5cbiB9fSk7XG5cbiB9O1xuaGFyZGVuKG1lcmdlKTtcblxuLyogV2Ugc2hvdWxkIGJlIGFibGUgdG8gdXNlIHRoaXMgZm9yIGl0ZXJJc1N1cGVyc2V0IGFzIHdlbGwuKi9cbi8qIFRoZSBnZW5lcmFsaXphdGlvbiBpcyBmcmVlLiovXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgYmFnSXRlcklzU3VwZXJiYWc9KHh5aSk9PntcbmZvcihjb25zdFtfbSx4Yyx5Y11vZiB4eWkpe1xuaWYoeGM8eWMpe1xuLyogc29tZXRoaW5nIGluIHkgaXMgbm90IGluIHgsIHNvIHggaXMgbm90IGEgc3VwZXJiYWcgb2YgeSovXG5yZXR1cm4gZmFsc2U7XG4gfVxuIH1cbnJldHVybiB0cnVlO1xuIH07XG5cbi8qIFdlIHNob3VsZCBiZSBhYmxlIHRvIHVzZSB0aGlzIGZvciBpdGVySXNEaXNqb2ludCBhcyB3ZWxsLiovXG4vKiBUaGUgY29kZSBpcyBpZGVudGljYWwuKi9cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8W1QsYmlnaW50LGJpZ2ludF0+fSB4eWlcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBiYWdJdGVySXNEaXNqb2ludD0oeHlpKT0+e1xuZm9yKGNvbnN0W19tLHhjLHljXW9mIHh5aSl7XG5pZih4Yz49MW4mJnljPj0xbil7XG4vKiBTb21ldGhpbmcgaW4gYm90aCwgc28gbm90IGRpc2pvaW50Ki9cbnJldHVybiBmYWxzZTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTtcblxuLyogV2Ugc2hvdWxkIGJlIGFibGUgdG8gdXNlIHRoaXMgZm9yIGl0ZXJDb21wYXJlIGFzIHdlbGwuKi9cbi8qIFRoZSBnZW5lcmFsaXphdGlvbiBpcyBmcmVlLiovXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7S2V5Q29tcGFyaXNvbn1cbiAqL1xuY29uc3QgYmFnSXRlckNvbXBhcmU9KHh5aSk9PntcbmxldCBsb25lWT1mYWxzZTtcbmxldCBsb25lWD1mYWxzZTtcbmZvcihjb25zdFtfbSx4Yyx5Y11vZiB4eWkpe1xuaWYoeGM8eWMpe1xuLyogc29tZXRoaW5nIGluIHkgaXMgbm90IGluIHgsIHNvIHggaXMgbm90IGEgc3VwZXJiYWcgb2YgeSovXG5sb25lWT10cnVlO1xuIH1cbmlmKHhjPnljKXtcbi8qIHNvbWV0aGluZyBpbiB4IGlzIG5vdCBpbiB5LCBzbyB5IGlzIG5vdCBhIHN1cGVyYmFnIG9mIHgqL1xubG9uZVg9dHJ1ZTtcbiB9XG5pZihsb25lWCYmbG9uZVkpe1xucmV0dXJuIE5hTjtcbiB9XG4gfVxuaWYobG9uZVgpe1xucmV0dXJuIDE7XG4gfWVsc2UgaWYobG9uZVkpe1xucmV0dXJuLTE7XG4gfWVsc2V7XG4hbG9uZVgmJiFsb25lWXx8XG5GYWlsIGBJbnRlcm5hbDogVW5leHBlY3RlZCBsb25lIHBhaXIgJHtxKFtsb25lWCxsb25lWV0pfWA7XG5yZXR1cm4gMDtcbiB9XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtbVCxiaWdpbnQsYmlnaW50XVtdfSB4eWlcbiAqIEByZXR1cm5zIHtbVCxiaWdpbnRdW119XG4gKi9cbmNvbnN0IGJhZ0l0ZXJVbmlvbj0oeHlpKT0+e1xuLyoqIEB0eXBlIHtbVCxiaWdpbnRdW119ICovXG5jb25zdCByZXN1bHQ9W107XG5mb3IoY29uc3RbbSx4Yyx5Y11vZiB4eWkpe1xucmVzdWx0LnB1c2goW20seGMreWNdKTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8W1QsYmlnaW50LGJpZ2ludF0+fSB4eWlcbiAqIEByZXR1cm5zIHtbVCxiaWdpbnRdW119XG4gKi9cbmNvbnN0IGJhZ0l0ZXJJbnRlcnNlY3Rpb249KHh5aSk9Pntcbi8qKiBAdHlwZSB7W1QsYmlnaW50XVtdfSAqL1xuY29uc3QgcmVzdWx0PVtdO1xuZm9yKGNvbnN0W20seGMseWNdb2YgeHlpKXtcbmNvbnN0IG1jPXhjPD15Yz94Yzp5YztcbnJlc3VsdC5wdXNoKFttLG1jXSk7XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7W1QsYmlnaW50XVtdfVxuICovXG5jb25zdCBiYWdJdGVyRGlzam9pbnRTdWJ0cmFjdD0oeHlpKT0+e1xuLyoqIEB0eXBlIHtbVCxiaWdpbnRdW119ICovXG5jb25zdCByZXN1bHQ9W107XG5mb3IoY29uc3RbbSx4Yyx5Y11vZiB4eWkpe1xuY29uc3QgbWM9eGMteWM7XG5tYz49MG58fEZhaWwgYHJpZ2h0IGVsZW1lbnQgJHttfSB3YXMgbm90IGluIGxlZnRgO1xuaWYobWM+PTFuKXtcbi8qIHRoZSB4IHdhcyBub3QgaW4geSovXG5yZXN1bHQucHVzaChbbSxtY10pO1xuIH1cbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH07XG5cbmNvbnN0IG1lcmdlaWZ5PShiYWdJdGVyT3ApPT4oeGJhZ0VudHJpZXMseWJhZ0VudHJpZXMpPT5cbmJhZ0l0ZXJPcChtZXJnZSh4YmFnRW50cmllcyx5YmFnRW50cmllcykpO1xuXG5jb25zdCBiYWdFbnRyaWVzSXNTdXBlcmJhZz1tZXJnZWlmeShiYWdJdGVySXNTdXBlcmJhZyk7XG5jb25zdCBiYWdFbnRyaWVzSXNEaXNqb2ludD1tZXJnZWlmeShiYWdJdGVySXNEaXNqb2ludCk7XG5jb25zdCBiYWdFbnRyaWVzQ29tcGFyZT1tZXJnZWlmeShiYWdJdGVyQ29tcGFyZSk7XG5jb25zdCBiYWdFbnRyaWVzVW5pb249bWVyZ2VpZnkoYmFnSXRlclVuaW9uKTtcbmNvbnN0IGJhZ0VudHJpZXNJbnRlcnNlY3Rpb249bWVyZ2VpZnkoYmFnSXRlckludGVyc2VjdGlvbik7XG5jb25zdCBiYWdFbnRyaWVzRGlzam9pbnRTdWJ0cmFjdD1tZXJnZWlmeShiYWdJdGVyRGlzam9pbnRTdWJ0cmFjdCk7XG5cbmNvbnN0IHJhd0JhZ2lmeT0oYmFnRW50cmllc09wKT0+KHhiYWcseWJhZyk9PlxuYmFnRW50cmllc09wKHhiYWcucGF5bG9hZCx5YmFnLnBheWxvYWQpO1xuXG5jb25zdCBiYWdpZnk9KGJhZ0VudHJpZXNPcCk9Pih4YmFnLHliYWcpPT5cbm1ha2VCYWdPZkVudHJpZXMoYmFnRW50cmllc09wKHhiYWcucGF5bG9hZCx5YmFnLnBheWxvYWQpKTtcblxuY29uc3QgICAgICAgIGJhZ0lzU3VwZXJiYWc9cmF3QmFnaWZ5KGJhZ0VudHJpZXNJc1N1cGVyYmFnKTskaOKAjV9vbmNlLmJhZ0lzU3VwZXJiYWcoYmFnSXNTdXBlcmJhZyk7XG5jb25zdCAgICAgICAgYmFnSXNEaXNqb2ludD1yYXdCYWdpZnkoYmFnRW50cmllc0lzRGlzam9pbnQpOyRo4oCNX29uY2UuYmFnSXNEaXNqb2ludChiYWdJc0Rpc2pvaW50KTtcbmNvbnN0ICAgICAgICBiYWdDb21wYXJlPXJhd0JhZ2lmeShiYWdFbnRyaWVzQ29tcGFyZSk7JGjigI1fb25jZS5iYWdDb21wYXJlKGJhZ0NvbXBhcmUpO1xuY29uc3QgICAgICAgIGJhZ1VuaW9uPWJhZ2lmeShiYWdFbnRyaWVzVW5pb24pOyRo4oCNX29uY2UuYmFnVW5pb24oYmFnVW5pb24pO1xuY29uc3QgICAgICAgIGJhZ0ludGVyc2VjdGlvbj1iYWdpZnkoYmFnRW50cmllc0ludGVyc2VjdGlvbik7JGjigI1fb25jZS5iYWdJbnRlcnNlY3Rpb24oYmFnSW50ZXJzZWN0aW9uKTtcbmNvbnN0ICAgICAgICBiYWdEaXNqb2ludFN1YnRyYWN0PWJhZ2lmeShiYWdFbnRyaWVzRGlzam9pbnRTdWJ0cmFjdCk7JGjigI1fb25jZS5iYWdEaXNqb2ludFN1YnRyYWN0KGJhZ0Rpc2pvaW50U3VidHJhY3QpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImJhZ0lzU3VwZXJiYWciOlsiYmFnSXNTdXBlcmJhZyJdLCJiYWdJc0Rpc2pvaW50IjpbImJhZ0lzRGlzam9pbnQiXSwiYmFnQ29tcGFyZSI6WyJiYWdDb21wYXJlIl0sImJhZ1VuaW9uIjpbImJhZ1VuaW9uIl0sImJhZ0ludGVyc2VjdGlvbiI6WyJiYWdJbnRlcnNlY3Rpb24iXSwiYmFnRGlzam9pbnRTdWJ0cmFjdCI6WyJiYWdEaXNqb2ludFN1YnRyYWN0Il19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAACL2dVKeKAAAnigAADUAAABAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvbWVyZ2Utc2V0LW9wZXJhdG9ycy5qc3siaW1wb3J0cyI6WyIuL2NvcHlTZXQuanMiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiZWxlbWVudHNDb21wYXJlIiwiZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0IiwiZWxlbWVudHNEaXNqb2ludFVuaW9uIiwiZWxlbWVudHNJbnRlcnNlY3Rpb24iLCJlbGVtZW50c0lzRGlzam9pbnQiLCJlbGVtZW50c0lzU3VwZXJzZXQiLCJlbGVtZW50c1VuaW9uIiwic2V0Q29tcGFyZSIsInNldERpc2pvaW50U3VidHJhY3QiLCJzZXREaXNqb2ludFVuaW9uIiwic2V0SW50ZXJzZWN0aW9uIiwic2V0SXNEaXNqb2ludCIsInNldElzU3VwZXJzZXQiLCJzZXRVbmlvbiJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRSYW5rU29ydGVkLGNvbXBhcmVBbnRpUmFuayxtYWtlRnVsbE9yZGVyQ29tcGFyYXRvcktpdCxzb3J0QnlSYW5rLGFzc2VydE5vRHVwbGljYXRlcyxtYWtlU2V0T2ZFbGVtZW50czskaOKAjV9pbXBvcnRzKFtbXCJAZW5kby9tYXJzaGFsXCIsIFtbXCJhc3NlcnRSYW5rU29ydGVkXCIsIFskaOKAjV9hID0+IChhc3NlcnRSYW5rU29ydGVkID0gJGjigI1fYSldXSxbXCJjb21wYXJlQW50aVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVBbnRpUmFuayA9ICRo4oCNX2EpXV0sW1wibWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VGdWxsT3JkZXJDb21wYXJhdG9yS2l0ID0gJGjigI1fYSldXSxbXCJzb3J0QnlSYW5rXCIsIFskaOKAjV9hID0+IChzb3J0QnlSYW5rID0gJGjigI1fYSldXV1dLFtcIi4vY29weVNldC5qc1wiLCBbW1wiYXNzZXJ0Tm9EdXBsaWNhdGVzXCIsIFskaOKAjV9hID0+IChhc3NlcnROb0R1cGxpY2F0ZXMgPSAkaOKAjV9hKV1dLFtcIm1ha2VTZXRPZkVsZW1lbnRzXCIsIFskaOKAjV9hID0+IChtYWtlU2V0T2ZFbGVtZW50cyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5jb25zdHtxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLktleUNvbXBhcmlzb259IEtleUNvbXBhcmlzb24gKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5GdWxsQ29tcGFyZX0gRnVsbENvbXBhcmUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLlJhbmtDb21wYXJlfSBSYW5rQ29tcGFyZSAqL1xuXG4vKipcbiAqIEFzc2VydHMgdGhhdCBgZWxlbWVudHNgIGlzIGFscmVhZHkgcmFuayBzb3J0ZWQgYnkgYHJhbmtDb21wYXJlYCwgd2hlcmUgdGhlcmVcbiAqIG1heSBiZSBjb250aWd1b3VzIHJlZ2lvbnMgb2YgZWxlbWVudHMgdGllZCBmb3IgdGhlIHNhbWUgcmFuay5cbiAqIFJldHVybnMgYW4gaXRlcmFibGUgdGhhdCB3aWxsIGVudW1lcmF0ZSBhbGwgdGhlIGVsZW1lbnRzIGluIG9yZGVyXG4gKiBhY2NvcmRpbmcgdG8gYGZ1bGxPcmRlcmAsIHdoaWNoIHNob3VsZCBkaWZmZXIgZnJvbSBgcmFua09yZGVyYCBvbmx5XG4gKiBieSBiZWluZyBtb3JlIHByZWNpc2UuXG4gKlxuICogVGhpcyBzaG91bGQgYmUgZXF1aXZhbGVudCB0byByZXNvcnRpbmcgdGhlIGVudGlyZSBgZWxlbWVudHNgIGFycmF5IGFjY29yZGluZ1xuICogIHRvIGBmdWxsT3JkZXJgLiBIb3dldmVyLCBpdCBvcHRpbWl6ZXMgZm9yIHRoZSBjYXNlIHdoZXJlIHRoZXNlIGNvbnRpZ3VvdXNcbiAqIHJ1bnMgdGhhdCBuZWVkIHRvIGJlIHJlc29ydGVkIGFyZSBlaXRoZXIgYWJzZW50IG9yIHNtYWxsLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1RbXX0gZWxlbWVudHNcbiAqIEBwYXJhbSB7UmFua0NvbXBhcmV9IHJhbmtDb21wYXJlXG4gKiBAcGFyYW0ge0Z1bGxDb21wYXJlfSBmdWxsQ29tcGFyZVxuICogQHJldHVybnMge0l0ZXJhYmxlPFQ+fVxuICovXG5jb25zdCB3aW5kb3dSZXNvcnQ9KGVsZW1lbnRzLHJhbmtDb21wYXJlLGZ1bGxDb21wYXJlKT0+e1xuYXNzZXJ0UmFua1NvcnRlZChlbGVtZW50cyxyYW5rQ29tcGFyZSk7XG5jb25zdHtsZW5ndGh9PWVsZW1lbnRzO1xubGV0IGk9MDtcbmxldCBvcHRJbm5lckl0ZXJhdG9yO1xucmV0dXJuIGhhcmRlbih7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+XG5oYXJkZW4oe1xubmV4dDooKT0+e1xuaWYob3B0SW5uZXJJdGVyYXRvcil7XG5jb25zdCByZXN1bHQ9b3B0SW5uZXJJdGVyYXRvci5uZXh0KCk7XG5pZihyZXN1bHQuZG9uZSl7XG5vcHRJbm5lckl0ZXJhdG9yPXVuZGVmaW5lZDtcbi8qIGZhbGwgdGhyb3VnaCovXG4gfWVsc2V7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbiB9XG5pZihpPGxlbmd0aCl7XG5jb25zdCB2YWx1ZT1lbGVtZW50c1tpXTtcbmxldCBqPWkrMTtcbndoaWxlKGo8bGVuZ3RoJiZyYW5rQ29tcGFyZSh2YWx1ZSxlbGVtZW50c1tqXSk9PT0wKXtcbmorPTE7XG4gfVxuaWYoaj09PWkrMSl7XG5pPWo7XG5yZXR1cm4gaGFyZGVuKHtkb25lOmZhbHNlLHZhbHVlfSk7XG4gfVxuY29uc3Qgc2ltaWxhclJ1bj1lbGVtZW50cy5zbGljZShpLGopO1xuaT1qO1xuY29uc3QgcmVzb3J0ZWQ9c29ydEJ5UmFuayhzaW1pbGFyUnVuLGZ1bGxDb21wYXJlKTtcbi8qIFByb3ZpZGluZyB0aGUgc2FtZSBgZnVsbENvbXBhcmVgIHNob3VsZCBjYXVzZSBhIG1lbW8gaGl0Ki9cbi8qIHdpdGhpbiBgYXNzZXJ0Tm9EdXBsaWNhdGVzYCBlbmFibGluZyBpdCB0byBhdm9pZCBhKi9cbi8qIHJlZHVuZGFudCByZXNvcnRpbmcuKi9cbmFzc2VydE5vRHVwbGljYXRlcyhyZXNvcnRlZCxmdWxsQ29tcGFyZSk7XG4vKiBUaGlzIGlzIHRoZSByYXcgSlMgYXJyYXkgaXRlcmF0b3Igd2hvc2UgYC5uZXh0KClgIG1ldGhvZCovXG4vKiBkb2VzIG5vdCBoYXJkZW4gdGhlIEl0ZXJhdG9yUmVzdWx0LCBpbiB2aW9sYXRpb24gb2Ygb3VyKi9cbi8qIGNvbnZlbnRpb25zLiBGaXhpbmcgdGhpcyBpcyBleHBlbnNpdmUgYW5kIEknbSBjb25maWRlbnQgdGhlKi9cbi8qIHVuZnJvemVuIHZhbHVlIGRvZXMgbm90IGVzY2FwZSB0aGlzIGZpbGUsIHNvIEknbSBsZWF2aW5nIHRoaXMqL1xuLyogYXMgaXMuKi9cbm9wdElubmVySXRlcmF0b3I9cmVzb3J0ZWRbU3ltYm9sLml0ZXJhdG9yXSgpO1xucmV0dXJuIG9wdElubmVySXRlcmF0b3IubmV4dCgpO1xuIH1lbHNle1xucmV0dXJuIGhhcmRlbih7ZG9uZTp0cnVlLHZhbHVlOm51bGx9KTtcbiB9XG4gfX0pfSk7XG5cblxuIH07XG5cbi8qKlxuICogUmV0dXJucyBhbiBpdGVyYWJsZSB3aG9zZSBpdGVyYXRpb24gcmVzdWx0cyBhcmUgW2tleSwgeENvdW50LCB5Q291bnRdIHR1cGxlc1xuICogcmVwcmVzZW50aW5nIHRoZSBuZXh0IGtleSBpbiB0aGUgbG9jYWwgZnVsbCBvcmRlciwgYXMgd2VsbCBhcyBob3cgbWFueVxuICogdGltZXMgaXQgb2NjdXJyZWQgaW4gdGhlIHggaW5wdXQgaXRlcmF0b3IgYW5kIHRoZSB5IGlucHV0IGl0ZXJhdG9yLlxuICpcbiAqIEZvciBzZXRzLCB0aGVzZSBjb3VudHMgYXJlIGFsd2F5cyAwIG9yIDEsIGJ1dCB0aGlzIHJlcHJlc2VudGF0aW9uXG4gKiBnZW5lcmFsaXplcyBuaWNlbHkgZm9yIGJhZ3MuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7VFtdfSB4ZWxlbWVudHNcbiAqIEBwYXJhbSB7VFtdfSB5ZWxlbWVudHNcbiAqIEByZXR1cm5zIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59XG4gKi9cbmNvbnN0IG1lcmdlPSh4ZWxlbWVudHMseWVsZW1lbnRzKT0+e1xuLyogVGhpcyBmdWxsT3JkZXIgY29udGFpbnMgaGlzdG9yeSBkZXBlbmRlbnQgc3RhdGUuIEl0IGlzIHNwZWNpZmljKi9cbi8qIHRvIHRoaXMgb25lIGBtZXJnZWAgY2FsbCBhbmQgZG9lcyBub3Qgc3Vydml2ZSBpdC4qL1xuY29uc3QgZnVsbENvbXBhcmU9bWFrZUZ1bGxPcmRlckNvbXBhcmF0b3JLaXQoKS5hbnRpQ29tcGFyYXRvcjtcblxuY29uc3QgeHM9d2luZG93UmVzb3J0KHhlbGVtZW50cyxjb21wYXJlQW50aVJhbmssZnVsbENvbXBhcmUpO1xuY29uc3QgeXM9d2luZG93UmVzb3J0KHllbGVtZW50cyxjb21wYXJlQW50aVJhbmssZnVsbENvbXBhcmUpO1xucmV0dXJuIGhhcmRlbih7XG5bU3ltYm9sLml0ZXJhdG9yXTooKT0+e1xuLyogVGhlc2UgZm91ciBgbGV0YCB2YXJpYWJsZXMgYXJlIGJ1ZmZlcmluZyBvbmUgYWhlYWQgZnJvbSB0aGUgdW5kZXJseWluZyovXG4vKiBpdGVyYXRvcnMuIEVhY2ggaXRlcmF0aW9uIHJlcG9ydHMgb25lIG9yIHRoZSBvdGhlciBvciBib3RoLCBhbmQqL1xuLyogdGhlbiByZWZpbGxzIHRoZSBidWZmZXJzIG9mIHRob3NlIGl0IGFkdmFuY2VkLiovXG4vKiogQHR5cGUge1R9ICovXG5sZXQgeDtcbmxldCB4RG9uZTtcbi8qKiBAdHlwZSB7VH0gKi9cbmxldCB5O1xubGV0IHlEb25lO1xuXG5jb25zdCB4aT14c1tTeW1ib2wuaXRlcmF0b3JdKCk7XG5jb25zdCBuZXh0WD0oKT0+e1xuIXhEb25lfHxGYWlsIGBJbnRlcm5hbDogbmV4dFggc2hvdWxkIG5vdCBiZSBjYWxsZWQgb25jZSBkb25lYDtcbih7ZG9uZTp4RG9uZSx2YWx1ZTp4fT14aS5uZXh0KCkpO1xuIH07XG5uZXh0WCgpO1xuXG5jb25zdCB5aT15c1tTeW1ib2wuaXRlcmF0b3JdKCk7XG5jb25zdCBuZXh0WT0oKT0+e1xuIXlEb25lfHxGYWlsIGBJbnRlcm5hbDogbmV4dFkgc2hvdWxkIG5vdCBiZSBjYWxsZWQgb25jZSBkb25lYDtcbih7ZG9uZTp5RG9uZSx2YWx1ZTp5fT15aS5uZXh0KCkpO1xuIH07XG5uZXh0WSgpO1xuXG5yZXR1cm4gaGFyZGVuKHtcbm5leHQ6KCk9Pntcbi8qKiBAdHlwZSB7Ym9vbGVhbn0gKi9cbmxldCBkb25lPWZhbHNlO1xuLyoqIEB0eXBlIHtbVCxiaWdpbnQsYmlnaW50XX0gKi9cbmxldCB2YWx1ZTtcbmlmKHhEb25lJiZ5RG9uZSl7XG5kb25lPXRydWU7XG4vKiBAdHMtZXhwZWN0LWVycm9yIEJlY2F1c2UgdGhlIHRlcm1pbmF0aW5nIHZhbHVlIGRvZXMgbm90IG1hdHRlciovXG52YWx1ZT1bbnVsbCwwbiwwbl07XG4gfWVsc2UgaWYoeERvbmUpe1xuLyogb25seSB5cyBhcmUgbGVmdCovXG52YWx1ZT1beSwwbiwxbl07XG5uZXh0WSgpO1xuIH1lbHNlIGlmKHlEb25lKXtcbi8qIG9ubHkgeHMgYXJlIGxlZnQqL1xudmFsdWU9W3gsMW4sMG5dO1xubmV4dFgoKTtcbiB9ZWxzZXtcbmNvbnN0IGNvbXA9ZnVsbENvbXBhcmUoeCx5KTtcbmlmKGNvbXA9PT0wKXtcbi8qIHggYW5kIHkgYXJlIGVxdWl2YWxlbnQsIHNvIHJlcG9ydCBib3RoKi9cbnZhbHVlPVt4LDFuLDFuXTtcbm5leHRYKCk7XG5uZXh0WSgpO1xuIH1lbHNlIGlmKGNvbXA8MCl7XG4vKiB4IGlzIGVhcmxpZXIsIHNvIHJlcG9ydCBpdCovXG52YWx1ZT1beCwxbiwwbl07XG5uZXh0WCgpO1xuIH1lbHNle1xuLyogeSBpcyBlYXJsaWVyLCBzbyByZXBvcnQgaXQqL1xuY29tcD4wfHxGYWlsIGBJbnRlcm5hbDogVW5leHBlY3RlZCBjb21wICR7cShjb21wKX1gO1xudmFsdWU9W3ksMG4sMW5dO1xubmV4dFkoKTtcbiB9XG4gfVxucmV0dXJuIGhhcmRlbih7ZG9uZSx2YWx1ZX0pO1xuIH19KTtcblxuIH19KTtcblxuIH07XG5oYXJkZW4obWVyZ2UpO1xuXG5jb25zdCBpdGVySXNTdXBlcnNldD0oeHlpKT0+e1xuZm9yKGNvbnN0W19tLHhjLF95Y11vZiB4eWkpe1xuaWYoeGM9PT0wbil7XG4vKiBzb21ldGhpbmcgaW4geSBpcyBub3QgaW4geCwgc28geCBpcyBub3QgYSBzdXBlcnNldCBvZiB5Ki9cbnJldHVybiBmYWxzZTtcbiB9XG4gfVxucmV0dXJuIHRydWU7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGl0ZXJJc0Rpc2pvaW50PSh4eWkpPT57XG5mb3IoY29uc3RbX20seGMseWNdb2YgeHlpKXtcbmlmKHhjPj0xbiYmeWM+PTFuKXtcbi8qIFNvbWV0aGluZyBpbiBib3RoLCBzbyBub3QgZGlzam9pbnQqL1xucmV0dXJuIGZhbHNlO1xuIH1cbiB9XG5yZXR1cm4gdHJ1ZTtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7S2V5Q29tcGFyaXNvbn1cbiAqL1xuY29uc3QgaXRlckNvbXBhcmU9KHh5aSk9PntcbmxldCBsb25lWT1mYWxzZTtcbmxldCBsb25lWD1mYWxzZTtcbmZvcihjb25zdFtfbSx4Yyx5Y11vZiB4eWkpe1xuaWYoeGM9PT0wbil7XG4vKiBzb21ldGhpbmcgaW4geSBpcyBub3QgaW4geCwgc28geCBpcyBub3QgYSBzdXBlcnNldCBvZiB5Ki9cbmxvbmVZPXRydWU7XG4gfVxuaWYoeWM9PT0wbil7XG4vKiBzb21ldGhpbmcgaW4geCBpcyBub3QgaW4geSwgc28geSBpcyBub3QgYSBzdXBlcnNldCBvZiB4Ki9cbmxvbmVYPXRydWU7XG4gfVxuaWYobG9uZVgmJmxvbmVZKXtcbnJldHVybiBOYU47XG4gfVxuIH1cbmlmKGxvbmVYKXtcbnJldHVybiAxO1xuIH1lbHNlIGlmKGxvbmVZKXtcbnJldHVybi0xO1xuIH1lbHNle1xuIWxvbmVYJiYhbG9uZVl8fFxuRmFpbCBgSW50ZXJuYWw6IFVuZXhwZWN0ZWQgbG9uZSBwYWlyICR7cShbbG9uZVgsbG9uZVldKX1gO1xucmV0dXJuIDA7XG4gfVxuIH07XG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8W1QsYmlnaW50LGJpZ2ludF0+fSB4eWlcbiAqIEByZXR1cm5zIHtUW119XG4gKi9cbmNvbnN0IGl0ZXJVbmlvbj0oeHlpKT0+e1xuY29uc3QgcmVzdWx0PVtdO1xuZm9yKGNvbnN0W20seGMseWNdb2YgeHlpKXtcbmlmKHhjPj0wbil7XG5yZXN1bHQucHVzaChtKTtcbiB9ZWxzZXtcbnljPj0wbnx8RmFpbCBgSW50ZXJuYWw6IFVuZXhwZWN0ZWQgY291bnQgJHtxKHljKX1gO1xuLyogaWYgeCBhbmQgeSB3ZXJlIGJvdGggcmVhZHksIHRoZW4gdGhleSB3ZXJlIGVxdWl2YWxlbnQgYW5kKi9cbi8qIGFib3ZlIGNsYXVzZSBhbHJlYWR5IHRvb2sgY2FyZSBvZiBpdC4gT3RoZXJ3aXNlIHB1c2ggaGVyZS4qL1xucmVzdWx0LnB1c2gobSk7XG4gfVxuIH1cbnJldHVybiByZXN1bHQ7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgaXRlckRpc2pvaW50VW5pb249KHh5aSk9PntcbmNvbnN0IHJlc3VsdD1bXTtcbmZvcihjb25zdFttLHhjLHljXW9mIHh5aSl7XG54Yz09PTBufHx5Yz09PTBufHxGYWlsIGBTZXRzIG11c3Qgbm90IGhhdmUgY29tbW9uIGVsZW1lbnRzOiAke219YDtcbmlmKHhjPj0xbil7XG5yZXN1bHQucHVzaChtKTtcbiB9ZWxzZXtcbnljPj0xbnx8RmFpbCBgSW50ZXJuYWw6IFVuZXhwZWN0ZWQgY291bnQgJHtxKHljKX1gO1xucmVzdWx0LnB1c2gobSk7XG4gfVxuIH1cbnJldHVybiByZXN1bHQ7XG4gfTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxbVCxiaWdpbnQsYmlnaW50XT59IHh5aVxuICogQHJldHVybnMge1RbXX1cbiAqL1xuY29uc3QgaXRlckludGVyc2VjdGlvbj0oeHlpKT0+e1xuY29uc3QgcmVzdWx0PVtdO1xuZm9yKGNvbnN0W20seGMseWNdb2YgeHlpKXtcbmlmKHhjPj0xbiYmeWM+PTFuKXtcbi8qIElmIHRoZXkgYXJlIGJvdGggcHJlc2VudCwgdGhlbiB0aGV5IHdlcmUgZXF1aXZhbGVudCovXG5yZXN1bHQucHVzaChtKTtcbiB9XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFtULGJpZ2ludCxiaWdpbnRdPn0geHlpXG4gKiBAcmV0dXJucyB7VFtdfVxuICovXG5jb25zdCBpdGVyRGlzam9pbnRTdWJ0cmFjdD0oeHlpKT0+e1xuY29uc3QgcmVzdWx0PVtdO1xuZm9yKGNvbnN0W20seGMseWNdb2YgeHlpKXtcbnhjPj0xbnx8RmFpbCBgcmlnaHQgZWxlbWVudCAke219IHdhcyBub3QgaW4gbGVmdGA7XG5pZih5Yz09PTBuKXtcbi8qIHRoZSB4IHdhcyBub3QgaW4geSovXG5yZXN1bHQucHVzaChtKTtcbiB9XG4gfVxucmV0dXJuIHJlc3VsdDtcbiB9O1xuXG5jb25zdCBtZXJnZWlmeT0oaXRlck9wKT0+KHhlbGVtZW50cyx5ZWxlbWVudHMpPT5cbml0ZXJPcChtZXJnZSh4ZWxlbWVudHMseWVsZW1lbnRzKSk7XG5cbmNvbnN0ICAgICAgICBlbGVtZW50c0lzU3VwZXJzZXQ9bWVyZ2VpZnkoaXRlcklzU3VwZXJzZXQpOyRo4oCNX29uY2UuZWxlbWVudHNJc1N1cGVyc2V0KGVsZW1lbnRzSXNTdXBlcnNldCk7XG5jb25zdCAgICAgICAgZWxlbWVudHNJc0Rpc2pvaW50PW1lcmdlaWZ5KGl0ZXJJc0Rpc2pvaW50KTskaOKAjV9vbmNlLmVsZW1lbnRzSXNEaXNqb2ludChlbGVtZW50c0lzRGlzam9pbnQpO1xuY29uc3QgICAgICAgIGVsZW1lbnRzQ29tcGFyZT1tZXJnZWlmeShpdGVyQ29tcGFyZSk7JGjigI1fb25jZS5lbGVtZW50c0NvbXBhcmUoZWxlbWVudHNDb21wYXJlKTtcbmNvbnN0ICAgICAgICBlbGVtZW50c1VuaW9uPW1lcmdlaWZ5KGl0ZXJVbmlvbik7JGjigI1fb25jZS5lbGVtZW50c1VuaW9uKGVsZW1lbnRzVW5pb24pO1xuY29uc3QgICAgICAgIGVsZW1lbnRzRGlzam9pbnRVbmlvbj1tZXJnZWlmeShpdGVyRGlzam9pbnRVbmlvbik7JGjigI1fb25jZS5lbGVtZW50c0Rpc2pvaW50VW5pb24oZWxlbWVudHNEaXNqb2ludFVuaW9uKTtcbmNvbnN0ICAgICAgICBlbGVtZW50c0ludGVyc2VjdGlvbj1tZXJnZWlmeShpdGVySW50ZXJzZWN0aW9uKTskaOKAjV9vbmNlLmVsZW1lbnRzSW50ZXJzZWN0aW9uKGVsZW1lbnRzSW50ZXJzZWN0aW9uKTtcbmNvbnN0ICAgICAgICBlbGVtZW50c0Rpc2pvaW50U3VidHJhY3Q9bWVyZ2VpZnkoaXRlckRpc2pvaW50U3VidHJhY3QpOyRo4oCNX29uY2UuZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0KGVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCk7XG5cbmNvbnN0IHJhd1NldGlmeT0oZWxlbWVudHNPcCk9Pih4c2V0LHlzZXQpPT5cbmVsZW1lbnRzT3AoeHNldC5wYXlsb2FkLHlzZXQucGF5bG9hZCk7XG5cbmNvbnN0IHNldGlmeT0oZWxlbWVudHNPcCk9Pih4c2V0LHlzZXQpPT5cbm1ha2VTZXRPZkVsZW1lbnRzKGVsZW1lbnRzT3AoeHNldC5wYXlsb2FkLHlzZXQucGF5bG9hZCkpO1xuXG5jb25zdCAgICAgICAgc2V0SXNTdXBlcnNldD1yYXdTZXRpZnkoZWxlbWVudHNJc1N1cGVyc2V0KTskaOKAjV9vbmNlLnNldElzU3VwZXJzZXQoc2V0SXNTdXBlcnNldCk7XG5jb25zdCAgICAgICAgc2V0SXNEaXNqb2ludD1yYXdTZXRpZnkoZWxlbWVudHNJc0Rpc2pvaW50KTskaOKAjV9vbmNlLnNldElzRGlzam9pbnQoc2V0SXNEaXNqb2ludCk7XG5jb25zdCAgICAgICAgc2V0Q29tcGFyZT1yYXdTZXRpZnkoZWxlbWVudHNDb21wYXJlKTskaOKAjV9vbmNlLnNldENvbXBhcmUoc2V0Q29tcGFyZSk7XG5jb25zdCAgICAgICAgc2V0VW5pb249c2V0aWZ5KGVsZW1lbnRzVW5pb24pOyRo4oCNX29uY2Uuc2V0VW5pb24oc2V0VW5pb24pO1xuY29uc3QgICAgICAgIHNldERpc2pvaW50VW5pb249c2V0aWZ5KGVsZW1lbnRzRGlzam9pbnRVbmlvbik7JGjigI1fb25jZS5zZXREaXNqb2ludFVuaW9uKHNldERpc2pvaW50VW5pb24pO1xuY29uc3QgICAgICAgIHNldEludGVyc2VjdGlvbj1zZXRpZnkoZWxlbWVudHNJbnRlcnNlY3Rpb24pOyRo4oCNX29uY2Uuc2V0SW50ZXJzZWN0aW9uKHNldEludGVyc2VjdGlvbik7XG5jb25zdCAgICAgICAgc2V0RGlzam9pbnRTdWJ0cmFjdD1zZXRpZnkoZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0KTskaOKAjV9vbmNlLnNldERpc2pvaW50U3VidHJhY3Qoc2V0RGlzam9pbnRTdWJ0cmFjdCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiZWxlbWVudHNJc1N1cGVyc2V0IjpbImVsZW1lbnRzSXNTdXBlcnNldCJdLCJlbGVtZW50c0lzRGlzam9pbnQiOlsiZWxlbWVudHNJc0Rpc2pvaW50Il0sImVsZW1lbnRzQ29tcGFyZSI6WyJlbGVtZW50c0NvbXBhcmUiXSwiZWxlbWVudHNVbmlvbiI6WyJlbGVtZW50c1VuaW9uIl0sImVsZW1lbnRzRGlzam9pbnRVbmlvbiI6WyJlbGVtZW50c0Rpc2pvaW50VW5pb24iXSwiZWxlbWVudHNJbnRlcnNlY3Rpb24iOlsiZWxlbWVudHNJbnRlcnNlY3Rpb24iXSwiZWxlbWVudHNEaXNqb2ludFN1YnRyYWN0IjpbImVsZW1lbnRzRGlzam9pbnRTdWJ0cmFjdCJdLCJzZXRJc1N1cGVyc2V0IjpbInNldElzU3VwZXJzZXQiXSwic2V0SXNEaXNqb2ludCI6WyJzZXRJc0Rpc2pvaW50Il0sInNldENvbXBhcmUiOlsic2V0Q29tcGFyZSJdLCJzZXRVbmlvbiI6WyJzZXRVbmlvbiJdLCJzZXREaXNqb2ludFVuaW9uIjpbInNldERpc2pvaW50VW5pb24iXSwic2V0SW50ZXJzZWN0aW9uIjpbInNldEludGVyc2VjdGlvbiJdLCJzZXREaXNqb2ludFN1YnRyYWN0IjpbInNldERpc2pvaW50U3VidHJhY3QiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAiQw7BTPDAAAzwwAANQAAAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMvcGF0dGVybnMvcGF0dGVybk1hdGNoZXJzLmpzeyJpbXBvcnRzIjpbIi4uL2tleXMvY2hlY2tLZXkuanMiLCIuLi9rZXlzL2NvbXBhcmVLZXlzLmpzIiwiLi4vdXRpbHMuanMiLCJAZW5kby9tYXJzaGFsIl0sImV4cG9ydHMiOlsiTSIsImFzc2VydFBhdHRlcm4iLCJjaGVja01hdGNoZXMiLCJkZWZhdWx0TGltaXRzIiwiZ2V0UmFua0NvdmVyIiwiaXNQYXR0ZXJuIiwibWF0Y2hlcyIsIm11c3RNYXRjaCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBhc3NlcnRDaGVja2VyLEZhcixnZXRUYWcsbWFrZVRhZ2dlZCxwYXNzU3R5bGVPZixoYXNPd25Qcm9wZXJ0eU9mLG5hbWVGb3JQYXNzYWJsZVN5bWJvbCxjb21wYXJlUmFuayxnZXRQYXNzU3R5bGVDb3ZlcixpbnRlcnNlY3RSYW5rQ292ZXJzLHVuaW9uUmFua0NvdmVycyxyZWNvcmROYW1lcyxyZWNvcmRWYWx1ZXMsaWRlbnRDaGVja2VyLGFwcGx5TGFiZWxpbmdFcnJvcixmcm9tVW5pcXVlRW50cmllcyxsaXN0RGlmZmVyZW5jZSxrZXlFUSxrZXlHVCxrZXlHVEUsa2V5TFQsa2V5TFRFLGFzc2VydEtleSxjaGVja0tleSxpc0tleSxjaGVja1NjYWxhcktleSxjaGVja0NvcHlTZXQsY2hlY2tDb3B5TWFwLGNvcHlNYXBLZXlTZXQsY2hlY2tDb3B5QmFnOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL21hcnNoYWxcIiwgW1tcImFzc2VydENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENoZWNrZXIgPSAkaOKAjV9hKV1dLFtcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXSxbXCJnZXRUYWdcIiwgWyRo4oCNX2EgPT4gKGdldFRhZyA9ICRo4oCNX2EpXV0sW1wibWFrZVRhZ2dlZFwiLCBbJGjigI1fYSA9PiAobWFrZVRhZ2dlZCA9ICRo4oCNX2EpXV0sW1wicGFzc1N0eWxlT2ZcIiwgWyRo4oCNX2EgPT4gKHBhc3NTdHlsZU9mID0gJGjigI1fYSldXSxbXCJoYXNPd25Qcm9wZXJ0eU9mXCIsIFskaOKAjV9hID0+IChoYXNPd25Qcm9wZXJ0eU9mID0gJGjigI1fYSldXSxbXCJuYW1lRm9yUGFzc2FibGVTeW1ib2xcIiwgWyRo4oCNX2EgPT4gKG5hbWVGb3JQYXNzYWJsZVN5bWJvbCA9ICRo4oCNX2EpXV0sW1wiY29tcGFyZVJhbmtcIiwgWyRo4oCNX2EgPT4gKGNvbXBhcmVSYW5rID0gJGjigI1fYSldXSxbXCJnZXRQYXNzU3R5bGVDb3ZlclwiLCBbJGjigI1fYSA9PiAoZ2V0UGFzc1N0eWxlQ292ZXIgPSAkaOKAjV9hKV1dLFtcImludGVyc2VjdFJhbmtDb3ZlcnNcIiwgWyRo4oCNX2EgPT4gKGludGVyc2VjdFJhbmtDb3ZlcnMgPSAkaOKAjV9hKV1dLFtcInVuaW9uUmFua0NvdmVyc1wiLCBbJGjigI1fYSA9PiAodW5pb25SYW5rQ292ZXJzID0gJGjigI1fYSldXSxbXCJyZWNvcmROYW1lc1wiLCBbJGjigI1fYSA9PiAocmVjb3JkTmFtZXMgPSAkaOKAjV9hKV1dLFtcInJlY29yZFZhbHVlc1wiLCBbJGjigI1fYSA9PiAocmVjb3JkVmFsdWVzID0gJGjigI1fYSldXV1dLFtcIi4uL3V0aWxzLmpzXCIsIFtbXCJpZGVudENoZWNrZXJcIiwgWyRo4oCNX2EgPT4gKGlkZW50Q2hlY2tlciA9ICRo4oCNX2EpXV0sW1wiYXBwbHlMYWJlbGluZ0Vycm9yXCIsIFskaOKAjV9hID0+IChhcHBseUxhYmVsaW5nRXJyb3IgPSAkaOKAjV9hKV1dLFtcImZyb21VbmlxdWVFbnRyaWVzXCIsIFskaOKAjV9hID0+IChmcm9tVW5pcXVlRW50cmllcyA9ICRo4oCNX2EpXV0sW1wibGlzdERpZmZlcmVuY2VcIiwgWyRo4oCNX2EgPT4gKGxpc3REaWZmZXJlbmNlID0gJGjigI1fYSldXV1dLFtcIi4uL2tleXMvY29tcGFyZUtleXMuanNcIiwgW1tcImtleUVRXCIsIFskaOKAjV9hID0+IChrZXlFUSA9ICRo4oCNX2EpXV0sW1wia2V5R1RcIiwgWyRo4oCNX2EgPT4gKGtleUdUID0gJGjigI1fYSldXSxbXCJrZXlHVEVcIiwgWyRo4oCNX2EgPT4gKGtleUdURSA9ICRo4oCNX2EpXV0sW1wia2V5TFRcIiwgWyRo4oCNX2EgPT4gKGtleUxUID0gJGjigI1fYSldXSxbXCJrZXlMVEVcIiwgWyRo4oCNX2EgPT4gKGtleUxURSA9ICRo4oCNX2EpXV1dXSxbXCIuLi9rZXlzL2NoZWNrS2V5LmpzXCIsIFtbXCJhc3NlcnRLZXlcIiwgWyRo4oCNX2EgPT4gKGFzc2VydEtleSA9ICRo4oCNX2EpXV0sW1wiY2hlY2tLZXlcIiwgWyRo4oCNX2EgPT4gKGNoZWNrS2V5ID0gJGjigI1fYSldXSxbXCJpc0tleVwiLCBbJGjigI1fYSA9PiAoaXNLZXkgPSAkaOKAjV9hKV1dLFtcImNoZWNrU2NhbGFyS2V5XCIsIFskaOKAjV9hID0+IChjaGVja1NjYWxhcktleSA9ICRo4oCNX2EpXV0sW1wiY2hlY2tDb3B5U2V0XCIsIFskaOKAjV9hID0+IChjaGVja0NvcHlTZXQgPSAkaOKAjV9hKV1dLFtcImNoZWNrQ29weU1hcFwiLCBbJGjigI1fYSA9PiAoY2hlY2tDb3B5TWFwID0gJGjigI1fYSldXSxbXCJjb3B5TWFwS2V5U2V0XCIsIFskaOKAjV9hID0+IChjb3B5TWFwS2V5U2V0ID0gJGjigI1fYSldXSxbXCJjaGVja0NvcHlCYWdcIiwgWyRo4oCNX2EgPT4gKGNoZWNrQ29weUJhZyA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIi8+Ki9cblxuY29uc3R7cXVvdGU6cSxkZXRhaWxzOlgsRmFpbH09YXNzZXJ0O1xuY29uc3R7ZW50cmllcyx2YWx1ZXN9PU9iamVjdDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbi8qKiBAdHlwZSB7V2Vha1NldDxQYXR0ZXJuPn0gKi9cbmNvbnN0IHBhdHRlcm5NZW1vPW5ldyBXZWFrU2V0KCk7XG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIE1hdGNoIEhlbHBlcnMgSGVscGVycyAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKiBGb3IgZm9yd2FyZCByZWZlcmVuY2VzIHRvIGBNYCAqL1xubGV0IE1NO1xuXG4vKipcbiAqIFRoZSBhY3R1YWwgZGVmYXVsdCB2YWx1ZXMgaGVyZSBhcmUsIGF0IHRoZSBwcmVzZW50IHRpbWUsIGZhaXJseVxuICogYXJiaXRyYXJ5IGNob2ljZXMgYW5kIG1heSBjaGFuZ2UgYmVmb3JlIHRoZXkgc2V0dGxlIGRvd24uIE9mIGNvdXJzZVxuICogYXQgc29tZSBwb2ludCB3ZSdsbCBuZWVkIHRvIHN0b3AgY2hhbmdpbmcgdGhlbS4gQnV0IHdlIHNob3VsZCBmaXJzdFxuICogc2VlIGhvdyBvdXIgc3lzdGVtIGhvbGRzIHVwIHdpdGggdGhlc2UgY2hvaWNlcy4gVGhlIG1haW4gY3JpdGVyaWFcbiAqIGlzIHRoYXQgdGhleSBiZSBiaWcgZW5vdWdoIHRoYXQgXCJub3JtYWxcIiBpbm5vY2VudCBwcm9ncmFtcyByYXJlbHlcbiAqIGVuY291bnRlciB0aGVzZSBsaW1pdHMuXG4gKlxuICogRXhwb3J0ZWQgcHJpbWFyaWx5IGZvciB0ZXN0aW5nLlxuICovXG5jb25zdCAgICAgICAgZGVmYXVsdExpbWl0cz1oYXJkZW4oe1xuZGVjaW1hbERpZ2l0c0xpbWl0OjEwMCxcbnN0cmluZ0xlbmd0aExpbWl0OjEwMF8wMDAsXG5zeW1ib2xOYW1lTGVuZ3RoTGltaXQ6MTAwLFxubnVtUHJvcGVydGllc0xpbWl0OjgwLFxucHJvcGVydHlOYW1lTGVuZ3RoTGltaXQ6MTAwLFxuYXJyYXlMZW5ndGhMaW1pdDoxMF8wMDAsXG5udW1TZXRFbGVtZW50c0xpbWl0OjEwXzAwMCxcbm51bVVuaXF1ZUJhZ0VsZW1lbnRzTGltaXQ6MTBfMDAwLFxubnVtTWFwRW50cmllc0xpbWl0OjUwMDB9KTtcblxuXG4vKipcbiAqIFVzZSB0aGUgcmVzdWx0IG9ubHkgdG8gZ2V0IHRoZSBsaW1pdHMgeW91IG5lZWQgYnkgZGVzdHJ1Y3R1cmluZy5cbiAqIFRodXMsIHRoZSByZXN1bHQgb25seSBuZWVkcyB0byBzdXBwb3J0IGRlc3RydWN0dXJpbmcuIFRoZSBjdXJyZW50XG4gKiBpbXBsZW1lbnRhdGlvbiB1c2VzIGluaGVyaXRhbmNlIGFzIGEgY2hlYXAgaGFjay5cbiAqXG4gKiBAcGFyYW0ge0xpbWl0c30gW2xpbWl0c11cbiAqIEByZXR1cm5zIHtBbGxMaW1pdHN9XG4gKi8kaOKAjV9vbmNlLmRlZmF1bHRMaW1pdHMoZGVmYXVsdExpbWl0cyk7XG5jb25zdCBsaW1pdD0obGltaXRzPXt9KT0+XG4vKiogQHR5cGUge0FsbExpbWl0c30gKi9oYXJkZW4oe19fcHJvdG9fXzpkZWZhdWx0TGltaXRzLC4uLmxpbWl0c30pO1xuXG5jb25zdCBjaGVja0lzV2VsbEZvcm1lZFdpdGhMaW1pdD0oXG5wYXlsb2FkLFxubWFpblBheWxvYWRTaGFwZSxcbmNoZWNrLFxubGFiZWwpPT5cbntcbmFzc2VydChBcnJheS5pc0FycmF5KG1haW5QYXlsb2FkU2hhcGUpKTtcbmlmKCFBcnJheS5pc0FycmF5KHBheWxvYWQpKXtcbnJldHVybiBjaGVjayhmYWxzZSxYIGAke3EobGFiZWwpfSBwYXlsb2FkIG11c3QgYmUgYW4gYXJyYXk6ICR7cGF5bG9hZH1gKTtcbiB9XG5cbi8qIFdhcyB0aGUgZm9sbG93aW5nLCBidXQgaXRzIG92ZXJ1c2Ugb2YgcGF0dGVybnMgY2F1c2VkIGFuIGluZmluaXRlIHJlZ3Jlc3MqL1xuLyogY29uc3QgcGF5bG9hZExpbWl0U2hhcGUgPSBoYXJkZW4oKi9cbi8qIE0uc3BsaXQoKi9cbi8qIG1haW5QYXlsb2FkU2hhcGUsKi9cbi8qIE0ucGFydGlhbChoYXJkZW4oW00ucmVjb3JkT2YoTS5zdHJpbmcoKSwgTS5udW1iZXIoKSldKSwgaGFyZGVuKFtdKSksKi9cbi8qICksKi9cbi8qICk7Ki9cbi8qIHJldHVybiBjaGVja01hdGNoZXMocGF5bG9hZCwgcGF5bG9hZExpbWl0U2hhcGUsIGNoZWNrLCBsYWJlbCk7Ki9cblxuY29uc3QgbWFpbkxlbmd0aD1tYWluUGF5bG9hZFNoYXBlLmxlbmd0aDtcbmlmKCEocGF5bG9hZC5sZW5ndGg9PT1tYWluTGVuZ3RofHxwYXlsb2FkLmxlbmd0aD09PW1haW5MZW5ndGgrMSkpe1xucmV0dXJuIGNoZWNrKGZhbHNlLFggYCR7cShsYWJlbCl9IHBheWxvYWQgdW5leHBlY3RlZCBzaXplOiAke3BheWxvYWR9YCk7XG4gfVxuY29uc3QgbGltaXRzPXBheWxvYWRbbWFpbkxlbmd0aF07XG5wYXlsb2FkPWhhcmRlbihwYXlsb2FkLnNsaWNlKDAsbWFpbkxlbmd0aCkpO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbmlmKCFjaGVja01hdGNoZXMocGF5bG9hZCxtYWluUGF5bG9hZFNoYXBlLGNoZWNrLGxhYmVsKSl7XG5yZXR1cm4gZmFsc2U7XG4gfVxuaWYobGltaXRzPT09dW5kZWZpbmVkKXtcbnJldHVybiB0cnVlO1xuIH1cbnJldHVybihcbihwYXNzU3R5bGVPZihsaW1pdHMpPT09J2NvcHlSZWNvcmQnfHxcbmNoZWNrKGZhbHNlLFggYExpbWl0cyBtdXN0IGJlIGEgcmVjb3JkOiAke3EobGltaXRzKX1gKSkmJlxuZW50cmllcyhsaW1pdHMpLmV2ZXJ5KFxuKFtrZXksdmFsdWVdKT0+XG5wYXNzU3R5bGVPZih2YWx1ZSk9PT0nbnVtYmVyJ3x8XG5jaGVjayhmYWxzZSxYIGBWYWx1ZSBvZiBsaW1pdCAke3Eoa2V5KX0gYnV0IGJlIGEgbnVtYmVyOiAke3EodmFsdWUpfWApKSk7XG5cblxuIH07XG5cbi8qKlxuICogQHBhcmFtIHt1bmtub3dufSBzcGVjaW1lblxuICogQHBhcmFtIHtudW1iZXJ9IGRlY2ltYWxEaWdpdHNMaW1pdFxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICovXG5jb25zdCBjaGVja0RlY2ltYWxEaWdpdHNMaW1pdD0oc3BlY2ltZW4sZGVjaW1hbERpZ2l0c0xpbWl0LGNoZWNrKT0+e1xuaWYoXG5NYXRoLmZsb29yKE1hdGgubG9nMTAoTWF0aC5hYnMoTnVtYmVyKHNwZWNpbWVuKSkpKSsxPD1cbmRlY2ltYWxEaWdpdHNMaW1pdClcbntcbnJldHVybiB0cnVlO1xuIH1cbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgYmlnaW50ICR7c3BlY2ltZW59IG11c3Qgbm90IGhhdmUgbW9yZSB0aGFuICR7ZGVjaW1hbERpZ2l0c0xpbWl0fSBkaWdpdHNgKTtcblxuIH07XG5cbi8qKlxuICogQHJldHVybnMge1BhdHRlcm5LaXR9XG4gKi9cbmNvbnN0IG1ha2VQYXR0ZXJuS2l0PSgpPT57XG4vKipcbiAqIElmIHRoaXMgaXMgYSByZWNvZ25pemVkIG1hdGNoIHRhZywgcmV0dXJuIHRoZSBNYXRjaEhlbHBlci5cbiAqIE90aGVyd2lzZSByZXN1bHQgdW5kZWZpbmVkLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEByZXR1cm5zIHtNYXRjaEhlbHBlciB8IHVuZGVmaW5lZH1cbiAqL1xuY29uc3QgbWF5YmVNYXRjaEhlbHBlcj0odGFnKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuSGVscGVyc0J5TWF0Y2hUYWdbdGFnXTtcblxuLyoqXG4gKiBAdHlwZWRlZiB7c3RyaW5nfSBLaW5kXG4gKiBJdCBpcyBlaXRoZXIgYSBQYXNzU3R5bGUgb3RoZXIgdGhhbiAndGFnZ2VkJywgb3IsIGlmIHRoZSB1bmRlcmx5aW5nXG4gKiBQYXNzU3R5bGUgaXMgJ3RhZ2dlZCcsIHRoZW4gdGhlIGBnZXRUYWdgIHZhbHVlIGZvciB0YWdzIHRoYXQgYXJlXG4gKiByZWNvZ25pemVkIGF0IHRoZSBzdG9yZSBsZXZlbCBvZiBhYnN0cmFjdGlvbi4gRm9yIGVhY2ggb2YgdGhvc2VcbiAqIHRhZ3MsIGEgdGFnZ2VkIHJlY29yZCBvbmx5IGhhcyB0aGF0IGtpbmQgaWYgaXQgc2F0aXNmaWVzIHRoZSBpbnZhcmlhbnRzXG4gKiB0aGF0IHRoZSBzdG9yZSBsZXZlbCBhc3NvY2lhdGVzIHdpdGggdGhhdCBraW5kLlxuICovXG5cbi8qKlxuICogQHR5cGUge1dlYWtNYXA8Q29weVRhZ2dlZCwgS2luZD59XG4gKiBPbmx5IGZvciB0YWdnZWQgcmVjb3JkcyBvZiByZWNvZ25pemVkIGtpbmRzIHdob3NlIHN0b3JlLWxldmVsIGludmFyaWFudHNcbiAqIGhhdmUgYWxyZWFkeSBiZWVuIGNoZWNrZWQuXG4gKi9cbmNvbnN0IHRhZ01lbW89bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBDaGVja3Mgb25seSByZWNvZ25pemVkIHRhZ3MsIGFuZCBvbmx5IGlmIHRoZSB0YWdnZWRcbiAqIHBhc3NlcyB0aGUgaW52YXJpYW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCByZWNvZ25pdGlvbi5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSB0YWdnZWRcbiAqIEBwYXJhbSB7S2luZH0gdGFnXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tUYWdnZWQ9KHRhZ2dlZCx0YWcsY2hlY2spPT57XG5jb25zdCBtYXRjaEhlbHBlcj1tYXliZU1hdGNoSGVscGVyKHRhZyk7XG5pZihtYXRjaEhlbHBlcil7XG4vKiBCdXJpZWQgaGVyZSBpcyB0aGUgaW1wb3J0YW50IGNhc2UsIHdoZXJlIHdlIHByb2Nlc3MqL1xuLyogdGhlIHZhcmlvdXMgcGF0dGVybk5vZGVzKi9cbnJldHVybiBtYXRjaEhlbHBlci5jaGVja0lzV2VsbEZvcm1lZCh0YWdnZWQucGF5bG9hZCxjaGVjayk7XG4gfVxuc3dpdGNoKHRhZyl7XG5jYXNlJ2NvcHlTZXQnOntcbnJldHVybiBjaGVja0NvcHlTZXQodGFnZ2VkLGNoZWNrKTtcbiB9XG5jYXNlJ2NvcHlCYWcnOntcbnJldHVybiBjaGVja0NvcHlCYWcodGFnZ2VkLGNoZWNrKTtcbiB9XG5jYXNlJ2NvcHlNYXAnOntcbnJldHVybiBjaGVja0NvcHlNYXAodGFnZ2VkLGNoZWNrKTtcbiB9XG5kZWZhdWx0OntcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgY2Fubm90IGNoZWNrIHVucmVjb2duaXplZCB0YWcgJHtxKHRhZyl9OiAke3RhZ2dlZH1gKTtcblxuIH19XG5cbiB9O1xuXG4vKipcbiAqIFJldHVybnMgb25seSBhIHJlY29nbml6ZWQga2luZCwgYW5kIG9ubHkgaWYgdGhlIHNwZWNpbWVuIHBhc3NlcyB0aGVcbiAqIGludmFyaWFudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgcmVjb2duaXRpb24uXG4gKiBPdGhlcndpc2UsIGBjaGVjayhmYWxzZSwgLi4uKWAgYW5kIHJldHVybnMgdW5kZWZpbmVkXG4gKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7Q2hlY2tlcn0gW2NoZWNrXVxuICogQHJldHVybnMge0tpbmQgfCB1bmRlZmluZWR9XG4gKi9cbmNvbnN0IGtpbmRPZj0oc3BlY2ltZW4sY2hlY2s9aWRlbnRDaGVja2VyKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHNwZWNpbWVuKTtcbmlmKHBhc3NTdHlsZSE9PSd0YWdnZWQnKXtcbnJldHVybiBwYXNzU3R5bGU7XG4gfVxuLyogQXQgdGhpcyBwb2ludCB3ZSBrbm93IHRoYXQgc3BlY2ltZW4gaXMgYSB3ZWxsIGZvcm1lZCovXG4vKiBhcyBhIHRhZ2dlZCByZWNvcmQsIHdoaWNoIGlzIGRlZmluZWQgYXQgdGhlIG1hcnNoYWwgbGV2ZWwgb2YgYWJzdHJhY3Rpb24sKi9cbi8qIHNpbmNlIGBwYXNzU3R5bGVPZmAgY2hlY2tzIHRob3NlIGludmFyaWFudHMuKi9cbmlmKHRhZ01lbW8uaGFzKHNwZWNpbWVuKSl7XG5yZXR1cm4gdGFnTWVtby5nZXQoc3BlY2ltZW4pO1xuIH1cbmNvbnN0IHRhZz1nZXRUYWcoc3BlY2ltZW4pO1xuaWYoY2hlY2tUYWdnZWQoc3BlY2ltZW4sdGFnLGNoZWNrKSl7XG50YWdNZW1vLnNldChzcGVjaW1lbix0YWcpO1xucmV0dXJuIHRhZztcbiB9XG5pZihjaGVjayE9PWlkZW50Q2hlY2tlcil7XG5jaGVjayhmYWxzZSxYIGBjYW5ub3QgY2hlY2sgdW5yZWNvZ25pemVkIHRhZyAke3EodGFnKX1gKTtcbiB9XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH07XG5oYXJkZW4oa2luZE9mKTtcblxuLyoqXG4gKiBDaGVja3Mgb25seSByZWNvZ25pemVkIGtpbmRzLCBhbmQgb25seSBpZiB0aGUgc3BlY2ltZW5cbiAqIHBhc3NlcyB0aGUgaW52YXJpYW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCByZWNvZ25pdGlvbi5cbiAqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBzcGVjaW1lblxuICogQHBhcmFtIHtLaW5kfSBraW5kXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tLaW5kPShzcGVjaW1lbixraW5kLGNoZWNrKT0+e1xuY29uc3QgcmVhbEtpbmQ9a2luZE9mKHNwZWNpbWVuLGNoZWNrKTtcbmlmKGtpbmQ9PT1yZWFsS2luZCl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5pZihjaGVjayE9PWlkZW50Q2hlY2tlcil7XG4vKiBxdW90aW5nIHdpdGhvdXQgcXVvdGVzKi9cbmNvbnN0IGRldGFpbHM9WChbIGAke3JlYWxLaW5kfSBgLGAgLSBNdXN0IGJlIGEgJHtraW5kfWBdLHNwZWNpbWVuKTtcbmNoZWNrKGZhbHNlLGRldGFpbHMpO1xuIH1cbnJldHVybiBmYWxzZTtcbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNwZWNpbWVuXG4gKiBAcGFyYW0ge0tleX0ga2V5QXNQYXR0ZXJuXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuY29uc3QgY2hlY2tBc0tleVBhdHQ9KHNwZWNpbWVuLGtleUFzUGF0dGVybixjaGVjayk9PntcbmlmKGtleUVRKHNwZWNpbWVuLGtleUFzUGF0dGVybikpe1xucmV0dXJuIHRydWU7XG4gfVxucmV0dXJuKFxuY2hlY2shPT1pZGVudENoZWNrZXImJlxuY2hlY2soZmFsc2UsWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGJlOiAke2tleUFzUGF0dGVybn1gKSk7XG5cbiB9O1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBpc1BhdHRlcm4gLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiogQHR5cGUge0NoZWNrUGF0dGVybn0gKi9cbmNvbnN0IGNoZWNrUGF0dGVybj0ocGF0dCxjaGVjayk9PntcbmlmKGlzS2V5KHBhdHQpKXtcbi8qIEFsbCBrZXlzIGFyZSBwYXR0ZXJucy4gRm9yIHRoZXNlLCB0aGUga2V5TWVtbyB3aWxsIGRvLiovXG4vKiBBbGwgcHJpbWl0aXZlcyB0aGF0IGFyZSBwYXR0ZXJucyBhcmUgYWxzbyBrZXlzLCB3aGljaCB0aGlzKi9cbi8qIGFsc28gdGFrZXMgY2FyZSBvZiB3aXRob3V0IG1lbW8uIFRoZSByZXN0IG9mIG91ciBjaGVja2luZyBsb2dpYyovXG4vKiBpcyBvbmx5IGNvbmNlcm5lZCB3aXRoIG5vbi1rZXkgcGF0dGVybnMuKi9cbnJldHVybiB0cnVlO1xuIH1cbmlmKHBhdHRlcm5NZW1vLmhhcyhwYXR0KSl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuY29uc3QgcmVzdWx0PWNoZWNrUGF0dGVybkludGVybmFsKHBhdHQsY2hlY2spO1xuaWYocmVzdWx0KXtcbnBhdHRlcm5NZW1vLmFkZChwYXR0KTtcbiB9XG5yZXR1cm4gcmVzdWx0O1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gcGF0dCAtIGtub3duIG5vdCB0byBiZSBhIGtleSwgYW5kIHRoZXJlZm9yZSBrbm93blxuICogbm90IHRvIGJlIHByaW1pdGl2ZS5cbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja1BhdHRlcm5JbnRlcm5hbD0ocGF0dCxjaGVjayk9Pntcbi8qIFB1cnBvc2VseSBwYXJhbGxlbHMgY2hlY2tLZXkuIFRPRE8gcmV1c2UgbW9yZSBsb2dpYyBiZXR3ZWVuIHRoZW0uKi9cbi8qIE1vc3Qgb2YgdGhlIHRleHQgb2YgdGhlIHN3aXRjaCBiZWxvdyBub3QgZGVhbGluZyB3aXRoIG1hdGNoZXJzIGlzKi9cbi8qIGVzc2VudGlhbGx5IGlkZW50aWNhbC4qL1xuY29uc3QgY2hlY2tJdD0oY2hpbGQpPT5jaGVja1BhdHRlcm4oY2hpbGQsY2hlY2spO1xuXG5jb25zdCBraW5kPWtpbmRPZihwYXR0LGNoZWNrKTtcbnN3aXRjaChraW5kKXtcbmNhc2UgdW5kZWZpbmVkOntcbnJldHVybiBmYWxzZTtcbiB9XG5jYXNlJ2NvcHlSZWNvcmQnOntcbi8qIEEgY29weVJlY29yZCBpcyBhIHBhdHRlcm4gaWZmIGFsbCBpdHMgY2hpbGRyZW4gYXJlKi9cbi8qIHBhdHRlcm5zKi9cbnJldHVybiB2YWx1ZXMocGF0dCkuZXZlcnkoY2hlY2tJdCk7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbi8qIEEgY29weUFycmF5IGlzIGEgcGF0dGVybiBpZmYgYWxsIGl0cyBjaGlsZHJlbiBhcmUqL1xuLyogcGF0dGVybnMqL1xucmV0dXJuIHBhdHQuZXZlcnkoY2hlY2tJdCk7XG4gfVxuY2FzZSdjb3B5TWFwJzp7XG4vKiBBIGNvcHlNYXAncyBrZXlzIGFyZSBrZXlzIGFuZCB0aGVyZWZvcmUgYWxyZWFkeSBrbm93biB0byBiZSovXG4vKiBwYXR0ZXJucy4qL1xuLyogQSBjb3B5TWFwIGlzIGEgcGF0dGVybiBpZiBpdHMgdmFsdWVzIGFyZSBwYXR0ZXJucy4qL1xucmV0dXJuIGNoZWNrUGF0dGVybihwYXR0LnZhbHVlcyxjaGVjayk7XG4gfVxuY2FzZSdlcnJvcic6XG5jYXNlJ3Byb21pc2UnOntcbnJldHVybiBjaGVjayhmYWxzZSxYIGBBICR7cShraW5kKX0gY2Fubm90IGJlIGEgcGF0dGVybmApO1xuIH1cbmRlZmF1bHQ6e1xuaWYobWF5YmVNYXRjaEhlbHBlcihraW5kKSE9PXVuZGVmaW5lZCl7XG5yZXR1cm4gdHJ1ZTtcbiB9XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYEEgcGFzc2FibGUgb2Yga2luZCAke3Eoa2luZCl9IGlzIG5vdCBhIHBhdHRlcm46ICR7cGF0dH1gKTtcblxuIH19XG5cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHBhdHRcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBpc1BhdHRlcm49KHBhdHQpPT5jaGVja1BhdHRlcm4ocGF0dCxpZGVudENoZWNrZXIpO1xuXG4vKipcbiAqIEBwYXJhbSB7UGF0dGVybn0gcGF0dFxuICovXG5jb25zdCBhc3NlcnRQYXR0ZXJuPShwYXR0KT0+e1xuY2hlY2tQYXR0ZXJuKHBhdHQsYXNzZXJ0Q2hlY2tlcik7XG4gfTtcblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gbWF0Y2hlcyAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqXG4gKiBAcGFyYW0ge1Bhc3NhYmxlfSBzcGVjaW1lblxuICogQHBhcmFtIHtQYXR0ZXJufSBwYXR0ZXJuXG4gKiBAcGFyYW0ge0NoZWNrZXJ9IGNoZWNrXG4gKiBAcGFyYW0ge3N0cmluZ3xudW1iZXJ9IFtsYWJlbF1cbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBjaGVja01hdGNoZXM9KHNwZWNpbWVuLHBhdHRlcm4sY2hlY2ssbGFiZWw9dW5kZWZpbmVkKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdXNlLWJlZm9yZS1kZWZpbmUqL1xuYXBwbHlMYWJlbGluZ0Vycm9yKGNoZWNrTWF0Y2hlc0ludGVybmFsLFtzcGVjaW1lbixwYXR0ZXJuLGNoZWNrXSxsYWJlbCk7XG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZX0gc3BlY2ltZW5cbiAqIEBwYXJhbSB7UGF0dGVybn0gcGF0dFxuICogQHBhcmFtIHtDaGVja2VyfSBjaGVja1xuICogQHJldHVybnMge2Jvb2xlYW59XG4gKi9cbmNvbnN0IGNoZWNrTWF0Y2hlc0ludGVybmFsPShzcGVjaW1lbixwYXR0LGNoZWNrKT0+e1xuLyogV29ydGggYmVpbmcgYSBiaXQgdmVyYm9zZSBhbmQgcmVwZXRpdGl2ZSBpbiBvcmRlciB0byBvcHRpbWl6ZSovXG5jb25zdCBwYXR0ZXJuS2luZD1raW5kT2YocGF0dCxjaGVjayk7XG5jb25zdCBzcGVjaW1lbktpbmQ9a2luZE9mKHNwZWNpbWVuKTsvKiBtYXkgYmUgdW5kZWZpbmVkKi9cbnN3aXRjaChwYXR0ZXJuS2luZCl7XG5jYXNlIHVuZGVmaW5lZDp7XG5yZXR1cm4gRmFpbCBgcGF0dGVybiBleHBlY3RlZDogJHtwYXR0fWA7XG4gfVxuY2FzZSdwcm9taXNlJzp7XG5yZXR1cm4gRmFpbCBgcHJvbWlzZXMgY2Fubm90IGJlIHBhdHRlcm5zOiAke3BhdHR9YDtcbiB9XG5jYXNlJ2Vycm9yJzp7XG5yZXR1cm4gRmFpbCBgZXJyb3JzIGNhbm5vdCBiZSBwYXR0ZXJuczogJHtwYXR0fWA7XG4gfVxuY2FzZSd1bmRlZmluZWQnOlxuY2FzZSdudWxsJzpcbmNhc2UnYm9vbGVhbic6XG5jYXNlJ251bWJlcic6XG5jYXNlJ2JpZ2ludCc6XG5jYXNlJ3N0cmluZyc6XG5jYXNlJ3N5bWJvbCc6XG5jYXNlJ2NvcHlTZXQnOlxuY2FzZSdjb3B5QmFnJzpcbmNhc2UncmVtb3RhYmxlJzp7XG4vKiBUaGVzZSBraW5kcyBhcmUgbmVjZXNzYXJpbHkga2V5cyovXG5yZXR1cm4gY2hlY2tBc0tleVBhdHQoc3BlY2ltZW4scGF0dCxjaGVjayk7XG4gfVxuY2FzZSdjb3B5QXJyYXknOntcbmlmKGlzS2V5KHBhdHQpKXtcbi8qIFRha2VzIGNhcmUgb2YgcGF0dGVybnMgd2hpY2ggYXJlIGtleXMsIHNvIHRoZSByZXN0IG9mIHRoaXMqL1xuLyogbG9naWMgY2FuIGFzc3VtZSBwYXR0ZXJucyB0aGF0IGFyZSBub3Qga2V5cy4qL1xucmV0dXJuIGNoZWNrQXNLZXlQYXR0KHNwZWNpbWVuLHBhdHQsY2hlY2spO1xuIH1cbmlmKHNwZWNpbWVuS2luZCE9PSdjb3B5QXJyYXknKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGJlIGEgY29weUFycmF5IHRvIG1hdGNoIGEgY29weUFycmF5IHBhdHRlcm46ICR7cGF0dH1gKTtcblxuIH1cbmNvbnN0e2xlbmd0aH09cGF0dDtcbmlmKHNwZWNpbWVuLmxlbmd0aCE9PWxlbmd0aCl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYEFycmF5ICR7c3BlY2ltZW59IC0gTXVzdCBiZSBhcyBsb25nIGFzIGNvcHlBcnJheSBwYXR0ZXJuOiAke3BhdHR9YCk7XG5cbiB9XG5yZXR1cm4gcGF0dC5ldmVyeSgocCxpKT0+Y2hlY2tNYXRjaGVzKHNwZWNpbWVuW2ldLHAsY2hlY2ssaSkpO1xuIH1cbmNhc2UnY29weVJlY29yZCc6e1xuaWYoaXNLZXkocGF0dCkpe1xuLyogVGFrZXMgY2FyZSBvZiBwYXR0ZXJucyB3aGljaCBhcmUga2V5cywgc28gdGhlIHJlc3Qgb2YgdGhpcyovXG4vKiBsb2dpYyBjYW4gYXNzdW1lIHBhdHRlcm5zIHRoYXQgYXJlIG5vdCBrZXlzLiovXG5yZXR1cm4gY2hlY2tBc0tleVBhdHQoc3BlY2ltZW4scGF0dCxjaGVjayk7XG4gfVxuaWYoc3BlY2ltZW5LaW5kIT09J2NvcHlSZWNvcmQnKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGJlIGEgY29weVJlY29yZCB0byBtYXRjaCBhIGNvcHlSZWNvcmQgcGF0dGVybjogJHtwYXR0fWApO1xuXG4gfVxuLyogVE9ETyBEZXRlY3QgYW5kIGFjY3VtdWxhdGUgZGlmZmVyZW5jZSBpbiBvbmUgcGFzcy4qL1xuLyogUmF0aGVyIHRoYW4gdXNpbmcgdHdvIGNhbGxzIHRvIGBsaXN0RGlmZmVyZW5jZWAgdG8gZGV0ZWN0IGFuZCovXG4vKiByZXBvcnQgaWYgYW5kIGhvdyB0aGVzZSBsaXN0cyBkaWZmZXIsIHNpbmNlIHRoZXkgYXJlIGFscmVhZHkqL1xuLyogaW4gc29ydGVkIG9yZGVyLCB3ZSBzaG91bGQgaW5zdGVhZCB1c2UgYW4gYWxnb3JpdGhtIGxpa2UqL1xuLyogYGl0ZXJEaXNqb2ludFVuaW9uYCBmcm9tIG1lcmdlLXNvcnQtb3BlcmF0b3JzLmpzKi9cbmNvbnN0IHNwZWNpbWVuTmFtZXM9cmVjb3JkTmFtZXMoc3BlY2ltZW4pO1xuY29uc3QgcGF0dE5hbWVzPXJlY29yZE5hbWVzKHBhdHQpO1xuY29uc3QgbWlzc2luZz1saXN0RGlmZmVyZW5jZShwYXR0TmFtZXMsc3BlY2ltZW5OYW1lcyk7XG5pZihtaXNzaW5nLmxlbmd0aD49MSl7XG5yZXR1cm4gY2hlY2soXG5mYWxzZSxcblggYCR7c3BlY2ltZW59IC0gTXVzdCBoYXZlIG1pc3NpbmcgcHJvcGVydGllcyAke3EobWlzc2luZyl9YCk7XG5cbiB9XG5jb25zdCB1bmV4cGVjdGVkPWxpc3REaWZmZXJlbmNlKHNwZWNpbWVuTmFtZXMscGF0dE5hbWVzKTtcbmlmKHVuZXhwZWN0ZWQubGVuZ3RoPj0xKXtcbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgJHtzcGVjaW1lbn0gLSBNdXN0IG5vdCBoYXZlIHVuZXhwZWN0ZWQgcHJvcGVydGllczogJHtxKFxudW5leHBlY3RlZClcbiB9YCk7XG5cbiB9XG5jb25zdCBzcGVjaW1lblZhbHVlcz1yZWNvcmRWYWx1ZXMoc3BlY2ltZW4sc3BlY2ltZW5OYW1lcyk7XG5jb25zdCBwYXR0VmFsdWVzPXJlY29yZFZhbHVlcyhwYXR0LHBhdHROYW1lcyk7XG5yZXR1cm4gcGF0dE5hbWVzLmV2ZXJ5KChsYWJlbCxpKT0+XG5jaGVja01hdGNoZXMoc3BlY2ltZW5WYWx1ZXNbaV0scGF0dFZhbHVlc1tpXSxjaGVjayxsYWJlbCkpO1xuXG4gfVxuY2FzZSdjb3B5TWFwJzp7XG5pZihpc0tleShwYXR0KSl7XG4vKiBUYWtlcyBjYXJlIG9mIHBhdHRlcm5zIHdoaWNoIGFyZSBrZXlzLCBzbyB0aGUgcmVzdCBvZiB0aGlzKi9cbi8qIGxvZ2ljIGNhbiBhc3N1bWUgcGF0dGVybnMgdGhhdCBhcmUgbm90IGtleXMuKi9cbnJldHVybiBjaGVja0FzS2V5UGF0dChzcGVjaW1lbixwYXR0LGNoZWNrKTtcbiB9XG5pZihzcGVjaW1lbktpbmQhPT0nY29weU1hcCcpe1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGAke3NwZWNpbWVufSAtIE11c3QgYmUgYSBjb3B5TWFwIHRvIG1hdGNoIGEgY29weU1hcCBwYXR0ZXJuOiAke3BhdHR9YCk7XG5cbiB9XG5jb25zdHtwYXlsb2FkOnBhdHRQYXlsb2FkfT1wYXR0O1xuY29uc3R7cGF5bG9hZDpzcGVjaW1lblBheWxvYWR9PXNwZWNpbWVuO1xuY29uc3QgcGF0dEtleVNldD1jb3B5TWFwS2V5U2V0KHBhdHRQYXlsb2FkKTtcbmNvbnN0IHNwZWNpbWVuS2V5U2V0PWNvcHlNYXBLZXlTZXQoc3BlY2ltZW5QYXlsb2FkKTtcbi8qIENvbXBhcmUga2V5cyBhcyBjb3B5U2V0cyovXG5pZighY2hlY2tNYXRjaGVzKHNwZWNpbWVuS2V5U2V0LHBhdHRLZXlTZXQsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdCBwYXR0VmFsdWVzPXBhdHRQYXlsb2FkLnZhbHVlcztcbmNvbnN0IHNwZWNpbWVuVmFsdWVzPXNwZWNpbWVuUGF5bG9hZC52YWx1ZXM7XG4vKiBjb21wYXJlIHZhbHVlcyBhcyBjb3B5QXJyYXlzKi9cbnJldHVybiBjaGVja01hdGNoZXMoc3BlY2ltZW5WYWx1ZXMscGF0dFZhbHVlcyxjaGVjayk7XG4gfVxuZGVmYXVsdDp7XG5jb25zdCBtYXRjaEhlbHBlcj1tYXliZU1hdGNoSGVscGVyKHBhdHRlcm5LaW5kKTtcbmlmKG1hdGNoSGVscGVyKXtcbnJldHVybiBtYXRjaEhlbHBlci5jaGVja01hdGNoZXMoc3BlY2ltZW4scGF0dC5wYXlsb2FkLGNoZWNrKTtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogc2hvdWxkIGhhdmUgcmVjb2duaXplZCAke3EocGF0dGVybktpbmQpfSBgO1xuIH19XG5cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNwZWNpbWVuXG4gKiBAcGFyYW0ge1BhdHRlcm59IHBhdHRcbiAqIEByZXR1cm5zIHtib29sZWFufVxuICovXG5jb25zdCBtYXRjaGVzPShzcGVjaW1lbixwYXR0KT0+XG5jaGVja01hdGNoZXMoc3BlY2ltZW4scGF0dCxpZGVudENoZWNrZXIpO1xuXG4vKipcbiAqIFJldHVybmluZyBub3JtYWxseSBpbmRpY2F0ZXMgc3VjY2Vzcy4gTWF0Y2ggZmFpbHVyZSBpcyBpbmRpY2F0ZWQgYnlcbiAqIHRocm93aW5nLlxuICpcbiAqIEBwYXJhbSB7UGFzc2FibGV9IHNwZWNpbWVuXG4gKiBAcGFyYW0ge1BhdHRlcm59IHBhdHRcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcn0gW2xhYmVsXVxuICovXG5jb25zdCBtdXN0TWF0Y2g9KHNwZWNpbWVuLHBhdHQsbGFiZWw9dW5kZWZpbmVkKT0+e1xuaWYoY2hlY2tNYXRjaGVzKHNwZWNpbWVuLHBhdHQsaWRlbnRDaGVja2VyLGxhYmVsKSl7XG5yZXR1cm47XG4gfVxuLyogc2hvdWxkIG9ubHkgdGhyb3cqL1xuY2hlY2tNYXRjaGVzKHNwZWNpbWVuLHBhdHQsYXNzZXJ0Q2hlY2tlcixsYWJlbCk7XG5GYWlsIGBpbnRlcm5hbDogJHtsYWJlbH06IGluY29uc2lzdGVudCBwYXR0ZXJuIG1hdGNoOiAke3EocGF0dCl9YDtcbiB9O1xuXG4vKiAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyBnZXRSYW5rQ292ZXIgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8qL1xuXG4vKiogQHR5cGUge0dldFJhbmtDb3Zlcn0gKi9cbmNvbnN0IGdldFJhbmtDb3Zlcj0ocGF0dCxlbmNvZGVQYXNzYWJsZSk9PntcbmlmKGlzS2V5KHBhdHQpKXtcbmNvbnN0IGVuY29kZWQ9ZW5jb2RlUGFzc2FibGUocGF0dCk7XG5pZihlbmNvZGVkIT09dW5kZWZpbmVkKXtcbnJldHVybltlbmNvZGVkLCBgJHtlbmNvZGVkfX5gXTtcbiB9XG4gfVxuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHBhdHQpO1xuc3dpdGNoKHBhc3NTdHlsZSl7XG5jYXNlJ2NvcHlBcnJheSc6e1xuLyogWFhYIHRoaXMgZG9lc24ndCBnZXQgYWxvbmcgd2l0aCB0aGUgd29ybGQgb2YgY292ZXIgPT09IHBhaXIgb2YqL1xuLyogc3RyaW5ncy4gSW4gdGhlIG1lYW50aW1lLCBmYWxsIHRocm91Z2ggdG8gdGhlIGRlZmF1bHQgd2hpY2gqL1xuLyogcmV0dXJucyBhIGNvdmVyIHRoYXQgY292ZXJzIGFsbCBjb3B5QXJyYXlzLiovXG4vKiovXG4vKiBjb25zdCByYW5rQ292ZXJzID0gcGF0dC5tYXAocCA9PiBnZXRSYW5rQ292ZXIocCwgZW5jb2RlUGFzc2FibGUpKTsqL1xuLyogcmV0dXJuIGhhcmRlbihbKi9cbi8qIHJhbmtDb3ZlcnMubWFwKChbbGVmdCwgX3JpZ2h0XSkgPT4gbGVmdCksKi9cbi8qIHJhbmtDb3ZlcnMubWFwKChbX2xlZnQsIHJpZ2h0XSkgPT4gcmlnaHQpLCovXG4vKiBdKTsqL1xuYnJlYWs7XG4gfVxuY2FzZSdjb3B5UmVjb3JkJzp7XG4vKiBYWFggdGhpcyBkb2Vzbid0IGdldCBhbG9uZyB3aXRoIHRoZSB3b3JsZCBvZiBjb3ZlciA9PT0gcGFpciBvZiovXG4vKiBzdHJpbmdzLiBJbiB0aGUgbWVhbnRpbWUsIGZhbGwgdGhyb3VnaCB0byB0aGUgZGVmYXVsdCB3aGljaCovXG4vKiByZXR1cm5zIGEgY292ZXIgdGhhdCBjb3ZlcnMgYWxsIGNvcHlSZWNvcmRzLiovXG4vKiovXG4vKiBjb25zdCBwYXR0S2V5cyA9IG93bktleXMocGF0dCk7Ki9cbi8qIGNvbnN0IHBhdHRFbnRyaWVzID0gaGFyZGVuKHBhdHRLZXlzLm1hcChrZXkgPT4gW2tleSwgcGF0dFtrZXldXSkpOyovXG4vKiBjb25zdCBbbGVmdEVudHJpZXNMaW1pdCwgcmlnaHRFbnRyaWVzTGltaXRdID0qL1xuLyogZ2V0UmFua0NvdmVyKHBhdHRFbnRyaWVzKTsqL1xuLyogcmV0dXJuIGhhcmRlbihbKi9cbi8qIGZyb21VbmlxdWVFbnRyaWVzKGxlZnRFbnRyaWVzTGltaXQpLCovXG4vKiBmcm9tVW5pcXVlRW50cmllcyhyaWdodEVudHJpZXNMaW1pdCksKi9cbi8qIF0pOyovXG5icmVhaztcbiB9XG5jYXNlJ3RhZ2dlZCc6e1xuY29uc3QgdGFnPWdldFRhZyhwYXR0KTtcbmNvbnN0IG1hdGNoSGVscGVyPW1heWJlTWF0Y2hIZWxwZXIodGFnKTtcbmlmKG1hdGNoSGVscGVyKXtcbi8qIEJ1cmllZCBoZXJlIGlzIHRoZSBpbXBvcnRhbnQgY2FzZSwgd2hlcmUgd2UgcHJvY2VzcyovXG4vKiB0aGUgdmFyaW91cyBwYXR0ZXJuTm9kZXMqL1xucmV0dXJuIG1hdGNoSGVscGVyLmdldFJhbmtDb3ZlcihwYXR0LnBheWxvYWQsZW5jb2RlUGFzc2FibGUpO1xuIH1cbnN3aXRjaCh0YWcpe1xuY2FzZSdjb3B5U2V0Jzp7XG4vKiBYWFggdGhpcyBkb2Vzbid0IGdldCBhbG9uZyB3aXRoIHRoZSB3b3JsZCBvZiBjb3ZlciA9PT0gcGFpciBvZiovXG4vKiBzdHJpbmdzLiBJbiB0aGUgbWVhbnRpbWUsIGZhbGwgdGhyb3VnaCB0byB0aGUgZGVmYXVsdCB3aGljaCovXG4vKiByZXR1cm5zIGEgY292ZXIgdGhhdCBjb3ZlcnMgYWxsIGNvcHlTZXRzLiovXG4vKiovXG4vKiAvLyBTaG91bGQgYWxyZWFkeSBiZSB2YWxpZGF0ZWQgYnkgY2hlY2tQYXR0ZXJuLiBCdXQgYmVjYXVzZSB0aGlzKi9cbi8qIC8vIGlzIGEgY2hlY2sgdGhhdCBtYXkgbG9vc2VuIG92ZXIgdGltZSwgd2UgYWxzbyBhc3NlcnQqL1xuLyogLy8gZXZlcnl3aGVyZSB3ZSBzdGlsbCByZWx5IG9uIHRoZSByZXN0cmljdGlvbi4qL1xuLyogYGBganMqL1xuLyogcGF0dC5wYXlsb2FkLmxlbmd0aCA9PT0gMSB8fCovXG4vKiBGYWlsYE5vbi1zaW5nbGV0b24gY29weVNldHMgd2l0aCBtYXRjaGVyIG5vdCB5ZXQgaW1wbGVtZW50ZWQ6ICR7cGF0dH1gOyovXG4vKiBgYGAqL1xuLyoqL1xuLyogY29uc3QgW2xlZnRFbGVtZW50TGltaXQsIHJpZ2h0RWxlbWVudExpbWl0XSA9IGdldFJhbmtDb3ZlcigqL1xuLyogcGF0dC5wYXlsb2FkWzBdLCovXG4vKiApOyovXG4vKiByZXR1cm4gaGFyZGVuKFsqL1xuLyogbWFrZUNvcHlTZXQoW2xlZnRFbGVtZW50TGltaXRdKSwqL1xuLyogbWFrZUNvcHlTZXQoW3JpZ2h0RWxlbWVudExpbWl0XSksKi9cbi8qIF0pOyovXG5icmVhaztcbiB9XG5jYXNlJ2NvcHlNYXAnOntcbi8qIFhYWCB0aGlzIGRvZXNuJ3QgZ2V0IGFsb25nIHdpdGggdGhlIHdvcmxkIG9mIGNvdmVyID09PSBwYWlyIG9mKi9cbi8qIHN0cmluZ3MuIEluIHRoZSBtZWFudGltZSwgZmFsbCB0aHJvdWdoIHRvIHRoZSBkZWZhdWx0IHdoaWNoKi9cbi8qIHJldHVybnMgYSBjb3ZlciB0aGF0IGNvdmVycyBhbGwgY29weU1hcHMuKi9cbi8qKi9cbi8qIC8vIEEgbWF0Y2hpbmcgY29weU1hcCBtdXN0IGhhdmUgdGhlIHNhbWUga2V5cywgb3IgYXQgbW9zdCBvbmUqL1xuLyogLy8gbm9uLWtleSBrZXkgcGF0dGVybi4gVGh1cyB3ZSBjYW4gYXNzdW1lIHRoYXQgdmFsdWUgcG9zaXRpb25zKi9cbi8qIC8vIG1hdGNoIDEtdG8tMS4qL1xuLyogLy8qL1xuLyogLy8gVE9ETyBJIG1heSBiZSBvdmVybG9va2luZyB0aGF0IHRoZSBsZXNzIHByZWNpc2UgcmFua09yZGVyKi9cbi8qIC8vIGVxdWl2YWxlbmNlIGNsYXNzIG1heSBjYXVzZSB2YWx1ZXMgdG8gYmUgb3V0IG9mIG9yZGVyLCovXG4vKiAvLyBtYWtpbmcgdGhpcyByYW5rQ292ZXIgbm90IGFjdHVhbGx5IGNvdmVyLiBJbiB0aGF0IGNhc2UsIGZvciovXG4vKiAvLyBhbGwgdGhlIHZhbHVlcyBmb3Iga2V5cyBhdCB0aGUgc2FtZSByYW5rLCB3ZSBzaG91bGQgdW5pb24gdGhlaXIqL1xuLyogLy8gcmFuayBjb3ZlcnMuIFRPRE8gUE9TU0lCTEUgU0lMRU5UIENPUlJFQ1RORVNTIEJVRyovXG4vKiAvLyovXG4vKiAvLyBJZiB0aGlzIGlzIGEgYnVnLCBpdCBwcm9iYWJseSBhZmZlY3RzIHRoZSBnZXRSYW5rQ292ZXIqL1xuLyogLy8gY2FzZXMgb2YgbWF0Y2hMVEVIZWxwZXIgYW5kIG1hdGNoR1RFSGVscGVyIG9uIGNvcHlNYXAgYXMqL1xuLyogLy8gd2VsbC4gU2VlIG1ha2VDb3B5TWFwIGZvciBhbiBpZGVhIG9uIGZpeGluZyovXG4vKiAvLyB0aGlzIGJ1Zy4qL1xuLyogY29uc3QgW2xlZnRQYXlsb2FkTGltaXQsIHJpZ2h0UGF5bG9hZExpbWl0XSA9IGdldFJhbmtDb3ZlcigqL1xuLyogcGF0dC5wYXlsb2FkLCovXG4vKiBlbmNvZGVQYXNzYWJsZSwqL1xuLyogKTsqL1xuLyogcmV0dXJuIGhhcmRlbihbKi9cbi8qIG1ha2VUYWdnZWQoJ2NvcHlNYXAnLCBsZWZ0UGF5bG9hZExpbWl0KSwqL1xuLyogbWFrZVRhZ2dlZCgnY29weU1hcCcsIHJpZ2h0UGF5bG9hZExpbWl0KSwqL1xuLyogXSk7Ki9cbmJyZWFrO1xuIH1cbmRlZmF1bHQ6e1xuYnJlYWs7LyogZmFsbCB0aHJvdWdoIHRvIGRlZmF1bHQqL1xuIH19XG5cbmJyZWFrOy8qIGZhbGwgdGhyb3VnaCB0byBkZWZhdWx0Ki9cbiB9XG5kZWZhdWx0OntcbmJyZWFrOy8qIGZhbGwgdGhyb3VnaCB0byBkZWZhdWx0Ki9cbiB9fVxuXG5yZXR1cm4gZ2V0UGFzc1N0eWxlQ292ZXIocGFzc1N0eWxlKTtcbiB9O1xuXG5jb25zdCBhcnJheUV2ZXJ5TWF0Y2hQYXR0ZXJuPShhcnJheSxwYXR0LGNoZWNrLGxhYmVsUHJlZml4PScnKT0+e1xuaWYoY2hlY2tLaW5kKHBhdHQsJ21hdGNoOmFueScsaWRlbnRDaGVja2VyKSl7XG4vKiBpZiB0aGUgcGF0dGVybiBpcyBNLmFueSgpLCB3ZSBrbm93IGl0cyB0cnVlKi9cbnJldHVybiB0cnVlO1xuIH1cbnJldHVybiBhcnJheS5ldmVyeSgoZWwsaSk9PlxuY2hlY2tNYXRjaGVzKGVsLHBhdHQsY2hlY2ssIGAke2xhYmVsUHJlZml4fVske2l9XWApKTtcblxuIH07XG5cbi8qIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vIE1hdGNoIEhlbHBlcnMgLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLyovXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEFueUhlbHBlcj1GYXIoJ21hdGNoOmFueSBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooX3NwZWNpbWVuLF9tYXRjaGVyUGF5bG9hZCxfY2hlY2spPT50cnVlLFxuXG5jaGVja0lzV2VsbEZvcm1lZDoobWF0Y2hlclBheWxvYWQsY2hlY2spPT5cbm1hdGNoZXJQYXlsb2FkPT09dW5kZWZpbmVkfHxcbmNoZWNrKGZhbHNlLFggYG1hdGNoOmFueSBwYXlsb2FkOiAke21hdGNoZXJQYXlsb2FkfSAtIE11c3QgYmUgdW5kZWZpbmVkYCksXG5cbmdldFJhbmtDb3ZlcjooX21hdGNoUGF5bG9hZCxfZW5jb2RlUGFzc2FibGUpPT5bJycsJ3snXX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEFuZEhlbHBlcj1GYXIoJ21hdGNoOmFuZCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4scGF0dHMsY2hlY2spPT57XG5yZXR1cm4gcGF0dHMuZXZlcnkoKHBhdHQpPT5jaGVja01hdGNoZXMoc3BlY2ltZW4scGF0dCxjaGVjaykpO1xuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihhbGxlZ2VkUGF0dHMsY2hlY2spPT57XG5jb25zdCBjaGVja0l0PShwYXR0KT0+Y2hlY2tQYXR0ZXJuKHBhdHQsY2hlY2spO1xucmV0dXJuKFxuKHBhc3NTdHlsZU9mKGFsbGVnZWRQYXR0cyk9PT0nY29weUFycmF5J3x8XG5jaGVjayhmYWxzZSxYIGBOZWVkcyBhcnJheSBvZiBzdWItcGF0dGVybnM6ICR7YWxsZWdlZFBhdHRzfWApKSYmXG5hbGxlZ2VkUGF0dHMuZXZlcnkoY2hlY2tJdCkpO1xuXG4gfSxcblxuZ2V0UmFua0NvdmVyOihwYXR0cyxlbmNvZGVQYXNzYWJsZSk9PlxuaW50ZXJzZWN0UmFua0NvdmVycyhcbmNvbXBhcmVSYW5rLFxucGF0dHMubWFwKChwKT0+Z2V0UmFua0NvdmVyKHAsZW5jb2RlUGFzc2FibGUpKSl9KTtcblxuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaE9ySGVscGVyPUZhcignbWF0Y2g6b3IgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLHBhdHRzLGNoZWNrKT0+e1xuY29uc3R7bGVuZ3RofT1wYXR0cztcbmlmKGxlbmd0aD09PTApe1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGAke3NwZWNpbWVufSAtIG5vIHBhdHRlcm4gZGlzanVuY3RzIHRvIG1hdGNoOiAke3BhdHRzfWApO1xuXG4gfVxuaWYoXG5wYXR0cy5sZW5ndGg9PT0yJiZcbiFtYXRjaGVzKHNwZWNpbWVuLHBhdHRzWzBdKSYmXG5jaGVja0tpbmQocGF0dHNbMF0sJ21hdGNoOmtpbmQnLGlkZW50Q2hlY2tlcikmJlxucGF0dHNbMF0ucGF5bG9hZD09PSd1bmRlZmluZWQnKVxue1xuLyogV29ydGggc3BlY2lhbCBjYXNpbmcgdGhlIG9wdGlvbmFsIHBhdHRlcm4gZm9yKi9cbi8qIGJldHRlciBlcnJvciBtZXNzYWdlcy4qL1xucmV0dXJuIGNoZWNrTWF0Y2hlcyhzcGVjaW1lbixwYXR0c1sxXSxjaGVjayk7XG4gfVxuaWYocGF0dHMuc29tZSgocGF0dCk9Pm1hdGNoZXMoc3BlY2ltZW4scGF0dCkpKXtcbnJldHVybiB0cnVlO1xuIH1cbnJldHVybiBjaGVjayhmYWxzZSxYIGAke3NwZWNpbWVufSAtIE11c3QgbWF0Y2ggb25lIG9mICR7cGF0dHN9YCk7XG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6bWF0Y2hBbmRIZWxwZXIuY2hlY2tJc1dlbGxGb3JtZWQsXG5cbmdldFJhbmtDb3ZlcjoocGF0dHMsZW5jb2RlUGFzc2FibGUpPT5cbnVuaW9uUmFua0NvdmVycyhcbmNvbXBhcmVSYW5rLFxucGF0dHMubWFwKChwKT0+Z2V0UmFua0NvdmVyKHAsZW5jb2RlUGFzc2FibGUpKSl9KTtcblxuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaE5vdEhlbHBlcj1GYXIoJ21hdGNoOm5vdCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4scGF0dCxjaGVjayk9PntcbmlmKG1hdGNoZXMoc3BlY2ltZW4scGF0dCkpe1xucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGAke3NwZWNpbWVufSAtIE11c3QgZmFpbCBuZWdhdGVkIHBhdHRlcm46ICR7cGF0dH1gKTtcblxuIH1lbHNle1xucmV0dXJuIHRydWU7XG4gfVxuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOmNoZWNrUGF0dGVybixcblxuZ2V0UmFua0NvdmVyOihfcGF0dCxfZW5jb2RlUGFzc2FibGUpPT5bJycsJ3snXX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFNjYWxhckhlbHBlcj1GYXIoJ21hdGNoOnNjYWxhciBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sX21hdGNoZXJQYXlsb2FkLGNoZWNrKT0+XG5jaGVja1NjYWxhcktleShzcGVjaW1lbixjaGVjayksXG5cbmNoZWNrSXNXZWxsRm9ybWVkOm1hdGNoQW55SGVscGVyLmNoZWNrSXNXZWxsRm9ybWVkLFxuXG5nZXRSYW5rQ292ZXI6KF9tYXRjaFBheWxvYWQsX2VuY29kZVBhc3NhYmxlKT0+WydhJywnen4nXX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEtleUhlbHBlcj1GYXIoJ21hdGNoOmtleSBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sX21hdGNoZXJQYXlsb2FkLGNoZWNrKT0+XG5jaGVja0tleShzcGVjaW1lbixjaGVjayksXG5cbmNoZWNrSXNXZWxsRm9ybWVkOm1hdGNoQW55SGVscGVyLmNoZWNrSXNXZWxsRm9ybWVkLFxuXG5nZXRSYW5rQ292ZXI6KF9tYXRjaFBheWxvYWQsX2VuY29kZVBhc3NhYmxlKT0+WydhJywnen4nXX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFBhdHRlcm5IZWxwZXI9RmFyKCdtYXRjaDpwYXR0ZXJuIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixfbWF0Y2hlclBheWxvYWQsY2hlY2spPT5cbmNoZWNrUGF0dGVybihzcGVjaW1lbixjaGVjayksXG5cbmNoZWNrSXNXZWxsRm9ybWVkOm1hdGNoQW55SGVscGVyLmNoZWNrSXNXZWxsRm9ybWVkLFxuXG5nZXRSYW5rQ292ZXI6KF9tYXRjaFBheWxvYWQsX2VuY29kZVBhc3NhYmxlKT0+WydhJywnen4nXX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEtpbmRIZWxwZXI9RmFyKCdtYXRjaDpraW5kIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOmNoZWNrS2luZCxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KGFsbGVnZWRLZXlLaW5kLGNoZWNrKT0+XG50eXBlb2YgYWxsZWdlZEtleUtpbmQ9PT0nc3RyaW5nJ3x8XG5jaGVjayhcbmZhbHNlLFxuWCBgbWF0Y2g6a2luZDogcGF5bG9hZDogJHthbGxlZ2VkS2V5S2luZH0gLSBBIGtpbmQgbmFtZSBtdXN0IGJlIGEgc3RyaW5nYCksXG5cblxuZ2V0UmFua0NvdmVyOihraW5kLF9lbmNvZGVQYXNzYWJsZSk9PntcbmxldCBzdHlsZTtcbnN3aXRjaChraW5kKXtcbmNhc2UnY29weVNldCc6XG5jYXNlJ2NvcHlNYXAnOntcbnN0eWxlPSd0YWdnZWQnO1xuYnJlYWs7XG4gfVxuZGVmYXVsdDp7XG5zdHlsZT1raW5kO1xuYnJlYWs7XG4gfX1cblxucmV0dXJuIGdldFBhc3NTdHlsZUNvdmVyKHN0eWxlKTtcbiB9fSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoQmlnaW50SGVscGVyPUZhcignbWF0Y2g6YmlnaW50IGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixbbGltaXRzPXVuZGVmaW5lZF0sY2hlY2spPT57XG5jb25zdHtkZWNpbWFsRGlnaXRzTGltaXR9PWxpbWl0KGxpbWl0cyk7XG5yZXR1cm4oXG5jaGVja0tpbmQoc3BlY2ltZW4sJ2JpZ2ludCcsY2hlY2spJiZcbmNoZWNrRGVjaW1hbERpZ2l0c0xpbWl0KHNwZWNpbWVuLGRlY2ltYWxEaWdpdHNMaW1pdCxjaGVjaykpO1xuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbXSksXG5jaGVjayxcbidtYXRjaDpiaWdpbnQgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooX21hdGNoUGF5bG9hZCxfZW5jb2RlUGFzc2FibGUpPT5cbmdldFBhc3NTdHlsZUNvdmVyKCdiaWdpbnQnKX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaE5hdEhlbHBlcj1GYXIoJ21hdGNoOm5hdCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sW2xpbWl0cz11bmRlZmluZWRdLGNoZWNrKT0+e1xuY29uc3R7ZGVjaW1hbERpZ2l0c0xpbWl0fT1saW1pdChsaW1pdHMpO1xucmV0dXJuKFxuY2hlY2tLaW5kKHNwZWNpbWVuLCdiaWdpbnQnLGNoZWNrKSYmXG5jaGVjayhcbi8qKiBAdHlwZSB7YmlnaW50fSAqL3NwZWNpbWVuPj0wbixcblggYCR7c3BlY2ltZW59IC0gTXVzdCBiZSBub24tbmVnYXRpdmVgKSYmXG5cbmNoZWNrRGVjaW1hbERpZ2l0c0xpbWl0KHNwZWNpbWVuLGRlY2ltYWxEaWdpdHNMaW1pdCxjaGVjaykpO1xuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbXSksXG5jaGVjayxcbidtYXRjaDpuYXQgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooX21hdGNoUGF5bG9hZCxfZW5jb2RlUGFzc2FibGUpPT5cbi8qIFRPRE8gQ291bGQgYmUgbW9yZSBwcmVjaXNlKi9cbmdldFBhc3NTdHlsZUNvdmVyKCdiaWdpbnQnKX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFN0cmluZ0hlbHBlcj1GYXIoJ21hdGNoOnN0cmluZyBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sW2xpbWl0cz11bmRlZmluZWRdLGNoZWNrKT0+e1xuY29uc3R7c3RyaW5nTGVuZ3RoTGltaXR9PWxpbWl0KGxpbWl0cyk7XG4vKiBwcmV0dGllci1pZ25vcmUqL1xucmV0dXJuKFxuY2hlY2tLaW5kKHNwZWNpbWVuLCdzdHJpbmcnLGNoZWNrKSYmKFxuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBlbmRvL3Jlc3RyaWN0LWNvbXBhcmlzb24tb3BlcmFuZHMqL1xuLyoqIEB0eXBlIHtzdHJpbmd9ICovc3BlY2ltZW4ubGVuZ3RoPD1zdHJpbmdMZW5ndGhMaW1pdHx8XG5jaGVjayhcbmZhbHNlLFxuWCBgc3RyaW5nICR7c3BlY2ltZW59IG11c3Qgbm90IGJlIGJpZ2dlciB0aGFuICR7c3RyaW5nTGVuZ3RoTGltaXR9YCkpKTtcblxuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbXSksXG5jaGVjayxcbidtYXRjaDpzdHJpbmcgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooX21hdGNoUGF5bG9hZCxfZW5jb2RlUGFzc2FibGUpPT5cbmdldFBhc3NTdHlsZUNvdmVyKCdzdHJpbmcnKX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFN5bWJvbEhlbHBlcj1GYXIoJ21hdGNoOnN5bWJvbCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sW2xpbWl0cz11bmRlZmluZWRdLGNoZWNrKT0+e1xuY29uc3R7c3ltYm9sTmFtZUxlbmd0aExpbWl0fT1saW1pdChsaW1pdHMpO1xuaWYoIWNoZWNrS2luZChzcGVjaW1lbiwnc3ltYm9sJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmNvbnN0IHN5bWJvbE5hbWU9bmFtZUZvclBhc3NhYmxlU3ltYm9sKHNwZWNpbWVuKTtcblxuaWYodHlwZW9mIHN5bWJvbE5hbWUhPT0nc3RyaW5nJyl7XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogUGFzc2FibGUgc3ltYm9sICR7c3BlY2ltZW59IG11c3QgaGF2ZSBhIHBhc3NhYmxlIG5hbWVgO1xuIH1cbnJldHVybiBjaGVjayhcbnN5bWJvbE5hbWUubGVuZ3RoPD1zeW1ib2xOYW1lTGVuZ3RoTGltaXQsXG5YIGBTeW1ib2wgbmFtZSAke3EoXG5zeW1ib2xOYW1lKVxuIH0gbXVzdCBub3QgYmUgYmlnZ2VyIHRoYW4gJHtzeW1ib2xOYW1lTGVuZ3RoTGltaXR9YCk7XG5cbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDoocGF5bG9hZCxjaGVjayk9PlxuY2hlY2tJc1dlbGxGb3JtZWRXaXRoTGltaXQoXG5wYXlsb2FkLFxuaGFyZGVuKFtdKSxcbmNoZWNrLFxuJ21hdGNoOnN5bWJvbCBwYXlsb2FkJyksXG5cblxuZ2V0UmFua0NvdmVyOihfbWF0Y2hQYXlsb2FkLF9lbmNvZGVQYXNzYWJsZSk9PlxuZ2V0UGFzc1N0eWxlQ292ZXIoJ3N5bWJvbCcpfSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoUmVtb3RhYmxlSGVscGVyPUZhcignbWF0Y2g6cmVtb3RhYmxlIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixyZW1vdGFibGVEZXNjLGNoZWNrKT0+e1xuLyogVW5mb3J0dW5hdGUgZHVwbGljYXRpb24gb2YgY2hlY2tLaW5kIGxvZ2ljLCBidXQgbm8gYmV0dGVyIGNob2ljZXMuKi9cbmlmKGNoZWNrS2luZChzcGVjaW1lbiwncmVtb3RhYmxlJyxpZGVudENoZWNrZXIpKXtcbnJldHVybiB0cnVlO1xuIH1cbmlmKGNoZWNrPT09aWRlbnRDaGVja2VyKXtcbnJldHVybiBmYWxzZTtcbiB9XG5sZXQgc3BlY2ltZW5LaW5kPXBhc3NTdHlsZU9mKHNwZWNpbWVuKTtcbmlmKHNwZWNpbWVuS2luZD09PSd0YWdnZWQnKXtcbnNwZWNpbWVuS2luZD1nZXRUYWcoc3BlY2ltZW4pO1xuIH1cbmNvbnN0e2xhYmVsfT1yZW1vdGFibGVEZXNjO1xuXG4vKiBxdW90aW5nIHdpdGhvdXQgcXVvdGVzKi9cbmNvbnN0IGRldGFpbHM9WChcblsgYCR7c3BlY2ltZW5LaW5kfSBgLGAgLSBNdXN0IGJlIGEgcmVtb3RhYmxlICgke2xhYmVsfSlgXSxcbnNwZWNpbWVuKTtcblxucmV0dXJuIGNoZWNrKGZhbHNlLGRldGFpbHMpO1xuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihhbGxlZ2VkUmVtb3RhYmxlRGVzYyxjaGVjayk9PlxuY2hlY2tNYXRjaGVzKFxuYWxsZWdlZFJlbW90YWJsZURlc2MsXG5oYXJkZW4oe2xhYmVsOk1NLnN0cmluZygpfSksXG5jaGVjayxcbidtYXRjaDpyZW1vdGFibGUgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooX3JlbW90YWJsZURlc2MsX2VuY29kZVBhc3NhYmxlKT0+XG5nZXRQYXNzU3R5bGVDb3ZlcigncmVtb3RhYmxlJyl9KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hMVEVIZWxwZXI9RmFyKCdtYXRjaDpsdGUgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLHJpZ2h0T3BlcmFuZCxjaGVjayk9Plxua2V5TFRFKHNwZWNpbWVuLHJpZ2h0T3BlcmFuZCl8fFxuY2hlY2soZmFsc2UsWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGJlIDw9ICR7cmlnaHRPcGVyYW5kfWApLFxuXG5jaGVja0lzV2VsbEZvcm1lZDpjaGVja0tleSxcblxuZ2V0UmFua0NvdmVyOihyaWdodE9wZXJhbmQsZW5jb2RlUGFzc2FibGUpPT57XG5jb25zdCBwYXNzU3R5bGU9cGFzc1N0eWxlT2YocmlnaHRPcGVyYW5kKTtcbi8qIFRoZSBwcmVmZXItY29uc3QgbWFrZXMgbm8gc2Vuc2Ugd2hlbiBzb21lIG9mIHRoZSB2YXJpYWJsZXMgbmVlZCovXG4vKiB0byBiZSBgbGV0YCovXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgcHJlZmVyLWNvbnN0Ki9cbmxldFtsZWZ0Qm91bmQscmlnaHRCb3VuZF09Z2V0UGFzc1N0eWxlQ292ZXIocGFzc1N0eWxlKTtcbmNvbnN0IG5ld1JpZ2h0Qm91bmQ9IGAke2VuY29kZVBhc3NhYmxlKHJpZ2h0T3BlcmFuZCl9fmA7XG5pZihuZXdSaWdodEJvdW5kIT09dW5kZWZpbmVkKXtcbnJpZ2h0Qm91bmQ9bmV3UmlnaHRCb3VuZDtcbiB9XG5yZXR1cm5bbGVmdEJvdW5kLHJpZ2h0Qm91bmRdO1xuIH19KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hMVEhlbHBlcj1GYXIoJ21hdGNoOmx0IGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixyaWdodE9wZXJhbmQsY2hlY2spPT5cbmtleUxUKHNwZWNpbWVuLHJpZ2h0T3BlcmFuZCl8fFxuY2hlY2soZmFsc2UsWCBgJHtzcGVjaW1lbn0gLSBNdXN0IGJlIDwgJHtyaWdodE9wZXJhbmR9YCksXG5cbmNoZWNrSXNXZWxsRm9ybWVkOmNoZWNrS2V5LFxuXG5nZXRSYW5rQ292ZXI6bWF0Y2hMVEVIZWxwZXIuZ2V0UmFua0NvdmVyfSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoR1RFSGVscGVyPUZhcignbWF0Y2g6Z3RlIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixyaWdodE9wZXJhbmQsY2hlY2spPT5cbmtleUdURShzcGVjaW1lbixyaWdodE9wZXJhbmQpfHxcbmNoZWNrKGZhbHNlLFggYCR7c3BlY2ltZW59IC0gTXVzdCBiZSA+PSAke3JpZ2h0T3BlcmFuZH1gKSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6Y2hlY2tLZXksXG5cbmdldFJhbmtDb3ZlcjoocmlnaHRPcGVyYW5kLGVuY29kZVBhc3NhYmxlKT0+e1xuY29uc3QgcGFzc1N0eWxlPXBhc3NTdHlsZU9mKHJpZ2h0T3BlcmFuZCk7XG4vKiBUaGUgcHJlZmVyLWNvbnN0IG1ha2VzIG5vIHNlbnNlIHdoZW4gc29tZSBvZiB0aGUgdmFyaWFibGVzIG5lZWQqL1xuLyogdG8gYmUgYGxldGAqL1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIHByZWZlci1jb25zdCovXG5sZXRbbGVmdEJvdW5kLHJpZ2h0Qm91bmRdPWdldFBhc3NTdHlsZUNvdmVyKHBhc3NTdHlsZSk7XG5jb25zdCBuZXdMZWZ0Qm91bmQ9ZW5jb2RlUGFzc2FibGUocmlnaHRPcGVyYW5kKTtcbmlmKG5ld0xlZnRCb3VuZCE9PXVuZGVmaW5lZCl7XG5sZWZ0Qm91bmQ9bmV3TGVmdEJvdW5kO1xuIH1cbnJldHVybltsZWZ0Qm91bmQscmlnaHRCb3VuZF07XG4gfX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEdUSGVscGVyPUZhcignbWF0Y2g6Z3QgaGVscGVyJyx7XG5jaGVja01hdGNoZXM6KHNwZWNpbWVuLHJpZ2h0T3BlcmFuZCxjaGVjayk9Plxua2V5R1Qoc3BlY2ltZW4scmlnaHRPcGVyYW5kKXx8XG5jaGVjayhmYWxzZSxYIGAke3NwZWNpbWVufSAtIE11c3QgYmUgPiAke3JpZ2h0T3BlcmFuZH1gKSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6Y2hlY2tLZXksXG5cbmdldFJhbmtDb3ZlcjptYXRjaEdURUhlbHBlci5nZXRSYW5rQ292ZXJ9KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hSZWNvcmRPZkhlbHBlcj1GYXIoJ21hdGNoOnJlY29yZE9mIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihcbnNwZWNpbWVuLFxuW2tleVBhdHQsdmFsdWVQYXR0LGxpbWl0cz11bmRlZmluZWRdLFxuY2hlY2spPT5cbntcbmNvbnN0e251bVByb3BlcnRpZXNMaW1pdCxwcm9wZXJ0eU5hbWVMZW5ndGhMaW1pdH09bGltaXQobGltaXRzKTtcbnJldHVybihcbmNoZWNrS2luZChzcGVjaW1lbiwnY29weVJlY29yZCcsY2hlY2spJiZcbmNoZWNrKFxub3duS2V5cyhzcGVjaW1lbikubGVuZ3RoPD1udW1Qcm9wZXJ0aWVzTGltaXQsXG5YIGBNdXN0IG5vdCBoYXZlIG1vcmUgdGhhbiAke3EoXG5udW1Qcm9wZXJ0aWVzTGltaXQpXG4gfSBwcm9wZXJ0aWVzOiAke3NwZWNpbWVufWApJiZcblxuZW50cmllcyhzcGVjaW1lbikuZXZlcnkoXG4oW2tleSx2YWx1ZV0pPT5cbmFwcGx5TGFiZWxpbmdFcnJvcihcbmNoZWNrLFxuW1xua2V5Lmxlbmd0aDw9cHJvcGVydHlOYW1lTGVuZ3RoTGltaXQsXG5YIGBQcm9wZXJ0eSBuYW1lIG11c3Qgbm90IGJlIGxvbmdlciB0aGFuICR7cShcbnByb3BlcnR5TmFtZUxlbmd0aExpbWl0KVxuIH1gXSxcblxua2V5KSYmXG5cbmNoZWNrTWF0Y2hlcyhcbmhhcmRlbihba2V5LHZhbHVlXSksXG5oYXJkZW4oW2tleVBhdHQsdmFsdWVQYXR0XSksXG5jaGVjayxcbmtleSkpKTtcblxuXG5cbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDoocGF5bG9hZCxjaGVjayk9PlxuY2hlY2tJc1dlbGxGb3JtZWRXaXRoTGltaXQoXG5wYXlsb2FkLFxuaGFyZGVuKFtNTS5wYXR0ZXJuKCksTU0ucGF0dGVybigpXSksXG5jaGVjayxcbidtYXRjaDpyZWNvcmRPZiBwYXlsb2FkJyksXG5cblxuZ2V0UmFua0NvdmVyOihfZW50cnlQYXR0KT0+Z2V0UGFzc1N0eWxlQ292ZXIoJ2NvcHlSZWNvcmQnKX0pO1xuXG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaEFycmF5T2ZIZWxwZXI9RmFyKCdtYXRjaDphcnJheU9mIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihzcGVjaW1lbixbc3ViUGF0dCxsaW1pdHM9dW5kZWZpbmVkXSxjaGVjayk9PntcbmNvbnN0e2FycmF5TGVuZ3RoTGltaXR9PWxpbWl0KGxpbWl0cyk7XG4vKiBwcmV0dGllci1pZ25vcmUqL1xucmV0dXJuKFxuY2hlY2tLaW5kKHNwZWNpbWVuLCdjb3B5QXJyYXknLGNoZWNrKSYmKFxuLyoqIEB0eXBlIHtBcnJheX0gKi9zcGVjaW1lbi5sZW5ndGg8PWFycmF5TGVuZ3RoTGltaXR8fFxuY2hlY2soXG5mYWxzZSxcblggYEFycmF5IGxlbmd0aCAke3NwZWNpbWVuLmxlbmd0aH0gbXVzdCBiZSA8PSBsaW1pdCAke2FycmF5TGVuZ3RoTGltaXR9YCkpJiZcblxuYXJyYXlFdmVyeU1hdGNoUGF0dGVybihzcGVjaW1lbixzdWJQYXR0LGNoZWNrKSk7XG5cbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDoocGF5bG9hZCxjaGVjayk9PlxuY2hlY2tJc1dlbGxGb3JtZWRXaXRoTGltaXQoXG5wYXlsb2FkLFxuaGFyZGVuKFtNTS5wYXR0ZXJuKCldKSxcbmNoZWNrLFxuJ21hdGNoOmFycmF5T2YgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooKT0+Z2V0UGFzc1N0eWxlQ292ZXIoJ2NvcHlBcnJheScpfSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoU2V0T2ZIZWxwZXI9RmFyKCdtYXRjaDpzZXRPZiBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooc3BlY2ltZW4sW2tleVBhdHQsbGltaXRzPXVuZGVmaW5lZF0sY2hlY2spPT57XG5jb25zdHtudW1TZXRFbGVtZW50c0xpbWl0fT1saW1pdChsaW1pdHMpO1xucmV0dXJuKFxuY2hlY2tLaW5kKHNwZWNpbWVuLCdjb3B5U2V0JyxjaGVjaykmJlxuY2hlY2soXG4vKiogQHR5cGUge0FycmF5fSAqL3NwZWNpbWVuLnBheWxvYWQubGVuZ3RoPG51bVNldEVsZW1lbnRzTGltaXQsXG5YIGBTZXQgbXVzdCBub3QgaGF2ZSBtb3JlIHRoYW4gJHtxKG51bVNldEVsZW1lbnRzTGltaXQpfSBlbGVtZW50czogJHtcbnNwZWNpbWVuLnBheWxvYWQubGVuZ3RoXG4gfWApJiZcblxuYXJyYXlFdmVyeU1hdGNoUGF0dGVybihzcGVjaW1lbi5wYXlsb2FkLGtleVBhdHQsY2hlY2ssJ3NldCBlbGVtZW50cycpKTtcblxuIH0sXG5cbmNoZWNrSXNXZWxsRm9ybWVkOihwYXlsb2FkLGNoZWNrKT0+XG5jaGVja0lzV2VsbEZvcm1lZFdpdGhMaW1pdChcbnBheWxvYWQsXG5oYXJkZW4oW01NLnBhdHRlcm4oKV0pLFxuY2hlY2ssXG4nbWF0Y2g6c2V0T2YgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooKT0+Z2V0UGFzc1N0eWxlQ292ZXIoJ3RhZ2dlZCcpfSk7XG5cblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoQmFnT2ZIZWxwZXI9RmFyKCdtYXRjaDpiYWdPZiBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooXG5zcGVjaW1lbixcbltrZXlQYXR0LGNvdW50UGF0dCxsaW1pdHM9dW5kZWZpbmVkXSxcbmNoZWNrKT0+XG57XG5jb25zdHtudW1VbmlxdWVCYWdFbGVtZW50c0xpbWl0LGRlY2ltYWxEaWdpdHNMaW1pdH09bGltaXQobGltaXRzKTtcbnJldHVybihcbmNoZWNrS2luZChzcGVjaW1lbiwnY29weUJhZycsY2hlY2spJiZcbmNoZWNrKFxuLyoqIEB0eXBlIHtBcnJheX0gKi9zcGVjaW1lbi5wYXlsb2FkLmxlbmd0aDw9XG5udW1VbmlxdWVCYWdFbGVtZW50c0xpbWl0LFxuWCBgQmFnIG11c3Qgbm90IGhhdmUgbW9yZSB0aGFuICR7cShcbm51bVVuaXF1ZUJhZ0VsZW1lbnRzTGltaXQpXG4gfSB1bmlxdWUgZWxlbWVudHM6ICR7c3BlY2ltZW59YCkmJlxuXG5zcGVjaW1lbi5wYXlsb2FkLmV2ZXJ5KFxuKFtrZXksY291bnRdLGkpPT5cbmNoZWNrTWF0Y2hlcyhrZXksa2V5UGF0dCxjaGVjaywgYGJhZyBrZXlzWyR7aX1dYCkmJlxuYXBwbHlMYWJlbGluZ0Vycm9yKFxuY2hlY2tEZWNpbWFsRGlnaXRzTGltaXQsXG5bY291bnQsZGVjaW1hbERpZ2l0c0xpbWl0LGNoZWNrXSxcbiBgYmFnIGNvdW50c1ske2l9XWApJiZcblxuY2hlY2tNYXRjaGVzKGNvdW50LGNvdW50UGF0dCxjaGVjaywgYGJhZyBjb3VudHNbJHtpfV1gKSkpO1xuXG5cbiB9LFxuXG5jaGVja0lzV2VsbEZvcm1lZDoocGF5bG9hZCxjaGVjayk9PlxuY2hlY2tJc1dlbGxGb3JtZWRXaXRoTGltaXQoXG5wYXlsb2FkLFxuaGFyZGVuKFtNTS5wYXR0ZXJuKCksTU0ucGF0dGVybigpXSksXG5jaGVjayxcbidtYXRjaDpiYWdPZiBwYXlsb2FkJyksXG5cblxuZ2V0UmFua0NvdmVyOigpPT5nZXRQYXNzU3R5bGVDb3ZlcigndGFnZ2VkJyl9KTtcblxuXG4vKiogQHR5cGUge01hdGNoSGVscGVyfSAqL1xuY29uc3QgbWF0Y2hNYXBPZkhlbHBlcj1GYXIoJ21hdGNoOm1hcE9mIGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihcbnNwZWNpbWVuLFxuW2tleVBhdHQsdmFsdWVQYXR0LGxpbWl0cz11bmRlZmluZWRdLFxuY2hlY2spPT5cbntcbmNvbnN0e251bU1hcEVudHJpZXNMaW1pdH09bGltaXQobGltaXRzKTtcbnJldHVybihcbmNoZWNrS2luZChzcGVjaW1lbiwnY29weU1hcCcsY2hlY2spJiZcbmNoZWNrKFxuLyoqIEB0eXBlIHtBcnJheX0gKi9zcGVjaW1lbi5wYXlsb2FkLmtleXMubGVuZ3RoPD1cbm51bU1hcEVudHJpZXNMaW1pdCxcblggYENvcHlNYXAgbXVzdCBoYXZlIG5vIG1vcmUgdGhhbiAke3EoXG5udW1NYXBFbnRyaWVzTGltaXQpXG4gfSBlbnRyaWVzOiAke3NwZWNpbWVufWApJiZcblxuYXJyYXlFdmVyeU1hdGNoUGF0dGVybihcbnNwZWNpbWVuLnBheWxvYWQua2V5cyxcbmtleVBhdHQsXG5jaGVjayxcbidtYXAga2V5cycpJiZcblxuYXJyYXlFdmVyeU1hdGNoUGF0dGVybihcbnNwZWNpbWVuLnBheWxvYWQudmFsdWVzLFxudmFsdWVQYXR0LFxuY2hlY2ssXG4nbWFwIHZhbHVlcycpKTtcblxuXG4gfSxcblxuY2hlY2tJc1dlbGxGb3JtZWQ6KHBheWxvYWQsY2hlY2spPT5cbmNoZWNrSXNXZWxsRm9ybWVkV2l0aExpbWl0KFxucGF5bG9hZCxcbmhhcmRlbihbTU0ucGF0dGVybigpLE1NLnBhdHRlcm4oKV0pLFxuY2hlY2ssXG4nbWF0Y2g6bWFwT2YgcGF5bG9hZCcpLFxuXG5cbmdldFJhbmtDb3ZlcjooX2VudHJ5UGF0dCk9PmdldFBhc3NTdHlsZUNvdmVyKCd0YWdnZWQnKX0pO1xuXG5cbi8qKlxuICogQHBhcmFtIHtQYXNzYWJsZVtdfSBzcGVjaW1lblxuICogQHBhcmFtIHtQYXR0ZXJuW119IHJlcXVpcmVkUGF0dFxuICogQHBhcmFtIHtQYXR0ZXJuW119IG9wdGlvbmFsUGF0dFxuICogQHJldHVybnMge3tcbiAqICAgcmVxdWlyZWRTcGVjaW1lbjogUGFzc2FibGVbXSxcbiAqICAgb3B0aW9uYWxTcGVjaW1lbjogUGFzc2FibGVbXSxcbiAqICAgcmVzdFNwZWNpbWVuOiBQYXNzYWJsZVtdXG4gKiB9fVxuICovXG5jb25zdCBzcGxpdEFycmF5UGFydHM9KHNwZWNpbWVuLHJlcXVpcmVkUGF0dCxvcHRpb25hbFBhdHQpPT57XG5jb25zdCBudW1SZXF1aXJlZD1yZXF1aXJlZFBhdHQubGVuZ3RoO1xuY29uc3QgbnVtT3B0aW9uYWw9b3B0aW9uYWxQYXR0Lmxlbmd0aDtcbmNvbnN0IHJlcXVpcmVkU3BlY2ltZW49c3BlY2ltZW4uc2xpY2UoMCxudW1SZXF1aXJlZCk7XG5jb25zdCBvcHRpb25hbFNwZWNpbWVuPXNwZWNpbWVuLnNsaWNlKFxubnVtUmVxdWlyZWQsXG5udW1SZXF1aXJlZCtudW1PcHRpb25hbCk7XG5cbmNvbnN0IHJlc3RTcGVjaW1lbj1zcGVjaW1lbi5zbGljZShudW1SZXF1aXJlZCtudW1PcHRpb25hbCk7XG5yZXR1cm4gaGFyZGVuKHtyZXF1aXJlZFNwZWNpbWVuLG9wdGlvbmFsU3BlY2ltZW4scmVzdFNwZWNpbWVufSk7XG4gfTtcblxuLyoqXG4gKiBPcHRpb25hbCBzcGVjaW1lbiBlbGVtZW50cyB3aGljaCBhcmUgYHVuZGVmaW5lZGAgcGFzcyB1bmNvbmRpdGlvbmFsbHkuXG4gKiBXZSBlbmNvZGUgdGhpcyB3aXRoIHRoZSBgTS5vcmAgcGF0dGVybiBzbyBpdCBhbHNvIHByb2R1Y2VzIGEgZ29vZFxuICogY29tcHJlc3Npb24gZGlzdGluZ3Vpc2hpbmcgYHVuZGVmaW5lZGAgZnJvbSBhYnNlbmNlLlxuICpcbiAqIEBwYXJhbSB7UGF0dGVybltdfSBvcHRpb25hbFBhdHRcbiAqIEBwYXJhbSB7bnVtYmVyfSBsZW5ndGhcbiAqIEByZXR1cm5zIHtQYXR0ZXJuW119IFRoZSBwYXJ0aWFsUGF0dFxuICovXG5jb25zdCBhZGFwdEFycmF5UGF0dGVybj0ob3B0aW9uYWxQYXR0LGxlbmd0aCk9PlxuaGFyZGVuKG9wdGlvbmFsUGF0dC5zbGljZSgwLGxlbmd0aCkubWFwKChwYXR0KT0+TU0ub3B0KHBhdHQpKSk7XG5cbi8qKiBAdHlwZSB7TWF0Y2hIZWxwZXJ9ICovXG5jb25zdCBtYXRjaFNwbGl0QXJyYXlIZWxwZXI9RmFyKCdtYXRjaDpzcGxpdEFycmF5IGhlbHBlcicse1xuY2hlY2tNYXRjaGVzOihcbnNwZWNpbWVuLFxuW3JlcXVpcmVkUGF0dCxvcHRpb25hbFBhdHQ9W10scmVzdFBhdHQ9TU0uYW55KCldLFxuY2hlY2spPT5cbntcbmlmKCFjaGVja0tpbmQoc3BlY2ltZW4sJ2NvcHlBcnJheScsY2hlY2spKXtcbnJldHVybiBmYWxzZTtcbiB9XG5jb25zdHtyZXF1aXJlZFNwZWNpbWVuLG9wdGlvbmFsU3BlY2ltZW4scmVzdFNwZWNpbWVufT1cbnNwbGl0QXJyYXlQYXJ0cyhzcGVjaW1lbixyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0KTtcbmNvbnN0IHBhcnRpYWxQYXR0PWFkYXB0QXJyYXlQYXR0ZXJuKFxub3B0aW9uYWxQYXR0LFxub3B0aW9uYWxTcGVjaW1lbi5sZW5ndGgpO1xuXG5sZXQgYXJnTnVtPTA7XG5yZXR1cm4oXG4ocmVxdWlyZWRTcGVjaW1lbi5sZW5ndGg9PT1yZXF1aXJlZFBhdHQubGVuZ3RofHxcbmNoZWNrKFxuZmFsc2UsXG5YIGBFeHBlY3RlZCBhdCBsZWFzdCAke3EoXG5yZXF1aXJlZFBhdHQubGVuZ3RoKVxuIH0gYXJndW1lbnRzOiAke3NwZWNpbWVufWApKSYmXG5cbnJlcXVpcmVkUGF0dC5ldmVyeSgocCxpKT0+XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tcGx1c3BsdXMqL1xuY2hlY2tNYXRjaGVzKHJlcXVpcmVkU3BlY2ltZW5baV0scCxjaGVjaywgYGFyZyAke2FyZ051bSsrfWApKSYmXG5cbnBhcnRpYWxQYXR0LmV2ZXJ5KChwLGkpPT5cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1wbHVzcGx1cyovXG5jaGVja01hdGNoZXMob3B0aW9uYWxTcGVjaW1lbltpXSxwLGNoZWNrLCBgYXJnICR7YXJnTnVtKyt9P2ApKSYmXG5cbmNoZWNrTWF0Y2hlcyhyZXN0U3BlY2ltZW4scmVzdFBhdHQsY2hlY2ssJy4uLnJlc3QnKSk7XG5cbiB9LFxuXG4vKipcbiAqIEBwYXJhbSB7QXJyYXl9IHNwbGl0QXJyYXlcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqL1xuY2hlY2tJc1dlbGxGb3JtZWQ6KHNwbGl0QXJyYXksY2hlY2spPT57XG5pZihcbnBhc3NTdHlsZU9mKHNwbGl0QXJyYXkpPT09J2NvcHlBcnJheScmJihcbnNwbGl0QXJyYXkubGVuZ3RoPj0xfHxzcGxpdEFycmF5Lmxlbmd0aDw9MykpXG57XG5jb25zdFtyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0PXVuZGVmaW5lZCxyZXN0UGF0dD11bmRlZmluZWRdPVxuc3BsaXRBcnJheTtcbmlmKFxuaXNQYXR0ZXJuKHJlcXVpcmVkUGF0dCkmJlxucGFzc1N0eWxlT2YocmVxdWlyZWRQYXR0KT09PSdjb3B5QXJyYXknJiYoXG5vcHRpb25hbFBhdHQ9PT11bmRlZmluZWR8fFxuaXNQYXR0ZXJuKG9wdGlvbmFsUGF0dCkmJlxucGFzc1N0eWxlT2Yob3B0aW9uYWxQYXR0KT09PSdjb3B5QXJyYXknKSYmKFxucmVzdFBhdHQ9PT11bmRlZmluZWR8fGlzUGF0dGVybihyZXN0UGF0dCkpKVxue1xucmV0dXJuIHRydWU7XG4gfVxuIH1cbnJldHVybiBjaGVjayhcbmZhbHNlLFxuWCBgTXVzdCBiZSBhbiBhcnJheSBvZiBhIHJlcXVpcmVkUGF0dCBhcnJheSwgYW4gb3B0aW9uYWwgb3B0aW9uYWxQYXR0IGFycmF5LCBhbmQgYW4gb3B0aW9uYWwgcmVzdFBhdHQ6ICR7cShcbnNwbGl0QXJyYXkpXG4gfWApO1xuXG4gfSxcblxuZ2V0UmFua0NvdmVyOihbXG5fcmVxdWlyZWRQYXR0LFxuX29wdGlvbmFsUGF0dD11bmRlZmluZWQsXG5fcmVzdFBhdHQ9dW5kZWZpbmVkXSk9PlxuZ2V0UGFzc1N0eWxlQ292ZXIoJ2NvcHlBcnJheScpfSk7XG5cblxuLyoqXG4gKiBAcGFyYW0ge0NvcHlSZWNvcmQ8UGFzc2FibGU+fSBzcGVjaW1lblxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFBhdHRlcm4+fSByZXF1aXJlZFBhdHRcbiAqIEBwYXJhbSB7Q29weVJlY29yZDxQYXR0ZXJuPn0gb3B0aW9uYWxQYXR0XG4gKiBAcmV0dXJucyB7e1xuICogICByZXF1aXJlZFNwZWNpbWVuOiBDb3B5UmVjb3JkPFBhc3NhYmxlPixcbiAqICAgb3B0aW9uYWxTcGVjaW1lbjogQ29weVJlY29yZDxQYXNzYWJsZT4sXG4gKiAgIHJlc3RTcGVjaW1lbjogQ29weVJlY29yZDxQYXNzYWJsZT5cbiAqIH19XG4gKi9cbmNvbnN0IHNwbGl0UmVjb3JkUGFydHM9KHNwZWNpbWVuLHJlcXVpcmVkUGF0dCxvcHRpb25hbFBhdHQpPT57XG4vKiBOb3QgZnJvemVuISBNdXRhdGVkIGluIHBsYWNlKi9cbi8qKiBAdHlwZSB7W3N0cmluZywgUGFzc2FibGVdW119ICovXG5jb25zdCByZXF1aXJlZEVudHJpZXM9W107XG4vKiogQHR5cGUge1tzdHJpbmcsIFBhc3NhYmxlXVtdfSAqL1xuY29uc3Qgb3B0aW9uYWxFbnRyaWVzPVtdO1xuLyoqIEB0eXBlIHtbc3RyaW5nLCBQYXNzYWJsZV1bXX0gKi9cbmNvbnN0IHJlc3RFbnRyaWVzPVtdO1xuZm9yKGNvbnN0W25hbWUsdmFsdWVdb2YgZW50cmllcyhzcGVjaW1lbikpe1xuaWYoaGFzT3duUHJvcGVydHlPZihyZXF1aXJlZFBhdHQsbmFtZSkpe1xucmVxdWlyZWRFbnRyaWVzLnB1c2goW25hbWUsdmFsdWVdKTtcbiB9ZWxzZSBpZihoYXNPd25Qcm9wZXJ0eU9mKG9wdGlvbmFsUGF0dCxuYW1lKSl7XG5vcHRpb25hbEVudHJpZXMucHVzaChbbmFtZSx2YWx1ZV0pO1xuIH1lbHNle1xucmVzdEVudHJpZXMucHVzaChbbmFtZSx2YWx1ZV0pO1xuIH1cbiB9XG5yZXR1cm4gaGFyZGVuKHtcbnJlcXVpcmVkU3BlY2ltZW46ZnJvbVVuaXF1ZUVudHJpZXMocmVxdWlyZWRFbnRyaWVzKSxcbm9wdGlvbmFsU3BlY2ltZW46ZnJvbVVuaXF1ZUVudHJpZXMob3B0aW9uYWxFbnRyaWVzKSxcbnJlc3RTcGVjaW1lbjpmcm9tVW5pcXVlRW50cmllcyhyZXN0RW50cmllcyl9KTtcblxuIH07XG5cbi8qKlxuICogT3B0aW9uYWwgc3BlY2ltZW4gdmFsdWVzIHdoaWNoIGFyZSBgdW5kZWZpbmVkYCBwYXNzIHVuY29uZGl0aW9uYWxseS5cbiAqIFdlIGVuY29kZSB0aGlzIHdpdGggdGhlIGBNLm9yYCBwYXR0ZXJuIHNvIGl0IGFsc28gcHJvZHVjZXMgYSBnb29kXG4gKiBjb21wcmVzc2lvbiBkaXN0aW5ndWlzaGluZyBgdW5kZWZpbmVkYCBmcm9tIGFic2VuY2UuXG4gKlxuICogQHBhcmFtIHtDb3B5UmVjb3JkPFBhdHRlcm4+fSBvcHRpb25hbFBhdHRcbiAqIEBwYXJhbSB7c3RyaW5nW119IG5hbWVzXG4gKiBAcmV0dXJucyB7Q29weVJlY29yZDxQYXR0ZXJuPn0gVGhlIHBhcnRpYWxQYXR0XG4gKi9cbmNvbnN0IGFkYXB0UmVjb3JkUGF0dGVybj0ob3B0aW9uYWxQYXR0LG5hbWVzKT0+XG5mcm9tVW5pcXVlRW50cmllcyhuYW1lcy5tYXAoKG5hbWUpPT5bbmFtZSxNTS5vcHQob3B0aW9uYWxQYXR0W25hbWVdKV0pKTtcblxuLyoqIEB0eXBlIHtNYXRjaEhlbHBlcn0gKi9cbmNvbnN0IG1hdGNoU3BsaXRSZWNvcmRIZWxwZXI9RmFyKCdtYXRjaDpzcGxpdFJlY29yZCBoZWxwZXInLHtcbmNoZWNrTWF0Y2hlczooXG5zcGVjaW1lbixcbltyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0PXt9LHJlc3RQYXR0PU1NLmFueSgpXSxcbmNoZWNrKT0+XG57XG5pZighY2hlY2tLaW5kKHNwZWNpbWVuLCdjb3B5UmVjb3JkJyxjaGVjaykpe1xucmV0dXJuIGZhbHNlO1xuIH1cbmNvbnN0e3JlcXVpcmVkU3BlY2ltZW4sb3B0aW9uYWxTcGVjaW1lbixyZXN0U3BlY2ltZW59PVxuc3BsaXRSZWNvcmRQYXJ0cyhzcGVjaW1lbixyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0KTtcblxuY29uc3QgcGFydGlhbE5hbWVzPS8qKiBAdHlwZSB7c3RyaW5nW119ICovb3duS2V5cyhvcHRpb25hbFNwZWNpbWVuKTtcbmNvbnN0IHBhcnRpYWxQYXR0PWFkYXB0UmVjb3JkUGF0dGVybihvcHRpb25hbFBhdHQscGFydGlhbE5hbWVzKTtcbnJldHVybihcbmNoZWNrTWF0Y2hlcyhyZXF1aXJlZFNwZWNpbWVuLHJlcXVpcmVkUGF0dCxjaGVjaykmJlxucGFydGlhbE5hbWVzLmV2ZXJ5KChuYW1lKT0+XG5jaGVja01hdGNoZXMoXG5vcHRpb25hbFNwZWNpbWVuW25hbWVdLFxucGFydGlhbFBhdHRbbmFtZV0sXG5jaGVjayxcbiBgJHtuYW1lfT9gKSkmJlxuXG5cbmNoZWNrTWF0Y2hlcyhyZXN0U3BlY2ltZW4scmVzdFBhdHQsY2hlY2ssJy4uLnJlc3QnKSk7XG5cbiB9LFxuXG4vKipcbiAqIEBwYXJhbSB7QXJyYXl9IHNwbGl0QXJyYXlcbiAqIEBwYXJhbSB7Q2hlY2tlcn0gY2hlY2tcbiAqL1xuY2hlY2tJc1dlbGxGb3JtZWQ6KHNwbGl0QXJyYXksY2hlY2spPT57XG5pZihcbnBhc3NTdHlsZU9mKHNwbGl0QXJyYXkpPT09J2NvcHlBcnJheScmJihcbnNwbGl0QXJyYXkubGVuZ3RoPj0xfHxzcGxpdEFycmF5Lmxlbmd0aDw9MykpXG57XG5jb25zdFtyZXF1aXJlZFBhdHQsb3B0aW9uYWxQYXR0PXVuZGVmaW5lZCxyZXN0UGF0dD11bmRlZmluZWRdPVxuc3BsaXRBcnJheTtcbmlmKFxuaXNQYXR0ZXJuKHJlcXVpcmVkUGF0dCkmJlxucGFzc1N0eWxlT2YocmVxdWlyZWRQYXR0KT09PSdjb3B5UmVjb3JkJyYmKFxub3B0aW9uYWxQYXR0PT09dW5kZWZpbmVkfHxcbmlzUGF0dGVybihvcHRpb25hbFBhdHQpJiZcbnBhc3NTdHlsZU9mKG9wdGlvbmFsUGF0dCk9PT0nY29weVJlY29yZCcpJiYoXG5yZXN0UGF0dD09PXVuZGVmaW5lZHx8aXNQYXR0ZXJuKHJlc3RQYXR0KSkpXG57XG5yZXR1cm4gdHJ1ZTtcbiB9XG4gfVxucmV0dXJuIGNoZWNrKFxuZmFsc2UsXG5YIGBNdXN0IGJlIGFuIGFycmF5IG9mIGEgcmVxdWlyZWRQYXR0IHJlY29yZCwgYW4gb3B0aW9uYWwgb3B0aW9uYWxQYXR0IHJlY29yZCwgYW5kIGFuIG9wdGlvbmFsIHJlc3RQYXR0OiAke3EoXG5zcGxpdEFycmF5KVxuIH1gKTtcblxuIH0sXG5cbmdldFJhbmtDb3ZlcjooW1xucmVxdWlyZWRQYXR0LFxuX29wdGlvbmFsUGF0dD11bmRlZmluZWQsXG5fcmVzdFBhdHQ9dW5kZWZpbmVkXSk9PlxuZ2V0UGFzc1N0eWxlQ292ZXIocGFzc1N0eWxlT2YocmVxdWlyZWRQYXR0KSl9KTtcblxuXG4vKiogQHR5cGUge1JlY29yZDxzdHJpbmcsIE1hdGNoSGVscGVyPn0gKi9cbmNvbnN0IEhlbHBlcnNCeU1hdGNoVGFnPWhhcmRlbih7XG4nbWF0Y2g6YW55JzptYXRjaEFueUhlbHBlcixcbidtYXRjaDphbmQnOm1hdGNoQW5kSGVscGVyLFxuJ21hdGNoOm9yJzptYXRjaE9ySGVscGVyLFxuJ21hdGNoOm5vdCc6bWF0Y2hOb3RIZWxwZXIsXG5cbidtYXRjaDpzY2FsYXInOm1hdGNoU2NhbGFySGVscGVyLFxuJ21hdGNoOmtleSc6bWF0Y2hLZXlIZWxwZXIsXG4nbWF0Y2g6cGF0dGVybic6bWF0Y2hQYXR0ZXJuSGVscGVyLFxuJ21hdGNoOmtpbmQnOm1hdGNoS2luZEhlbHBlcixcbidtYXRjaDpiaWdpbnQnOm1hdGNoQmlnaW50SGVscGVyLFxuJ21hdGNoOm5hdCc6bWF0Y2hOYXRIZWxwZXIsXG4nbWF0Y2g6c3RyaW5nJzptYXRjaFN0cmluZ0hlbHBlcixcbidtYXRjaDpzeW1ib2wnOm1hdGNoU3ltYm9sSGVscGVyLFxuJ21hdGNoOnJlbW90YWJsZSc6bWF0Y2hSZW1vdGFibGVIZWxwZXIsXG5cbidtYXRjaDpsdCc6bWF0Y2hMVEhlbHBlcixcbidtYXRjaDpsdGUnOm1hdGNoTFRFSGVscGVyLFxuJ21hdGNoOmd0ZSc6bWF0Y2hHVEVIZWxwZXIsXG4nbWF0Y2g6Z3QnOm1hdGNoR1RIZWxwZXIsXG5cbidtYXRjaDphcnJheU9mJzptYXRjaEFycmF5T2ZIZWxwZXIsXG4nbWF0Y2g6cmVjb3JkT2YnOm1hdGNoUmVjb3JkT2ZIZWxwZXIsXG4nbWF0Y2g6c2V0T2YnOm1hdGNoU2V0T2ZIZWxwZXIsXG4nbWF0Y2g6YmFnT2YnOm1hdGNoQmFnT2ZIZWxwZXIsXG4nbWF0Y2g6bWFwT2YnOm1hdGNoTWFwT2ZIZWxwZXIsXG4nbWF0Y2g6c3BsaXRBcnJheSc6bWF0Y2hTcGxpdEFycmF5SGVscGVyLFxuJ21hdGNoOnNwbGl0UmVjb3JkJzptYXRjaFNwbGl0UmVjb3JkSGVscGVyfSk7XG5cblxuY29uc3QgbWFrZU1hdGNoZXI9KHRhZyxwYXlsb2FkKT0+e1xuY29uc3QgbWF0Y2hlcj1tYWtlVGFnZ2VkKHRhZyxwYXlsb2FkKTtcbmFzc2VydFBhdHRlcm4obWF0Y2hlcik7XG5yZXR1cm4gbWF0Y2hlcjtcbiB9O1xuXG5jb25zdCBtYWtlS2luZE1hdGNoZXI9KGtpbmQpPT5tYWtlTWF0Y2hlcignbWF0Y2g6a2luZCcsa2luZCk7XG5cbmNvbnN0IEFueVNoYXBlPW1ha2VNYXRjaGVyKCdtYXRjaDphbnknLHVuZGVmaW5lZCk7XG5jb25zdCBTY2FsYXJTaGFwZT1tYWtlTWF0Y2hlcignbWF0Y2g6c2NhbGFyJyx1bmRlZmluZWQpO1xuY29uc3QgS2V5U2hhcGU9bWFrZU1hdGNoZXIoJ21hdGNoOmtleScsdW5kZWZpbmVkKTtcbmNvbnN0IFBhdHRlcm5TaGFwZT1tYWtlTWF0Y2hlcignbWF0Y2g6cGF0dGVybicsdW5kZWZpbmVkKTtcbmNvbnN0IEJvb2xlYW5TaGFwZT1tYWtlS2luZE1hdGNoZXIoJ2Jvb2xlYW4nKTtcbmNvbnN0IE51bWJlclNoYXBlPW1ha2VLaW5kTWF0Y2hlcignbnVtYmVyJyk7XG5jb25zdCBCaWdJbnRTaGFwZT1tYWtlVGFnZ2VkKCdtYXRjaDpiaWdpbnQnLFtdKTtcbmNvbnN0IE5hdFNoYXBlPW1ha2VUYWdnZWQoJ21hdGNoOm5hdCcsW10pO1xuY29uc3QgU3RyaW5nU2hhcGU9bWFrZVRhZ2dlZCgnbWF0Y2g6c3RyaW5nJyxbXSk7XG5jb25zdCBTeW1ib2xTaGFwZT1tYWtlVGFnZ2VkKCdtYXRjaDpzeW1ib2wnLFtdKTtcbmNvbnN0IFJlY29yZFNoYXBlPW1ha2VUYWdnZWQoJ21hdGNoOnJlY29yZE9mJyxbQW55U2hhcGUsQW55U2hhcGVdKTtcbmNvbnN0IEFycmF5U2hhcGU9bWFrZVRhZ2dlZCgnbWF0Y2g6YXJyYXlPZicsW0FueVNoYXBlXSk7XG5jb25zdCBTZXRTaGFwZT1tYWtlVGFnZ2VkKCdtYXRjaDpzZXRPZicsW0FueVNoYXBlXSk7XG5jb25zdCBCYWdTaGFwZT1tYWtlVGFnZ2VkKCdtYXRjaDpiYWdPZicsW0FueVNoYXBlLEFueVNoYXBlXSk7XG5jb25zdCBNYXBTaGFwZT1tYWtlVGFnZ2VkKCdtYXRjaDptYXBPZicsW0FueVNoYXBlLEFueVNoYXBlXSk7XG5jb25zdCBSZW1vdGFibGVTaGFwZT1tYWtlS2luZE1hdGNoZXIoJ3JlbW90YWJsZScpO1xuY29uc3QgRXJyb3JTaGFwZT1tYWtlS2luZE1hdGNoZXIoJ2Vycm9yJyk7XG5jb25zdCBQcm9taXNlU2hhcGU9bWFrZUtpbmRNYXRjaGVyKCdwcm9taXNlJyk7XG5jb25zdCBVbmRlZmluZWRTaGFwZT1tYWtlS2luZE1hdGNoZXIoJ3VuZGVmaW5lZCcpO1xuXG4vKipcbiAqIEZvciB3aGVuIHRoZSBsYXN0IGVsZW1lbnQgb2YgdGhlIHBheWxvYWQgaXMgdGhlIG9wdGlvbmFsIGxpbWl0cyxcbiAqIHNvIHRoYXQgd2hlbiBpdCBpcyBgdW5kZWZpbmVkYCBpdCBpcyBkcm9wcGVkIGZyb20gdGhlIGVuZCBvZiB0aGVcbiAqIHBheWxvYWRzIGFycmF5LlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfSB0YWdcbiAqIEBwYXJhbSB7UGFzc2FibGVbXX0gcGF5bG9hZFxuICovXG5jb25zdCBtYWtlTGltaXRzTWF0Y2hlcj0odGFnLHBheWxvYWQpPT57XG5pZihwYXlsb2FkW3BheWxvYWQubGVuZ3RoLTFdPT09dW5kZWZpbmVkKXtcbnBheWxvYWQ9aGFyZGVuKHBheWxvYWQuc2xpY2UoMCxwYXlsb2FkLmxlbmd0aC0xKSk7XG4gfVxucmV0dXJuIG1ha2VNYXRjaGVyKHRhZyxwYXlsb2FkKTtcbiB9O1xuXG5jb25zdCBtYWtlUmVtb3RhYmxlTWF0Y2hlcj0obGFiZWw9dW5kZWZpbmVkKT0+XG5sYWJlbD09PXVuZGVmaW5lZD9cblJlbW90YWJsZVNoYXBlOlxubWFrZU1hdGNoZXIoJ21hdGNoOnJlbW90YWJsZScsaGFyZGVuKHtsYWJlbH0pKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtUfSBlbXB0eVxuICogQHBhcmFtIHtUfSBiYXNlXG4gKiBAcGFyYW0ge1R9IFtvcHRpb25hbF1cbiAqIEBwYXJhbSB7VH0gW3Jlc3RdXG4gKiBAcmV0dXJucyB7VFtdfVxuICovXG5jb25zdCBtYWtlU3BsaXRQYXlsb2FkPShcbmVtcHR5LFxuYmFzZSxcbm9wdGlvbmFsPXVuZGVmaW5lZCxcbnJlc3Q9dW5kZWZpbmVkKT0+XG57XG5pZihyZXN0KXtcbnJldHVybltiYXNlLG9wdGlvbmFsfHxlbXB0eSxyZXN0XTtcbiB9XG5pZihvcHRpb25hbCl7XG5yZXR1cm5bYmFzZSxvcHRpb25hbF07XG4gfVxucmV0dXJuW2Jhc2VdO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHsnc3luYyd8J2FzeW5jJ30gY2FsbEtpbmRcbiAqIEBwYXJhbSB7QXJnR3VhcmRbXX0gYXJnR3VhcmRzXG4gKiBAcGFyYW0ge0FyZ0d1YXJkW119IFtvcHRpb25hbEFyZ0d1YXJkc11cbiAqIEBwYXJhbSB7QXJnR3VhcmR9IFtyZXN0QXJnR3VhcmRdXG4gKiBAcmV0dXJucyB7TWV0aG9kR3VhcmRNYWtlcn1cbiAqL1xuY29uc3QgbWFrZU1ldGhvZEd1YXJkTWFrZXI9KFxuY2FsbEtpbmQsXG5hcmdHdWFyZHMsXG5vcHRpb25hbEFyZ0d1YXJkcz11bmRlZmluZWQsXG5yZXN0QXJnR3VhcmQ9dW5kZWZpbmVkKT0+XG5cbmhhcmRlbih7XG5vcHRpb25hbDooLi4ub3B0QXJnR3VhcmRzKT0+e1xub3B0aW9uYWxBcmdHdWFyZHM9PT11bmRlZmluZWR8fFxuRmFpbCBgQ2FuIG9ubHkgaGF2ZSBvbmUgc2V0IG9mIG9wdGlvbmFsIGd1YXJkc2A7XG5yZXN0QXJnR3VhcmQ9PT11bmRlZmluZWR8fFxuRmFpbCBgb3B0aW9uYWwgYXJnIGd1YXJkcyBtdXN0IGNvbWUgYmVmb3JlIHJlc3QgYXJnYDtcbnJldHVybiBtYWtlTWV0aG9kR3VhcmRNYWtlcihjYWxsS2luZCxhcmdHdWFyZHMsb3B0QXJnR3VhcmRzKTtcbiB9LFxucmVzdDoockFyZ0d1YXJkKT0+e1xucmVzdEFyZ0d1YXJkPT09dW5kZWZpbmVkfHxGYWlsIGBDYW4gb25seSBoYXZlIG9uZSByZXN0IGFyZ2A7XG5yZXR1cm4gbWFrZU1ldGhvZEd1YXJkTWFrZXIoXG5jYWxsS2luZCxcbmFyZ0d1YXJkcyxcbm9wdGlvbmFsQXJnR3VhcmRzLFxuckFyZ0d1YXJkKTtcblxuIH0sXG5yZXR1cm5zOihyZXR1cm5HdWFyZD1VbmRlZmluZWRTaGFwZSk9PlxuaGFyZGVuKHtcbmtsYXNzOidtZXRob2RHdWFyZCcsXG5jYWxsS2luZCxcbmFyZ0d1YXJkcyxcbm9wdGlvbmFsQXJnR3VhcmRzLFxucmVzdEFyZ0d1YXJkLFxucmV0dXJuR3VhcmR9KX0pO1xuXG5cblxuY29uc3QgbWFrZUF3YWl0QXJnR3VhcmQ9KGFyZ0d1YXJkKT0+XG5oYXJkZW4oe1xua2xhc3M6J2F3YWl0QXJnJyxcbmFyZ0d1YXJkfSk7XG5cblxuLyogLy8vLy8vLy8vLy8vLy8vLy8vKi9cblxuLyoqIEB0eXBlIHtNYXRjaGVyTmFtZXNwYWNlfSAqL1xuY29uc3QgTT1oYXJkZW4oe1xuYW55OigpPT5BbnlTaGFwZSxcbmFuZDooLi4ucGF0dHMpPT5tYWtlTWF0Y2hlcignbWF0Y2g6YW5kJyxwYXR0cyksXG5vcjooLi4ucGF0dHMpPT5tYWtlTWF0Y2hlcignbWF0Y2g6b3InLHBhdHRzKSxcbm5vdDooc3ViUGF0dCk9Pm1ha2VNYXRjaGVyKCdtYXRjaDpub3QnLHN1YlBhdHQpLFxuXG5zY2FsYXI6KCk9PlNjYWxhclNoYXBlLFxua2V5OigpPT5LZXlTaGFwZSxcbnBhdHRlcm46KCk9PlBhdHRlcm5TaGFwZSxcbmtpbmQ6bWFrZUtpbmRNYXRjaGVyLFxuYm9vbGVhbjooKT0+Qm9vbGVhblNoYXBlLFxubnVtYmVyOigpPT5OdW1iZXJTaGFwZSxcbmJpZ2ludDoobGltaXRzPXVuZGVmaW5lZCk9PlxubGltaXRzP21ha2VMaW1pdHNNYXRjaGVyKCdtYXRjaDpiaWdpbnQnLFtsaW1pdHNdKTpCaWdJbnRTaGFwZSxcbm5hdDoobGltaXRzPXVuZGVmaW5lZCk9PlxubGltaXRzP21ha2VMaW1pdHNNYXRjaGVyKCdtYXRjaDpuYXQnLFtsaW1pdHNdKTpOYXRTaGFwZSxcbnN0cmluZzoobGltaXRzPXVuZGVmaW5lZCk9PlxubGltaXRzP21ha2VMaW1pdHNNYXRjaGVyKCdtYXRjaDpzdHJpbmcnLFtsaW1pdHNdKTpTdHJpbmdTaGFwZSxcbnN5bWJvbDoobGltaXRzPXVuZGVmaW5lZCk9PlxubGltaXRzP21ha2VMaW1pdHNNYXRjaGVyKCdtYXRjaDpzeW1ib2wnLFtsaW1pdHNdKTpTeW1ib2xTaGFwZSxcbnJlY29yZDoobGltaXRzPXVuZGVmaW5lZCk9PlxubGltaXRzP00ucmVjb3JkT2YoTS5hbnkoKSxNLmFueSgpLGxpbWl0cyk6UmVjb3JkU2hhcGUsXG5hcnJheToobGltaXRzPXVuZGVmaW5lZCk9PlxubGltaXRzP00uYXJyYXlPZihNLmFueSgpLGxpbWl0cyk6QXJyYXlTaGFwZSxcbnNldDoobGltaXRzPXVuZGVmaW5lZCk9PmxpbWl0cz9NLnNldE9mKE0uYW55KCksbGltaXRzKTpTZXRTaGFwZSxcbmJhZzoobGltaXRzPXVuZGVmaW5lZCk9PlxubGltaXRzP00uYmFnT2YoTS5hbnkoKSxNLmFueSgpLGxpbWl0cyk6QmFnU2hhcGUsXG5tYXA6KGxpbWl0cz11bmRlZmluZWQpPT5cbmxpbWl0cz9NLm1hcE9mKE0uYW55KCksTS5hbnkoKSxsaW1pdHMpOk1hcFNoYXBlLFxucmVtb3RhYmxlOm1ha2VSZW1vdGFibGVNYXRjaGVyLFxuZXJyb3I6KCk9PkVycm9yU2hhcGUsXG5wcm9taXNlOigpPT5Qcm9taXNlU2hhcGUsXG51bmRlZmluZWQ6KCk9PlVuZGVmaW5lZFNoYXBlLFxubnVsbDooKT0+bnVsbCxcblxubHQ6KHJpZ2h0T3BlcmFuZCk9Pm1ha2VNYXRjaGVyKCdtYXRjaDpsdCcscmlnaHRPcGVyYW5kKSxcbmx0ZToocmlnaHRPcGVyYW5kKT0+bWFrZU1hdGNoZXIoJ21hdGNoOmx0ZScscmlnaHRPcGVyYW5kKSxcbmVxOihrZXkpPT57XG5hc3NlcnRLZXkoa2V5KTtcbnJldHVybiBrZXk9PT11bmRlZmluZWQ/TS51bmRlZmluZWQoKTprZXk7XG4gfSxcbm5lcTooa2V5KT0+TS5ub3QoTS5lcShrZXkpKSxcbmd0ZToocmlnaHRPcGVyYW5kKT0+bWFrZU1hdGNoZXIoJ21hdGNoOmd0ZScscmlnaHRPcGVyYW5kKSxcbmd0OihyaWdodE9wZXJhbmQpPT5tYWtlTWF0Y2hlcignbWF0Y2g6Z3QnLHJpZ2h0T3BlcmFuZCksXG5cbnJlY29yZE9mOihrZXlQYXR0PU0uYW55KCksdmFsdWVQYXR0PU0uYW55KCksbGltaXRzPXVuZGVmaW5lZCk9PlxubWFrZUxpbWl0c01hdGNoZXIoJ21hdGNoOnJlY29yZE9mJyxba2V5UGF0dCx2YWx1ZVBhdHQsbGltaXRzXSksXG5hcnJheU9mOihzdWJQYXR0PU0uYW55KCksbGltaXRzPXVuZGVmaW5lZCk9PlxubWFrZUxpbWl0c01hdGNoZXIoJ21hdGNoOmFycmF5T2YnLFtzdWJQYXR0LGxpbWl0c10pLFxuc2V0T2Y6KGtleVBhdHQ9TS5hbnkoKSxsaW1pdHM9dW5kZWZpbmVkKT0+XG5tYWtlTGltaXRzTWF0Y2hlcignbWF0Y2g6c2V0T2YnLFtrZXlQYXR0LGxpbWl0c10pLFxuYmFnT2Y6KGtleVBhdHQ9TS5hbnkoKSxjb3VudFBhdHQ9TS5hbnkoKSxsaW1pdHM9dW5kZWZpbmVkKT0+XG5tYWtlTGltaXRzTWF0Y2hlcignbWF0Y2g6YmFnT2YnLFtrZXlQYXR0LGNvdW50UGF0dCxsaW1pdHNdKSxcbm1hcE9mOihrZXlQYXR0PU0uYW55KCksdmFsdWVQYXR0PU0uYW55KCksbGltaXRzPXVuZGVmaW5lZCk9PlxubWFrZUxpbWl0c01hdGNoZXIoJ21hdGNoOm1hcE9mJyxba2V5UGF0dCx2YWx1ZVBhdHQsbGltaXRzXSksXG5zcGxpdEFycmF5OihiYXNlLG9wdGlvbmFsPXVuZGVmaW5lZCxyZXN0PXVuZGVmaW5lZCk9PlxubWFrZU1hdGNoZXIoXG4nbWF0Y2g6c3BsaXRBcnJheScsXG5tYWtlU3BsaXRQYXlsb2FkKFtdLGJhc2Usb3B0aW9uYWwscmVzdCkpLFxuXG5zcGxpdFJlY29yZDooYmFzZSxvcHRpb25hbD11bmRlZmluZWQscmVzdD11bmRlZmluZWQpPT5cbm1ha2VNYXRjaGVyKFxuJ21hdGNoOnNwbGl0UmVjb3JkJyxcbm1ha2VTcGxpdFBheWxvYWQoe30sYmFzZSxvcHRpb25hbCxyZXN0KSksXG5cbnNwbGl0OihiYXNlLHJlc3Q9dW5kZWZpbmVkKT0+e1xuaWYocGFzc1N0eWxlT2YoaGFyZGVuKGJhc2UpKT09PSdjb3B5QXJyYXknKXtcbi8qIEB0cy1leHBlY3QtZXJyb3IgV2Uga25vdyBpdCBzaG91bGQgYmUgYW4gYXJyYXkqL1xucmV0dXJuIE0uc3BsaXRBcnJheShiYXNlLHJlc3QmJltdLHJlc3QpO1xuIH1lbHNle1xucmV0dXJuIE0uc3BsaXRSZWNvcmQoYmFzZSxyZXN0JiZ7fSxyZXN0KTtcbiB9XG4gfSxcbnBhcnRpYWw6KGJhc2UscmVzdD11bmRlZmluZWQpPT57XG5pZihwYXNzU3R5bGVPZihoYXJkZW4oYmFzZSkpPT09J2NvcHlBcnJheScpe1xuLyogQHRzLWV4cGVjdC1lcnJvciBXZSBrbm93IGl0IHNob3VsZCBiZSBhbiBhcnJheSovXG5yZXR1cm4gTS5zcGxpdEFycmF5KFtdLGJhc2UscmVzdCk7XG4gfWVsc2V7XG5yZXR1cm4gTS5zcGxpdFJlY29yZCh7fSxiYXNlLHJlc3QpO1xuIH1cbiB9LFxuXG5lcmVmOih0KT0+TS5vcih0LE0ucHJvbWlzZSgpKSxcbm9wdDoodCk9Pk0ub3IoTS51bmRlZmluZWQoKSx0KSxcblxuaW50ZXJmYWNlOihpbnRlcmZhY2VOYW1lLG1ldGhvZEd1YXJkcyx7c2xvcHB5PWZhbHNlfT17fSk9PntcbmZvcihjb25zdFtfLG1ldGhvZEd1YXJkXW9mIGVudHJpZXMobWV0aG9kR3VhcmRzKSl7XG5tZXRob2RHdWFyZC5rbGFzcz09PSdtZXRob2RHdWFyZCd8fFxuRmFpbCBgdW5yZWNvZ25pemUgbWV0aG9kIGd1YXJkICR7bWV0aG9kR3VhcmR9YDtcbiB9XG5yZXR1cm4gaGFyZGVuKHtcbmtsYXNzOidJbnRlcmZhY2UnLFxuaW50ZXJmYWNlTmFtZSxcbm1ldGhvZEd1YXJkcyxcbnNsb3BweX0pO1xuXG4gfSxcbmNhbGw6KC4uLmFyZ0d1YXJkcyk9Pm1ha2VNZXRob2RHdWFyZE1ha2VyKCdzeW5jJyxhcmdHdWFyZHMpLFxuY2FsbFdoZW46KC4uLmFyZ0d1YXJkcyk9Pm1ha2VNZXRob2RHdWFyZE1ha2VyKCdhc3luYycsYXJnR3VhcmRzKSxcblxuYXdhaXQ6KGFyZ0d1YXJkKT0+bWFrZUF3YWl0QXJnR3VhcmQoYXJnR3VhcmQpfSk7XG5cblxucmV0dXJuIGhhcmRlbih7XG5jaGVja01hdGNoZXMsXG5tYXRjaGVzLFxubXVzdE1hdGNoLFxuYXNzZXJ0UGF0dGVybixcbmlzUGF0dGVybixcbmdldFJhbmtDb3Zlcixcbk19KTtcblxuIH07XG5cbi8qIE9ubHkgaW5jbHVkZSB0aG9zZSB3aG9zZSBtZWFuaW5nIGlzIGluZGVwZW5kZW50IG9mIGFuIGltcHV0ZWQgc29ydCBvcmRlciovXG4vKiBvZiByZW1vdGFibGVzLCBvciBvZiBlbmNvZGluZyBvZiBwYXNzYWJsZSBhcyBzb3J0YWJsZSBzdHJpbmdzLiBUaHVzLCovXG4vKiBnZXRSYW5rQ292ZXIgaXMgb21pdHRlZC4gVG8gZ2V0IG9uZSwgeW91J2QgbmVlZCB0byBpbnN0YW50aWF0ZSovXG4vKiBgbWFrZVBhdHRlcm5LaXQoKWAgeW91cnNlbGYuIFNpbmNlIHRoZXJlIGFyZSBjdXJyZW50bHkgbm8gZXh0ZXJuYWwqL1xuLyogdXNlcyBvZiBgZ2V0UmFua0NvdmVyYCwgZm9yIGNsYXJpdHkgZHVyaW5nIGRldmVsb3BtZW50LCBgbWFrZVBhdHRlcm5LaXRgKi9cbi8qIGlzIG5vdCBjdXJyZW50bHkgZXhwb3J0ZWQuKi9cbmNvbnN0ICAgICAgIHtcbmNoZWNrTWF0Y2hlcyxcbm1hdGNoZXMsXG5tdXN0TWF0Y2gsXG5hc3NlcnRQYXR0ZXJuLFxuaXNQYXR0ZXJuLFxuZ2V0UmFua0NvdmVyLFxuTX09XG5tYWtlUGF0dGVybktpdCgpOyRo4oCNX29uY2UuY2hlY2tNYXRjaGVzKGNoZWNrTWF0Y2hlcyk7JGjigI1fb25jZS5tYXRjaGVzKG1hdGNoZXMpOyRo4oCNX29uY2UubXVzdE1hdGNoKG11c3RNYXRjaCk7JGjigI1fb25jZS5hc3NlcnRQYXR0ZXJuKGFzc2VydFBhdHRlcm4pOyRo4oCNX29uY2UuaXNQYXR0ZXJuKGlzUGF0dGVybik7JGjigI1fb25jZS5nZXRSYW5rQ292ZXIoZ2V0UmFua0NvdmVyKTskaOKAjV9vbmNlLk0oTSk7XG5cbk1NPU07XG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLlBhc3NhYmxlfSBQYXNzYWJsZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAZW5kby9tYXJzaGFsJykuUGFzc1N0eWxlfSBQYXNzU3R5bGUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNvcHlUYWdnZWR9IENvcHlUYWdnZWQgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNvcHlSZWNvcmQ8VD59IENvcHlSZWNvcmQgKi9cbi8qKiBAdGVtcGxhdGUgVCBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLkNvcHlBcnJheTxUPn0gQ29weUFycmF5ICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5DaGVja2VyfSBDaGVja2VyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5SYW5rQ29tcGFyZX0gUmFua0NvbXBhcmUgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnQGVuZG8vbWFyc2hhbCcpLlJhbmtDb3Zlcn0gUmFua0NvdmVyICovXG5cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5BcmdHdWFyZH0gQXJnR3VhcmQgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5NZXRob2RHdWFyZE1ha2VyfSBNZXRob2RHdWFyZE1ha2VyICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuTWF0Y2hlck5hbWVzcGFjZX0gTWF0Y2hlck5hbWVzcGFjZSAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLktleX0gS2V5ICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuUGF0dGVybn0gUGF0dGVybiAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLlBhdHRlcm5LaXR9IFBhdHRlcm5LaXQgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5DaGVja1BhdHRlcm59IENoZWNrUGF0dGVybiAqL1xuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCcuLi90eXBlcycpLkxpbWl0c30gTGltaXRzICovXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJy4uL3R5cGVzJykuQWxsTGltaXRzfSBBbGxMaW1pdHMgKi9cbi8qKiBAdHlwZWRlZiB7WGltcG9ydCgnLi4vdHlwZXMnKS5HZXRSYW5rQ292ZXJ9IEdldFJhbmtDb3ZlciAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IE1hdGNoSGVscGVyXG4gKiBUaGlzIGZhY3RvcnMgb3V0IG9ubHkgdGhlIHBhcnRzIHNwZWNpZmljIHRvIGVhY2gga2luZCBvZiBNYXRjaGVyLiBJdCBpc1xuICogZW5jYXBzdWxhdGVkLCBhbmQgaXRzIG1ldGhvZHMgY2FuIG1ha2UgdGhlIHN0YXRlZCB1bmNoZWNrZXIgYXNzdW1wdGlvbnNcbiAqIGVuZm9yY2VkIGJ5IHRoZSBjb21tb24gY2FsbGluZyBsb2dpYy5cbiAqXG4gKiBAcHJvcGVydHkgeyhhbGxlZ2VkUGF5bG9hZDogUGFzc2FibGUsXG4gKiAgICAgICAgICAgICBjaGVjazogQ2hlY2tlclxuICogKSA9PiBib29sZWFufSBjaGVja0lzV2VsbEZvcm1lZFxuICogUmVwb3J0cyB3aGV0aGVyIGBhbGxlZ2VkUGF5bG9hZGAgaXMgdmFsaWQgYXMgdGhlIHBheWxvYWQgb2YgYSBDb3B5VGFnZ2VkXG4gKiB3aG9zZSB0YWcgY29ycmVzcG9uZHMgd2l0aCB0aGlzIE1hdGNoSGVscGVyJ3MgTWF0Y2hlcnMuXG4gKlxuICogQHByb3BlcnR5IHsoc3BlY2ltZW46IFBhc3NhYmxlLFxuICogICAgICAgICAgICAgbWF0Y2hlclBheWxvYWQ6IFBhc3NhYmxlLFxuICogICAgICAgICAgICAgY2hlY2s6IENoZWNrZXIsXG4gKiApID0+IGJvb2xlYW59IGNoZWNrTWF0Y2hlc1xuICogQXNzdW1pbmcgdmFsaWRpdHkgb2YgYG1hdGNoZXJQYXlsb2FkYCBhcyB0aGUgcGF5bG9hZCBvZiBhIE1hdGNoZXIgY29ycmVzcG9uZGluZ1xuICogd2l0aCB0aGlzIE1hdGNoSGVscGVyLCByZXBvcnRzIHdoZXRoZXIgYHNwZWNpbWVuYCBpcyBtYXRjaGVkIGJ5IHRoYXQgTWF0Y2hlci5cbiAqXG4gKiBAcHJvcGVydHkge1hpbXBvcnQoJy4uL3R5cGVzJykuR2V0UmFua0NvdmVyfSBnZXRSYW5rQ292ZXJcbiAqIEFzc3VtZXMgdGhpcyBpcyB0aGUgcGF5bG9hZCBvZiBhIENvcHlUYWdnZWQgd2l0aCB0aGUgY29ycmVzcG9uZGluZ1xuICogbWF0Y2hUYWcuIFJldHVybiBhIFJhbmtDb3ZlciB0byBib3VuZCBmcm9tIGJlbG93IGFuZCBhYm92ZSxcbiAqIGluIHJhbmsgb3JkZXIsIGFsbCBwb3NzaWJsZSBQYXNzYWJsZXMgdGhhdCB3b3VsZCBtYXRjaCB0aGlzIE1hdGNoZXIuXG4gKiBUaGUgbGVmdCBlbGVtZW50IG11c3QgYmUgYmVmb3JlIG9yIHRoZSBzYW1lIHJhbmsgYXMgYW55IHBvc3NpYmxlXG4gKiBtYXRjaGluZyBzcGVjaW1lbi4gVGhlIHJpZ2h0IGVsZW1lbnQgbXVzdCBiZSBhZnRlciBvciB0aGUgc2FtZVxuICogcmFuayBhcyBhbnkgcG9zc2libGUgbWF0Y2hpbmcgc3BlY2ltZW4uXG4gKi9cbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJkZWZhdWx0TGltaXRzIjpbImRlZmF1bHRMaW1pdHMiXSwiY2hlY2tNYXRjaGVzIjpbImNoZWNrTWF0Y2hlcyJdLCJtYXRjaGVzIjpbIm1hdGNoZXMiXSwibXVzdE1hdGNoIjpbIm11c3RNYXRjaCJdLCJhc3NlcnRQYXR0ZXJuIjpbImFzc2VydFBhdHRlcm4iXSwiaXNQYXR0ZXJuIjpbImlzUGF0dGVybiJdLCJnZXRSYW5rQ292ZXIiOlsiZ2V0UmFua0NvdmVyIl0sIk0iOlsiTSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACYGTuzNAEAADQBAAAiAAAAQGVuZG8vcGF0dGVybnMtdjAuMi4yL3NyYy90eXBlcy5qc3siaW1wb3J0cyI6W10sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACWHvfH6hoAAOoaAAAiAAAAQGVuZG8vcGF0dGVybnMtdjAuMi4yL3NyYy91dGlscy5qc3siaW1wb3J0cyI6WyJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vcHJvbWlzZS1raXQiXSwiZXhwb3J0cyI6WyJhcHBseUxhYmVsaW5nRXJyb3IiLCJmcm9tVW5pcXVlRW50cmllcyIsImlkZW50Q2hlY2tlciIsImxpc3REaWZmZXJlbmNlIiwib2JqZWN0TWFwIiwidGhyb3dMYWJlbGVkIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IEUsaXNQcm9taXNlOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcImlzUHJvbWlzZVwiLCBbJGjigI1fYSA9PiAoaXNQcm9taXNlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG4vKiogQHR5cGVkZWYge1hpbXBvcnQoJ0BlbmRvL21hcnNoYWwnKS5DaGVja2VyfSBDaGVja2VyICovXG5cbmNvbnN0e2Zyb21FbnRyaWVzLGVudHJpZXN9PU9iamVjdDtcbmNvbnN0e293bktleXN9PVJlZmxlY3Q7XG5cbmNvbnN0e2RldGFpbHM6WCxxdW90ZTpxLEZhaWx9PWFzc2VydDtcblxuLyogVE9ETyBtaWdyYXRlIHRvIHByb3BlciBob21lKi9cbi8qIEZyb20gdGhlIGBhZ29yaWMtc2RrYCBtb25vcmVwby4gTW92ZWQgaGVyZSB0ZW1wb3JhcmlseSBiZWNhdXNlIHRoZSBwYXR0ZXJuKi9cbi8qIGNvZGUgaXMgbWlncmF0ZWQgZnJvbSBgQGFnb3JpYy9zdG9yZWAgdG8gYEBlbmRvL3BhdHRlcm5zYCwgYW5kIGRlcGVuZHMgb24qL1xuLyogdGhlIGZ1bmN0aW9uYWxpdHkgaW4gdGhpcyBmaWxlLCB3aGljaCBpcyBvdGhlcndpc2UgYXZhaWxhYmxlIG9ubHkqL1xuLyogd2l0aGluIHRoZSBgYWdvcmljLXNka2AgbW9ub3JlcG8uKi9cblxuLyoqXG4gKiBUT0RPIGFzIGxvbmcgYXMgYEBlbmRvL3Bhc3Mtc3R5bGVgIHJlbWFpbnMgdGhlIHByb3BlciBob21lIG9mIHRoZVxuICogYENoZWNrZXJgIHR5cGUsIGl0IHByb2JhYmx5IG1ha2VzIG1vc3Qgc2Vuc2UgdG8gbW92ZSBgaWRlbnRDaGVja2VyYFxuICogaW50byBgQGVuZG8vcGFzcy1zdHlsZWAgYXMgd2VsbC5cbiAqXG4gKiBJbiB0aGUgYGFzc2VydEZvb2AvYGlzRm9vYC9gY2hlY2tGb29gIHBhdHRlcm4sIGBjaGVja0Zvb2AgaGFzIGEgYGNoZWNrYFxuICogcGFyYW1ldGVyIG9mIHR5cGUgYENoZWNrZXJgLiBgYXNzZXJ0Rm9vYCBjYWxscyBgY2hlY2tGb29gIHBhc3Nlc1xuICogYGFzc2VydENoZWNrZXJgIGFzIHRoZSBgY2hlY2tgIGFyZ3VtZW50LiBgaXNGb29gIHBhc3NlcyBgaWRlbnRDaGVja2VyYFxuICogYXMgdGhlIGBjaGVja2AgYXJndW1lbnQuIGBpZGVudENoZWNrZXJgIGFjdHMgcHJlY2lzZWx5IGxpa2UgYW5cbiAqIGlkZW50aXR5IGZ1bmN0aW9uLCBidXQgaXMgdHlwZWQgYXMgYSBgQ2hlY2tlcmAgdG8gaW5kaWNhdGUgaXRzXG4gKiBpbnRlbmRlZCB1c2UuXG4gKlxuICogQHR5cGUge0NoZWNrZXJ9XG4gKi9cbmNvbnN0ICAgICAgICBpZGVudENoZWNrZXI9KGNvbmQsX2RldGFpbHMpPT5jb25kOyRo4oCNX29uY2UuaWRlbnRDaGVja2VyKGlkZW50Q2hlY2tlcik7XG5oYXJkZW4oaWRlbnRDaGVja2VyKTtcblxuLyoqXG4gKiBUaHJvd3MgaWYgbXVsdGlwbGUgZW50cmllcyB1c2UgdGhlIHNhbWUgcHJvcGVydHkgbmFtZS4gT3RoZXJ3aXNlIGFjdHNcbiAqIGxpa2UgYE9iamVjdC5mcm9tRW50cmllc2AgYnV0IGhhcmRlbnMgdGhlIHJlc3VsdC5cbiAqIFVzZSBpdCB0byBwcm90ZWN0IGZyb20gcHJvcGVydHkgbmFtZXMgY29tcHV0ZWQgZnJvbSB1c2VyLXByb3ZpZGVkIGRhdGEuXG4gKlxuICogQHRlbXBsYXRlIEssVlxuICogQHBhcmFtIHtJdGVyYWJsZTxbSyxWXT59IGFsbEVudHJpZXNcbiAqIEByZXR1cm5zIHt7W2s6IEtdOiBWfX1cbiAqL1xuY29uc3QgICAgICAgIGZyb21VbmlxdWVFbnRyaWVzPShhbGxFbnRyaWVzKT0+e1xuY29uc3QgZW50cmllc0FycmF5PVsuLi5hbGxFbnRyaWVzXTtcbmNvbnN0IHJlc3VsdD1oYXJkZW4oZnJvbUVudHJpZXMoZW50cmllc0FycmF5KSk7XG5pZihvd25LZXlzKHJlc3VsdCkubGVuZ3RoPT09ZW50cmllc0FycmF5Lmxlbmd0aCl7XG5yZXR1cm4gcmVzdWx0O1xuIH1cbmNvbnN0IG5hbWVzPW5ldyBTZXQoKTtcbmZvcihjb25zdFtuYW1lLF9db2YgZW50cmllc0FycmF5KXtcbmlmKG5hbWVzLmhhcyhuYW1lKSl7XG5GYWlsIGBjb2xsaXNpb24gb24gcHJvcGVydHkgbmFtZSAke3EobmFtZSl9OiAke2VudHJpZXNBcnJheX1gO1xuIH1cbm5hbWVzLmFkZChuYW1lKTtcbiB9XG50aHJvdyBGYWlsIGBpbnRlcm5hbDogZmFpbGVkIHRvIGNyZWF0ZSBvYmplY3QgZnJvbSB1bmlxdWUgZW50cmllc2A7XG4gfTskaOKAjV9vbmNlLmZyb21VbmlxdWVFbnRyaWVzKGZyb21VbmlxdWVFbnRyaWVzKTtcbmhhcmRlbihmcm9tVW5pcXVlRW50cmllcyk7XG5cbi8qKlxuICogQnkgYW5hbG9neSB3aXRoIGhvdyBgQXJyYXkucHJvdG90eXBlLm1hcGAgd2lsbCBtYXAgdGhlIGVsZW1lbnRzIG9mXG4gKiBhbiBhcnJheSB0byB0cmFuc2Zvcm1lZCBlbGVtZW50cyBvZiBhbiBhcnJheSBvZiB0aGUgc2FtZSBzaGFwZSxcbiAqIGBvYmplY3RNYXBgIHdpbGwgZG8gbGlrZXdpc2UgZm9yIHRoZSBzdHJpbmctbmFtZWQgb3duIGVudW1lcmFibGVcbiAqIHByb3BlcnRpZXMgb2YgYW4gb2JqZWN0LlxuICpcbiAqIFR5cGljYWwgdXNhZ2UgYXBwbGllcyBgb2JqZWN0TWFwYCB0byBhIENvcHlSZWNvcmQsIGkuZS4sXG4gKiBhbiBvYmplY3QgZm9yIHdoaWNoIGBwYXNzU3R5bGVPZihvcmlnaW5hbCkgPT09ICdjb3B5UmVjb3JkJ2AuIEZvciB0aGVzZSxcbiAqIG5vbmUgb2YgdGhlIGZvbGxvd2luZyBlZGdlIGNhc2VzIGFyaXNlLiBUaGUgcmVzdWx0IHdpbGwgYmUgYSBDb3B5UmVjb3JkXG4gKiB3aXRoIGV4YWN0bHkgdGhlIHNhbWUgcHJvcGVydHkgbmFtZXMsIHdob3NlIHZhbHVlcyBhcmUgdGhlIG1hcHBlZCBmb3JtIG9mXG4gKiB0aGUgb3JpZ2luYWwncyB2YWx1ZXMuXG4gKlxuICogV2hlbiB0aGUgb3JpZ2luYWwgaXMgbm90IGEgQ29weVJlY29yZCwgc29tZSBlZGdlIGNhc2VzIHRvIGJlIGF3YXJlIG9mXG4gKiAgICAqIE5vIG1hdHRlciBob3cgbXV0YWJsZSB0aGUgb3JpZ2luYWwgb2JqZWN0LCB0aGUgcmV0dXJuZWQgb2JqZWN0IGlzXG4gKiAgICAgIGhhcmRlbmVkLlxuICogICAgKiBPbmx5IHRoZSBzdHJpbmctbmFtZWQgZW51bWVyYWJsZSBvd24gcHJvcGVydGllcyBvZiB0aGUgb3JpZ2luYWxcbiAqICAgICAgYXJlIG1hcHBlZC4gQWxsIG90aGVyIHByb3BlcnRpZXMgYXJlIGlnbm9yZWQuXG4gKiAgICAqIElmIGFueSBvZiB0aGUgb3JpZ2luYWwgcHJvcGVydGllcyB3ZXJlIGFjY2Vzc29ycywgYE9iamVjdC5lbnRyaWVzYFxuICogICAgICB3aWxsIGNhdXNlIGl0cyBgZ2V0dGVyYCB0byBiZSBjYWxsZWQgYW5kIHdpbGwgdXNlIHRoZSByZXN1bHRpbmdcbiAqICAgICAgdmFsdWUuXG4gKiAgICAqIE5vIG1hdHRlciB3aGV0aGVyIHRoZSBvcmlnaW5hbCBwcm9wZXJ0eSB3YXMgYW4gYWNjZXNzb3IsIHdyaXRhYmxlLFxuICogICAgICBvciBjb25maWd1cmFibGUsIGFsbCB0aGUgcHJvcGVydGllcyBvZiB0aGUgcmV0dXJuZWQgb2JqZWN0IHdpbGwgYmVcbiAqICAgICAgbm9uLXdyaXRhYmxlLCBub24tY29uZmlndXJhYmxlLCBkYXRhIHByb3BlcnRpZXMuXG4gKiAgICAqIE5vIG1hdHRlciB3aGF0IHRoZSBvcmlnaW5hbCBvYmplY3QgbWF5IGhhdmUgaW5oZXJpdGVkIGZyb20sIGFuZFxuICogICAgICBubyBtYXR0ZXIgd2hldGhlciBpdCB3YXMgYSBzcGVjaWFsIGtpbmQgb2Ygb2JqZWN0IHN1Y2ggYXMgYW4gYXJyYXksXG4gKiAgICAgIHRoZSByZXR1cm5lZCBvYmplY3Qgd2lsbCBhbHdheXMgYmUgYSBwbGFpbiBvYmplY3QgaW5oZXJpdGluZyBkaXJlY3RseVxuICogICAgICBmcm9tIGBPYmplY3QucHJvdG90eXBlYCBhbmQgd2hvc2Ugc3RhdGUgaXMgb25seSB0aGVzZSBuZXcgbWFwcGVkXG4gKiAgICAgIG93biBwcm9wZXJ0aWVzLlxuICpcbiAqIFdpdGggdGhlc2UgZGlmZmVyZW5jZXMsIGV2ZW4gaWYgdGhlIG9yaWdpbmFsIG9iamVjdCB3YXMgbm90IGEgQ29weVJlY29yZCxcbiAqIGlmIGFsbCB0aGUgbWFwcGVkIHZhbHVlcyBhcmUgUGFzc2FibGUsIHRoZW4gdGhlIHJldHVybmVkIG9iamVjdCB3aWxsIGJlXG4gKiBhIENvcHlSZWNvcmQuXG4gKlxuICogQHRlbXBsYXRlIHtSZWNvcmQ8c3RyaW5nLCBhbnk+fSBPXG4gKiBAcGFyYW0ge099IG9yaWdpbmFsXG4gKiBAdGVtcGxhdGUgUiBtYXAgcmVzdWx0XG4gKiBAcGFyYW0geyh2YWx1ZTogT1trZXlvZiBPXSwga2V5OiBrZXlvZiBPKSA9PiBSfSBtYXBGblxuICogQHJldHVybnMge3sgW1AgaW4ga2V5b2YgT106IFJ9fVxuICovXG5jb25zdCAgICAgICAgb2JqZWN0TWFwPShvcmlnaW5hbCxtYXBGbik9PntcbmNvbnN0IGVudHM9ZW50cmllcyhvcmlnaW5hbCk7XG5jb25zdCBtYXBFbnRzPWVudHMubWFwKChbayx2XSk9PltrLG1hcEZuKHYsayldKTtcbnJldHVybiBoYXJkZW4oZnJvbUVudHJpZXMobWFwRW50cykpO1xuIH07JGjigI1fb25jZS5vYmplY3RNYXAob2JqZWN0TWFwKTtcbmhhcmRlbihvYmplY3RNYXApO1xuXG4vKipcbiAqXG4gKiBAcGFyYW0ge0FycmF5PHN0cmluZyB8IHN5bWJvbD59IGxlZnROYW1lc1xuICogQHBhcmFtIHtBcnJheTxzdHJpbmcgfCBzeW1ib2w+fSByaWdodE5hbWVzXG4gKi9cbmNvbnN0ICAgICAgICBsaXN0RGlmZmVyZW5jZT0obGVmdE5hbWVzLHJpZ2h0TmFtZXMpPT57XG5jb25zdCByaWdodFNldD1uZXcgU2V0KHJpZ2h0TmFtZXMpO1xucmV0dXJuIGxlZnROYW1lcy5maWx0ZXIoKG5hbWUpPT4hcmlnaHRTZXQuaGFzKG5hbWUpKTtcbiB9OyRo4oCNX29uY2UubGlzdERpZmZlcmVuY2UobGlzdERpZmZlcmVuY2UpO1xuaGFyZGVuKGxpc3REaWZmZXJlbmNlKTtcblxuLyoqXG4gKiBAcGFyYW0ge0Vycm9yfSBpbm5lckVyclxuICogQHBhcmFtIHtzdHJpbmd8bnVtYmVyfSBsYWJlbFxuICogQHBhcmFtIHtFcnJvckNvbnN0cnVjdG9yPX0gRXJyb3JDb25zdHJ1Y3RvclxuICogQHJldHVybnMge25ldmVyfVxuICovXG5cbi8qIEV2YWRlIGh0dHBzOi8vZ2l0aHViLmNvbS9lbmRvanMvZW5kby9pc3N1ZXMvMTQ1MCB1c2luZyBibGFuayBsaW5lKi9cbmNvbnN0ICAgICAgICB0aHJvd0xhYmVsZWQ9KGlubmVyRXJyLGxhYmVsLEVycm9yQ29uc3RydWN0b3I9dW5kZWZpbmVkKT0+e1xuaWYodHlwZW9mIGxhYmVsPT09J251bWJlcicpe1xubGFiZWw9IGBbJHtsYWJlbH1dYDtcbiB9XG5jb25zdCBvdXRlckVycj1hc3NlcnQuZXJyb3IoXG4gYCR7bGFiZWx9OiAke2lubmVyRXJyLm1lc3NhZ2V9YCxcbkVycm9yQ29uc3RydWN0b3IpO1xuXG5hc3NlcnQubm90ZShvdXRlckVycixYIGBDYXVzZWQgYnkgJHtpbm5lckVycn1gKTtcbnRocm93IG91dGVyRXJyO1xuIH07JGjigI1fb25jZS50aHJvd0xhYmVsZWQodGhyb3dMYWJlbGVkKTtcbmhhcmRlbih0aHJvd0xhYmVsZWQpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBBLFJcbiAqIEBwYXJhbSB7KC4uLmFyZ3M6IEFbXSkgPT4gUn0gZnVuY1xuICogQHBhcmFtIHtBW119IGFyZ3NcbiAqIEBwYXJhbSB7c3RyaW5nfG51bWJlcn0gW2xhYmVsXVxuICogQHJldHVybnMge1J9XG4gKi9cbmNvbnN0ICAgICAgICBhcHBseUxhYmVsaW5nRXJyb3I9KGZ1bmMsYXJncyxsYWJlbD11bmRlZmluZWQpPT57XG5pZihsYWJlbD09PXVuZGVmaW5lZCl7XG5yZXR1cm4gZnVuYyguLi5hcmdzKTtcbiB9XG5sZXQgcmVzdWx0O1xudHJ5e1xucmVzdWx0PWZ1bmMoLi4uYXJncyk7XG4gfWNhdGNoKGVycil7XG50aHJvd0xhYmVsZWQoZXJyLGxhYmVsKTtcbiB9XG5pZihpc1Byb21pc2UocmVzdWx0KSl7XG4vKiBAdHMtZXhwZWN0LWVycm9yIElmIHJlc3VsdCBpcyBhIHJlamVjdGVkIHByb21pc2UsIHRoaXMgd2lsbCovXG4vKiByZXR1cm4gYSBwcm9taXNlIHdpdGggYSBkaWZmZXJlbnQgcmVqZWN0aW9uIHJlYXNvbi4gQnV0IHRoaXMqL1xuLyogY29uZnVzZXMgVHlwZVNjcmlwdCBiZWNhdXNlIGl0IHR5cGVzIHRoYXQgY2FzZSBhcyBgUHJvbWlzZTxuZXZlcj5gKi9cbi8qIHdoaWNoIGlzIGNvb2wgZm9yIGEgcHJvbWlzZSB0aGF0IHdpbGwgbmV2ZXIgZnVsZmxsLiovXG4vKiBCdXQgVHlwZVNjcmlwdCBkb2Vzbid0IHVuZGVyc3RhbmQgdGhhdCB0aGlzIHdpbGwgb25seSBoYXBwZW4qL1xuLyogd2hlbiBgcmVzdWx0YCB3YXMgYSByZWplY3RlZCBwcm9taXNlLiBJbiBvbmx5IHRoaXMgY2FzZSBgUmAqL1xuLyogc2hvdWxkIGFscmVhZHkgYWxsb3cgYFByb21pc2U8bmV2ZXI+YCBhcyBhIHN1YnR5cGUuKi9cbnJldHVybiBFLndoZW4ocmVzdWx0LHVuZGVmaW5lZCwocmVhc29uKT0+dGhyb3dMYWJlbGVkKHJlYXNvbixsYWJlbCkpO1xuIH1lbHNle1xucmV0dXJuIHJlc3VsdDtcbiB9XG4gfTskaOKAjV9vbmNlLmFwcGx5TGFiZWxpbmdFcnJvcihhcHBseUxhYmVsaW5nRXJyb3IpO1xuaGFyZGVuKGFwcGx5TGFiZWxpbmdFcnJvcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaWRlbnRDaGVja2VyIjpbImlkZW50Q2hlY2tlciJdLCJmcm9tVW5pcXVlRW50cmllcyI6WyJmcm9tVW5pcXVlRW50cmllcyJdLCJvYmplY3RNYXAiOlsib2JqZWN0TWFwIl0sImxpc3REaWZmZXJlbmNlIjpbImxpc3REaWZmZXJlbmNlIl0sInRocm93TGFiZWxlZCI6WyJ0aHJvd0xhYmVsZWQiXSwiYXBwbHlMYWJlbGluZ0Vycm9yIjpbImFwcGx5TGFiZWxpbmdFcnJvciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAKUr6fcAkAAHAJAAAiAAAAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41Ni9pbmRleC5qc3siaW1wb3J0cyI6WyIuL3NyYy9pcy1wcm9taXNlLmpzIiwiLi9zcmMvbWVtby1yYWNlLmpzIiwiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJleHBvcnRzIjpbIm1ha2VQcm9taXNlS2l0IiwicmFjZVByb21pc2VzIl0sInJlZXhwb3J0cyI6WyIuL3NyYy9pcy1wcm9taXNlLmpzIiwiLi9zcmMvdHlwZXMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0LG1lbW9SYWNlOyRo4oCNX2ltcG9ydHMoW1tcIi4vc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzXCIsIFtbXCJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXRcIiwgWyRo4oCNX2EgPT4gKG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCA9ICRo4oCNX2EpXV1dXSxbXCIuL3NyYy9tZW1vLXJhY2UuanNcIiwgW1tcIm1lbW9SYWNlXCIsIFskaOKAjV9hID0+IChtZW1vUmFjZSA9ICRo4oCNX2EpXV1dXSxbXCIuL3NyYy9pcy1wcm9taXNlLmpzXCIsIFtdXSxbXCIuL3NyYy90eXBlcy5qc1wiLCBbXV1dKTtPYmplY3QuZGVmaW5lUHJvcGVydHkobWFrZVByb21pc2VLaXQsICduYW1lJywge3ZhbHVlOiBcIm1ha2VQcm9taXNlS2l0XCJ9KTskaOKAjV9vbmNlLm1ha2VQcm9taXNlS2l0KG1ha2VQcm9taXNlS2l0KTtPYmplY3QuZGVmaW5lUHJvcGVydHkocmFjZVByb21pc2VzLCAnbmFtZScsIHt2YWx1ZTogXCJyYWNlUHJvbWlzZXNcIn0pOyRo4oCNX29uY2UucmFjZVByb21pc2VzKHJhY2VQcm9taXNlcyk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKiBAdHlwZSB7UHJvbWlzZUNvbnN0cnVjdG9yfSAqL1xuY29uc3QgQmVzdFBpcGVsaW5hYmxlUHJvbWlzZT1nbG9iYWxUaGlzLkhhbmRsZWRQcm9taXNlfHxQcm9taXNlO1xuXG4vKipcbiAqIG1ha2VQcm9taXNlS2l0KCkgYnVpbGRzIGEgUHJvbWlzZSBvYmplY3QsIGFuZCByZXR1cm5zIGEgcmVjb3JkXG4gKiBjb250YWluaW5nIHRoZSBwcm9taXNlIGl0c2VsZiwgYXMgd2VsbCBhcyBzZXBhcmF0ZSBmYWNldHMgZm9yIHJlc29sdmluZ1xuICogYW5kIHJlamVjdGluZyBpdC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1hpbXBvcnQoJy4vc3JjL3R5cGVzLmpzJykuUHJvbWlzZUtpdDxUPn1cbiAqL1xuZnVuY3Rpb24gICAgICAgIG1ha2VQcm9taXNlS2l0KCl7XG5jb25zdHtyZXNvbHZlLHJlamVjdCxleGVjdXRvcn09bWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCk7XG5cbmNvbnN0IHByb21pc2U9bmV3IEJlc3RQaXBlbGluYWJsZVByb21pc2UoZXhlY3V0b3IpO1xuXG5yZXR1cm4gaGFyZGVuKHtwcm9taXNlLHJlc29sdmUscmVqZWN0fSk7XG4gfVxuaGFyZGVuKG1ha2VQcm9taXNlS2l0KTtcblxuLyogTkI6IEFub3RoZXIgaW1wbGVtZW50YXRpb24gZm9yIFByb21pc2UucmFjZSB3b3VsZCBiZSB0byB1c2UgdGhlIHJlbGVhc2luZyBleGVjdXRvciwqL1xuLyogSG93ZXZlciB3aGlsZSBpdCB3b3VsZCBubyBsb25nZXIgbGVhayB0aGUgcmFjZWQgcHJvbWlzZSBvYmplY3RzIHRoZW1zZWx2ZXMsIGl0IHdvdWxkKi9cbi8qIHN0aWxsIGxlYWsgcmVhY3Rpb25zIG9uIHRoZSBub24tcmVzb2x2ZWQgcHJvbWlzZXMgY29udGVuZGluZyBmb3IgdGhlIHJhY2UuKi9cblxuLyoqXG4gKiBDcmVhdGVzIGEgUHJvbWlzZSB0aGF0IGlzIHJlc29sdmVkIG9yIHJlamVjdGVkIHdoZW4gYW55IG9mIHRoZSBwcm92aWRlZCBQcm9taXNlcyBhcmUgcmVzb2x2ZWRcbiAqIG9yIHJlamVjdGVkLlxuICpcbiAqIFVubGlrZSBgUHJvbWlzZS5yYWNlYCBpdCBjbGVhbnMgdXAgYWZ0ZXIgaXRzZWxmIHNvIGEgbm9uLXJlc29sdmVkIHZhbHVlIGRvZXNuJ3QgaG9sZCBvbnRvXG4gKiB0aGUgcmVzdWx0IHByb21pc2UuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEBwYXJhbSB7SXRlcmFibGU8VD59IHZhbHVlcyBBbiBpdGVyYWJsZSBvZiBQcm9taXNlcy5cbiAqIEByZXR1cm5zIHtQcm9taXNlPEF3YWl0ZWQ8VD4+fSBBIG5ldyBQcm9taXNlLlxuICovXG5mdW5jdGlvbiAgICAgICAgcmFjZVByb21pc2VzKHZhbHVlcyl7XG5yZXR1cm4gaGFyZGVuKG1lbW9SYWNlLmNhbGwoQmVzdFBpcGVsaW5hYmxlUHJvbWlzZSx2YWx1ZXMpKTtcbiB9XG5oYXJkZW4ocmFjZVByb21pc2VzKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJtYWtlUHJvbWlzZUtpdCI6WyJtYWtlUHJvbWlzZUtpdCJdLCJyYWNlUHJvbWlzZXMiOlsicmFjZVByb21pc2VzIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAIh9gazfAgAA3wIAACsAAABAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy9pcy1wcm9taXNlLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJpc1Byb21pc2UiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTtPYmplY3QuZGVmaW5lUHJvcGVydHkoaXNQcm9taXNlLCAnbmFtZScsIHt2YWx1ZTogXCJpc1Byb21pc2VcIn0pOyRo4oCNX29uY2UuaXNQcm9taXNlKGlzUHJvbWlzZSk7ICAgLyoqXG4gKiBEZXRlcm1pbmUgaWYgdGhlIGFyZ3VtZW50IGlzIGEgUHJvbWlzZS5cbiAqXG4gKiBAcGFyYW0ge3Vua25vd259IG1heWJlUHJvbWlzZSBUaGUgdmFsdWUgdG8gZXhhbWluZVxuICogQHJldHVybnMge21heWJlUHJvbWlzZSBpcyBQcm9taXNlfSBXaGV0aGVyIGl0IGlzIGEgcHJvbWlzZVxuICovXG5mdW5jdGlvbiAgICAgICAgaXNQcm9taXNlKG1heWJlUHJvbWlzZSl7XG5yZXR1cm4gUHJvbWlzZS5yZXNvbHZlKG1heWJlUHJvbWlzZSk9PT1tYXliZVByb21pc2U7XG4gfVxuaGFyZGVuKGlzUHJvbWlzZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiaXNQcm9taXNlIjpbImlzUHJvbWlzZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAAdp03rvhIAAL4SAAAqAAAAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41Ni9zcmMvbWVtby1yYWNlLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJtZW1vUmFjZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qIEluaXRpYWwgdmVyc2lvbiBhdXRob3JlZCBieSBCcmlhbiBLaW06XG5odHRwczovL2dpdGh1Yi5jb20vbm9kZWpzL25vZGUvaXNzdWVzLzE3NDY5I2lzc3VlY29tbWVudC02ODUyMTY3NzdcbiBUaGlzIGlzIGZyZWUgYW5kIHVuZW5jdW1iZXJlZCBzb2Z0d2FyZSByZWxlYXNlZCBpbnRvIHRoZSBwdWJsaWMgZG9tYWluLlxuIEFueW9uZSBpcyBmcmVlIHRvIGNvcHksIG1vZGlmeSwgcHVibGlzaCwgdXNlLCBjb21waWxlLCBzZWxsLCBvclxuZGlzdHJpYnV0ZSB0aGlzIHNvZnR3YXJlLCBlaXRoZXIgaW4gc291cmNlIGNvZGUgZm9ybSBvciBhcyBhIGNvbXBpbGVkXG5iaW5hcnksIGZvciBhbnkgcHVycG9zZSwgY29tbWVyY2lhbCBvciBub24tY29tbWVyY2lhbCwgYW5kIGJ5IGFueVxubWVhbnMuXG4gSW4ganVyaXNkaWN0aW9ucyB0aGF0IHJlY29nbml6ZSBjb3B5cmlnaHQgbGF3cywgdGhlIGF1dGhvciBvciBhdXRob3JzXG5vZiB0aGlzIHNvZnR3YXJlIGRlZGljYXRlIGFueSBhbmQgYWxsIGNvcHlyaWdodCBpbnRlcmVzdCBpbiB0aGVcbnNvZnR3YXJlIHRvIHRoZSBwdWJsaWMgZG9tYWluLiBXZSBtYWtlIHRoaXMgZGVkaWNhdGlvbiBmb3IgdGhlIGJlbmVmaXRcbm9mIHRoZSBwdWJsaWMgYXQgbGFyZ2UgYW5kIHRvIHRoZSBkZXRyaW1lbnQgb2Ygb3VyIGhlaXJzIGFuZFxuc3VjY2Vzc29ycy4gV2UgaW50ZW5kIHRoaXMgZGVkaWNhdGlvbiB0byBiZSBhbiBvdmVydCBhY3Qgb2ZcbnJlbGlucXVpc2htZW50IGluIHBlcnBldHVpdHkgb2YgYWxsIHByZXNlbnQgYW5kIGZ1dHVyZSByaWdodHMgdG8gdGhpc1xuc29mdHdhcmUgdW5kZXIgY29weXJpZ2h0IGxhdy5cbiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELFxuRVhQUkVTUyBPUiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GXG5NRVJDSEFOVEFCSUxJVFksIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuXG5JTiBOTyBFVkVOVCBTSEFMTCBUSEUgQVVUSE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUlxuT1RIRVIgTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsXG5BUklTSU5HIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1Jcbk9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS5cbiBGb3IgbW9yZSBpbmZvcm1hdGlvbiwgcGxlYXNlIHJlZmVyIHRvIDxodHRwOi8vdW5saWNlbnNlLm9yZy8+XG4qL1xuXG5cblxuXG5cblxuXG5jb25zdCBpc09iamVjdD0odmFsdWUpPT5PYmplY3QodmFsdWUpPT09dmFsdWU7XG5cbi8qKlxuICogQHRlbXBsYXRlIFtUPWFueV1cbiAqIEB0eXBlZGVmIHtvYmplY3R9IERlZmVycmVkXG4gKiBAcHJvcGVydHkgeyh2YWx1ZT86IFhpbXBvcnQoXCIuL3R5cGVzLmpzXCIpLkVSZWY8VD4gKSA9PiB2b2lkfSByZXNvbHZlXG4gKiBAcHJvcGVydHkgeyhlcnI/OiBhbnkgKSA9PiB2b2lkfSByZWplY3RcbiAqL1xuXG4vKipcbiAqIEB0eXBlZGVmIHsgbmV2ZXJcbiAqICB8IHtzZXR0bGVkOiBmYWxzZSwgZGVmZXJyZWRzOiBTZXQ8RGVmZXJyZWQ+fVxuICogIHwge3NldHRsZWQ6IHRydWUsIGRlZmVycmVkcz86IHVuZGVmaW5lZH1cbiAqIH0gUHJvbWlzZU1lbW9SZWNvcmRcbiAqL1xuXG4vKiBLZXlzIGFyZSB0aGUgdmFsdWVzIHBhc3NlZCB0byByYWNlLCB2YWx1ZXMgYXJlIGEgcmVjb3JkIG9mIGRhdGEgY29udGFpbmluZyBhKi9cbi8qIHNldCBvZiBkZWZlcnJlZHMgYW5kIHdoZXRoZXIgdGhlIHZhbHVlIGhhcyBzZXR0bGVkLiovXG4vKiogQHR5cGUge1dlYWtNYXA8b2JqZWN0LCBQcm9taXNlTWVtb1JlY29yZD59ICovXG5jb25zdCBrbm93blByb21pc2VzPW5ldyBXZWFrTWFwKCk7XG5cbi8qKlxuICogQHBhcmFtIHtQcm9taXNlTWVtb1JlY29yZCB8IHVuZGVmaW5lZH0gcmVjb3JkXG4gKiBAcmV0dXJucyB7U2V0PERlZmVycmVkPn1cbiAqL1xuY29uc3QgbWFya1NldHRsZWQ9KHJlY29yZCk9PntcbmlmKCFyZWNvcmR8fHJlY29yZC5zZXR0bGVkKXtcbnJldHVybiBuZXcgU2V0KCk7XG4gfVxuXG5jb25zdHtkZWZlcnJlZHN9PXJlY29yZDtcbk9iamVjdC5hc3NpZ24ocmVjb3JkLHtcbmRlZmVycmVkczp1bmRlZmluZWQsXG5zZXR0bGVkOnRydWV9KTtcblxuT2JqZWN0LmZyZWV6ZShyZWNvcmQpO1xucmV0dXJuIGRlZmVycmVkcztcbiB9O1xuXG4vKipcbiAqXG4gKiBAcGFyYW0ge2FueX0gdmFsdWVcbiAqIEByZXR1cm5zIHtQcm9taXNlTWVtb1JlY29yZH1cbiAqL1xuY29uc3QgZ2V0TWVtb1JlY29yZD0odmFsdWUpPT57XG5pZighaXNPYmplY3QodmFsdWUpKXtcbi8qIElmIHRoZSBjb250ZW5kZXIgaXMgYSBwcmltaXRpdmUsIGF0dGVtcHRpbmcgdG8gdXNlIGl0IGFzIGEga2V5IGluIHRoZSovXG4vKiB3ZWFrbWFwIHdvdWxkIHRocm93IGFuIGVycm9yLiBMdWNraWx5LCBpdCBpcyBzYWZlIHRvIGNhbGwqL1xuLyogYFByb21pc2UucmVzb2x2ZShjb250ZW5kZXIpLnRoZW5gIG9uIGEgcHJpbWl0aXZlIHZhbHVlIG11bHRpcGxlIHRpbWVzKi9cbi8qIGJlY2F1c2UgdGhlIHByb21pc2UgZnVsZmlsbHMgaW1tZWRpYXRlbHkuIFNvIHdlIGZha2UgYSBzZXR0bGVkIHJlY29yZC4qL1xucmV0dXJuIGhhcmRlbih7c2V0dGxlZDp0cnVlfSk7XG4gfVxuXG5sZXQgcmVjb3JkPWtub3duUHJvbWlzZXMuZ2V0KHZhbHVlKTtcblxuaWYoIXJlY29yZCl7XG5yZWNvcmQ9e2RlZmVycmVkczpuZXcgU2V0KCksc2V0dGxlZDpmYWxzZX07XG5rbm93blByb21pc2VzLnNldCh2YWx1ZSxyZWNvcmQpO1xuLyogVGhpcyBjYWxsIHRvIGB0aGVuYCBoYXBwZW5zIG9uY2UgZm9yIHRoZSBsaWZldGltZSBvZiB0aGUgdmFsdWUuKi9cblByb21pc2UucmVzb2x2ZSh2YWx1ZSkudGhlbihcbih2YWwpPT57XG5mb3IoY29uc3R7cmVzb2x2ZX1vZiBtYXJrU2V0dGxlZChyZWNvcmQpKXtcbnJlc29sdmUodmFsKTtcbiB9XG4gfSxcbihlcnIpPT57XG5mb3IoY29uc3R7cmVqZWN0fW9mIG1hcmtTZXR0bGVkKHJlY29yZCkpe1xucmVqZWN0KGVycik7XG4gfVxuIH0pO1xuXG4gfVxucmV0dXJuIHJlY29yZDtcbiB9O1xuXG5jb25zdHtyYWNlfT17XG4vKipcbiAqIENyZWF0ZXMgYSBQcm9taXNlIHRoYXQgaXMgcmVzb2x2ZWQgb3IgcmVqZWN0ZWQgd2hlbiBhbnkgb2YgdGhlIHByb3ZpZGVkIFByb21pc2VzIGFyZSByZXNvbHZlZFxuICogb3IgcmVqZWN0ZWQuXG4gKlxuICogVW5saWtlIGBQcm9taXNlLnJhY2VgIGl0IGNsZWFucyB1cCBhZnRlciBpdHNlbGYgc28gYSBub24tcmVzb2x2ZWQgdmFsdWUgZG9lc24ndCBob2xkIG9udG9cbiAqIHRoZSByZXN1bHQgcHJvbWlzZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHRlbXBsYXRlIHtQcm9taXNlQ29uc3RydWN0b3J9IFtQPVByb21pc2VDb25zdHJ1Y3Rvcl1cbiAqIEB0aGlzIHtQfVxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gdmFsdWVzIEFuIGl0ZXJhYmxlIG9mIFByb21pc2VzLlxuICogQHJldHVybnMge1Byb21pc2U8QXdhaXRlZDxUPj59IEEgbmV3IFByb21pc2UuXG4gKi9cbnJhY2UodmFsdWVzKXtcbmxldCBkZWZlcnJlZDtcbi8qKiBAdHlwZSB7VFtdfSAqL1xuY29uc3QgY2FjaGVkVmFsdWVzPVtdO1xuY29uc3QgQz10aGlzO1xuY29uc3QgcmVzdWx0PW5ldyBDKChyZXNvbHZlLHJlamVjdCk9PntcbmRlZmVycmVkPXtyZXNvbHZlLHJlamVjdH07XG5mb3IoY29uc3QgdmFsdWUgb2YgdmFsdWVzKXtcbmNhY2hlZFZhbHVlcy5wdXNoKHZhbHVlKTtcbmNvbnN0e3NldHRsZWQsZGVmZXJyZWRzfT1nZXRNZW1vUmVjb3JkKHZhbHVlKTtcbmlmKHNldHRsZWQpe1xuLyogSWYgdGhlIGNvbnRlbmRlciBpcyBzZXR0bGVkIChpbmNsdWRpbmcgcHJpbWl0aXZlcyksIGl0IGlzIHNhZmUqL1xuLyogdG8gY2FsbCBgUHJvbWlzZS5yZXNvbHZlKHZhbHVlKS50aGVuYCBvbiBpdC4qL1xuQy5yZXNvbHZlKHZhbHVlKS50aGVuKHJlc29sdmUscmVqZWN0KTtcbiB9ZWxzZXtcbmRlZmVycmVkcy5hZGQoZGVmZXJyZWQpO1xuIH1cbiB9XG4gfSk7XG5cbi8qIFRoZSBmaW5hbGx5IGNhbGxiYWNrIGV4ZWN1dGVzIHdoZW4gYW55IHZhbHVlIHNldHRsZXMsIHByZXZlbnRpbmcgYW55IG9mKi9cbi8qIHRoZSB1bnJlc29sdmVkIHZhbHVlcyBmcm9tIHJldGFpbmluZyBhIHJlZmVyZW5jZSB0byB0aGUgcmVzb2x2ZWQgdmFsdWUuKi9cbnJldHVybiByZXN1bHQuZmluYWxseSgoKT0+e1xuZm9yKGNvbnN0IHZhbHVlIG9mIGNhY2hlZFZhbHVlcyl7XG5jb25zdHtkZWZlcnJlZHN9PWdldE1lbW9SZWNvcmQodmFsdWUpO1xuaWYoZGVmZXJyZWRzKXtcbmRlZmVycmVkcy5kZWxldGUoZGVmZXJyZWQpO1xuIH1cbiB9XG4gfSk7XG4gfX07JGjigI1fb25jZS5yYWNlKHJhY2UpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1lbW9SYWNlIjpbInJhY2UiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA00Ow7mkHAABpBwAANQAAAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYvc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKi8gPHJlZmVyZW5jZSB0eXBlcz1cInNlc1wiLz4qL1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAY2FsbGJhY2sgUHJvbWlzZUV4ZWN1dG9yIFRoZSBwcm9taXNlIGV4ZWN1dG9yXG4gKiBAcGFyYW0geyh2YWx1ZTogWGltcG9ydCgnLi90eXBlcy5qcycpLkVSZWY8VD4pID0+IHZvaWR9IHJlc29sdmVcbiAqIEBwYXJhbSB7KHJlYXNvbjogYW55KSA9PiB2b2lkfSByZWplY3RcbiAqL1xuXG4vKipcbiAqIG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCgpIGJ1aWxkcyByZXNvbHZlL3JlamVjdCBmdW5jdGlvbnMgd2hpY2ggZHJvcCByZWZlcmVuY2VzXG4gKiB0byB0aGUgcmVzb2x2ZS9yZWplY3QgZnVuY3Rpb25zIGdhdGhlcmVkIGZyb20gYW4gZXhlY3V0b3IgdG8gYmUgdXNlZCB3aXRoIGFcbiAqIHByb21pc2UgY29uc3RydWN0b3IuXG4gKlxuICogQHRlbXBsYXRlIFRcbiAqIEByZXR1cm5zIHtQaWNrPFhpbXBvcnQoJy4vdHlwZXMuanMnKS5Qcm9taXNlS2l0PFQ+LCAncmVzb2x2ZScgfCAncmVqZWN0Jz4gJiB7IGV4ZWN1dG9yOiBQcm9taXNlRXhlY3V0b3I8VD59fVxuICovXG5jb25zdCAgICAgICAgbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0PSgpPT57XG4vKiogQHR5cGUge251bGwgfCB1bmRlZmluZWQgfCAoKHZhbHVlOiBYaW1wb3J0KCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZCl9ICovXG5sZXQgaW50ZXJuYWxSZXNvbHZlO1xuLyoqIEB0eXBlIHtudWxsIHwgdW5kZWZpbmVkIHwgKChyZWFzb246IHVua25vd24pID0+IHZvaWQpfSAqL1xubGV0IGludGVybmFsUmVqZWN0O1xuXG4vKiogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuRVJlZjxUPn0gdmFsdWUgKi9cbmNvbnN0IHJlc29sdmU9KHZhbHVlKT0+e1xuaWYoaW50ZXJuYWxSZXNvbHZlKXtcbmludGVybmFsUmVzb2x2ZSh2YWx1ZSk7XG5pbnRlcm5hbFJlc29sdmU9bnVsbDtcbmludGVybmFsUmVqZWN0PW51bGw7XG4gfWVsc2V7XG5hc3NlcnQoaW50ZXJuYWxSZXNvbHZlPT09bnVsbCk7XG4gfVxuIH07XG5cbi8qKiBAcGFyYW0ge3Vua25vd259IHJlYXNvbiAqL1xuY29uc3QgcmVqZWN0PShyZWFzb24pPT57XG5pZihpbnRlcm5hbFJlamVjdCl7XG5pbnRlcm5hbFJlamVjdChyZWFzb24pO1xuaW50ZXJuYWxSZXNvbHZlPW51bGw7XG5pbnRlcm5hbFJlamVjdD1udWxsO1xuIH1lbHNle1xuYXNzZXJ0KGludGVybmFsUmVqZWN0PT09bnVsbCk7XG4gfVxuIH07XG5cbmNvbnN0IGV4ZWN1dG9yPShyZXMscmVqKT0+e1xuYXNzZXJ0KGludGVybmFsUmVzb2x2ZT09PXVuZGVmaW5lZCYmaW50ZXJuYWxSZWplY3Q9PT11bmRlZmluZWQpO1xuaW50ZXJuYWxSZXNvbHZlPXJlcztcbmludGVybmFsUmVqZWN0PXJlajtcbiB9O1xuXG5yZXR1cm4gaGFyZGVuKHtyZXNvbHZlLHJlamVjdCxleGVjdXRvcn0pO1xuIH07JGjigI1fb25jZS5tYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQobWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KTtcbmhhcmRlbihtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCI6WyJtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAmBk7szQBAAA0AQAAJgAAAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYvc3JjL3R5cGVzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAApSvp9wCQAAcAkAACIAAABAZW5kby9wcm9taXNlLWtpdC12MC4yLjYwL2luZGV4LmpzeyJpbXBvcnRzIjpbIi4vc3JjL2lzLXByb21pc2UuanMiLCIuL3NyYy9tZW1vLXJhY2UuanMiLCIuL3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qcyIsIi4vc3JjL3R5cGVzLmpzIl0sImV4cG9ydHMiOlsibWFrZVByb21pc2VLaXQiLCJyYWNlUHJvbWlzZXMiXSwicmVleHBvcnRzIjpbIi4vc3JjL2lzLXByb21pc2UuanMiLCIuL3NyYy90eXBlcy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQsbWVtb1JhY2U7JGjigI1faW1wb3J0cyhbW1wiLi9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanNcIiwgW1tcIm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdFwiLCBbJGjigI1fYSA9PiAobWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0ID0gJGjigI1fYSldXV1dLFtcIi4vc3JjL21lbW8tcmFjZS5qc1wiLCBbW1wibWVtb1JhY2VcIiwgWyRo4oCNX2EgPT4gKG1lbW9SYWNlID0gJGjigI1fYSldXV1dLFtcIi4vc3JjL2lzLXByb21pc2UuanNcIiwgW11dLFtcIi4vc3JjL3R5cGVzLmpzXCIsIFtdXV0pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShtYWtlUHJvbWlzZUtpdCwgJ25hbWUnLCB7dmFsdWU6IFwibWFrZVByb21pc2VLaXRcIn0pOyRo4oCNX29uY2UubWFrZVByb21pc2VLaXQobWFrZVByb21pc2VLaXQpO09iamVjdC5kZWZpbmVQcm9wZXJ0eShyYWNlUHJvbWlzZXMsICduYW1lJywge3ZhbHVlOiBcInJhY2VQcm9taXNlc1wifSk7JGjigI1fb25jZS5yYWNlUHJvbWlzZXMocmFjZVByb21pc2VzKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlIHtQcm9taXNlQ29uc3RydWN0b3J9ICovXG5jb25zdCBCZXN0UGlwZWxpbmFibGVQcm9taXNlPWdsb2JhbFRoaXMuSGFuZGxlZFByb21pc2V8fFByb21pc2U7XG5cbi8qKlxuICogbWFrZVByb21pc2VLaXQoKSBidWlsZHMgYSBQcm9taXNlIG9iamVjdCwgYW5kIHJldHVybnMgYSByZWNvcmRcbiAqIGNvbnRhaW5pbmcgdGhlIHByb21pc2UgaXRzZWxmLCBhcyB3ZWxsIGFzIHNlcGFyYXRlIGZhY2V0cyBmb3IgcmVzb2x2aW5nXG4gKiBhbmQgcmVqZWN0aW5nIGl0LlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcmV0dXJucyB7WGltcG9ydCgnLi9zcmMvdHlwZXMuanMnKS5Qcm9taXNlS2l0PFQ+fVxuICovXG5mdW5jdGlvbiAgICAgICAgbWFrZVByb21pc2VLaXQoKXtcbmNvbnN0e3Jlc29sdmUscmVqZWN0LGV4ZWN1dG9yfT1tYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQoKTtcblxuY29uc3QgcHJvbWlzZT1uZXcgQmVzdFBpcGVsaW5hYmxlUHJvbWlzZShleGVjdXRvcik7XG5cbnJldHVybiBoYXJkZW4oe3Byb21pc2UscmVzb2x2ZSxyZWplY3R9KTtcbiB9XG5oYXJkZW4obWFrZVByb21pc2VLaXQpO1xuXG4vKiBOQjogQW5vdGhlciBpbXBsZW1lbnRhdGlvbiBmb3IgUHJvbWlzZS5yYWNlIHdvdWxkIGJlIHRvIHVzZSB0aGUgcmVsZWFzaW5nIGV4ZWN1dG9yLCovXG4vKiBIb3dldmVyIHdoaWxlIGl0IHdvdWxkIG5vIGxvbmdlciBsZWFrIHRoZSByYWNlZCBwcm9taXNlIG9iamVjdHMgdGhlbXNlbHZlcywgaXQgd291bGQqL1xuLyogc3RpbGwgbGVhayByZWFjdGlvbnMgb24gdGhlIG5vbi1yZXNvbHZlZCBwcm9taXNlcyBjb250ZW5kaW5nIGZvciB0aGUgcmFjZS4qL1xuXG4vKipcbiAqIENyZWF0ZXMgYSBQcm9taXNlIHRoYXQgaXMgcmVzb2x2ZWQgb3IgcmVqZWN0ZWQgd2hlbiBhbnkgb2YgdGhlIHByb3ZpZGVkIFByb21pc2VzIGFyZSByZXNvbHZlZFxuICogb3IgcmVqZWN0ZWQuXG4gKlxuICogVW5saWtlIGBQcm9taXNlLnJhY2VgIGl0IGNsZWFucyB1cCBhZnRlciBpdHNlbGYgc28gYSBub24tcmVzb2x2ZWQgdmFsdWUgZG9lc24ndCBob2xkIG9udG9cbiAqIHRoZSByZXN1bHQgcHJvbWlzZS5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtJdGVyYWJsZTxUPn0gdmFsdWVzIEFuIGl0ZXJhYmxlIG9mIFByb21pc2VzLlxuICogQHJldHVybnMge1Byb21pc2U8QXdhaXRlZDxUPj59IEEgbmV3IFByb21pc2UuXG4gKi9cbmZ1bmN0aW9uICAgICAgICByYWNlUHJvbWlzZXModmFsdWVzKXtcbnJldHVybiBoYXJkZW4obWVtb1JhY2UuY2FsbChCZXN0UGlwZWxpbmFibGVQcm9taXNlLHZhbHVlcykpO1xuIH1cbmhhcmRlbihyYWNlUHJvbWlzZXMpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VQcm9taXNlS2l0IjpbIm1ha2VQcm9taXNlS2l0Il0sInJhY2VQcm9taXNlcyI6WyJyYWNlUHJvbWlzZXMiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAiH2BrN8CAADfAgAAKwAAAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAvc3JjL2lzLXByb21pc2UuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImlzUHJvbWlzZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pO09iamVjdC5kZWZpbmVQcm9wZXJ0eShpc1Byb21pc2UsICduYW1lJywge3ZhbHVlOiBcImlzUHJvbWlzZVwifSk7JGjigI1fb25jZS5pc1Byb21pc2UoaXNQcm9taXNlKTsgICAvKipcbiAqIERldGVybWluZSBpZiB0aGUgYXJndW1lbnQgaXMgYSBQcm9taXNlLlxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gbWF5YmVQcm9taXNlIFRoZSB2YWx1ZSB0byBleGFtaW5lXG4gKiBAcmV0dXJucyB7bWF5YmVQcm9taXNlIGlzIFByb21pc2V9IFdoZXRoZXIgaXQgaXMgYSBwcm9taXNlXG4gKi9cbmZ1bmN0aW9uICAgICAgICBpc1Byb21pc2UobWF5YmVQcm9taXNlKXtcbnJldHVybiBQcm9taXNlLnJlc29sdmUobWF5YmVQcm9taXNlKT09PW1heWJlUHJvbWlzZTtcbiB9XG5oYXJkZW4oaXNQcm9taXNlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJpc1Byb21pc2UiOlsiaXNQcm9taXNlIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAB2nTeu+EgAAvhIAACoAAABAZW5kby9wcm9taXNlLWtpdC12MC4yLjYwL3NyYy9tZW1vLXJhY2UuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbIm1lbW9SYWNlIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogSW5pdGlhbCB2ZXJzaW9uIGF1dGhvcmVkIGJ5IEJyaWFuIEtpbTpcbmh0dHBzOi8vZ2l0aHViLmNvbS9ub2RlanMvbm9kZS9pc3N1ZXMvMTc0NjkjaXNzdWVjb21tZW50LTY4NTIxNjc3N1xuIFRoaXMgaXMgZnJlZSBhbmQgdW5lbmN1bWJlcmVkIHNvZnR3YXJlIHJlbGVhc2VkIGludG8gdGhlIHB1YmxpYyBkb21haW4uXG4gQW55b25lIGlzIGZyZWUgdG8gY29weSwgbW9kaWZ5LCBwdWJsaXNoLCB1c2UsIGNvbXBpbGUsIHNlbGwsIG9yXG5kaXN0cmlidXRlIHRoaXMgc29mdHdhcmUsIGVpdGhlciBpbiBzb3VyY2UgY29kZSBmb3JtIG9yIGFzIGEgY29tcGlsZWRcbmJpbmFyeSwgZm9yIGFueSBwdXJwb3NlLCBjb21tZXJjaWFsIG9yIG5vbi1jb21tZXJjaWFsLCBhbmQgYnkgYW55XG5tZWFucy5cbiBJbiBqdXJpc2RpY3Rpb25zIHRoYXQgcmVjb2duaXplIGNvcHlyaWdodCBsYXdzLCB0aGUgYXV0aG9yIG9yIGF1dGhvcnNcbm9mIHRoaXMgc29mdHdhcmUgZGVkaWNhdGUgYW55IGFuZCBhbGwgY29weXJpZ2h0IGludGVyZXN0IGluIHRoZVxuc29mdHdhcmUgdG8gdGhlIHB1YmxpYyBkb21haW4uIFdlIG1ha2UgdGhpcyBkZWRpY2F0aW9uIGZvciB0aGUgYmVuZWZpdFxub2YgdGhlIHB1YmxpYyBhdCBsYXJnZSBhbmQgdG8gdGhlIGRldHJpbWVudCBvZiBvdXIgaGVpcnMgYW5kXG5zdWNjZXNzb3JzLiBXZSBpbnRlbmQgdGhpcyBkZWRpY2F0aW9uIHRvIGJlIGFuIG92ZXJ0IGFjdCBvZlxucmVsaW5xdWlzaG1lbnQgaW4gcGVycGV0dWl0eSBvZiBhbGwgcHJlc2VudCBhbmQgZnV0dXJlIHJpZ2h0cyB0byB0aGlzXG5zb2Z0d2FyZSB1bmRlciBjb3B5cmlnaHQgbGF3LlxuIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsXG5FWFBSRVNTIE9SIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Zcbk1FUkNIQU5UQUJJTElUWSwgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC5cbklOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1JTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SXG5PVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSxcbkFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUlxuT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLlxuIEZvciBtb3JlIGluZm9ybWF0aW9uLCBwbGVhc2UgcmVmZXIgdG8gPGh0dHA6Ly91bmxpY2Vuc2Uub3JnLz5cbiovXG5cblxuXG5cblxuXG5cbmNvbnN0IGlzT2JqZWN0PSh2YWx1ZSk9Pk9iamVjdCh2YWx1ZSk9PT12YWx1ZTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgW1Q9YW55XVxuICogQHR5cGVkZWYge29iamVjdH0gRGVmZXJyZWRcbiAqIEBwcm9wZXJ0eSB7KHZhbHVlPzogWGltcG9ydChcIi4vdHlwZXMuanNcIikuRVJlZjxUPiApID0+IHZvaWR9IHJlc29sdmVcbiAqIEBwcm9wZXJ0eSB7KGVycj86IGFueSApID0+IHZvaWR9IHJlamVjdFxuICovXG5cbi8qKlxuICogQHR5cGVkZWYgeyBuZXZlclxuICogIHwge3NldHRsZWQ6IGZhbHNlLCBkZWZlcnJlZHM6IFNldDxEZWZlcnJlZD59XG4gKiAgfCB7c2V0dGxlZDogdHJ1ZSwgZGVmZXJyZWRzPzogdW5kZWZpbmVkfVxuICogfSBQcm9taXNlTWVtb1JlY29yZFxuICovXG5cbi8qIEtleXMgYXJlIHRoZSB2YWx1ZXMgcGFzc2VkIHRvIHJhY2UsIHZhbHVlcyBhcmUgYSByZWNvcmQgb2YgZGF0YSBjb250YWluaW5nIGEqL1xuLyogc2V0IG9mIGRlZmVycmVkcyBhbmQgd2hldGhlciB0aGUgdmFsdWUgaGFzIHNldHRsZWQuKi9cbi8qKiBAdHlwZSB7V2Vha01hcDxvYmplY3QsIFByb21pc2VNZW1vUmVjb3JkPn0gKi9cbmNvbnN0IGtub3duUHJvbWlzZXM9bmV3IFdlYWtNYXAoKTtcblxuLyoqXG4gKiBAcGFyYW0ge1Byb21pc2VNZW1vUmVjb3JkIHwgdW5kZWZpbmVkfSByZWNvcmRcbiAqIEByZXR1cm5zIHtTZXQ8RGVmZXJyZWQ+fVxuICovXG5jb25zdCBtYXJrU2V0dGxlZD0ocmVjb3JkKT0+e1xuaWYoIXJlY29yZHx8cmVjb3JkLnNldHRsZWQpe1xucmV0dXJuIG5ldyBTZXQoKTtcbiB9XG5cbmNvbnN0e2RlZmVycmVkc309cmVjb3JkO1xuT2JqZWN0LmFzc2lnbihyZWNvcmQse1xuZGVmZXJyZWRzOnVuZGVmaW5lZCxcbnNldHRsZWQ6dHJ1ZX0pO1xuXG5PYmplY3QuZnJlZXplKHJlY29yZCk7XG5yZXR1cm4gZGVmZXJyZWRzO1xuIH07XG5cbi8qKlxuICpcbiAqIEBwYXJhbSB7YW55fSB2YWx1ZVxuICogQHJldHVybnMge1Byb21pc2VNZW1vUmVjb3JkfVxuICovXG5jb25zdCBnZXRNZW1vUmVjb3JkPSh2YWx1ZSk9PntcbmlmKCFpc09iamVjdCh2YWx1ZSkpe1xuLyogSWYgdGhlIGNvbnRlbmRlciBpcyBhIHByaW1pdGl2ZSwgYXR0ZW1wdGluZyB0byB1c2UgaXQgYXMgYSBrZXkgaW4gdGhlKi9cbi8qIHdlYWttYXAgd291bGQgdGhyb3cgYW4gZXJyb3IuIEx1Y2tpbHksIGl0IGlzIHNhZmUgdG8gY2FsbCovXG4vKiBgUHJvbWlzZS5yZXNvbHZlKGNvbnRlbmRlcikudGhlbmAgb24gYSBwcmltaXRpdmUgdmFsdWUgbXVsdGlwbGUgdGltZXMqL1xuLyogYmVjYXVzZSB0aGUgcHJvbWlzZSBmdWxmaWxscyBpbW1lZGlhdGVseS4gU28gd2UgZmFrZSBhIHNldHRsZWQgcmVjb3JkLiovXG5yZXR1cm4gaGFyZGVuKHtzZXR0bGVkOnRydWV9KTtcbiB9XG5cbmxldCByZWNvcmQ9a25vd25Qcm9taXNlcy5nZXQodmFsdWUpO1xuXG5pZighcmVjb3JkKXtcbnJlY29yZD17ZGVmZXJyZWRzOm5ldyBTZXQoKSxzZXR0bGVkOmZhbHNlfTtcbmtub3duUHJvbWlzZXMuc2V0KHZhbHVlLHJlY29yZCk7XG4vKiBUaGlzIGNhbGwgdG8gYHRoZW5gIGhhcHBlbnMgb25jZSBmb3IgdGhlIGxpZmV0aW1lIG9mIHRoZSB2YWx1ZS4qL1xuUHJvbWlzZS5yZXNvbHZlKHZhbHVlKS50aGVuKFxuKHZhbCk9PntcbmZvcihjb25zdHtyZXNvbHZlfW9mIG1hcmtTZXR0bGVkKHJlY29yZCkpe1xucmVzb2x2ZSh2YWwpO1xuIH1cbiB9LFxuKGVycik9PntcbmZvcihjb25zdHtyZWplY3R9b2YgbWFya1NldHRsZWQocmVjb3JkKSl7XG5yZWplY3QoZXJyKTtcbiB9XG4gfSk7XG5cbiB9XG5yZXR1cm4gcmVjb3JkO1xuIH07XG5cbmNvbnN0e3JhY2V9PXtcbi8qKlxuICogQ3JlYXRlcyBhIFByb21pc2UgdGhhdCBpcyByZXNvbHZlZCBvciByZWplY3RlZCB3aGVuIGFueSBvZiB0aGUgcHJvdmlkZWQgUHJvbWlzZXMgYXJlIHJlc29sdmVkXG4gKiBvciByZWplY3RlZC5cbiAqXG4gKiBVbmxpa2UgYFByb21pc2UucmFjZWAgaXQgY2xlYW5zIHVwIGFmdGVyIGl0c2VsZiBzbyBhIG5vbi1yZXNvbHZlZCB2YWx1ZSBkb2Vzbid0IGhvbGQgb250b1xuICogdGhlIHJlc3VsdCBwcm9taXNlLlxuICpcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAdGVtcGxhdGUge1Byb21pc2VDb25zdHJ1Y3Rvcn0gW1A9UHJvbWlzZUNvbnN0cnVjdG9yXVxuICogQHRoaXMge1B9XG4gKiBAcGFyYW0ge0l0ZXJhYmxlPFQ+fSB2YWx1ZXMgQW4gaXRlcmFibGUgb2YgUHJvbWlzZXMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxBd2FpdGVkPFQ+Pn0gQSBuZXcgUHJvbWlzZS5cbiAqL1xucmFjZSh2YWx1ZXMpe1xubGV0IGRlZmVycmVkO1xuLyoqIEB0eXBlIHtUW119ICovXG5jb25zdCBjYWNoZWRWYWx1ZXM9W107XG5jb25zdCBDPXRoaXM7XG5jb25zdCByZXN1bHQ9bmV3IEMoKHJlc29sdmUscmVqZWN0KT0+e1xuZGVmZXJyZWQ9e3Jlc29sdmUscmVqZWN0fTtcbmZvcihjb25zdCB2YWx1ZSBvZiB2YWx1ZXMpe1xuY2FjaGVkVmFsdWVzLnB1c2godmFsdWUpO1xuY29uc3R7c2V0dGxlZCxkZWZlcnJlZHN9PWdldE1lbW9SZWNvcmQodmFsdWUpO1xuaWYoc2V0dGxlZCl7XG4vKiBJZiB0aGUgY29udGVuZGVyIGlzIHNldHRsZWQgKGluY2x1ZGluZyBwcmltaXRpdmVzKSwgaXQgaXMgc2FmZSovXG4vKiB0byBjYWxsIGBQcm9taXNlLnJlc29sdmUodmFsdWUpLnRoZW5gIG9uIGl0LiovXG5DLnJlc29sdmUodmFsdWUpLnRoZW4ocmVzb2x2ZSxyZWplY3QpO1xuIH1lbHNle1xuZGVmZXJyZWRzLmFkZChkZWZlcnJlZCk7XG4gfVxuIH1cbiB9KTtcblxuLyogVGhlIGZpbmFsbHkgY2FsbGJhY2sgZXhlY3V0ZXMgd2hlbiBhbnkgdmFsdWUgc2V0dGxlcywgcHJldmVudGluZyBhbnkgb2YqL1xuLyogdGhlIHVucmVzb2x2ZWQgdmFsdWVzIGZyb20gcmV0YWluaW5nIGEgcmVmZXJlbmNlIHRvIHRoZSByZXNvbHZlZCB2YWx1ZS4qL1xucmV0dXJuIHJlc3VsdC5maW5hbGx5KCgpPT57XG5mb3IoY29uc3QgdmFsdWUgb2YgY2FjaGVkVmFsdWVzKXtcbmNvbnN0e2RlZmVycmVkc309Z2V0TWVtb1JlY29yZCh2YWx1ZSk7XG5pZihkZWZlcnJlZHMpe1xuZGVmZXJyZWRzLmRlbGV0ZShkZWZlcnJlZCk7XG4gfVxuIH1cbiB9KTtcbiB9fTskaOKAjV9vbmNlLnJhY2UocmFjZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWVtb1JhY2UiOlsicmFjZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADTQ7DuaQcAAGkHAAA1AAAAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi42MC9zcmMvcHJvbWlzZS1leGVjdXRvci1raXQuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbIm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qLyA8cmVmZXJlbmNlIHR5cGVzPVwic2VzXCIvPiovXG5cbi8qKlxuICogQHRlbXBsYXRlIFRcbiAqIEBjYWxsYmFjayBQcm9taXNlRXhlY3V0b3IgVGhlIHByb21pc2UgZXhlY3V0b3JcbiAqIEBwYXJhbSB7KHZhbHVlOiBYaW1wb3J0KCcuL3R5cGVzLmpzJykuRVJlZjxUPikgPT4gdm9pZH0gcmVzb2x2ZVxuICogQHBhcmFtIHsocmVhc29uOiBhbnkpID0+IHZvaWR9IHJlamVjdFxuICovXG5cbi8qKlxuICogbWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0KCkgYnVpbGRzIHJlc29sdmUvcmVqZWN0IGZ1bmN0aW9ucyB3aGljaCBkcm9wIHJlZmVyZW5jZXNcbiAqIHRvIHRoZSByZXNvbHZlL3JlamVjdCBmdW5jdGlvbnMgZ2F0aGVyZWQgZnJvbSBhbiBleGVjdXRvciB0byBiZSB1c2VkIHdpdGggYVxuICogcHJvbWlzZSBjb25zdHJ1Y3Rvci5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHJldHVybnMge1BpY2s8WGltcG9ydCgnLi90eXBlcy5qcycpLlByb21pc2VLaXQ8VD4sICdyZXNvbHZlJyB8ICdyZWplY3QnPiAmIHsgZXhlY3V0b3I6IFByb21pc2VFeGVjdXRvcjxUPn19XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQ9KCk9Pntcbi8qKiBAdHlwZSB7bnVsbCB8IHVuZGVmaW5lZCB8ICgodmFsdWU6IFhpbXBvcnQoJy4vdHlwZXMuanMnKS5FUmVmPFQ+KSA9PiB2b2lkKX0gKi9cbmxldCBpbnRlcm5hbFJlc29sdmU7XG4vKiogQHR5cGUge251bGwgfCB1bmRlZmluZWQgfCAoKHJlYXNvbjogdW5rbm93bikgPT4gdm9pZCl9ICovXG5sZXQgaW50ZXJuYWxSZWplY3Q7XG5cbi8qKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5FUmVmPFQ+fSB2YWx1ZSAqL1xuY29uc3QgcmVzb2x2ZT0odmFsdWUpPT57XG5pZihpbnRlcm5hbFJlc29sdmUpe1xuaW50ZXJuYWxSZXNvbHZlKHZhbHVlKTtcbmludGVybmFsUmVzb2x2ZT1udWxsO1xuaW50ZXJuYWxSZWplY3Q9bnVsbDtcbiB9ZWxzZXtcbmFzc2VydChpbnRlcm5hbFJlc29sdmU9PT1udWxsKTtcbiB9XG4gfTtcblxuLyoqIEBwYXJhbSB7dW5rbm93bn0gcmVhc29uICovXG5jb25zdCByZWplY3Q9KHJlYXNvbik9PntcbmlmKGludGVybmFsUmVqZWN0KXtcbmludGVybmFsUmVqZWN0KHJlYXNvbik7XG5pbnRlcm5hbFJlc29sdmU9bnVsbDtcbmludGVybmFsUmVqZWN0PW51bGw7XG4gfWVsc2V7XG5hc3NlcnQoaW50ZXJuYWxSZWplY3Q9PT1udWxsKTtcbiB9XG4gfTtcblxuY29uc3QgZXhlY3V0b3I9KHJlcyxyZWopPT57XG5hc3NlcnQoaW50ZXJuYWxSZXNvbHZlPT09dW5kZWZpbmVkJiZpbnRlcm5hbFJlamVjdD09PXVuZGVmaW5lZCk7XG5pbnRlcm5hbFJlc29sdmU9cmVzO1xuaW50ZXJuYWxSZWplY3Q9cmVqO1xuIH07XG5cbnJldHVybiBoYXJkZW4oe3Jlc29sdmUscmVqZWN0LGV4ZWN1dG9yfSk7XG4gfTskaOKAjV9vbmNlLm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdChtYWtlUmVsZWFzaW5nRXhlY3V0b3JLaXQpO1xuaGFyZGVuKG1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsibWFrZVJlbGVhc2luZ0V4ZWN1dG9yS2l0IjpbIm1ha2VSZWxlYXNpbmdFeGVjdXRvcktpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACYGTuzNAEAADQBAAAmAAAAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi42MC9zcmMvdHlwZXMuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAADK4l5PQYAAD0GAAAHQAAAEBlbmRvL3N0cmVhbS12MC4zLjI1L2luZGV4LmpzeyJpbXBvcnRzIjpbIkBlbmRvL2V2ZW50dWFsLXNlbmQiLCJAZW5kby9wcm9taXNlLWtpdCJdLCJleHBvcnRzIjpbIm1ha2VQaXBlIiwibWFrZVF1ZXVlIiwibWFrZVN0cmVhbSIsIm1hcFJlYWRlciIsIm1hcFdyaXRlciIsInByaW1lIiwicHVtcCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLG1ha2VQcm9taXNlS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vcHJvbWlzZS1raXRcIiwgW1tcIm1ha2VQcm9taXNlS2l0XCIsIFskaOKAjV9hID0+IChtYWtlUHJvbWlzZUtpdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAdGVtcGxhdGUgVFxuICogQHR5cGVkZWYge3tcbiAqICAgcmVzb2x2ZSh2YWx1ZT86IFQgfCBQcm9taXNlPFQ+KTogdm9pZCxcbiAqICAgcmVqZWN0KGVycm9yOiBFcnJvcik6IHZvaWQsXG4gKiAgIHByb21pc2U6IFByb21pc2U8VD5cbiAqIH19IFByb21pc2VLaXRcbiAqL1xuXG4vKiBUeXBlU2NyaXB0IFJlYWRPbmx5IHNlbWFudGljcyBhcmUgbm90IHN1ZmZpY2llbnRseSBleHByZXNzaXZlIHRvIGRpc3Rpbmd1aXNoKi9cbi8qIGEgdmFsdWUgb25lIHByb21pc2VzIG5vdCB0byBhbHRlciBmcm9tIGEgdmFsdWUgb25lIG11c3Qgbm90IGFsdGVyLCovXG4vKiBtYWtpbmcgaXQgdXNlbGVzcy4qL1xuY29uc3QgZnJlZXplPS8qKiBAdHlwZSB7PFQ+KHY6IFQgfCBSZWFkb25seTxUPikgPT4gVH0gKi9PYmplY3QuZnJlZXplO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcmV0dXJucyB7WGltcG9ydCgnLi90eXBlcy5qcycpLkFzeW5jUXVldWU8VD59XG4gKi9cbmNvbnN0ICAgICAgICBtYWtlUXVldWU9KCk9PntcbmxldHtwcm9taXNlOnRhaWxQcm9taXNlLHJlc29sdmU6dGFpbFJlc29sdmV9PW1ha2VQcm9taXNlS2l0KCk7XG5yZXR1cm57XG5wdXQodmFsdWUpe1xuY29uc3R7cmVzb2x2ZSxwcm9taXNlfT1tYWtlUHJvbWlzZUtpdCgpO1xudGFpbFJlc29sdmUoZnJlZXplKHt2YWx1ZSxwcm9taXNlfSkpO1xudGFpbFJlc29sdmU9cmVzb2x2ZTtcbiB9LFxuZ2V0KCl7XG5jb25zdCBwcm9taXNlPXRhaWxQcm9taXNlLnRoZW4oKG5leHQpPT5uZXh0LnZhbHVlKTtcbnRhaWxQcm9taXNlPXRhaWxQcm9taXNlLnRoZW4oKG5leHQpPT5uZXh0LnByb21pc2UpO1xucmV0dXJuIGhhcmRlbihwcm9taXNlKTtcbiB9fTtcblxuIH07JGjigI1fb25jZS5tYWtlUXVldWUobWFrZVF1ZXVlKTtcbmhhcmRlbihtYWtlUXVldWUpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUUmVhZFxuICogQHRlbXBsYXRlIFRXcml0ZVxuICogQHRlbXBsYXRlIFRSZWFkUmV0dXJuXG4gKiBAdGVtcGxhdGUgVFdyaXRlUmV0dXJuXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Bc3luY1F1ZXVlPEl0ZXJhdG9yUmVzdWx0PFRSZWFkLCBUUmVhZFJldHVybj4+fSBhY2tzXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Bc3luY1F1ZXVlPEl0ZXJhdG9yUmVzdWx0PFRXcml0ZSwgVFdyaXRlUmV0dXJuPj59IGRhdGFcbiAqL1xuY29uc3QgICAgICAgIG1ha2VTdHJlYW09KGFja3MsZGF0YSk9PntcbmNvbnN0IHN0cmVhbT1oYXJkZW4oe1xuLyoqXG4gKiBAcGFyYW0ge1RXcml0ZX0gdmFsdWVcbiAqL1xubmV4dCh2YWx1ZSl7XG4vKiBOb3RlIHRoZSBzaGFsbG93IGZyZWV6ZSBzaW5jZSB2YWx1ZSBpcyBub3QgZ3VhcmFudGVlZCB0byBiZSBmcmVlemFibGUqL1xuLyogKHR5cGVkIGFycmF5cyBhcmUgbm90KS4qL1xuZGF0YS5wdXQoZnJlZXplKHt2YWx1ZSxkb25lOmZhbHNlfSkpO1xucmV0dXJuIGFja3MuZ2V0KCk7XG4gfSxcbi8qKlxuICogQHBhcmFtIHtUV3JpdGVSZXR1cm59IHZhbHVlXG4gKi9cbnJldHVybih2YWx1ZSl7XG5kYXRhLnB1dChmcmVlemUoe3ZhbHVlLGRvbmU6dHJ1ZX0pKTtcbnJldHVybiBhY2tzLmdldCgpO1xuIH0sXG4vKipcbiAqIEBwYXJhbSB7RXJyb3J9IGVycm9yXG4gKi9cbnRocm93KGVycm9yKXtcbmRhdGEucHV0KGhhcmRlbihQcm9taXNlLnJlamVjdChlcnJvcikpKTtcbnJldHVybiBhY2tzLmdldCgpO1xuIH0sXG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCl7XG5yZXR1cm4gc3RyZWFtO1xuIH19KTtcblxucmV0dXJuIHN0cmVhbTtcbiB9OyRo4oCNX29uY2UubWFrZVN0cmVhbShtYWtlU3RyZWFtKTtcbmhhcmRlbihtYWtlU3RyZWFtKTtcblxuLyogSlNEb2MgVHlwZVNjcmlwdCBzZWVtcyB1bmFibGUgdG8gZXhwcmVzcyB0aGlzIHBhcnRpY3VsYXIgZnVuY3Rpb24ncyovXG4vKiBlbnRhbmdsZW1lbnQgb2YgcXVldWVzLCBidXQgdGhlIGRlZmluaXRpb24gaW4gdHlwZXMuZC50cyB3b3JrcyBmb3IgdGhlIGVuZCovXG4vKiB1c2VyLiovXG5jb25zdCAgICAgICAgbWFrZVBpcGU9KCk9PntcbmNvbnN0IGRhdGE9bWFrZVF1ZXVlKCk7XG5jb25zdCBhY2tzPW1ha2VRdWV1ZSgpO1xuY29uc3QgcmVhZGVyPW1ha2VTdHJlYW0oYWNrcyxkYXRhKTtcbmNvbnN0IHdyaXRlcj1tYWtlU3RyZWFtKGRhdGEsYWNrcyk7XG5yZXR1cm4gaGFyZGVuKFt3cml0ZXIscmVhZGVyXSk7XG4gfTskaOKAjV9vbmNlLm1ha2VQaXBlKG1ha2VQaXBlKTtcbmhhcmRlbihtYWtlUGlwZSk7XG5cbi8qKlxuICogQHRlbXBsYXRlIFRSZWFkXG4gKiBAdGVtcGxhdGUgVFdyaXRlXG4gKiBAdGVtcGxhdGUgVFJlYWRSZXR1cm5cbiAqIEB0ZW1wbGF0ZSBUV3JpdGVSZXR1cm5cbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlN0cmVhbTxUV3JpdGUsIFRSZWFkLCBUV3JpdGVSZXR1cm4sIFRSZWFkUmV0dXJuPn0gd3JpdGVyXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5TdHJlYW08VFJlYWQsIFRXcml0ZSwgVFJlYWRSZXR1cm4sIFRXcml0ZVJldHVybj59IHJlYWRlclxuICogQHBhcmFtIHtUV3JpdGV9IHByaW1lclxuICovXG5jb25zdCAgICAgICAgcHVtcD1hc3luYyh3cml0ZXIscmVhZGVyLHByaW1lcik9Pntcbi8qKiBAcGFyYW0ge1Byb21pc2U8SXRlcmF0b3JSZXN1bHQ8VFJlYWQsIFRSZWFkUmV0dXJuPj59IHByb21pc2UgKi9cbmNvbnN0IHRpY2s9KHByb21pc2UpPT5cbkUud2hlbihcbnByb21pc2UsXG4ocmVzdWx0KT0+e1xuaWYocmVzdWx0LmRvbmUpe1xucmV0dXJuIHdyaXRlci5yZXR1cm4ocmVzdWx0LnZhbHVlKTtcbiB9ZWxzZXtcbi8qIEJlaG9sZDogbXV0dWFsIHJlY3Vyc2lvbi4qL1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVzZS1iZWZvcmUtZGVmaW5lKi9cbnJldHVybiB0b2NrKHdyaXRlci5uZXh0KHJlc3VsdC52YWx1ZSkpO1xuIH1cbiB9LFxuKC8qKiBAdHlwZSB7RXJyb3J9ICovZXJyb3IpPT57XG5yZXR1cm4gd3JpdGVyLnRocm93KGVycm9yKTtcbiB9KTtcblxuLyoqIEBwYXJhbSB7UHJvbWlzZTxJdGVyYXRvclJlc3VsdDxUV3JpdGUsIFRXcml0ZVJldHVybj4+fSBwcm9taXNlICovXG5jb25zdCB0b2NrPShwcm9taXNlKT0+XG5FLndoZW4oXG5wcm9taXNlLFxuKHJlc3VsdCk9PntcbmlmKHJlc3VsdC5kb25lKXtcbnJldHVybiByZWFkZXIucmV0dXJuKHJlc3VsdC52YWx1ZSk7XG4gfWVsc2V7XG5yZXR1cm4gdGljayhyZWFkZXIubmV4dChyZXN1bHQudmFsdWUpKTtcbiB9XG4gfSxcbigvKiogQHR5cGUge0Vycm9yfSAqL2Vycm9yKT0+e1xucmV0dXJuIHJlYWRlci50aHJvdyhlcnJvcik7XG4gfSk7XG5cbmF3YWl0IHRpY2socmVhZGVyLm5leHQocHJpbWVyKSk7XG5yZXR1cm4gdW5kZWZpbmVkO1xuIH07JGjigI1fb25jZS5wdW1wKHB1bXApO1xuaGFyZGVuKHB1bXApO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUUmVhZFxuICogQHRlbXBsYXRlIFRXcml0ZVxuICogQHRlbXBsYXRlIFRSZXR1cm5cbiAqIEBwYXJhbSB7QXN5bmNHZW5lcmF0b3I8VFJlYWQsIFRSZXR1cm4sIFRXcml0ZT59IGdlbmVyYXRvclxuICogQHBhcmFtIHtUV3JpdGV9IHByaW1lclxuICovXG5jb25zdCAgICAgICAgcHJpbWU9KGdlbmVyYXRvcixwcmltZXIpPT57XG4vKiBXZSBjYXB0dXJlIHRoZSBmaXJzdCByZXR1cm5lZCBwcm9taXNlLiovXG5jb25zdCBmaXJzdD1nZW5lcmF0b3IubmV4dChwcmltZXIpO1xuLyoqIEB0eXBlIHtJdGVyYXRvclJlc3VsdDxUUmVhZCwgVFJldHVybj49fSAqL1xubGV0IHJlc3VsdDtcbmNvbnN0IHByaW1lZD1oYXJkZW4oe1xuLyoqIEBwYXJhbSB7VFdyaXRlfSB2YWx1ZSAqL1xuICAgICAgYXN5bmMgbmV4dCh2YWx1ZSl7XG5pZihyZXN1bHQ9PT11bmRlZmluZWQpe1xucmVzdWx0PWF3YWl0IGZpcnN0O1xuaWYocmVzdWx0LmRvbmUpe1xucmV0dXJuIHJlc3VsdDtcbiB9XG4gfVxucmV0dXJuIGdlbmVyYXRvci5uZXh0KHZhbHVlKTtcbiB9LFxuLyoqIEBwYXJhbSB7VFJldHVybn0gdmFsdWUgKi9cbiAgICAgIGFzeW5jIHJldHVybih2YWx1ZSl7XG5pZihyZXN1bHQ9PT11bmRlZmluZWQpe1xucmVzdWx0PWF3YWl0IGZpcnN0O1xuaWYocmVzdWx0LmRvbmUpe1xucmV0dXJuIHJlc3VsdDtcbiB9XG4gfVxucmV0dXJuIGdlbmVyYXRvci5yZXR1cm4odmFsdWUpO1xuIH0sXG4vKiogQHBhcmFtIHtFcnJvcn0gZXJyb3IgKi9cbiAgICAgIGFzeW5jIHRocm93KGVycm9yKXtcbmlmKHJlc3VsdD09PXVuZGVmaW5lZCl7XG5yZXN1bHQ9YXdhaXQgZmlyc3Q7XG5pZihyZXN1bHQuZG9uZSl7XG50aHJvdyBlcnJvcjtcbiB9XG4gfVxucmV0dXJuIGdlbmVyYXRvci50aHJvdyhlcnJvcik7XG4gfX0pO1xuXG5yZXR1cm4gcHJpbWVkO1xuIH07JGjigI1fb25jZS5wcmltZShwcmltZSk7XG5oYXJkZW4ocHJpbWUpO1xuXG4vKipcbiAqIEB0ZW1wbGF0ZSBUSW5cbiAqIEB0ZW1wbGF0ZSBUT3V0XG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZWFkZXI8VEluPn0gcmVhZGVyXG4gKiBAcGFyYW0geyh2YWx1ZTogVEluKSA9PiBUT3V0fSB0cmFuc2Zvcm1cbiAqIEByZXR1cm5zIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVhZGVyPFRPdXQ+fVxuICovXG5jb25zdCAgICAgICAgbWFwUmVhZGVyPShyZWFkZXIsdHJhbnNmb3JtKT0+e1xuYXN5bmMgZnVuY3Rpb24qdHJhbnNmb3JtR2VuZXJhdG9yKCl7XG5mb3IgYXdhaXQoY29uc3QgdmFsdWUgb2YgcmVhZGVyKXtcbnlpZWxkIHRyYW5zZm9ybSh2YWx1ZSk7XG4gfVxucmV0dXJuIHVuZGVmaW5lZDtcbiB9XG5yZXR1cm4gaGFyZGVuKHRyYW5zZm9ybUdlbmVyYXRvcigpKTtcbiB9OyRo4oCNX29uY2UubWFwUmVhZGVyKG1hcFJlYWRlcik7XG5oYXJkZW4obWFwUmVhZGVyKTtcblxuLyoqXG4gKiBAdGVtcGxhdGUgVEluXG4gKiBAdGVtcGxhdGUgVE91dFxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuV3JpdGVyPFRPdXQ+fSB3cml0ZXJcbiAqIEBwYXJhbSB7KHZhbHVlOiBUSW4pID0+IFRPdXR9IHRyYW5zZm9ybVxuICogQHJldHVybnMge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5Xcml0ZXI8VEluPn1cbiAqL1xuY29uc3QgICAgICAgIG1hcFdyaXRlcj0od3JpdGVyLHRyYW5zZm9ybSk9PntcbmNvbnN0IHRyYW5zZm9ybWVkV3JpdGVyPWhhcmRlbih7XG4vKipcbiAqIEBwYXJhbSB7VElufSB2YWx1ZVxuICovXG4gICAgICBhc3luYyBuZXh0KHZhbHVlKXtcbnJldHVybiB3cml0ZXIubmV4dCh0cmFuc2Zvcm0odmFsdWUpKTtcbiB9LFxuLyoqXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJvclxuICovXG4gICAgICBhc3luYyB0aHJvdyhlcnJvcil7XG5yZXR1cm4gd3JpdGVyLnRocm93KGVycm9yKTtcbiB9LFxuLyoqXG4gKiBAcGFyYW0ge3VuZGVmaW5lZH0gdmFsdWVcbiAqL1xuICAgICAgYXN5bmMgcmV0dXJuKHZhbHVlKXtcbnJldHVybiB3cml0ZXIucmV0dXJuKHZhbHVlKTtcbiB9LFxuW1N5bWJvbC5hc3luY0l0ZXJhdG9yXSgpe1xucmV0dXJuIHRyYW5zZm9ybWVkV3JpdGVyO1xuIH19KTtcblxucmV0dXJuIHRyYW5zZm9ybWVkV3JpdGVyO1xuIH07JGjigI1fb25jZS5tYXBXcml0ZXIobWFwV3JpdGVyKTtcbmhhcmRlbihtYXBXcml0ZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VRdWV1ZSI6WyJtYWtlUXVldWUiXSwibWFrZVN0cmVhbSI6WyJtYWtlU3RyZWFtIl0sIm1ha2VQaXBlIjpbIm1ha2VQaXBlIl0sInB1bXAiOlsicHVtcCJdLCJwcmltZSI6WyJwcmltZSJdLCJtYXBSZWFkZXIiOlsibWFwUmVhZGVyIl0sIm1hcFdyaXRlciI6WyJtYXBXcml0ZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAqbIw0bQcAAC0HAAALwAAAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9hc3NlcnRpb25IZWxwZXJzLmpzeyJpbXBvcnRzIjpbIi4vdHlwZUd1YXJkcy5qcyIsIkBhZ29yaWMvZXJ0cCIsIkBhZ29yaWMvc3RvcmUiLCJAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L3NhZmVNYXRoLmpzIl0sImV4cG9ydHMiOlsiYXNzZXJ0QW1vdW50Tm90RW1wdHkiLCJhc3NlcnRCaWRDb25maWciLCJhc3NlcnRDb2xsYXRlcmFsIiwiYXNzZXJ0R3JhY2VQZXJpb2QiLCJhc3NlcnRSZW50YWxDb25maWciLCJhc3NlcnRSZW50YWxGZWUiLCJhc3NlcnRSZW50YWxIYW5kbGUiLCJhc3NlcnRSZW50YWxQaGFzZSIsImFzc2VydFJlbnRpbmdEdXJhdGlvbiIsImFzc2VydFJlbnRpbmdUaWVyIiwiYXNzZXJ0VXRpbGl0eSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBBbW91bnRNYXRoLG5hdFNhZmVNYXRoLG11c3RNYXRjaCxtYWtlQXVjdGlvblJlbnRhbENvbmZpZ0d1YXJkLG1ha2VBZEhvY1JlbnRhbENvbmZpZ0d1YXJkLG1ha2VCaWRDb25maWdHdWFyZDskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL2VydHBcIiwgW1tcIkFtb3VudE1hdGhcIiwgWyRo4oCNX2EgPT4gKEFtb3VudE1hdGggPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC9zYWZlTWF0aC5qc1wiLCBbW1wibmF0U2FmZU1hdGhcIiwgWyRo4oCNX2EgPT4gKG5hdFNhZmVNYXRoID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvc3RvcmVcIiwgW1tcIm11c3RNYXRjaFwiLCBbJGjigI1fYSA9PiAobXVzdE1hdGNoID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZUd1YXJkcy5qc1wiLCBbW1wibWFrZUF1Y3Rpb25SZW50YWxDb25maWdHdWFyZFwiLCBbJGjigI1fYSA9PiAobWFrZUF1Y3Rpb25SZW50YWxDb25maWdHdWFyZCA9ICRo4oCNX2EpXV0sW1wibWFrZUFkSG9jUmVudGFsQ29uZmlnR3VhcmRcIiwgWyRo4oCNX2EgPT4gKG1ha2VBZEhvY1JlbnRhbENvbmZpZ0d1YXJkID0gJGjigI1fYSldXSxbXCJtYWtlQmlkQ29uZmlnR3VhcmRcIiwgWyRo4oCNX2EgPT4gKG1ha2VCaWRDb25maWdHdWFyZCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuLyoqXG4gKiBAcGFyYW0ge0hhbmRsZTxzdHJpbmc+fSAgZXhwZWN0ZWRcbiAqIEBwYXJhbSB7SGFuZGxlPHN0cmluZz59IHByb3ZpZGVkXG4gKi9cbmNvbnN0ICAgICAgICBhc3NlcnRSZW50YWxIYW5kbGU9KGV4cGVjdGVkLHByb3ZpZGVkKT0+e1xuYXNzZXJ0KGV4cGVjdGVkPT09cHJvdmlkZWQsJ1JlbnRhbEhhbmRsZSBtaXNtYXRjaCcpO1xuIH07XG5cbi8qKlxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVudGFsQ29uZmlnfSByZW50YWxDb25maWdcbiAqLyRo4oCNX29uY2UuYXNzZXJ0UmVudGFsSGFuZGxlKGFzc2VydFJlbnRhbEhhbmRsZSk7XG5jb25zdCAgICAgICAgYXNzZXJ0UmVudGFsQ29uZmlnPSh6Y2YscmVudGFsQ29uZmlnKT0+e1xuY29uc3R7cmVudGluZ1RpZXIsbWluUmVudGluZ0R1cmF0aW9uVW5pdHMsbWF4UmVudGluZ0R1cmF0aW9uVW5pdHN9PVxucmVudGFsQ29uZmlnO1xuXG5pZihyZW50aW5nVGllcj09PSdBZC1Ib2MnKXtcbm11c3RNYXRjaChcbmhhcmRlbihyZW50YWxDb25maWcpLFxuaGFyZGVuKG1ha2VBZEhvY1JlbnRhbENvbmZpZ0d1YXJkKHpjZikpLFxuJ1JlbnRhbENvbmZpZyBwYXR0ZXJuIChBZC1Ib2MpJyk7XG5cbiB9ZWxzZXtcbm11c3RNYXRjaChcbmhhcmRlbihyZW50YWxDb25maWcpLFxuaGFyZGVuKG1ha2VBdWN0aW9uUmVudGFsQ29uZmlnR3VhcmQoemNmKSksXG4nUmVudGFsQ29uZmlnIHBhdHRlcm4gKEF1Y3Rpb24pJyk7XG5cbiB9XG5cbmFzc2VydChcbm1heFJlbnRpbmdEdXJhdGlvblVuaXRzPj1taW5SZW50aW5nRHVyYXRpb25Vbml0cyxcbiBgUmVudGFsIGNvbmZpZ3VyYXRpb24gcGF0dGVybjogbWF4UmVudGluZ0R1cmF0aW9uVW5pdHMgJHttYXhSZW50aW5nRHVyYXRpb25Vbml0c30gbmVlZCB0byBiZSBoaWdoZXIgdGhhbiAke21pblJlbnRpbmdEdXJhdGlvblVuaXRzfSBgKTtcblxuIH07XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVudGFsUGhhc2V9IGN1cnJlbnRSZW50YWxQaGFzZVxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVudGFsUGhhc2V9IHJlbnRhbFBoYXNlXG4gKi8kaOKAjV9vbmNlLmFzc2VydFJlbnRhbENvbmZpZyhhc3NlcnRSZW50YWxDb25maWcpO1xuY29uc3QgICAgICAgIGFzc2VydFJlbnRhbFBoYXNlPShjdXJyZW50UmVudGFsUGhhc2UscmVudGFsUGhhc2UpPT57XG5hc3NlcnQoXG5jdXJyZW50UmVudGFsUGhhc2U9PT1yZW50YWxQaGFzZSxcbidyZW50YWxQaGFzZTogY3VycmVudCByZW50YWxQaGFzZSBpbnZhbGlkJyk7XG5cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlbnRhbENvbmZpZ30gcmVudGFsQ29uZmlnXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZW50aW5nVGllcn0gcmVudGluZ1RpZXJcbiAqLyRo4oCNX29uY2UuYXNzZXJ0UmVudGFsUGhhc2UoYXNzZXJ0UmVudGFsUGhhc2UpO1xuY29uc3QgICAgICAgIGFzc2VydFJlbnRpbmdUaWVyPShyZW50YWxDb25maWcscmVudGluZ1RpZXIpPT57XG5jb25zdHtyZW50aW5nVGllcjpjdXJyZW50UmVudGluZ1RpZXJ9PXJlbnRhbENvbmZpZztcbmFzc2VydChcbmN1cnJlbnRSZW50aW5nVGllcj09PXJlbnRpbmdUaWVyLFxuJ3JlbnRpbmdUaWVyOiBjdXJyZW50IHJlbnRpbmdUaWVyIGludmFsaWQnKTtcblxuIH07XG5cbi8qKlxuICpcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlbnRhbENvbmZpZ30gcmVudGFsQ29uZmlnXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdGltZScpLlJlbGF0aXZlVGltZVZhbHVlfSByZW50aW5nRHVyYXRpb25cbiAqLyRo4oCNX29uY2UuYXNzZXJ0UmVudGluZ1RpZXIoYXNzZXJ0UmVudGluZ1RpZXIpO1xuY29uc3QgICAgICAgIGFzc2VydFJlbnRpbmdEdXJhdGlvbj0ocmVudGFsQ29uZmlnLHJlbnRpbmdEdXJhdGlvbik9PntcbmNvbnN0e21pblJlbnRpbmdEdXJhdGlvblVuaXRzLG1heFJlbnRpbmdEdXJhdGlvblVuaXRzfT1yZW50YWxDb25maWc7XG5hc3NlcnQoXG5yZW50aW5nRHVyYXRpb24+PW1pblJlbnRpbmdEdXJhdGlvblVuaXRzLFxuJ1JlbnRpbmdEdXJhdGlvbjogcmVudGluZ0R1cmF0aW9uIGlzIGxvd2VyIHRoYW4gdGhlIG1pbmltdW0gc3BlY2lmaWVkJyk7XG5cbmFzc2VydChcbm1heFJlbnRpbmdEdXJhdGlvblVuaXRzPj1yZW50aW5nRHVyYXRpb24sXG4nUmVudGluZ0R1cmF0aW9uOiByZW50aW5nRHVyYXRpb24gaXMgaGlnaGVyIHRoYW4gdGhlIG1heGltdW0gc3BlY2lmaWVkJyk7XG5cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlbnRhbENvbmZpZ30gcmVudGFsQ29uZmlnXG4gKiBAcGFyYW0ge0Ftb3VudDxBc3NldEtpbmQ+fSB1dGlsaXR5QW1vdW50XG4gKi8kaOKAjV9vbmNlLmFzc2VydFJlbnRpbmdEdXJhdGlvbihhc3NlcnRSZW50aW5nRHVyYXRpb24pO1xuY29uc3QgICAgICAgIGFzc2VydFV0aWxpdHk9KHJlbnRhbENvbmZpZyx1dGlsaXR5QW1vdW50KT0+e1xuY29uc3R7dXRpbGl0eUFtb3VudDpjb25maWdVdGlsaXR5QW1vdW50fT1yZW50YWxDb25maWc7XG5jb25zdCBlbXB0eT1BbW91bnRNYXRoLm1ha2VFbXB0eUZyb21BbW91bnQodXRpbGl0eUFtb3VudCk7XG5cbmFzc2VydChcbkFtb3VudE1hdGguZ2V0VmFsdWUodXRpbGl0eUFtb3VudC5icmFuZCxlbXB0eSkhPT0wbixcbidVdGlsaXR5IG11c3QgYmUgYW4gTkZUJyk7XG5cbmFzc2VydChcbkFtb3VudE1hdGguaXNFcXVhbChjb25maWdVdGlsaXR5QW1vdW50LHV0aWxpdHlBbW91bnQpLFxuJ1RoZSBVdGlsaXR5IHByb3ZpZGVkIGlzIG5vdCBlcXVhbCB0byB0aGUgc3BlY2lmaWVkIG9uIHRoZSByZW50YWwgY29uZmlndXJhdGlvbicpO1xuXG4gfTtcblxuLyoqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZW50YWxDb25maWd8WGltcG9ydCgnLi90eXBlcy5qcycpLkJpZENvbmZpZ30gY29uZmlnXG4gKiBAcGFyYW0ge1pDRlNlYXR9IGJvcnJvd2VyU2VhdFxuICogQHBhcmFtIHtOYXRWYWx1ZX0gcmVudGluZ0R1cmF0aW9uXG4gKi8kaOKAjV9vbmNlLmFzc2VydFV0aWxpdHkoYXNzZXJ0VXRpbGl0eSk7XG5jb25zdCAgICAgICAgYXNzZXJ0UmVudGFsRmVlPShjb25maWcsYm9ycm93ZXJTZWF0LHJlbnRpbmdEdXJhdGlvbik9PntcbmNvbnN0e211bHRpcGx5fT1uYXRTYWZlTWF0aDtcblxuY29uc3R7cmVudGFsRmVlUGVyVW5pdEFtb3VudH09Y29uZmlnO1xuY29uc3R7dmFsdWU6ZmVlUGVyVW5pdCxicmFuZH09cmVudGFsRmVlUGVyVW5pdEFtb3VudDtcbmNvbnN0IHRvdGFsRmVlQW1vdW50PW11bHRpcGx5KGZlZVBlclVuaXQscmVudGluZ0R1cmF0aW9uKTtcbmNvbnN0IGFza2VkQW1vdW50PUFtb3VudE1hdGgubWFrZShicmFuZCx0b3RhbEZlZUFtb3VudCk7XG5cbmNvbnN0e1xuZ2l2ZTp7UmVudGFsRmVlOnJlbnRhbEZlZUFtb3VudH19PVxuYm9ycm93ZXJTZWF0LmdldFByb3Bvc2FsKCk7XG5cbmFzc2VydChcbkFtb3VudE1hdGguaXNHVEUocmVudGFsRmVlQW1vdW50LGFza2VkQW1vdW50KSxcbidSZW50YWxGZWU6IHJlbnRhbEZlZUFtb3VudCBkb2VzIG5vdCBjb3JyZXNwb25kIHRvIHRoZSBzcGVjaWZpZWQnKTtcblxuIH07XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVudGFsQ29uZmlnfFhpbXBvcnQoJy4vdHlwZXMuanMnKS5CaWRDb25maWd9IGNvbmZpZ1xuICogQHBhcmFtIHtaQ0ZTZWF0fSBib3Jyb3dlclNlYXRcbiAqLyRo4oCNX29uY2UuYXNzZXJ0UmVudGFsRmVlKGFzc2VydFJlbnRhbEZlZSk7XG5jb25zdCAgICAgICAgYXNzZXJ0Q29sbGF0ZXJhbD0oY29uZmlnLGJvcnJvd2VyU2VhdCk9PntcbmNvbnN0e2NvbGxhdGVyYWxBbW91bnQ6Y29uZmlnQ29sbGF0ZXJhbEFtb3VudH09Y29uZmlnO1xuY29uc3R7XG5naXZlOntDb2xsYXRlcmFsOmNvbGxhdGVyYWxBbW91bnR9fT1cbmJvcnJvd2VyU2VhdC5nZXRQcm9wb3NhbCgpO1xuXG5hc3NlcnQoXG5BbW91bnRNYXRoLmlzRXF1YWwoY29uZmlnQ29sbGF0ZXJhbEFtb3VudCxjb2xsYXRlcmFsQW1vdW50KSxcbidDb2xsYXRlcmFsOiBjb2xsYXRlcmFsQW1vdW50IGRvZXMgbm90IGNvcnJlc3BvbmQgdG8gdGhlIHNwZWNpZmllZCcpO1xuXG4gfTtcblxuLyoqIEBwYXJhbSB7QW1vdW50fSBhbW91bnQgKi8kaOKAjV9vbmNlLmFzc2VydENvbGxhdGVyYWwoYXNzZXJ0Q29sbGF0ZXJhbCk7XG5jb25zdCAgICAgICAgYXNzZXJ0QW1vdW50Tm90RW1wdHk9KGFtb3VudCk9PntcbmFzc2VydCghQW1vdW50TWF0aC5pc0VtcHR5KGFtb3VudCksJ0Ftb3VudCByZXF1ZXN0ZWQgbm90IGZvdW5kJyk7XG4gfTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuQmlkQ29uZmlnfSBiaWRDb25maWdcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlbnRhbENvbmZpZ30gcmVudGFsQ29uZmlnXG4gKi8kaOKAjV9vbmNlLmFzc2VydEFtb3VudE5vdEVtcHR5KGFzc2VydEFtb3VudE5vdEVtcHR5KTtcbmNvbnN0ICAgICAgICBhc3NlcnRCaWRDb25maWc9KHpjZixiaWRDb25maWcscmVudGFsQ29uZmlnKT0+e1xuY29uc3R7cmVudGluZ0R1cmF0aW9ufT1iaWRDb25maWc7XG5jb25zdHttaW5SZW50aW5nRHVyYXRpb25Vbml0cyxtYXhSZW50aW5nRHVyYXRpb25Vbml0c309cmVudGFsQ29uZmlnO1xuXG5tdXN0TWF0Y2goYmlkQ29uZmlnLG1ha2VCaWRDb25maWdHdWFyZCh6Y2YpLCdiaWNDb25maWcgaXMgaW52YWxpZCcpO1xuYXNzZXJ0KFxucmVudGluZ0R1cmF0aW9uPj1taW5SZW50aW5nRHVyYXRpb25Vbml0cyxcbidiaWRDb25maWc6IHJlbnRpbmdEdXJhdGlvbiBpcyBsb3dlciB0aGFuIHRoZSBtaW5pbXVtIHNwZWNpZmllZCcpO1xuXG5hc3NlcnQoXG5tYXhSZW50aW5nRHVyYXRpb25Vbml0cz49cmVudGluZ0R1cmF0aW9uLFxuJ2JpZENvbmZpZzogcmVudGluZ0R1cmF0aW9uIGlzIGhpZ2hlciB0aGFuIHRoZSBtYXhpbXVtIHNwZWNpZmllZCcpO1xuXG4gfTtcblxuLyoqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLkdyYWNlUGVyaW9kfSBncmFjZVBlcmlvZCAqLyRo4oCNX29uY2UuYXNzZXJ0QmlkQ29uZmlnKGFzc2VydEJpZENvbmZpZyk7XG5jb25zdCAgICAgICAgYXNzZXJ0R3JhY2VQZXJpb2Q9KGdyYWNlUGVyaW9kKT0+e1xuYXNzZXJ0KGdyYWNlUGVyaW9kLnN0YXJ0Lndha2VBdCE9PS0xbiwnQ2Fubm90IHNjaGVkdWxlIGEgd2FrZXVwIGZvciAtMW4nKTtcbmFzc2VydChncmFjZVBlcmlvZC5lbmQud2FrZUF0IT09LTFuLCdDYW5ub3Qgc2NoZWR1bGUgYSB3YWtldXAgZm9yIC0xbicpO1xuYXNzZXJ0KFxuZ3JhY2VQZXJpb2Quc3RhcnQuY2FuY2VsVG9rZW4sXG4nQ2FuY2VsIHRva2VuIGdyYWNlUGVyaW9kU3RhcnQgY2Fubm90IGJlIHVuZGVmaW5lZCcpO1xuXG5hc3NlcnQoXG5ncmFjZVBlcmlvZC5lbmQuY2FuY2VsVG9rZW4sXG4nQ2FuY2VsIHRva2VuIGdyYWNlUGVyaW9kRW5kIGNhbm5vdCBiZSB1bmRlZmluZWQnKTtcblxuIH07JGjigI1fb25jZS5hc3NlcnRHcmFjZVBlcmlvZChhc3NlcnRHcmFjZVBlcmlvZCk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiYXNzZXJ0UmVudGFsSGFuZGxlIjpbImFzc2VydFJlbnRhbEhhbmRsZSJdLCJhc3NlcnRSZW50YWxDb25maWciOlsiYXNzZXJ0UmVudGFsQ29uZmlnIl0sImFzc2VydFJlbnRhbFBoYXNlIjpbImFzc2VydFJlbnRhbFBoYXNlIl0sImFzc2VydFJlbnRpbmdUaWVyIjpbImFzc2VydFJlbnRpbmdUaWVyIl0sImFzc2VydFJlbnRpbmdEdXJhdGlvbiI6WyJhc3NlcnRSZW50aW5nRHVyYXRpb24iXSwiYXNzZXJ0VXRpbGl0eSI6WyJhc3NlcnRVdGlsaXR5Il0sImFzc2VydFJlbnRhbEZlZSI6WyJhc3NlcnRSZW50YWxGZWUiXSwiYXNzZXJ0Q29sbGF0ZXJhbCI6WyJhc3NlcnRDb2xsYXRlcmFsIl0sImFzc2VydEFtb3VudE5vdEVtcHR5IjpbImFzc2VydEFtb3VudE5vdEVtcHR5Il0sImFzc2VydEJpZENvbmZpZyI6WyJhc3NlcnRCaWRDb25maWciXSwiYXNzZXJ0R3JhY2VQZXJpb2QiOlsiYXNzZXJ0R3JhY2VQZXJpb2QiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA6F0b/UgJAABICQAAKAAAAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9iaWRIb2xkZXIuanN7ImltcG9ydHMiOlsiQGFnb3JpYy92YXQtZGF0YSIsIkBhZ29yaWMvem9lL3NyYy90eXBlR3VhcmRzLmpzIl0sImV4cG9ydHMiOlsicHJlcGFyZUJpZEhvbGRlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLHByZXBhcmVFeG9DbGFzc0tpdCxJbnN0YW5jZUhhbmRsZVNoYXBlOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dLFtcInByZXBhcmVFeG9DbGFzc0tpdFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4b0NsYXNzS2l0ID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy90eXBlR3VhcmRzLmpzXCIsIFtbXCJJbnN0YW5jZUhhbmRsZVNoYXBlXCIsIFskaOKAjV9hID0+IChJbnN0YW5jZUhhbmRsZVNoYXBlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG4vKiogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gYmFnZ2FnZSAqL1xuY29uc3QgICAgICAgIHByZXBhcmVCaWRIb2xkZXI9KGJhZ2dhZ2UpPT57XG5jb25zdCBtYWtlQmlkSG9sZGVyPXByZXBhcmVFeG9DbGFzc0tpdChcbmJhZ2dhZ2UsXG4nQmlkIEhvbGRlcicsXG57XG5wdWJsaWNUb3BpY3M6TS5pbnRlcmZhY2UoJ1B1YmxpY1N1YnNjcmliZXJzJyx7XG5nZXRPcGVuQmlkc1RvcGljczpNLmNhbGwoKS5yZXR1cm5zKE0uYW55KCkpfSksXG5cbmludml0YXRpb25NYWtlcnM6TS5pbnRlcmZhY2UoJ0ludml0YXRpb25NYWtlcnMnLHtcbnVwZGF0ZUJpZDpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmNhbmNlbEJpZDpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmJvcnJvd1V0aWxpdHk6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSl9KSxcblxuYmlkSG9sZGVyOk0uaW50ZXJmYWNlKCdCaWRNZXRob2RzJyx7XG5nZXRCaWRIYW5kbGU6TS5jYWxsKCkucmV0dXJucyhJbnN0YW5jZUhhbmRsZVNoYXBlKSxcbmdldEJpZEJ5SGFuZGxlOk0uY2FsbChJbnN0YW5jZUhhbmRsZVNoYXBlKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxuZ2V0V2lubmVyQmlkQnlJRDpNLmNhbGwoTS5udW1iZXIoKSkucmV0dXJucyhNLnJlY29yZCgpKX0pfSxcblxuXG4vKipcbiAqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5BdWN0aW9ufSBhdWN0aW9uXG4gKiBAcGFyYW0ge0hhbmRsZTwnQmlkJz59IGJpZEhhbmRsZVxuICovXG4oYXVjdGlvbixiaWRIYW5kbGUpPT57XG5yZXR1cm4gaGFyZGVuKHthdWN0aW9uLGJpZEhhbmRsZX0pO1xuIH0sXG57XG5wdWJsaWNUb3BpY3M6e1xuZ2V0T3BlbkJpZHNUb3BpY3MoKXtcbnJldHVybiB0aGlzLnN0YXRlLmF1Y3Rpb24uZ2V0T3BlbkJpZHNTdWJzY3JpYmVyKCk7XG4gfX0sXG5cbmludml0YXRpb25NYWtlcnM6e1xudXBkYXRlQmlkKCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5hdWN0aW9uLm1ha2VVcGRhdGVCaWRJbnZpdGF0aW9uKFxudGhpcy5zdGF0ZS5iaWRIYW5kbGUpO1xuXG4gfSxcbmNhbmNlbEJpZCgpe1xucmV0dXJuIHRoaXMuc3RhdGUuYXVjdGlvbi5tYWtlQ2FuY2VsQmlkSW52aXRhdGlvbihcbnRoaXMuc3RhdGUuYmlkSGFuZGxlKTtcblxuIH0sXG5ib3Jyb3dVdGlsaXR5KCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5hdWN0aW9uLm1ha2VCb3Jyb3dJbnZpdGF0aW9uKHRoaXMuc3RhdGUuYmlkSGFuZGxlKTtcbiB9fSxcblxuYmlkSG9sZGVyOntcbmdldEJpZEhhbmRsZSgpe1xuY29uc3R7YmlkSGFuZGxlfT10aGlzLnN0YXRlO1xucmV0dXJuIGJpZEhhbmRsZTtcbiB9LFxuLyoqIEBwYXJhbSB7SGFuZGxlPCdCaWQnPn0gYmlkSGFuZGxlICovXG5nZXRCaWRCeUhhbmRsZShiaWRIYW5kbGUpe1xucmV0dXJuIHRoaXMuc3RhdGUuYXVjdGlvbi5nZXRCaWRCeUhhbmRsZShiaWRIYW5kbGUpO1xuIH0sXG4vKiogQHBhcmFtIHtudW1iZXJ9IGJpZElEICovXG5nZXRXaW5uZXJCaWRCeUlEKGJpZElEKXtcbnJldHVybiB0aGlzLnN0YXRlLmF1Y3Rpb24uZ2V0V2lubmVyQmlkQnlJRChiaWRJRCk7XG4gfX19KTtcblxuXG5cblxucmV0dXJuIG1ha2VCaWRIb2xkZXI7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVCaWRIb2xkZXIocHJlcGFyZUJpZEhvbGRlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicHJlcGFyZUJpZEhvbGRlciI6WyJwcmVwYXJlQmlkSG9sZGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAK/vNJnKBQAAygUAACUAAABjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvYmlkS2l0LmpzeyJpbXBvcnRzIjpbIi4vYmlkSG9sZGVyLmpzIiwiQGFnb3JpYy96b2UvZXhwb3J0ZWQuanMiXSwiZXhwb3J0cyI6WyJwcmVwYXJlQmlkS2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHByZXBhcmVCaWRIb2xkZXI7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy96b2UvZXhwb3J0ZWQuanNcIiwgW11dLFtcIi4vYmlkSG9sZGVyLmpzXCIsIFtbXCJwcmVwYXJlQmlkSG9sZGVyXCIsIFskaOKAjV9hID0+IChwcmVwYXJlQmlkSG9sZGVyID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG4vKipcbiAqIEJpZGRlcnMgYXJlIGhhbmRlZCBhICdiaWRLaXQnIHRvIGZvbGxvdyB1cCBvbiB0aGVpciBpbnRlcmVzdCBpbiB0aGUgcmVudGFsLiBXZSBnaXZlIGJpZGRlciB0aGUgJ29wZW5CaWRzU3Vic2NyaWJlcidcbiAqIHRvIGtlZXAgdHJhY2sgb2Ygb3RoZXIgYmlkcyBhcyB3ZWxsIGFzIGEgc2V0IG9mIG1ldGhvZHMgZm9yIGZldGNoaW5nIGluZm9ybWF0aW9uIGFib3V0IHRoZSBiaWRkZXIncyBvd24gYmlkIGFuZCB0aGVcbiAqIHdpbm5lciBiaWQuIE5leHQgYWN0aW9ucyBmb3IgYmlkZGVyIGlzIGFsbG93ZWQgdG8gdGFrZSBpcyBpbiBgaW52aXRhdGlvbk1ha2Vyc2AuXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlQmlkS2l0PShiYWdnYWdlKT0+e1xuY29uc3QgbWFrZUJpZEhvbGRlcj1wcmVwYXJlQmlkSG9sZGVyKGJhZ2dhZ2UpO1xuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLkF1Y3Rpb259IGF1Y3Rpb25cbiAqIEBwYXJhbSB7SGFuZGxlPCdCaWQnPn0gYmlkSGFuZGxlXG4gKi9cbmNvbnN0IG1ha2VCaWRLaXQ9KGF1Y3Rpb24sYmlkSGFuZGxlKT0+e1xuY29uc3R7cHVibGljVG9waWNzLGludml0YXRpb25NYWtlcnMsYmlkSG9sZGVyfT1tYWtlQmlkSG9sZGVyKFxuYXVjdGlvbixcbmJpZEhhbmRsZSk7XG5cblxuY29uc3QgYmlkS2l0PWhhcmRlbih7XG5wdWJsaWNTdWJzY3JpYmVyczp7XG5vcGVuQmlkc1N1YnNjcmliZXI6cHVibGljVG9waWNzLmdldE9wZW5CaWRzVG9waWNzKCl9LFxuXG5pbnZpdGF0aW9uTWFrZXJzLFxuYmlkSG9sZGVyfSk7XG5cbnJldHVybiBiaWRLaXQ7XG4gfTtcbnJldHVybiBtYWtlQmlkS2l0O1xuIH07JGjigI1fb25jZS5wcmVwYXJlQmlkS2l0KHByZXBhcmVCaWRLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVCaWRLaXQiOlsicHJlcGFyZUJpZEtpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABa3eZikC0AAJAtAAAqAAAAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL2JpZHNNYW5hZ2VyLmpzeyJpbXBvcnRzIjpbIi4vY29uc3RhbnRzLmpzIiwiLi90eXBlR3VhcmRzLmpzIiwiQGFnb3JpYy90aW1lIiwiQGFnb3JpYy92YXQtZGF0YSIsIkBhZ29yaWMvem9lL2V4cG9ydGVkLmpzIiwiQGVuZG8vZXZlbnR1YWwtc2VuZCIsIkBlbmRvL2ZhciJdLCJleHBvcnRzIjpbInByZXBhcmVCaWRzTWFuYWdlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixwcmVwYXJlRXhvQ2xhc3MscHJlcGFyZUV4b0NsYXNzS2l0LHByb3ZpZGVEdXJhYmxlTWFwU3RvcmUsVGltZU1hdGgsQmlkUGhhc2UsQmlkc01hbmFnZXJIZWxwZXJJLEJpZHNNYW5hZ2VySTskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3pvZS9leHBvcnRlZC5qc1wiLCBbXV0sW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9mYXJcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcInByZXBhcmVFeG9DbGFzc1wiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4b0NsYXNzID0gJGjigI1fYSldXSxbXCJwcmVwYXJlRXhvQ2xhc3NLaXRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzc0tpdCA9ICRo4oCNX2EpXV0sW1wicHJvdmlkZUR1cmFibGVNYXBTdG9yZVwiLCBbJGjigI1fYSA9PiAocHJvdmlkZUR1cmFibGVNYXBTdG9yZSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3RpbWVcIiwgW1tcIlRpbWVNYXRoXCIsIFskaOKAjV9hID0+IChUaW1lTWF0aCA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvbnN0YW50cy5qc1wiLCBbW1wiQmlkUGhhc2VcIiwgWyRo4oCNX2EgPT4gKEJpZFBoYXNlID0gJGjigI1fYSldXV1dLFtcIi4vdHlwZUd1YXJkcy5qc1wiLCBbW1wiQmlkc01hbmFnZXJIZWxwZXJJXCIsIFskaOKAjV9hID0+IChCaWRzTWFuYWdlckhlbHBlckkgPSAkaOKAjV9hKV1dLFtcIkJpZHNNYW5hZ2VySVwiLCBbJGjigI1fYSA9PiAoQmlkc01hbmFnZXJJID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG4vKipcbiAqIFdlIGJyb3VnaHQgdG9nZXRoZXIgdGhlIGxvZ2ljIHJlcXVpcmVkIGZvciBpbXBsZW1lbnRpbmcgYXVjdGlvbnMuIFdlIGltcGxlbWVudCB0aGlzIGJlaGF2aW9yIGluIGEgZHVyYWJsZSBtYW5uZXIgYXNcbiAqIHdlbGwuXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMuanMnKS5UaW1lclNlcnZpY2V9IHRpbWVyXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlQmlkc01hbmFnZXI9KGJhZ2dhZ2UsdGltZXIpPT57XG5jb25zdCBtYWtlQ2FuY2VsVG9rZW49cHJlcGFyZUV4b0NsYXNzKFxuYmFnZ2FnZSxcbidCaWRDYW5jZWxUb2tlbicsXG51bmRlZmluZWQsXG4obGFiZWwpPT4oe2xhYmVsfSksXG57fSk7XG5cblxuLyoqXG4gKiBIb2xkcyB0d28gYmFzaWMgZHVyYWJsZSBtYXBzIHRoYXQga2VlcHMgdHJhY2sgb2YgYmlkcyB0aGF0IGFyZSBvcGVuIGFuZCB0aGUgd2lubmluZyBiaWQuXG4gKlxuICogV2UgaW5kZXggdGhlIGJpZHMgaW4gdHdvIHdheXMuIEJ5IGFuIElEIGFuZCBhIHVuaXF1ZSBoYW5kbGUuIEhhbmRsZSBpcyBzcGVjaWZpYyB0byB0aGUgYmlkZGVyIGFuZCBJRCBpcyBwdWJsaWMuXG4gKiBPbmx5IHRoZSB1c2VyIHdpdGggdGhlIGNvcnJlY3QgaGFuZGxlIGNhbiBzZW5kIG9mZmVycyByZWxhdGVkIHRvIHRoYXQgYmlkLlxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L3JlY29yZGVyLmpzJykuTWFrZVJlY29yZGVyS2l0fSBtYWtlUmVjb3JkZXJLaXRcbiAqIEBwYXJhbSB7U3RvcmFnZU5vZGV9IG9wZW5CaWRzU3RvcmFnZU5vZGVcbiAqIEBwYXJhbSB7U3RvcmFnZU5vZGV9IHdpbm5lckJpZHNTdG9yYWdlTm9kZVxuICogQHBhcmFtIHtudW1iZXJ9IHJlbnRhbENvdW50XG4gKi9cbmNvbnN0IGluaXRTdGF0ZT0oXG5tYWtlUmVjb3JkZXJLaXQsXG5vcGVuQmlkc1N0b3JhZ2VOb2RlLFxud2lubmVyQmlkc1N0b3JhZ2VOb2RlLFxucmVudGFsQ291bnQpPT5cbntcbi8qKiBAdHlwZSB7TWFwU3RvcmU8SGFuZGxlPCdCaWQnPiwgeyBiaWRJRDogbnVtYmVyLCBjYW5jZWxUb2tlbjogWGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcy5qcycpLkNhbmNlbFRva2VuLCBjb25maWd1cmF0aW9uOiBYaW1wb3J0KCcuL3R5cGVzJykuQmlkQ29uZmlnLCBkZWFkbGluZTogVGltZXN0YW1wLCBzdGF0dXM6IHVua25vd24gfT59ICovXG5jb25zdCBvcGVuQmlkc0xpc3Q9cHJvdmlkZUR1cmFibGVNYXBTdG9yZShiYWdnYWdlLCBgJHtyZW50YWxDb3VudH0tYmlkc2ApO1xuLyoqIEB0eXBlIHtNYXBTdG9yZTxudW1iZXIsIFhpbXBvcnQoJy4vdHlwZXMnKS5CaWRDb25maWc+fSAqL1xuY29uc3Qgd2lubmVyQmlkc0xpc3Q9cHJvdmlkZUR1cmFibGVNYXBTdG9yZShcbmJhZ2dhZ2UsXG4gYCR7cmVudGFsQ291bnR9LWFjY2VwdGVkQmlkc2ApO1xuXG5cbmNvbnN0IG9wZW5CaWRzS2l0PW1ha2VSZWNvcmRlcktpdChvcGVuQmlkc1N0b3JhZ2VOb2RlKTtcbmNvbnN0IHdpbm5lckJpZHNLaXQ9bWFrZVJlY29yZGVyS2l0KHdpbm5lckJpZHNTdG9yYWdlTm9kZSk7XG5cbnJldHVybiBoYXJkZW4oe1xub3BlbkJpZHNMaXN0LFxud2lubmVyQmlkc0xpc3QsXG5iaWRJRENvdW50OjAsXG53aW5uZXJCaWRJRENvdW50OjAsXG5vcGVuQmlkc0tpdCxcbndpbm5lckJpZHNLaXR9KTtcblxuIH07XG5cbmNvbnN0IG1ha2VCaWRzTWFuYWdlcj1wcmVwYXJlRXhvQ2xhc3NLaXQoXG5iYWdnYWdlLFxuJ0JpZHNNYW5hZ2VyJyxcbntcbmhlbHBlcjpCaWRzTWFuYWdlckhlbHBlckksXG5tYW5hZ2VyOkJpZHNNYW5hZ2VySX0sXG5cbmluaXRTdGF0ZSxcbntcbmhlbHBlcjp7XG4vKipcbiAqIFNpbmNlIGJpZHMgaGF2ZSBhbiBleHBpcmF0aW9uIHRpbWUgd2UgbXVzdCByZWdpc3RlciBhIHdha2V1cCBjYWxsIHRvIHRoZSB0aW1lciBzZXJ2aWNlIHRvIGtub3cgd2hlbiB0aGF0XG4gKiBleHBpcmF0aW9uIGFjdHVhbGx5IGhhcHBlbnMuIFdlIHJlZ2lzdGVyIHRoZSB3YWtldXAgY2FsbCBmb3IgYSBiaWQgaW4gdHdvIHNjZW5yaW9zLFxuICogLSBXaGVuIHRoZSBiaWQgaXMgY3JlYXRlZFxuICogLSBXaGVuIHRoZSBjb250cmFjdCBpcyB1cGdyYWRlZFxuICpcbiAqIFdlIHVzZSB0aGlzIG1ldGhvZCB0byBoYW5kbGUgYm90aCB0aG9zZSBzY2VuYXJpb3NcbiAqIEBwYXJhbSB7SGFuZGxlPCdCaWQnPn0gYmlkSGFuZGxlXG4gKi9cbnNldEV4cGlyYXRpb25UaW1lcihiaWRIYW5kbGUpe1xuY29uc29sZS5sb2coJ1JlZ2lzdGVyaW5nJyk7XG5jb25zdHtcbnN0YXRlOntvcGVuQmlkc0xpc3R9LFxuZmFjZXRzOntoZWxwZXJ9fT1cbnRoaXM7XG5cbmNvbnN0e2NhbmNlbFRva2VuLGRlYWRsaW5lfT1vcGVuQmlkc0xpc3QuZ2V0KGJpZEhhbmRsZSk7XG5jb25zb2xlLmxvZyh7XG5kZWFkbGluZX0pO1xuXG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdm9pZCovXG52b2lkIEUodGltZXIpLmNhbmNlbChjYW5jZWxUb2tlbik7XG5cbmNvbnN0IHdha2VyPUZhcignd2FrZXInLHtcbndha2UoKXtcbmNvbnNvbGUubG9nKCdXYWtpbmcgVVAhISEnKTtcbmhlbHBlci51cGRhdGVCaWRTdGF0ZShiaWRIYW5kbGUsJ3N0YXR1cycsQmlkUGhhc2UuRVhQSVJFRCk7XG52b2lkIGhlbHBlci5wdWJsaXNoQmlkU3RvcmFnZSgpO1xuIH19KTtcblxuXG5yZXR1cm4gRSh0aW1lcikuc2V0V2FrZXVwKGRlYWRsaW5lLHdha2VyLGNhbmNlbFRva2VuKTtcbiB9LFxuLyoqXG4gKiBQdWJsaXNoIHRoZSBvcGVuIGJpZHNcbiAqL1xucHVibGlzaEJpZFN0b3JhZ2UoKXtcbmNvbnN0e29wZW5CaWRzTGlzdCxvcGVuQmlkc0tpdH09dGhpcy5zdGF0ZTtcblxuY29uc3QgYmlkc1B1YmxpY0xpc3Q9W107XG5mb3IoY29uc3R7YmlkSUR9b2Ygb3BlbkJpZHNMaXN0LnZhbHVlcygpKXtcbmJpZHNQdWJsaWNMaXN0LnB1c2goYmlkSUQpO1xuIH1cblxucmV0dXJuIEUob3BlbkJpZHNLaXQucmVjb3JkZXIpLndyaXRlKGJpZHNQdWJsaWNMaXN0KTtcbiB9LFxuLyoqXG4gKiBQdWJsaXNoIHRoZSB3aW5uaW5nIGJpZFxuICovXG5wdWJsaXNoV2lubmVyQmlkc1N0b3JhZ2UoKXtcbmNvbnN0e3dpbm5lckJpZHNMaXN0LHdpbm5lckJpZHNLaXR9PXRoaXMuc3RhdGU7XG5cbmNvbnN0IHdpbm5lckJpZHNQdWJsaWNMaXN0PVtdO1xuZm9yKGNvbnN0IGJpZElEIG9mIHdpbm5lckJpZHNMaXN0LmtleXMoKSl7XG53aW5uZXJCaWRzUHVibGljTGlzdC5wdXNoKGJpZElEKTtcbiB9XG5cbnJldHVybiBFKHdpbm5lckJpZHNLaXQucmVjb3JkZXIpLndyaXRlKHdpbm5lckJpZHNQdWJsaWNMaXN0KTtcbiB9LFxuLyoqXG4gKiBCaWRTdGF0ZSBpcyB0aGUgaW5mb3JtYXRpb24gc3RvcmVkIGluIHRoZSBvcGVuIGJpZHMgc3RvcmFnZS4gU28gaXQgc2hvdWxkIGJlIHVwZGF0ZWQgd2hlbiB0aGUgYmlkIGlzXG4gKiB1cGRhdGVkLlxuICogQHBhcmFtIHtIYW5kbGU8J0JpZCc+fSBiaWRIYW5kbGVcbiAqIEBwYXJhbSB7UHJvcGVydHlLZXl9IGFyZ3VtZW50XG4gKiBAcGFyYW0ge3Vua25vd259IHZhbHVlXG4gKi9cbnVwZGF0ZUJpZFN0YXRlKGJpZEhhbmRsZSxhcmd1bWVudCx2YWx1ZSl7XG5jb25zdHtvcGVuQmlkc0xpc3R9PXRoaXMuc3RhdGU7XG5cbmNvbnN0IGN1cnJlbnRCaWRTdGF0ZT1vcGVuQmlkc0xpc3QuZ2V0KGJpZEhhbmRsZSk7XG5cbmNvbnN0IHVwZGF0ZWRCaWRTdGF0ZT17XG4uLi5jdXJyZW50QmlkU3RhdGUsXG5bYXJndW1lbnRdOnZhbHVlfTtcblxuXG5vcGVuQmlkc0xpc3Quc2V0KGJpZEhhbmRsZSxoYXJkZW4odXBkYXRlZEJpZFN0YXRlKSk7XG4gfSxcbi8qKlxuICogTmVlZCBhIGNhbmNlbCB0b2tlbiB0byB1bnJlZ2lzdGVyIG91ciB3YWtldXAgY2FsbCBmcm9tIHRoZSB0aW1lciBzZXJ2aWNlLiBXZSB1c2UgZHVyYWJsZSBoYW5kbGUgZm9yIHRoYXQuXG4gKiBAcGFyYW0ge0hhbmRsZTwnQmlkJz59IGJpZEhhbmRsZVxuICovXG5tYWtlQ2FuY2VsVG9rZW4oYmlkSGFuZGxlKXtcbnJldHVybiBtYWtlQ2FuY2VsVG9rZW4oIGBDYW5jZWxUb2tlbi0ke2JpZEhhbmRsZX1gKTtcbiB9LFxuLyoqXG4gKiBDYWxjdWxhdGVzIHRoZSBleGFjdCB0aW1lIHRoZSBiaWQgd2lsbCBiZSBleHBpcmVkLlxuICpcbiAqIC0gZXhwaXJhdGlvbkRlYWRsaW5lID0gZXhwaXJhdGlvblRpbWUoZHVyYXRpb24pICsgY3VycmVudFRpbWVzdGFtcFxuICogQHBhcmFtIHtSZWxhdGl2ZVRpbWV9IGV4cGlyYXRpb25UaW1lXG4gKi9cbiAgICAgIGFzeW5jIGNhbGN1bGF0ZURlYWRsaW5lKGV4cGlyYXRpb25UaW1lKXtcbmNvbnN0IG5vdz1hd2FpdCBFKHRpbWVyKS5nZXRDdXJyZW50VGltZXN0YW1wKCk7XG5yZXR1cm4gVGltZU1hdGguYWRkQWJzUmVsKG5vdyxleHBpcmF0aW9uVGltZSk7XG4gfX0sXG5cbi8qKlxuICogV2UgZXhwb3NlIHRoaXMgZmFjZXQgdG8gdGhlIHJlbnRhbFxuICovXG5tYW5hZ2VyOntcbmdldE9wZW5CaWRzU3Vic2NyaWJlcigpe1xuY29uc3R7b3BlbkJpZHNLaXR9PXRoaXMuc3RhdGU7XG5yZXR1cm4gb3BlbkJpZHNLaXQuc3Vic2NyaWJlcjtcbiB9LFxuZ2V0V2lubmVyQmlkc1N1YnNjcmliZXIoKXtcbmNvbnN0e3dpbm5lckJpZHNLaXR9PXRoaXMuc3RhdGU7XG5yZXR1cm4gd2lubmVyQmlkc0tpdC5zdWJzY3JpYmVyO1xuIH0sXG4vKiogQHBhcmFtIHtudW1iZXJ9IHdhbnRlZEJpZElEICovXG5nZXRCaWRCeUlEKHdhbnRlZEJpZElEKXtcbmNvbnN0e29wZW5CaWRzTGlzdH09dGhpcy5zdGF0ZTtcblxubGV0IHdhbnRlZEJpZEhhbmRsZTtcbmZvcihjb25zdFtiaWRIYW5kbGUsYmlkU3RhdGVdb2Ygb3BlbkJpZHNMaXN0LmVudHJpZXMoKSl7XG5jb25zdHtiaWRJRH09YmlkU3RhdGU7XG5pZih3YW50ZWRCaWRJRD09PWJpZElEKXtcbndhbnRlZEJpZEhhbmRsZT1iaWRIYW5kbGU7XG4gfVxuIH1cblxuYXNzZXJ0KFxud2FudGVkQmlkSGFuZGxlLFxuJ0JpZHNNYW5hZ2VyOiBUaGUgYmlkIHlvdSBhcmUgdHJ5aW5nIHRvIGdldCBpcyBub3QgcmVnaXN0ZXJlZCcpO1xuXG5cbmNvbnN0e2NvbmZpZ3VyYXRpb24sc3RhdHVzfT1vcGVuQmlkc0xpc3QuZ2V0KHdhbnRlZEJpZEhhbmRsZSk7XG5cbnJldHVybntjb25maWd1cmF0aW9uLHN0YXR1c307XG4gfSxcbi8qKiBAcGFyYW0ge0hhbmRsZTwnQmlkJz59IGJpZEhhbmRsZSAqL1xuZ2V0QmlkQnlIYW5kbGUoYmlkSGFuZGxlKXtcbmNvbnN0e29wZW5CaWRzTGlzdH09dGhpcy5zdGF0ZTtcbmFzc2VydChcbm9wZW5CaWRzTGlzdC5oYXMoYmlkSGFuZGxlKSxcbidCaWRzTWFuYWdlcjogVGhlIGJpZCB5b3UgYXJlIHRyeWluZyB0byBnZXQgaXMgbm90IHJlZ2lzdGVyZWQnKTtcblxuXG5yZXR1cm4gb3BlbkJpZHNMaXN0LmdldChiaWRIYW5kbGUpO1xuIH0sXG4vKiogQHBhcmFtIHtudW1iZXJ9IHdpbm5lckJpZElkICovXG5nZXRXaW5uZXJCaWRCeUlEKHdpbm5lckJpZElkKXtcbmNvbnN0e3dpbm5lckJpZHNMaXN0fT10aGlzLnN0YXRlO1xuYXNzZXJ0KFxud2lubmVyQmlkc0xpc3QuaGFzKHdpbm5lckJpZElkKSxcbidCaWRzTWFuYWdlcjogVGhlIHdpbm5lciBiaWQgeW91IGFyZSB0cnlpbmcgdG8gZ2V0IGlzIG5vdCByZWdpc3RlcmVkJyk7XG5cblxucmV0dXJuIHdpbm5lckJpZHNMaXN0LmdldCh3aW5uZXJCaWRJZCk7XG4gfSxcbi8qKlxuICogQWRkcyBhIG5ldyBiaWQgdG8gdGhlIG9wZW5CaWRzTGlzdC4gUmV0dXJucyBhbiBhcnJheSBvZiBwcm9taXNlcyB0aGF0IHdpbGwgcmVjb3JkZXJLaXQud3JpdGUgY29tcGxldGVzLlxuICogQHBhcmFtIHtIYW5kbGU8J0JpZCc+fSBiaWRIYW5kbGVcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcycpLkJpZENvbmZpZ30gYmlkQ29uZmlnXG4gKi9cbiAgICAgIGFzeW5jIGFkZEJpZChiaWRIYW5kbGUsYmlkQ29uZmlnKXtcbmNvbnN0e29wZW5CaWRzTGlzdCxiaWRJRENvdW50fT10aGlzLnN0YXRlO1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcblxuY29uc3QgZGVhZGxpbmU9YXdhaXQgaGVscGVyLmNhbGN1bGF0ZURlYWRsaW5lKFxuYmlkQ29uZmlnLmV4cGlyYXRpb25UaW1lKTtcblxuXG5hc3NlcnQoXG4hb3BlbkJpZHNMaXN0LmhhcyhiaWRIYW5kbGUpLFxuJ0JpZHNNYW5hZ2VyOiBUaGUgYmlkIHlvdSBhcmUgdHJ5aW5nIHRvIGFkZCBpcyBhbHJlYWR5IHJlZ2lzdGVyZWQnKTtcblxuXG5jb25zdCBjYW5jZWxUb2tlbj1oZWxwZXIubWFrZUNhbmNlbFRva2VuKGJpZEhhbmRsZSk7XG5cbmNvbnN0IGJpZFN0YXRlPWhhcmRlbih7XG5iaWRJRDpiaWRJRENvdW50LFxuY29uZmlndXJhdGlvbjpiaWRDb25maWcsXG5zdGF0dXM6QmlkUGhhc2UuQUNUSVZFLFxuY2FuY2VsVG9rZW4sXG5kZWFkbGluZX0pO1xuXG5cbnRoaXMuc3RhdGUuYmlkSURDb3VudD1iaWRJRENvdW50KzE7XG5cbm9wZW5CaWRzTGlzdC5pbml0KGJpZEhhbmRsZSxiaWRTdGF0ZSk7XG5jb25zdCBleHBSZWdpc3RlclA9dGhpcy5mYWNldHMuaGVscGVyLnNldEV4cGlyYXRpb25UaW1lcihiaWRIYW5kbGUpO1xuY29uc3QgcHVibGlzaFA9dGhpcy5mYWNldHMuaGVscGVyLnB1Ymxpc2hCaWRTdG9yYWdlKCk7XG5cbnJldHVybltleHBSZWdpc3RlclAscHVibGlzaFBdO1xuIH0sXG4vKipcbiAqIFVwZGF0ZXMgYW4gZXhpc3RpbmcgYmlkIGZyb20gdGhlIG9wZW5CaWRzTGlzdC4gUmV0dXJucyBhbiBhcnJheSBvZiBwcm9taXNlcyB0aGF0IHdpbGwgcmVjb3JkZXJLaXQud3JpdGUgY29tcGxldGVzLlxuICogQHBhcmFtIHtIYW5kbGU8J0JpZCc+fSBiaWRIYW5kbGVcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcycpLkJpZENvbmZpZ30gdXBkYXRlZEJpZENvbmZpZ1xuICovXG4gICAgICBhc3luYyB1cGRhdGVCaWQoYmlkSGFuZGxlLHVwZGF0ZWRCaWRDb25maWcpe1xuY29uc3R7b3BlbkJpZHNMaXN0fT10aGlzLnN0YXRlO1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcblxuLyogUHJvYmFibHkgYmV0dGVyIHRvIHNraXAgdGhpcyBpZiBleHBpcmF0aW9uVGltZSBpcyBub3QgdXBkYXRlZCovXG5jb25zdCBkZWFkbGluZT1hd2FpdCBoZWxwZXIuY2FsY3VsYXRlRGVhZGxpbmUoXG51cGRhdGVkQmlkQ29uZmlnLmV4cGlyYXRpb25UaW1lKTtcblxuXG5hc3NlcnQoXG5vcGVuQmlkc0xpc3QuaGFzKGJpZEhhbmRsZSksXG4nQmlkc01hbmFnZXI6IFRoZSBiaWQgeW91IGFyZSB0cnlpbmcgdG8gdXBkYXRlIGlzIG5vdCByZWdpc3RlcmVkJyk7XG5cblxuY29uc3R7c3RhdHVzfT1vcGVuQmlkc0xpc3QuZ2V0KGJpZEhhbmRsZSk7XG5cbmFzc2VydChcbnN0YXR1cz09PUJpZFBoYXNlLkFDVElWRSxcbidCaWRzTWFuYWdlcjogVGhlIGJpZCB5b3UgYXJlIHRyeWluZyB0byB1cGRhdGUgaGFzIGFuIGludmFsaWQgc3RhdHVzJyk7XG5cblxuaGVscGVyLnVwZGF0ZUJpZFN0YXRlKGJpZEhhbmRsZSwnY29uZmlndXJhdGlvbicsdXBkYXRlZEJpZENvbmZpZyk7XG5oZWxwZXIudXBkYXRlQmlkU3RhdGUoYmlkSGFuZGxlLCdkZWFkbGluZScsZGVhZGxpbmUpO1xuXG5jb25zdCBleHByVXBkYXRlUD1oZWxwZXIuc2V0RXhwaXJhdGlvblRpbWVyKGJpZEhhbmRsZSk7XG5jb25zdCBwdWJsaXNoUD1oZWxwZXIucHVibGlzaEJpZFN0b3JhZ2UoKTtcblxucmV0dXJuW2V4cHJVcGRhdGVQLHB1Ymxpc2hQXTtcbiB9LFxuLyoqIEBwYXJhbSB7SGFuZGxlPCdCaWQnPn0gYmlkSGFuZGxlICovXG5jYW5jZWxCaWQoYmlkSGFuZGxlKXtcbmNvbnN0e29wZW5CaWRzTGlzdH09dGhpcy5zdGF0ZTtcblxuYXNzZXJ0KFxub3BlbkJpZHNMaXN0LmhhcyhiaWRIYW5kbGUpLFxuJ0JpZHNNYW5hZ2VyOiBUaGUgYmlkIHlvdSBhcmUgdHJ5aW5nIHRvIGNhbmNlbCBpcyBub3QgcmVnaXN0ZXJlZCcpO1xuXG5cbmNvbnN0e3N0YXR1cyxjYW5jZWxUb2tlbn09b3BlbkJpZHNMaXN0LmdldChiaWRIYW5kbGUpO1xuXG5hc3NlcnQoXG5zdGF0dXM9PT1CaWRQaGFzZS5BQ1RJVkUsXG4nQmlkc01hbmFnZXI6IFRoZSBiaWQgeW91IGFyZSB0cnlpbmcgdG8gY2FuY2VsIGhhcyBhbiBpbnZhbGlkIHN0YXR1cycpO1xuXG5cbi8qIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby12b2lkKi9cbnZvaWQgRSh0aW1lcikuY2FuY2VsKGNhbmNlbFRva2VuKTtcbm9wZW5CaWRzTGlzdC5kZWxldGUoYmlkSGFuZGxlKTtcbnJldHVybiB0aGlzLmZhY2V0cy5oZWxwZXIucHVibGlzaEJpZFN0b3JhZ2UoKTtcbiB9LFxuLyoqXG4gKiBAcGFyYW0ge251bWJlcn0gYWNjZXB0ZWRCaWRJRFxuICogQHBhcmFtIHtSZWxhdGl2ZVRpbWV9IGFjY2VwdGVkV2FpdGluZ1BlcmlvZFxuICovXG4gICAgICBhc3luYyBhY2NlcHRCaWQoYWNjZXB0ZWRCaWRJRCxhY2NlcHRlZFdhaXRpbmdQZXJpb2Qpe1xuY29uc3R7b3BlbkJpZHNMaXN0fT10aGlzLnN0YXRlO1xuY29uc3R7aGVscGVyfT10aGlzLmZhY2V0cztcblxubGV0IGFjY2VwdGVkQmlkSGFuZGxlO1xuXG5mb3IoY29uc3RbYmlkSGFuZGxlLGJpZFN0YXRlXW9mIG9wZW5CaWRzTGlzdC5lbnRyaWVzKCkpe1xuY29uc3R7YmlkSUR9PWJpZFN0YXRlO1xuaWYoYWNjZXB0ZWRCaWRJRD09PWJpZElEKXtcbmFjY2VwdGVkQmlkSGFuZGxlPWJpZEhhbmRsZTtcbiB9XG4gfVxuXG5hc3NlcnQoXG5hY2NlcHRlZEJpZEhhbmRsZSxcbidCaWRzTWFuYWdlcjogVGhlIGJpZCB5b3UgYXJlIHRyeWluZyB0byBhY2NlcHQgaXMgbm90IHJlZ2lzdGVyZWQnKTtcblxuXG5jb25zdHtzdGF0dXN9PW9wZW5CaWRzTGlzdC5nZXQoYWNjZXB0ZWRCaWRIYW5kbGUpO1xuXG5hc3NlcnQoXG5zdGF0dXM9PT1CaWRQaGFzZS5BQ1RJVkUsXG4nQmlkc01hbmFnZXI6IFRoZSBiaWQgeW91IGFyZSB0cnlpbmcgdG8gYWNjZXB0IGhhcyBhbiBpbnZhbGlkIHN0YXR1cycpO1xuXG5cbmNvbnN0IGRlYWRsaW5lPWF3YWl0IGhlbHBlci5jYWxjdWxhdGVEZWFkbGluZShcbmFjY2VwdGVkV2FpdGluZ1BlcmlvZCk7XG4vKiBTZXQgZXhwaXJhdGlvbiBkZWFkbGluZSovXG5cbmhlbHBlci51cGRhdGVCaWRTdGF0ZShhY2NlcHRlZEJpZEhhbmRsZSwnc3RhdHVzJyxCaWRQaGFzZS5IT0xEKTtcbmhlbHBlci51cGRhdGVCaWRTdGF0ZShhY2NlcHRlZEJpZEhhbmRsZSwnZGVhZGxpbmUnLGRlYWRsaW5lKTtcblxuY29uc3QgZXhwUmVnaXN0ZXJQPWhlbHBlci5zZXRFeHBpcmF0aW9uVGltZXIoYWNjZXB0ZWRCaWRIYW5kbGUpO1xuY29uc3QgcHVibGlzaFA9aGVscGVyLnB1Ymxpc2hCaWRTdG9yYWdlKCk7XG5cbnJldHVybltleHBSZWdpc3RlclAscHVibGlzaFBdO1xuIH0sXG4vKiogQHBhcmFtIHtIYW5kbGU8J0JpZCc+fSBiaWRIYW5kbGUgKi9cbmZpbmlzaEF1Y3Rpb25Sb3VuZChiaWRIYW5kbGUpe1xuY29uc3R7b3BlbkJpZHNMaXN0LHdpbm5lckJpZHNMaXN0LHdpbm5lckJpZElEQ291bnR9PXRoaXMuc3RhdGU7XG5cbmNvbnN0e2NvbmZpZ3VyYXRpb259PW9wZW5CaWRzTGlzdC5nZXQoYmlkSGFuZGxlKTtcblxud2lubmVyQmlkc0xpc3QuaW5pdCh3aW5uZXJCaWRJRENvdW50LGNvbmZpZ3VyYXRpb24pO1xudGhpcy5zdGF0ZS53aW5uZXJCaWRJRENvdW50PXdpbm5lckJpZElEQ291bnQrMTtcblxuZm9yKGNvbnN0e2NhbmNlbFRva2VufW9mIG9wZW5CaWRzTGlzdC52YWx1ZXMoKSl7XG4vKiBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tdm9pZCovXG52b2lkIEUodGltZXIpLmNhbmNlbChjYW5jZWxUb2tlbik7XG4gfVxuXG5vcGVuQmlkc0xpc3QuY2xlYXIoKTtcbnRoaXMuc3RhdGUuYmlkSURDb3VudD0wO1xuXG5jb25zdCBwdWJsaXNoQmlkUD10aGlzLmZhY2V0cy5oZWxwZXIucHVibGlzaEJpZFN0b3JhZ2UoKTtcbmNvbnN0IHB1Ymxpc2hXaW5uZXJCaWRQPVxudGhpcy5mYWNldHMuaGVscGVyLnB1Ymxpc2hXaW5uZXJCaWRzU3RvcmFnZSgpO1xuXG5yZXR1cm5bcHVibGlzaEJpZFAscHVibGlzaFdpbm5lckJpZFBdO1xuIH0sXG4vKipcbiAqIFVzZWQgdG8gcmVnaXN0ZXIgZXhwaXJhdGlvbiBjYWxsYmFja3Mgb24gdGhlIHN0YXJ0dXBcbiAqL1xuc3RhcnQoKXtcbmNvbnN0e29wZW5CaWRzTGlzdH09dGhpcy5zdGF0ZTtcbmNvbnN0e2hlbHBlcn09dGhpcy5mYWNldHM7XG5jb25zb2xlLmxvZygnc3RhcnRpbmcnKTtcbmZvcihjb25zdCBiaWRIYW5kbGUgb2Ygb3BlbkJpZHNMaXN0LmtleXMoKSl7XG52b2lkIEUoaGVscGVyKS5zZXRFeHBpcmF0aW9uVGltZXIoYmlkSGFuZGxlKTtcbiB9XG4gfX19KTtcblxuXG5cblxucmV0dXJuIG1ha2VCaWRzTWFuYWdlcjtcbiB9O1xuLyoqIEB0eXBlZGVmIHtBd2FpdGVkPFJldHVyblR5cGU8UmV0dXJuVHlwZTx0eXBlb2YgcHJlcGFyZUJpZHNNYW5hZ2VyPj4+fSBCaWRzTWFuYWdlciAqLyRo4oCNX29uY2UucHJlcGFyZUJpZHNNYW5hZ2VyKHByZXBhcmVCaWRzTWFuYWdlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicHJlcGFyZUJpZHNNYW5hZ2VyIjpbInByZXBhcmVCaWRzTWFuYWdlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAC8qFCVmQwAAJkMAAAmAAAAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL2NhdGFsb2cuanN7ImltcG9ydHMiOlsiLi9hc3NlcnRpb25IZWxwZXJzLmpzIiwiLi9jb25zdGFudHMuanMiLCJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsibWFrZUNhdGFsb2ciXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcHJvdmlkZUR1cmFibGVNYXBTdG9yZSxhc3NlcnRSZW50YWxIYW5kbGUsQ0FUQUxPR19LRVk7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wicHJvdmlkZUR1cmFibGVNYXBTdG9yZVwiLCBbJGjigI1fYSA9PiAocHJvdmlkZUR1cmFibGVNYXBTdG9yZSA9ICRo4oCNX2EpXV1dXSxbXCIuL2Fzc2VydGlvbkhlbHBlcnMuanNcIiwgW1tcImFzc2VydFJlbnRhbEhhbmRsZVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0UmVudGFsSGFuZGxlID0gJGjigI1fYSldXV1dLFtcIi4vY29uc3RhbnRzLmpzXCIsIFtbXCJDQVRBTE9HX0tFWVwiLCBbJGjigI1fYSA9PiAoQ0FUQUxPR19LRVkgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuLyoqXG4gKiBDYXRhbG9nIGlzIHdoZXJlIHdlIGxpc3QgdGhlIHV0aWxpdGllcyB0aGF0IG93bmVycyB3YW50IHRvIHJlbnQuIEN1cnJlbnQgZGVzaWduIGlzIHRoZSBjbGllbnQgZmlyc3QgZmV0Y2hlcyBhbiBhcnJheVxuICogb2YgcmVudGFsIGhhbmRsZXMgYW5kIHVzaW5nIHRob3NlIGhhbmRsZXMgY2xpZW50IGNhbiBhY2Nlc3MgYSBjZXJ0YWluIHJlbnRhbCdzIHB1YmxpY0ZhY2V0LiBUaGlzIHBhdHRlcm4gaXMgbGlrZVxuICogaG93IHVzZXJzIGZpcnN0IGdldCBhIHZhdWx0TWFuYWdlciBieSBxdWVyeWluZyBpdCBmcm9tIHZhdWx0RmFjdG9yeSBieSB0aGUgdmF1bHRNYW5hZ2VyJ3MgY29sbGF0ZXJhbCBicmFuZC4gSG93ZXZlcixcbiAqIGdpdmVuIHRoYXQgb3VyIHN5c3RlbSBtdWNoIGxlc3MgY29tcGxleCB0aGFuIHRoZSB2YXVsdHMsIHRoaXMgcGF0dGVybiBtaWdodCBjYXVzZSBhbiB1bm5lY2Vzc2FyeSBpbmNvbnZlbmllbmNlIGZvclxuICogdGhlIGNsaWVudCdzIHVzZXIgZXhwZXJpZW5jZS4gU28gd2UgbWlnaHQgY2hhbmdlIHRoaXMgdG8gYSBzZXR1cCB3aGVyZSB3ZSBleHBvc2UgdGhlIHJlbnRhbCdzIHB1YmxpY0ZhY2V0IGRpcmVjdGx5XG4gKiBmcm9tIHRoZSBzdWJzY3JpYmVyKHJlY29yZGVyKSBpdHNlbGYuXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKi9cbmNvbnN0ICAgICAgICBtYWtlQ2F0YWxvZz1hc3luYyhiYWdnYWdlKT0+e1xuLyogV2Ugc3RvcmUgYWxsIHJlbnRhbHMgYWxvbmcgd2l0aCBhbGwgdGhlaXIgZmFjZXRzIGluIHRoaXMgZHVyYWJsZSBtYXAuIFRoaXMgaXMgaG93IHdlIHByZXNlcnZlIGFsbCByZW50YWxzLiovXG5jb25zdCBjYXRhbG9nU3RvcmFnZT1wcm92aWRlRHVyYWJsZU1hcFN0b3JlKGJhZ2dhZ2UsQ0FUQUxPR19LRVkpO1xuXG4vKiogQHBhcmFtIHtIYW5kbGU8J1JlbnRhbCc+fSByZW50YWxIYW5kbGUgKi9cbmNvbnN0IGdldFJlbnRhbEJ5SGFuZGxlPShyZW50YWxIYW5kbGUpPT57XG4vKiBPbmx5IGV4cG9zZSB0aGUgcHVibGljRmFjZXQqL1xuYXNzZXJ0KFxuY2F0YWxvZ1N0b3JhZ2UuaGFzKHJlbnRhbEhhbmRsZSksXG4nUmVudGFsSGFuZGxlIG5vdCBmb3VuZCBvbiBjYXRhbG9nU3RvcmFnZScpO1xuXG5cbmNvbnN0IHJlbnRhbFB1YmxpY0ZhY2V0PWNhdGFsb2dTdG9yYWdlLmdldChyZW50YWxIYW5kbGUpLnB1YmxpY0ZhY2V0O1xuY29uc3R7cmVudGFsSGFuZGxlOmV4cGVjdGVkUmVudGFsSGFuZGxlfT1cbnJlbnRhbFB1YmxpY0ZhY2V0LmdldENhdGFsb2dEYXRhKCk7XG5cbmFzc2VydFJlbnRhbEhhbmRsZShleHBlY3RlZFJlbnRhbEhhbmRsZSxyZW50YWxIYW5kbGUpO1xuXG5yZXR1cm4gcmVudGFsUHVibGljRmFjZXQ7XG4gfTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHtIYW5kbGU8J1JlbnRhbCc+fSByZW50YWxIYW5kbGVcbiAqIEBwYXJhbSB7e319IHJlbnRhbCAtIFhYWCBGSVhNRSBwcmVwYXJlUmVudGFsIHJldHVybiB0eXBlIChleG8gY2xhc3NraXQpXG4gKi9cbmNvbnN0IGFkZFJlbnRhbFRvQ2F0YWxvZz0ocmVudGFsSGFuZGxlLHJlbnRhbCk9PntcbmFzc2VydChcbiFjYXRhbG9nU3RvcmFnZS5oYXMocmVudGFsSGFuZGxlKSxcbidDYXRhbG9nOiByZW50YWxIYW5kbGUgYWxyZWFkeSBleGlzdHMgaW4gdGhlIGNhdGFsb2cnKTtcblxuY2F0YWxvZ1N0b3JhZ2UuaW5pdChyZW50YWxIYW5kbGUscmVudGFsKTtcbiB9O1xuXG4vKiogQHBhcmFtIHtIYW5kbGU8J1JlbnRhbCc+fSByZW50YWxIYW5kbGUgKi9cbmNvbnN0IHJlbW92ZVJlbnRhbEZyb21DYXRhbG9nPShyZW50YWxIYW5kbGUpPT57XG5hc3NlcnQoXG5jYXRhbG9nU3RvcmFnZS5oYXMocmVudGFsSGFuZGxlKSxcbidDYXRhbG9nOiByZW50YWxIYW5kbGUgZG9lcyBub3QgZXhpc3RzIGluIHRoZSBjYXRhbG9nJyk7XG5cblxuY2F0YWxvZ1N0b3JhZ2UuZGVsZXRlKHJlbnRhbEhhbmRsZSk7XG4gfTtcblxuLyoqXG4gKiBXZSBpdGVyYXRlIG92ZXIgYWxsIHJlbnRhbHMgdG8gcmVnaXN0ZXIgd2FrZXVwIGNhbGxiYWNrcyBvbiBldmVyeSBpbmNhcm5hdGlvbi5cbiAqL1xuY29uc3Qgc3RhcnRDYXRhbG9nSXRlbXM9KCk9PntcbmZvcihjb25zdCBjYXRhbG9nU3RvcmFnZUVsZW1lbnQgb2YgY2F0YWxvZ1N0b3JhZ2UudmFsdWVzKCkpe1xuY2F0YWxvZ1N0b3JhZ2VFbGVtZW50LnNlbGYuc3RhcnQoKTtcbiB9XG4gfTtcblxuY29uc3QgY2F0YWxvZ0ZhY2V0PWhhcmRlbih7XG5nZXRSZW50YWxCeUhhbmRsZSxcbmFkZFJlbnRhbFRvQ2F0YWxvZyxcbnJlbW92ZVJlbnRhbEZyb21DYXRhbG9nLFxuc3RhcnRDYXRhbG9nSXRlbXN9KTtcblxuXG5yZXR1cm4gY2F0YWxvZ0ZhY2V0O1xuIH07XG4vKiogQHR5cGVkZWYge0F3YWl0ZWQ8UmV0dXJuVHlwZTx0eXBlb2YgbWFrZUNhdGFsb2c+Pn0gQ2F0YWxvZyAqLyRo4oCNX29uY2UubWFrZUNhdGFsb2cobWFrZUNhdGFsb2cpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VDYXRhbG9nIjpbIm1ha2VDYXRhbG9nIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAMCrb+wwCAAAMAgAACgAAABjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvY29uc3RhbnRzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJCSURfRVhQSVJBVElPTl9VTklUIiwiQlJBTkRfVE9fS0VZV09SRF9LRVkiLCJCaWRQaGFzZSIsIkNBVEFMT0dfS0VZIiwiUGhhc2UiLCJSZW50aW5nRHVyYXRpb25Vbml0VG9TZWNvbmRzIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbXSk7ICAgLyogQHRzLWNoZWNrKi9cbi8qKlxuICogQ29uc3RhbnRzIGZvciBhIHJlbnRhbCBwaGFzZTpcbiAqXG4gKiBBVkFJTEFCTEUgOiBleHBvc2VkIGluIHRoZSBjYXRhbG9nO1xuICogQVVDVElPTiA6IHJlY2VpdmluZyBiaWRzIGFuZCBhdWN0aW9uIGRlYWRsaW5lIG5vdCByZWFjaGVkXG4gKiBIT0xEIDogYSBiaWQgd2FzIGFjY2VwdGVkIGJ5IHRoZSBvd25lciBidXQgbm90IGJvcnJvd2VkIHlldFxuICogUkVOVEVEIDogYm9ycm93ZXIgaGFzIHJlbnRlZCB0aGUgTkZUXG4gKiBHUkFDRV9QRVJJT0Q6IHRoZSByZW50YWwgZGVhZGxpbmUgaXMgb3ZlciBhbmQgdGhlIGJvcnJvd2VyIGNhbiByZXR1cm4gdGhlIE5GVCBhbmQgd2l0aGRyYXcgdGhlIGNvbGxhdGVyYWxcbiAqIExJUVVJREFUSU9OOiB0aGUgb3duZXIgY2FuIHdpdGhkcmF3IHRoZSBjb2xsYXRlcmFsXG4gKiBSRU1PVkVEIDogbm8gbG9uZ2VyIGF2YWlsYWJsZSB0byBiZSByZW50ZWRcbiAqIEB0eXBlIHtSZWNvcmQ8c3RyaW5nLFhpbXBvcnQoJy4vdHlwZXMnKS5SZW50YWxQaGFzZT59XG4gKi9cbmNvbnN0ICAgICAgICBQaGFzZT17XG5BVkFJTEFCTEU6J2F2YWlsYWJsZScsXG5IT0xEOidob2xkJyxcblJFTlRFRDoncmVudGVkJyxcbkdSQUNFX1BFUklPRDonZ3JhY2VQZXJpb2QnLFxuTElRVUlEQVRJT046J2xpcXVpZGF0aW9uJyxcblJFTU9WRUQ6J3JlbW92ZWQnfTskaOKAjV9vbmNlLlBoYXNlKFBoYXNlKTtcblxuXG5jb25zdCAgICAgICAgUmVudGluZ0R1cmF0aW9uVW5pdFRvU2Vjb25kcz17XG5taW51dGU6NjBuLC8qIE1vc3RseSBmb3IgdGVzdGluZyovXG5ob3VyOjM2MDBuLC8qIHVwZGF0ZSB0byAzNjAwbiAoNW4gaXMgZm9yIHRlc3RpbmcgcHVycG9zZSkqL1xuZGF5Ojg2NDAwbixcbndlZWs6NjA0ODAwbn07JGjigI1fb25jZS5SZW50aW5nRHVyYXRpb25Vbml0VG9TZWNvbmRzKFJlbnRpbmdEdXJhdGlvblVuaXRUb1NlY29uZHMpO1xuXG5cbmNvbnN0ICAgICAgICBDQVRBTE9HX0tFWT0nY2F0YWxvZ0l0ZW1zJzskaOKAjV9vbmNlLkNBVEFMT0dfS0VZKENBVEFMT0dfS0VZKTtcbmNvbnN0ICAgICAgICBCUkFORF9UT19LRVlXT1JEX0tFWT0nYnJhbmRUb0tleXdvcmQnO1xuXG4vKiogQHR5cGUge1JlY29yZDxzdHJpbmcsWGltcG9ydCgnLi90eXBlcycpLkJpZFBoYXNlPn0gKi8kaOKAjV9vbmNlLkJSQU5EX1RPX0tFWVdPUkRfS0VZKEJSQU5EX1RPX0tFWVdPUkRfS0VZKTtcbmNvbnN0ICAgICAgICBCaWRQaGFzZT17XG5BQ1RJVkU6J2FjdGl2ZScsXG5IT0xEOidob2xkJyxcbkVYUElSRUQ6J2V4cGlyZWQnfTskaOKAjV9vbmNlLkJpZFBoYXNlKEJpZFBoYXNlKTtcblxuXG5jb25zdCAgICAgICAgQklEX0VYUElSQVRJT05fVU5JVD0xMG4qNjBuOyRo4oCNX29uY2UuQklEX0VYUElSQVRJT05fVU5JVChCSURfRVhQSVJBVElPTl9VTklUKTtcbmhhcmRlbihCSURfRVhQSVJBVElPTl9VTklUKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJQaGFzZSI6WyJQaGFzZSJdLCJSZW50aW5nRHVyYXRpb25Vbml0VG9TZWNvbmRzIjpbIlJlbnRpbmdEdXJhdGlvblVuaXRUb1NlY29uZHMiXSwiQ0FUQUxPR19LRVkiOlsiQ0FUQUxPR19LRVkiXSwiQlJBTkRfVE9fS0VZV09SRF9LRVkiOlsiQlJBTkRfVE9fS0VZV09SRF9LRVkiXSwiQmlkUGhhc2UiOlsiQmlkUGhhc2UiXSwiQklEX0VYUElSQVRJT05fVU5JVCI6WyJCSURfRVhQSVJBVElPTl9VTklUIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAGydoQZjHgAAYx4AACYAAABjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvY3JhYmJsZS5qc3siaW1wb3J0cyI6WyIuL2Fzc2VydGlvbkhlbHBlcnMuanMiLCIuL2NhdGFsb2cuanMiLCIuL3JlbnRhbC5qcyIsIi4vdXRpbHMuanMiLCJAYWdvcmljL2VydHAiLCJAYWdvcmljL2dvdmVybmFuY2UiLCJAYWdvcmljL3ZhdC1kYXRhIiwiQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC9pbmRleC5qcyIsIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvcmVjb3JkZXIuanMiLCJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vZmFyIl0sImV4cG9ydHMiOlsicHJlcGFyZSJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBFLEZhcixNLHByZXBhcmVFeG8scHJvdmlkZSxBbW91bnRTaGFwZSxwcmVwYXJlUmVjb3JkZXJLaXRNYWtlcnMscHJvdmlkZUFsbCxoYW5kbGVQYXJhbUdvdmVybmFuY2UscHVibGljTWl4aW5BUEksYXNzZXJ0UmVudGFsQ29uZmlnLGFzc2VydFV0aWxpdHksbWFrZUNhdGFsb2cscHJlcGFyZVJlbnRhbEhlbHBlcixpbml0SXNzdWVycyxwcm92aWRlQnJhbmRUb0tleXdvcmRNYXAsbG9nZ2VyOyRo4oCNX2ltcG9ydHMoW1tcIkBlbmRvL2V2ZW50dWFsLXNlbmRcIiwgW1tcIkVcIiwgWyRo4oCNX2EgPT4gKEUgPSAkaOKAjV9hKV1dXV0sW1wiQGVuZG8vZmFyXCIsIFtbXCJGYXJcIiwgWyRo4oCNX2EgPT4gKEZhciA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJwcmVwYXJlRXhvXCIsIFskaOKAjV9hID0+IChwcmVwYXJlRXhvID0gJGjigI1fYSldXSxbXCJwcm92aWRlXCIsIFskaOKAjV9hID0+IChwcm92aWRlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvZXJ0cFwiLCBbW1wiQW1vdW50U2hhcGVcIiwgWyRo4oCNX2EgPT4gKEFtb3VudFNoYXBlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvcmVjb3JkZXIuanNcIiwgW1tcInByZXBhcmVSZWNvcmRlcktpdE1ha2Vyc1wiLCBbJGjigI1fYSA9PiAocHJlcGFyZVJlY29yZGVyS2l0TWFrZXJzID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvaW5kZXguanNcIiwgW1tcInByb3ZpZGVBbGxcIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVBbGwgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9nb3Zlcm5hbmNlXCIsIFtbXCJoYW5kbGVQYXJhbUdvdmVybmFuY2VcIiwgWyRo4oCNX2EgPT4gKGhhbmRsZVBhcmFtR292ZXJuYW5jZSA9ICRo4oCNX2EpXV0sW1wicHVibGljTWl4aW5BUElcIiwgWyRo4oCNX2EgPT4gKHB1YmxpY01peGluQVBJID0gJGjigI1fYSldXV1dLFtcIi4vYXNzZXJ0aW9uSGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0UmVudGFsQ29uZmlnXCIsIFskaOKAjV9hID0+IChhc3NlcnRSZW50YWxDb25maWcgPSAkaOKAjV9hKV1dLFtcImFzc2VydFV0aWxpdHlcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFV0aWxpdHkgPSAkaOKAjV9hKV1dXV0sW1wiLi9jYXRhbG9nLmpzXCIsIFtbXCJtYWtlQ2F0YWxvZ1wiLCBbJGjigI1fYSA9PiAobWFrZUNhdGFsb2cgPSAkaOKAjV9hKV1dXV0sW1wiLi9yZW50YWwuanNcIiwgW1tcInByZXBhcmVSZW50YWxIZWxwZXJcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVSZW50YWxIZWxwZXIgPSAkaOKAjV9hKV1dXV0sW1wiLi91dGlscy5qc1wiLCBbW1wiaW5pdElzc3VlcnNcIiwgWyRo4oCNX2EgPT4gKGluaXRJc3N1ZXJzID0gJGjigI1fYSldXSxbXCJwcm92aWRlQnJhbmRUb0tleXdvcmRNYXBcIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVCcmFuZFRvS2V5d29yZE1hcCA9ICRo4oCNX2EpXV0sW1wibG9nZ2VyXCIsIFskaOKAjV9hID0+IChsb2dnZXIgPSAkaOKAjV9hKV1dXV1dKTsgICBcblxuXG5cblxuXG5cblxuXG5cblxuXG5cbi8qKlxuICogUm9vdCBtb2R1bGUgZm9yIENyYWJibGUgUHJvdG9jb2wuIENyYWJibGUgaXMgYSBwcm90b2NvbCB0aGF0IGVuYWJsZXMgdGhlIG93bmVycyBvZiBORlRzIHdpdGggdXRpbGl0eSB0byBlYXJuIGluY29tZVxuICogd2hpbGUgb3RoZXIgdXNlcnMgY2FuIG1ha2UgdXNlIG9mIHRoYXQgTkZUcyB1dGlsaXR5LiBDcmFiYmxlIGlzIHdoZXJlIHBlb3BsZSBjYW4gYm9ycm93IHRoZSBORlRzIGxpc3RlZCBpbiB0aGUgY2F0YWxvZ1xuICogc28gdGhhdCB0aGV5IGNhbiBiZW5lZml0IGl0cyB1dGlsaXR5IHRoZW4gcmV0dXJuIGl0IHdoZW4gdGhleSdyZSBkb25lLiBDcmFiYmxlIGFsc28gcHJvdGVjdHMgdGhlIG93bmVyIGJ5IGZvcmNpbmcgdGhlXG4gKiBib3Jyb3dlciB0byBlc2Nyb3cgYSBjb2xsYXRlcmFsIGFjY2VwdGVkIGJ5IHRoZSBvd25lciB0byBtaW5pbWl6ZSB0aGUgcmlzay4gVGhlIHRlcm1zIG9mIHRoaXMgcmVudGluZyBwcm9jZXNzIGFyZVxuICogcHJlZGV0ZXJtaW5lZCBpbiB0aGUgcmVsZXZhbnQgY29uZmlndXJhdGlvbnMuIENyYWJibGUgc3VwcG9ydHMgdHdvIHR5cGVzIG9mIHJlbnRpbmc7XG4gKiAxLiBBZC1Ib2M6IEJvcnJvd2VycyBtdXN0IGdpdmUgdGhlIGNvbGxhdGVyYWwgYW5kIHJlbnRpbmcgZmVlIHNwZWNpZmllZCBieSB0aGUgb3duZXIgYmVmb3JlaGFuZC5cbiAqIDIuIEF1Y3Rpb246IEJvcnJvd2VycyBjYW4gYmlkIG9uIHRoZSB1dGlsaXR5IGFuZCB0aGUgb3duZXJzIGFjY2VwdCBvbmUgb2YgdGhlIGJpZHMgdGhhdCB0aGV5IGxpa2UgdGhlIG1vc3QuXG4gKlxuICogS2V5d29yZHMgdG8gdW5kZXJzdGFuZCB0aGUgc291cmNlIGNvZGUgYmV0dGVyO1xuICogLSBSZW50YWw6IEFuIG9iamVjdCB0aGF0IGVzY3Jvd3MgdGhlIHV0aWxpdHkgTkZUIGFuZCBob2xkcyB0aGUgcmVxdWlyZWQgbG9naWMgb3ZlciB0aGUgYXNzZXQncyBsaWZlY3ljbGUgaW4gdGhlXG4gKiBwcm90b2NvbC5cbiAqIC0gUmVudGluZ1RpZXI6IEVpdGhlciAnQWQtSG9jJyBvciAnQXVjdGlvbidcbiAqIC0gQmlkOiBGb3IgdGhlIGxpc3RlZCB1dGlsaXRpZXMgd2l0aCB0aGUgcmVudGluZ1RpZXIgPSBBdWN0aW9uLCBib3Jyb3dlcnMgc3VibWl0IGEgYmlkIHdoZXJlIHRoZXkgc3BlY2lmeSB0aGVpclxuICogY29sbGF0ZXJhbCwgcmVudGluZ0ZlZSwgcmVudGluZ0R1cmF0aW9uIGV0Yy4gT25jZSBhIGJpZCBpcyBzdWJtaXR0ZWQsIHRoZSBiaWRkZXIgaXMgaGFuZGVkIGEgYmlkS2l0IHdoaWNoIGVuYWJsZXMgdGhlXG4gKiBiaWRkZXIgdGFrZSBmdXJ0aGVyIGFjdGlvbnMgYWNjb3JkaW5nIHRvIHRoZSBvd25lcidzIHJlc3BvbnNlLlxuICogLSBMZWFzZTogT25jZSB0aGUgdXRpbGl0eSBpcyBoYW5kZWQgdG8gYSBib3Jyb3dlciBhIGxlYXNlIGlzIGNyZWF0ZWQuIFRoZSBsZWFzZSBpcyBtYW5hZ2VkIGJ5IGEgbGVhc2VLaXQgd2hpY2ggZW5hYmxlc1xuICogdGhlIGJvcnJvd2VyIHRvIHRha2UgZnVydGhlciBhY3Rpb25zIHJlbGF0ZWQgdG8gdGhlIGJvcnJvd2VkIGFzc2V0IHN1Y2ggYXMgcmV0dXJuaW5nIHRoZSB1dGlsaXR5LlxuICogLSBHcmFjZVBlcmlvZDogRHVyYXRpb24gb2YgdGltZSB0aGUgYm9ycm93ZXIgaXMgZ2l2ZW4gdG8gcmV0dXJuIHRoZSB1dGlsaXR5IGFmdGVyIHRoZSByZW50aW5nIGR1cmF0aW9uIGlzIG92ZXIuIE9uY2VcbiAqIHRoaXMgZHVyYXRpb24gZW5kcyB0aGUgY29sbGF0ZXJhbCBpcyBsaXF1aWRhdGVkLlxuICogLSBDb2xsYXRlcmFsOiBUaGUgYXNzZXQgZXNjcm93ZWQgYnkgQ3JhYmJsZSB0byBzZWN1cmUgdGhlIG93bmVyIGluY2FzZSB0aGUgYm9ycm93ZXIgcmVmdXNlcyB0byByZXR1cm4gdGhlIHV0aWxpdHkuXG4gKiBUaGlzIGNvbGxhdGVyYWwgbWlnaHQgYmUgZnVuZ2libGUgb3Igbm9uLWZ1bmdpYmxlIGRlcGVuZGluZyBvbiB0aGUgb3duZXIncyBjaG9pY2UuXG4gKiAtIExpcXVpZGF0aW9uOiBUaGUgdGVybSAnbGlxdWlkYXRpb24nIGluIENyYWJibGUgY29udGV4dCBtZWFucyB0aGUgb3duZXIgaXMgYWxsb3dlZCB0byB3aXRoZHJhdyB0aGUgY29sbGF0ZXJhbC5cbiAqXG4gKiBAcGFyYW0ge1pDRjxYaW1wb3J0KCcuL3R5cGVzLmpzJykuQ3JhYmJsZVRlcm1zPn0gemNmXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5DcmFiYmxlUHJpdmF0ZUFyZ3N9IHByaXZhdGVBcmdzXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKi9cbmNvbnN0IHByZXBhcmU9YXN5bmMoemNmLHByaXZhdGVBcmdzLGJhZ2dhZ2UpPT57XG5jb25zdHttYXJzaGFsbGVyLHN0b3JhZ2VOb2RlLHRpbWVyLGluaXRpYWxQb3Nlckludml0YXRpb259PVxucHJpdmF0ZUFyZ3M7XG5cbmNvbnN0e2Fnb3JpY05hbWVzfT16Y2YuZ2V0VGVybXMoKTtcblxucHJvdmlkZShiYWdnYWdlLCdyZW50YWxDb3VudCcsKCk9PjApO1xuY29uc3R7bWFrZVJlY29yZGVyS2l0fT1wcmVwYXJlUmVjb3JkZXJLaXRNYWtlcnMoXG5iYWdnYWdlLFxuLyogQHRzLWV4cGVjdC1lcnJvciBFbmRvIHZlcnNpb24gbWlzbWF0Y2gqL1xubWFyc2hhbGxlcik7XG5cblxuLyogQ3JlYXRlIGEgZHVyYWJsZSBjaGlsZCBzdG9yYWdlIG5vZGUqL1xuY29uc3R7cmVudGFsU3RvcmFnZU5vZGV9PWF3YWl0IHByb3ZpZGVBbGwoYmFnZ2FnZSx7XG5yZW50YWxTdG9yYWdlTm9kZTooKT0+RShzdG9yYWdlTm9kZSkubWFrZUNoaWxkTm9kZSgncmVudGFscycpLFxuc2F2ZUlzc3VlcnM6KCk9PmluaXRJc3N1ZXJzKGFnb3JpY05hbWVzLHpjZil9KTtcblxucHJvdmlkZUJyYW5kVG9LZXl3b3JkTWFwKGJhZ2dhZ2UsemNmKTsvKiBNdXN0IGNhbGwgdGhpcyBhZnRlciBwcm92aWRlQWxsKi9cblxuY29uc3RbcGFyYW1Hb3Zlcm5hbmNlRmFjZXQsY2F0YWxvZ0ZhY2V0XT1hd2FpdCBQcm9taXNlLmFsbChbXG5oYW5kbGVQYXJhbUdvdmVybmFuY2UoXG4vKiBAdHMtZXhwZWN0LWVycm9yIEZJWE1FIGNyYWJibGVHb3Zlcm5vciovXG56Y2YsXG5pbml0aWFsUG9zZXJJbnZpdGF0aW9uLFxue30sXG5zdG9yYWdlTm9kZSxcbm1hcnNoYWxsZXIpLFxuXG5tYWtlQ2F0YWxvZyhiYWdnYWdlKV0pO1xuXG5cbmNvbnN0e21ha2VEdXJhYmxlR292ZXJub3JGYWNldCxwdWJsaWNNaXhpbn09cGFyYW1Hb3Zlcm5hbmNlRmFjZXQ7XG4vKiBFeHBvc2UgdGhlc2UgdmlhIHB1YmxpY0ZhY2V0LCB0aGV5J3JlIG5lZWRlZCB0byBhY2Nlc3MgcmVudGFscyBmcm9tIG91dHNpZGUgd29ybGQqL1xuY29uc3R7Z2V0UmVudGFsQnlIYW5kbGV9PWNhdGFsb2dGYWNldDtcblxuY29uc3QgbWFrZVJlbnRhbEhlbHBlcj1wcmVwYXJlUmVudGFsSGVscGVyKFxuemNmLFxuY2F0YWxvZ0ZhY2V0LFxuYmFnZ2FnZSxcbnRpbWVyLFxubWFrZVJlY29yZGVyS2l0KTtcblxuXG5jYXRhbG9nRmFjZXQuc3RhcnRDYXRhbG9nSXRlbXMoKTsvKiBNdXN0IGNhbGwgdGhpcyBhZnRlciBwcmVwYXJlUmVudGFsKCkqL1xuXG4vKipcbiAqIEFkZCBuZXcgcmVudGFsXG4gKlxuICogQHBhcmFtIHtaQ0ZTZWF0fSBvd25lclNlYXRcbiAqIEBwYXJhbSB7e3JlbnRhbENvbmZpZzogWGltcG9ydCgnLi90eXBlcy5qcycpLlJlbnRhbENvbmZpZ318dW5kZWZpbmVkfSBvZmZlckFyZ3NcbiAqL1xuY29uc3QgbWFrZVJlbnRhbEhvb2s9YXN5bmMob3duZXJTZWF0LG9mZmVyQXJncyk9PntcbmFzc2VydChvZmZlckFyZ3M/LnJlbnRhbENvbmZpZywncmVudGFsQ29uZmlnIG5vdCBwcm92aWRlZC4nKTsvKiBYWFggcGF0dGVybiBtYXRjaGVyIGlzIGJldHRlciBoZXJlISovXG5jb25zdHtyZW50YWxDb25maWd9PW9mZmVyQXJncztcbmNvbnN0e1xuZ2l2ZTp7VXRpbGl0eTp1dGlsaXR5QW1vdW50fX09XG5vd25lclNlYXQuZ2V0UHJvcG9zYWwoKTtcblxuYXNzZXJ0UmVudGFsQ29uZmlnKHpjZixyZW50YWxDb25maWcpO1xuYXNzZXJ0VXRpbGl0eShyZW50YWxDb25maWcsdXRpbGl0eUFtb3VudCk7XG5cbmxvZ2dlcignSU5GTycsJ0NyZWF0aW5nIG5ldyByZW50YWwuLi4nLHtcbnJlbnRhbENvbmZpZyxcbnV0aWxpdHk6dXRpbGl0eUFtb3VudH0pO1xuXG5cbmNvbnN0IHJlbnRhbENvdW50PWJhZ2dhZ2UuZ2V0KCdyZW50YWxDb3VudCcpO1xubG9nZ2VyKCdERUJVRycsJ1dhaXRpbmcgZm9yIG1ha2VSZW50YWxIZWxwZXIoKSB0byByZXNvbHZlLi4uJyk7XG5jb25zdHtyZW50YWwscmVudGFsSGFuZGxlfT1hd2FpdCBtYWtlUmVudGFsSGVscGVyKFxucmVudGFsU3RvcmFnZU5vZGUsXG5yZW50YWxDb3VudCxcbnJlbnRhbENvbmZpZyk7XG5cbmNvbnN0IHJlbnRhbEtpdD1yZW50YWwuY3JhYmJsZS5pbml0UmVudGFsS2l0KG93bmVyU2VhdCk7XG5jYXRhbG9nRmFjZXQuYWRkUmVudGFsVG9DYXRhbG9nKHJlbnRhbEhhbmRsZSxyZW50YWwpO1xuYmFnZ2FnZS5zZXQoJ3JlbnRhbENvdW50JyxyZW50YWxDb3VudCsxKTtcblxubG9nZ2VyKCdJTkZPJywnTmV3IHJlbnRhbCBjcmVhdGVkIHN1Y2Nlc3NmdWxseScpO1xucmV0dXJuIHJlbnRhbEtpdDtcbiB9O1xuXG5jb25zdCBtYWtlUmVudGFsSW52aXRhdGlvbj0oKT0+e1xucmV0dXJuIHpjZi5tYWtlSW52aXRhdGlvbihcbi8qIEB0cy1leHBlY3QtZXJyb3IgRklYTUUgdW5jaGVja2VkIG9mZmVyQXJncyB0eXBlKi9cbm1ha2VSZW50YWxIb29rLFxuJ21ha2UgcmVudGFsJyxcbnVuZGVmaW5lZCxcbk0uc3BsaXRSZWNvcmQoe2dpdmU6e1V0aWxpdHk6QW1vdW50U2hhcGV9fSkpO1xuXG4gfTtcblxuLyoqXG4gKiBMb29rdXAga2V5d29yZCBmcm9tIGFnb3JpY05hbWVzLCBpZiBwcmVzZW50IHVwZGF0ZSBrZXl3b3JkIG1hcCBhbmQgYWRkIHRoZSBpc3N1ZXIgdG8gem9lXG4gKiBAcGFyYW0ge3N0cmluZ30ga2V5d29yZFxuICovXG5jb25zdCBhZGROZXdBc3NldD1hc3luYyhrZXl3b3JkKT0+e1xuemNmLmFzc2VydFVuaXF1ZUtleXdvcmQoa2V5d29yZCk7XG5cbmNvbnN0IGlzc3Vlcj1hd2FpdCBFKGFnb3JpY05hbWVzKS5sb29rdXAoJ2lzc3Vlcicsa2V5d29yZCk7XG5hd2FpdCB6Y2Yuc2F2ZUlzc3Vlcihpc3N1ZXIsa2V5d29yZCk7XG5cbnByb3ZpZGVCcmFuZFRvS2V5d29yZE1hcChiYWdnYWdlLHpjZik7XG4gfTtcblxuLyoqXG4gKiBQdWJsaWNGYWNldCBzaG91bGQgYmUgZHVyYWJsZSBhcyB3ZWxsLlxuICovXG5jb25zdCBwdWJsaWNGYWNldD1wcmVwYXJlRXhvKFxuYmFnZ2FnZSxcbidDcmFiYmxlIFB1YmxpY0ZhY2V0Jyxcbk0uaW50ZXJmYWNlKCdDcmFiYmxlIFB1YmxpY0ZhY2V0Jyx7XG5tYWtlUmVudGFsSW52aXRhdGlvbjpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmdldFJlbnRhbEJ5SGFuZGxlOk0uY2FsbChNLnJlbW90YWJsZSgpKS5yZXR1cm5zKE0uYW55KCkpLFxuLi4ucHVibGljTWl4aW5BUEl9KSxcblxue1xubWFrZVJlbnRhbEludml0YXRpb24sXG5nZXRSZW50YWxCeUhhbmRsZSxcbi4uLnB1YmxpY01peGlufSk7XG5cblxuXG5jb25zdHtnb3Zlcm5vckZhY2V0fT1tYWtlRHVyYWJsZUdvdmVybm9yRmFjZXQoXG5iYWdnYWdlLFxuRmFyKCdFbXB0eSBDcmVhdG9yIEZhY2V0Jyx7YWRkTmV3QXNzZXR9KSxcbnthZGROZXdBc3NldH0pO1xuXG5cbnJldHVybntwdWJsaWNGYWNldCxjcmVhdG9yRmFjZXQ6Z292ZXJub3JGYWNldH07XG4gfTskaOKAjV9vbmNlLnByZXBhcmUocHJlcGFyZSk7XG5cbmhhcmRlbihwcmVwYXJlKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJwcmVwYXJlIjpbInByZXBhcmUiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAab6yMm0FAABtBQAAKgAAAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9sZWFzZUhvbGRlci5qc3siaW1wb3J0cyI6WyJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsicHJlcGFyZUxlYXNlSG9sZGVyIl0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IE0scHJlcGFyZUV4b0NsYXNzS2l0OyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dLFtcInByZXBhcmVFeG9DbGFzc0tpdFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4b0NsYXNzS2l0ID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuLyoqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy92YXQtZGF0YScpLkJhZ2dhZ2V9IGJhZ2dhZ2UgKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlTGVhc2VIb2xkZXI9KGJhZ2dhZ2UpPT57XG5jb25zdCBtYWtlTGVhc2VIb2xkZXI9cHJlcGFyZUV4b0NsYXNzS2l0KFxuYmFnZ2FnZSxcbidMZWFzZSBIb2xkZXInLFxue1xucHVibGljVG9waWNzOk0uaW50ZXJmYWNlKCdQdWJsaWNTdWJzY3JpYmVycycse1xuZ2V0UHVibGljU3Vic2NyaWJlcnM6TS5jYWxsKCkucmV0dXJucyhNLmFueSgpKX0pLFxuXG5pbnZpdGF0aW9uTWFrZXJzOk0uaW50ZXJmYWNlKCdJbnZpdGF0aW9uTWFrZXJzJyx7XG5yZXR1cm5VdGlsaXR5Ok0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpfSl9LFxuXG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3JlbnRhbC5qcycpLlJlbnRhbFsnc2VsZiddfSByZW50YWxcbiAqL1xuKHJlbnRhbCk9PntcbnJldHVybiBoYXJkZW4oe3JlbnRhbH0pO1xuIH0sXG57XG5wdWJsaWNUb3BpY3M6e1xuZ2V0UHVibGljU3Vic2NyaWJlcnMoKXtcbmNvbnN0IHB1YmxpY1RvcGljcz10aGlzLnN0YXRlLnJlbnRhbC5nZXRQdWJsaWNUb3BpY3MoKTtcbnJldHVybntcbnJlbnRhbDp7XG4uLi5wdWJsaWNUb3BpY3N9fTtcblxuXG4gfX0sXG5cbmludml0YXRpb25NYWtlcnM6e1xucmV0dXJuVXRpbGl0eSgpe1xucmV0dXJuIHRoaXMuc3RhdGUucmVudGFsLm1ha2VSZXR1cm5VdGlsaXR5SW52aXRhdGlvbigpO1xuIH19fSk7XG5cblxuXG5cbnJldHVybiBtYWtlTGVhc2VIb2xkZXI7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVMZWFzZUhvbGRlcihwcmVwYXJlTGVhc2VIb2xkZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVMZWFzZUhvbGRlciI6WyJwcmVwYXJlTGVhc2VIb2xkZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAmkt4aacEAACnBAAAJwAAAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9sZWFzZUtpdC5qc3siaW1wb3J0cyI6WyIuL2xlYXNlSG9sZGVyLmpzIiwiQGFnb3JpYy96b2UvZXhwb3J0ZWQuanMiXSwiZXhwb3J0cyI6WyJwcmVwYXJlTGVhc2VLaXQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgcHJlcGFyZUxlYXNlSG9sZGVyOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvem9lL2V4cG9ydGVkLmpzXCIsIFtdXSxbXCIuL2xlYXNlSG9sZGVyLmpzXCIsIFtbXCJwcmVwYXJlTGVhc2VIb2xkZXJcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVMZWFzZUhvbGRlciA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuLyoqXG4gKiBCb3Jyb3dlcnMgYXJlIGhhbmRlZCBhIGxlYXNlS2l0IG9uY2UgdGhlIGJvcnJvdyBvcGVyYXRpb24gc3VjY2VlZHMuXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKi9cbmNvbnN0ICAgICAgICBwcmVwYXJlTGVhc2VLaXQ9KGJhZ2dhZ2UpPT57XG5jb25zdCBtYWtlTGVhc2VIb2xkZXI9cHJlcGFyZUxlYXNlSG9sZGVyKGJhZ2dhZ2UpO1xuXG4vKipcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi9yZW50YWwuanMnKS5SZW50YWxbJ3NlbGYnXX0gcmVudGFsXG4gKi9cbmNvbnN0IG1ha2VMZWFzZUtpdD0ocmVudGFsKT0+e1xuY29uc3R7aW52aXRhdGlvbk1ha2VycyxwdWJsaWNUb3BpY3N9PW1ha2VMZWFzZUhvbGRlcihyZW50YWwpO1xuXG5jb25zdCBwdWJsaWNTdWJzY3JpYmVycz1wdWJsaWNUb3BpY3MuZ2V0UHVibGljU3Vic2NyaWJlcnMoKTtcblxuY29uc3QgbGVhc2VLaXQ9aGFyZGVuKHtcbnB1YmxpY1N1YnNjcmliZXJzLFxuaW52aXRhdGlvbk1ha2Vyc30pO1xuXG5yZXR1cm4gbGVhc2VLaXQ7XG4gfTtcbnJldHVybiBtYWtlTGVhc2VLaXQ7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVMZWFzZUtpdChwcmVwYXJlTGVhc2VLaXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7InByZXBhcmVMZWFzZUtpdCI6WyJwcmVwYXJlTGVhc2VLaXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAA5dFaZXMRAABzEQAANAAAAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9wYXR0ZXJuTWF0Y2hlckhlbHBlcnMuanN7ImltcG9ydHMiOlsiQGFnb3JpYy9lcnRwIiwiQGFnb3JpYy92YXQtZGF0YSIsIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvc2FmZU1hdGguanMiXSwiZXhwb3J0cyI6WyJtYWtlQm9ycm93UGF0dGVybk1hdGNoZXIiLCJtYWtlQnV5T3V0UGF0dGVybk1hdGNoZXIiLCJtYWtlUmV0dXJuVXRpbGl0eVBhdHRlcm5NYXRjaGVyIiwibWFrZVdpdGhkcmF3Q29sbGF0ZXJhbFBhdHRlcm5NYXRjaGVyIiwibWFrZVdpdGhkcmF3UmVudGFsRmVlUGF0dGVybk1hdGNoZXIiLCJtYWtlV2l0aGRyYXdVdGlsaXR5UGF0dGVybk1hdGNoZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgTSxBbW91bnRNYXRoLG5hdFNhZmVNYXRoOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcIk1cIiwgWyRo4oCNX2EgPT4gKE0gPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBbW91bnRNYXRoXCIsIFskaOKAjV9hID0+IChBbW91bnRNYXRoID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvc2FmZU1hdGguanNcIiwgW1tcIm5hdFNhZmVNYXRoXCIsIFskaOKAjV9hID0+IChuYXRTYWZlTWF0aCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuY29uc3QgbWFrZVJldHVyblV0aWxpdHlQYXR0ZXJuTWF0Y2hlcj0oe2NvbmZpZ3VyYXRpb24sbGFzdFdpbm5lckJpZH0pPT57XG5jb25zdCB1dGlsaXR5QW1vdW50PWNvbmZpZ3VyYXRpb24udXRpbGl0eUFtb3VudDtcbmlmKGNvbmZpZ3VyYXRpb24ucmVudGluZ1RpZXI9PT0nQWQtSG9jJyl7XG5yZXR1cm4gTS5zcGxpdFJlY29yZCh7XG5naXZlOntVdGlsaXR5OnV0aWxpdHlBbW91bnR9LFxud2FudDp7Q29sbGF0ZXJhbDpjb25maWd1cmF0aW9uLmNvbGxhdGVyYWxBbW91bnR9fSk7XG5cbiB9ZWxzZSBpZihjb25maWd1cmF0aW9uLnJlbnRpbmdUaWVyPT09J0F1Y3Rpb24nKXtcbnJldHVybiBNLnNwbGl0UmVjb3JkKHtcbmdpdmU6e1V0aWxpdHk6dXRpbGl0eUFtb3VudH0sXG53YW50OntDb2xsYXRlcmFsOmxhc3RXaW5uZXJCaWQuY29sbGF0ZXJhbEFtb3VudH19KTtcblxuIH1cbiB9OyRo4oCNX29uY2UubWFrZVJldHVyblV0aWxpdHlQYXR0ZXJuTWF0Y2hlcihtYWtlUmV0dXJuVXRpbGl0eVBhdHRlcm5NYXRjaGVyKTtcbmhhcmRlbihtYWtlUmV0dXJuVXRpbGl0eVBhdHRlcm5NYXRjaGVyKTtcblxuY29uc3QgbWFrZVdpdGhkcmF3VXRpbGl0eVBhdHRlcm5NYXRjaGVyPSh7Y29uZmlndXJhdGlvbn0pPT57XG5yZXR1cm4gTS5zcGxpdFJlY29yZCh7XG53YW50OntVdGlsaXR5OmNvbmZpZ3VyYXRpb24udXRpbGl0eUFtb3VudH19KTtcblxuIH07JGjigI1fb25jZS5tYWtlV2l0aGRyYXdVdGlsaXR5UGF0dGVybk1hdGNoZXIobWFrZVdpdGhkcmF3VXRpbGl0eVBhdHRlcm5NYXRjaGVyKTtcbmhhcmRlbihtYWtlV2l0aGRyYXdVdGlsaXR5UGF0dGVybk1hdGNoZXIpO1xuXG5jb25zdCBtYWtlV2l0aGRyYXdSZW50YWxGZWVQYXR0ZXJuTWF0Y2hlcj0oXG5yZW50YWxTZWF0LFxue2NvbmZpZ3VyYXRpb24sbGFzdFdpbm5lckJpZH0sXG5rZXl3b3JkSGVscGVyKT0+XG57XG5sZXQgcmVudGFsRmVlQW1vdW50O1xuXG5pZihjb25maWd1cmF0aW9uLnJlbnRpbmdUaWVyPT09J0FkLUhvYycpe1xucmVudGFsRmVlQW1vdW50PWNvbmZpZ3VyYXRpb24ucmVudGFsRmVlUGVyVW5pdEFtb3VudDtcbiB9ZWxzZSBpZihjb25maWd1cmF0aW9uLnJlbnRpbmdUaWVyPT09J0F1Y3Rpb24nKXtcbnJlbnRhbEZlZUFtb3VudD1sYXN0V2lubmVyQmlkLnJlbnRhbEZlZVBlclVuaXRBbW91bnQ7XG4gfVxuXG5jb25zdCBzZWF0S2V5d29yZD1rZXl3b3JkSGVscGVyLmdldEtleXdvcmQocmVudGFsRmVlQW1vdW50KTtcbmNvbnN0IGZlZVRvV2l0aGRyYXc9cmVudGFsU2VhdC5nZXRBbW91bnRBbGxvY2F0ZWQoc2VhdEtleXdvcmQpO1xuXG5yZXR1cm4gTS5zcGxpdFJlY29yZCh7XG53YW50OntSZW50YWxGZWU6ZmVlVG9XaXRoZHJhd319KTtcblxuIH07JGjigI1fb25jZS5tYWtlV2l0aGRyYXdSZW50YWxGZWVQYXR0ZXJuTWF0Y2hlcihtYWtlV2l0aGRyYXdSZW50YWxGZWVQYXR0ZXJuTWF0Y2hlcik7XG5oYXJkZW4obWFrZVdpdGhkcmF3UmVudGFsRmVlUGF0dGVybk1hdGNoZXIpO1xuXG5jb25zdCBtYWtlV2l0aGRyYXdDb2xsYXRlcmFsUGF0dGVybk1hdGNoZXI9KHtcbmNvbmZpZ3VyYXRpb24sXG5sYXN0V2lubmVyQmlkfSk9Plxue1xubGV0IGNvbEFtb3VudDtcblxuaWYoY29uZmlndXJhdGlvbi5yZW50aW5nVGllcj09PSdBZC1Ib2MnKXtcbmNvbEFtb3VudD1jb25maWd1cmF0aW9uLmNvbGxhdGVyYWxBbW91bnQ7XG4gfWVsc2UgaWYoY29uZmlndXJhdGlvbi5yZW50aW5nVGllcj09PSdBdWN0aW9uJyl7XG5jb2xBbW91bnQ9bGFzdFdpbm5lckJpZC5jb2xsYXRlcmFsQW1vdW50O1xuIH1cblxucmV0dXJuIE0uc3BsaXRSZWNvcmQoe1xud2FudDp7Q29sbGF0ZXJhbDpjb2xBbW91bnR9fSk7XG5cbiB9OyRo4oCNX29uY2UubWFrZVdpdGhkcmF3Q29sbGF0ZXJhbFBhdHRlcm5NYXRjaGVyKG1ha2VXaXRoZHJhd0NvbGxhdGVyYWxQYXR0ZXJuTWF0Y2hlcik7XG5oYXJkZW4obWFrZVdpdGhkcmF3Q29sbGF0ZXJhbFBhdHRlcm5NYXRjaGVyKTtcblxuY29uc3QgbWFrZUJvcnJvd1BhdHRlcm5NYXRjaGVyPShyZW50YWxTdGF0ZSxiaWRzTWFuYWdlcixiaWRIYW5kbGUpPT57XG5jb25zdHtjb25maWd1cmF0aW9ufT1iaWRzTWFuYWdlci5nZXRCaWRCeUhhbmRsZShiaWRIYW5kbGUpO1xuXG5jb25zdHt2YWx1ZTpmZWVQZXJVbml0LGJyYW5kfT1jb25maWd1cmF0aW9uLnJlbnRhbEZlZVBlclVuaXRBbW91bnQ7XG5jb25zdCB0b3RhbEZlZUFtb3VudD1uYXRTYWZlTWF0aC5tdWx0aXBseShcbmZlZVBlclVuaXQsXG5jb25maWd1cmF0aW9uLnJlbnRpbmdEdXJhdGlvbik7XG5cbmNvbnN0IGFza2VkQW1vdW50PUFtb3VudE1hdGgubWFrZShicmFuZCx0b3RhbEZlZUFtb3VudCk7XG5cbnJldHVybiBNLnNwbGl0UmVjb3JkKHtcbmdpdmU6e1xuQ29sbGF0ZXJhbDpjb25maWd1cmF0aW9uLmNvbGxhdGVyYWxBbW91bnQsXG5SZW50YWxGZWU6YXNrZWRBbW91bnR9LFxuXG53YW50OntVdGlsaXR5OnJlbnRhbFN0YXRlLmNvbmZpZ3VyYXRpb24udXRpbGl0eUFtb3VudH19KTtcblxuIH07JGjigI1fb25jZS5tYWtlQm9ycm93UGF0dGVybk1hdGNoZXIobWFrZUJvcnJvd1BhdHRlcm5NYXRjaGVyKTtcbmhhcmRlbihtYWtlQm9ycm93UGF0dGVybk1hdGNoZXIpO1xuXG5jb25zdCBtYWtlQnV5T3V0UGF0dGVybk1hdGNoZXI9KHtjb25maWd1cmF0aW9ufSk9PntcbmNvbnN0e1xuY29sbGF0ZXJhbEFtb3VudCxcbnV0aWxpdHlBbW91bnQsXG5yZW50YWxGZWVQZXJVbml0QW1vdW50LFxubWF4UmVudGluZ0R1cmF0aW9uVW5pdHN9PVxuY29uZmlndXJhdGlvbjtcblxuY29uc3R7dmFsdWU6ZmVlUGVyVW5pdCxicmFuZH09cmVudGFsRmVlUGVyVW5pdEFtb3VudDtcbmNvbnN0IHRvdGFsRmVlQW1vdW50PW5hdFNhZmVNYXRoLm11bHRpcGx5KFxuZmVlUGVyVW5pdCxcbm1heFJlbnRpbmdEdXJhdGlvblVuaXRzKTtcblxuY29uc3QgYXNrZWRBbW91bnRNYXg9QW1vdW50TWF0aC5tYWtlKGJyYW5kLHRvdGFsRmVlQW1vdW50KTtcblxucmV0dXJuIE0uc3BsaXRSZWNvcmQoe1xuZ2l2ZTp7XG5Db2xsYXRlcmFsOmNvbGxhdGVyYWxBbW91bnQsXG5SZW50YWxGZWU6TS5sdGUoYXNrZWRBbW91bnRNYXgpfSxcblxud2FudDp7VXRpbGl0eTp1dGlsaXR5QW1vdW50fX0pO1xuXG4gfTskaOKAjV9vbmNlLm1ha2VCdXlPdXRQYXR0ZXJuTWF0Y2hlcihtYWtlQnV5T3V0UGF0dGVybk1hdGNoZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VSZXR1cm5VdGlsaXR5UGF0dGVybk1hdGNoZXIiOlsibWFrZVJldHVyblV0aWxpdHlQYXR0ZXJuTWF0Y2hlciJdLCJtYWtlV2l0aGRyYXdVdGlsaXR5UGF0dGVybk1hdGNoZXIiOlsibWFrZVdpdGhkcmF3VXRpbGl0eVBhdHRlcm5NYXRjaGVyIl0sIm1ha2VXaXRoZHJhd1JlbnRhbEZlZVBhdHRlcm5NYXRjaGVyIjpbIm1ha2VXaXRoZHJhd1JlbnRhbEZlZVBhdHRlcm5NYXRjaGVyIl0sIm1ha2VXaXRoZHJhd0NvbGxhdGVyYWxQYXR0ZXJuTWF0Y2hlciI6WyJtYWtlV2l0aGRyYXdDb2xsYXRlcmFsUGF0dGVybk1hdGNoZXIiXSwibWFrZUJvcnJvd1BhdHRlcm5NYXRjaGVyIjpbIm1ha2VCb3Jyb3dQYXR0ZXJuTWF0Y2hlciJdLCJtYWtlQnV5T3V0UGF0dGVybk1hdGNoZXIiOlsibWFrZUJ1eU91dFBhdHRlcm5NYXRjaGVyIl19LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwMECgAAAAAAAAAAAKjJ4bLIoAAAyKAAACUAAABjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvcmVudGFsLmpzeyJpbXBvcnRzIjpbIi4vYXNzZXJ0aW9uSGVscGVycy5qcyIsIi4vYmlkS2l0LmpzIiwiLi9iaWRzTWFuYWdlci5qcyIsIi4vY29uc3RhbnRzLmpzIiwiLi9sZWFzZUtpdC5qcyIsIi4vcGF0dGVybk1hdGNoZXJIZWxwZXJzLmpzIiwiLi9yZW50YWxLaXQuanMiLCIuL3R5cGVHdWFyZHMuanMiLCIuL3V0aWxzLmpzIiwiQGFnb3JpYy90aW1lIiwiQGFnb3JpYy92YXQtZGF0YSIsIkBhZ29yaWMvem9lL2V4cG9ydGVkLmpzIiwiQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC9hdG9taWNUcmFuc2Zlci5qcyIsIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvdG9waWNzLmpzIiwiQGFnb3JpYy96b2Uvc3JjL21ha2VIYW5kbGUuanMiLCJAZW5kby9ldmVudHVhbC1zZW5kIiwiQGVuZG8vZmFyIl0sImV4cG9ydHMiOlsicHJlcGFyZVJlbnRhbCIsInByZXBhcmVSZW50YWxIZWxwZXIiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRSxGYXIscHJlcGFyZUV4b0NsYXNzS2l0LFRpbWVNYXRoLGRlZmluZUR1cmFibGVIYW5kbGUsYXRvbWljUmVhcnJhbmdlLGF0b21pY1RyYW5zZmVyLG1ha2VSZWNvcmRlclRvcGljLHByZXBhcmVSZW50YWx0S2l0LHByZXBhcmVMZWFzZUtpdCxwcmVwYXJlQmlkS2l0LHByZXBhcmVCaWRzTWFuYWdlcixhc3NlcnRSZW50YWxDb25maWcsYXNzZXJ0UmVudGFsUGhhc2UsYXNzZXJ0UmVudGluZ1RpZXIsYXNzZXJ0UmVudGluZ0R1cmF0aW9uLGFzc2VydFV0aWxpdHksYXNzZXJ0UmVudGFsRmVlLGFzc2VydENvbGxhdGVyYWwsYXNzZXJ0QW1vdW50Tm90RW1wdHksYXNzZXJ0R3JhY2VQZXJpb2QsYXNzZXJ0QmlkQ29uZmlnLEhlbHBlckksU2VsZkksQXVjdGlvbkksUHVibGljSSxDcmFiYmxlSSxCaWRQaGFzZSxQaGFzZSxSZW50aW5nRHVyYXRpb25Vbml0VG9TZWNvbmRzLHByb3ZpZGVCcmFuZFRvS2V5d29yZEhlbHBlcixsb2dnZXIsZ2V0SXNzdWVyRnJvbUFtb3VudCxtYWtlQm9ycm93UGF0dGVybk1hdGNoZXIsbWFrZUJ1eU91dFBhdHRlcm5NYXRjaGVyLG1ha2VSZXR1cm5VdGlsaXR5UGF0dGVybk1hdGNoZXIsbWFrZVdpdGhkcmF3Q29sbGF0ZXJhbFBhdHRlcm5NYXRjaGVyLG1ha2VXaXRoZHJhd1JlbnRhbEZlZVBhdHRlcm5NYXRjaGVyLG1ha2VXaXRoZHJhd1V0aWxpdHlQYXR0ZXJuTWF0Y2hlcjskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3pvZS9leHBvcnRlZC5qc1wiLCBbXV0sW1wiQGVuZG8vZXZlbnR1YWwtc2VuZFwiLCBbW1wiRVwiLCBbJGjigI1fYSA9PiAoRSA9ICRo4oCNX2EpXV1dXSxbXCJAZW5kby9mYXJcIiwgW1tcIkZhclwiLCBbJGjigI1fYSA9PiAoRmFyID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcInByZXBhcmVFeG9DbGFzc0tpdFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUV4b0NsYXNzS2l0ID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdGltZVwiLCBbW1wiVGltZU1hdGhcIiwgWyRo4oCNX2EgPT4gKFRpbWVNYXRoID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy9tYWtlSGFuZGxlLmpzXCIsIFtbXCJkZWZpbmVEdXJhYmxlSGFuZGxlXCIsIFskaOKAjV9hID0+IChkZWZpbmVEdXJhYmxlSGFuZGxlID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvYXRvbWljVHJhbnNmZXIuanNcIiwgW1tcImF0b21pY1JlYXJyYW5nZVwiLCBbJGjigI1fYSA9PiAoYXRvbWljUmVhcnJhbmdlID0gJGjigI1fYSldXSxbXCJhdG9taWNUcmFuc2ZlclwiLCBbJGjigI1fYSA9PiAoYXRvbWljVHJhbnNmZXIgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC90b3BpY3MuanNcIiwgW1tcIm1ha2VSZWNvcmRlclRvcGljXCIsIFskaOKAjV9hID0+IChtYWtlUmVjb3JkZXJUb3BpYyA9ICRo4oCNX2EpXV1dXSxbXCIuL3JlbnRhbEtpdC5qc1wiLCBbW1wicHJlcGFyZVJlbnRhbHRLaXRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVSZW50YWx0S2l0ID0gJGjigI1fYSldXV1dLFtcIi4vbGVhc2VLaXQuanNcIiwgW1tcInByZXBhcmVMZWFzZUtpdFwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUxlYXNlS2l0ID0gJGjigI1fYSldXV1dLFtcIi4vYmlkS2l0LmpzXCIsIFtbXCJwcmVwYXJlQmlkS2l0XCIsIFskaOKAjV9hID0+IChwcmVwYXJlQmlkS2l0ID0gJGjigI1fYSldXV1dLFtcIi4vYmlkc01hbmFnZXIuanNcIiwgW1tcInByZXBhcmVCaWRzTWFuYWdlclwiLCBbJGjigI1fYSA9PiAocHJlcGFyZUJpZHNNYW5hZ2VyID0gJGjigI1fYSldXV1dLFtcIi4vYXNzZXJ0aW9uSGVscGVycy5qc1wiLCBbW1wiYXNzZXJ0UmVudGFsQ29uZmlnXCIsIFskaOKAjV9hID0+IChhc3NlcnRSZW50YWxDb25maWcgPSAkaOKAjV9hKV1dLFtcImFzc2VydFJlbnRhbFBoYXNlXCIsIFskaOKAjV9hID0+IChhc3NlcnRSZW50YWxQaGFzZSA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UmVudGluZ1RpZXJcIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlbnRpbmdUaWVyID0gJGjigI1fYSldXSxbXCJhc3NlcnRSZW50aW5nRHVyYXRpb25cIiwgWyRo4oCNX2EgPT4gKGFzc2VydFJlbnRpbmdEdXJhdGlvbiA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0VXRpbGl0eVwiLCBbJGjigI1fYSA9PiAoYXNzZXJ0VXRpbGl0eSA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0UmVudGFsRmVlXCIsIFskaOKAjV9hID0+IChhc3NlcnRSZW50YWxGZWUgPSAkaOKAjV9hKV1dLFtcImFzc2VydENvbGxhdGVyYWxcIiwgWyRo4oCNX2EgPT4gKGFzc2VydENvbGxhdGVyYWwgPSAkaOKAjV9hKV1dLFtcImFzc2VydEFtb3VudE5vdEVtcHR5XCIsIFskaOKAjV9hID0+IChhc3NlcnRBbW91bnROb3RFbXB0eSA9ICRo4oCNX2EpXV0sW1wiYXNzZXJ0R3JhY2VQZXJpb2RcIiwgWyRo4oCNX2EgPT4gKGFzc2VydEdyYWNlUGVyaW9kID0gJGjigI1fYSldXSxbXCJhc3NlcnRCaWRDb25maWdcIiwgWyRo4oCNX2EgPT4gKGFzc2VydEJpZENvbmZpZyA9ICRo4oCNX2EpXV1dXSxbXCIuL3R5cGVHdWFyZHMuanNcIiwgW1tcIkhlbHBlcklcIiwgWyRo4oCNX2EgPT4gKEhlbHBlckkgPSAkaOKAjV9hKV1dLFtcIlNlbGZJXCIsIFskaOKAjV9hID0+IChTZWxmSSA9ICRo4oCNX2EpXV0sW1wiQXVjdGlvbklcIiwgWyRo4oCNX2EgPT4gKEF1Y3Rpb25JID0gJGjigI1fYSldXSxbXCJQdWJsaWNJXCIsIFskaOKAjV9hID0+IChQdWJsaWNJID0gJGjigI1fYSldXSxbXCJDcmFiYmxlSVwiLCBbJGjigI1fYSA9PiAoQ3JhYmJsZUkgPSAkaOKAjV9hKV1dXV0sW1wiLi9jb25zdGFudHMuanNcIiwgW1tcIkJpZFBoYXNlXCIsIFskaOKAjV9hID0+IChCaWRQaGFzZSA9ICRo4oCNX2EpXV0sW1wiUGhhc2VcIiwgWyRo4oCNX2EgPT4gKFBoYXNlID0gJGjigI1fYSldXSxbXCJSZW50aW5nRHVyYXRpb25Vbml0VG9TZWNvbmRzXCIsIFskaOKAjV9hID0+IChSZW50aW5nRHVyYXRpb25Vbml0VG9TZWNvbmRzID0gJGjigI1fYSldXV1dLFtcIi4vdXRpbHMuanNcIiwgW1tcInByb3ZpZGVCcmFuZFRvS2V5d29yZEhlbHBlclwiLCBbJGjigI1fYSA9PiAocHJvdmlkZUJyYW5kVG9LZXl3b3JkSGVscGVyID0gJGjigI1fYSldXSxbXCJsb2dnZXJcIiwgWyRo4oCNX2EgPT4gKGxvZ2dlciA9ICRo4oCNX2EpXV0sW1wiZ2V0SXNzdWVyRnJvbUFtb3VudFwiLCBbJGjigI1fYSA9PiAoZ2V0SXNzdWVyRnJvbUFtb3VudCA9ICRo4oCNX2EpXV1dXSxbXCIuL3BhdHRlcm5NYXRjaGVySGVscGVycy5qc1wiLCBbW1wibWFrZUJvcnJvd1BhdHRlcm5NYXRjaGVyXCIsIFskaOKAjV9hID0+IChtYWtlQm9ycm93UGF0dGVybk1hdGNoZXIgPSAkaOKAjV9hKV1dLFtcIm1ha2VCdXlPdXRQYXR0ZXJuTWF0Y2hlclwiLCBbJGjigI1fYSA9PiAobWFrZUJ1eU91dFBhdHRlcm5NYXRjaGVyID0gJGjigI1fYSldXSxbXCJtYWtlUmV0dXJuVXRpbGl0eVBhdHRlcm5NYXRjaGVyXCIsIFskaOKAjV9hID0+IChtYWtlUmV0dXJuVXRpbGl0eVBhdHRlcm5NYXRjaGVyID0gJGjigI1fYSldXSxbXCJtYWtlV2l0aGRyYXdDb2xsYXRlcmFsUGF0dGVybk1hdGNoZXJcIiwgWyRo4oCNX2EgPT4gKG1ha2VXaXRoZHJhd0NvbGxhdGVyYWxQYXR0ZXJuTWF0Y2hlciA9ICRo4oCNX2EpXV0sW1wibWFrZVdpdGhkcmF3UmVudGFsRmVlUGF0dGVybk1hdGNoZXJcIiwgWyRo4oCNX2EgPT4gKG1ha2VXaXRoZHJhd1JlbnRhbEZlZVBhdHRlcm5NYXRjaGVyID0gJGjigI1fYSldXSxbXCJtYWtlV2l0aGRyYXdVdGlsaXR5UGF0dGVybk1hdGNoZXJcIiwgWyRo4oCNX2EgPT4gKG1ha2VXaXRoZHJhd1V0aWxpdHlQYXR0ZXJuTWF0Y2hlciA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cblxuLyoqIEB0eXBlZGVmIHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzJykuVGltZXJTZXJ2aWNlfSBUaW1lciAqL1xuXG4vKipcbiAqIEEgcmVudGFsIGlzIHRoZSBzbWFsbGVzdCB1bml0IG9mIHVzZXIgZXhwZXJpbmNlIGluIG91ciBwcm90b2NvbC4gQW4gb3duZXIgY3JlYXRlcyBhIHJlbnRhbCBieSBlc2Nyb3dpbmcgdGhlaXIgdXRpbGl0eVxuICogaW4gb3VyIHByb3RvY29sLiBUaGVuIGJvcnJvd2VycyBleHByZXNzIGludGVyZXN0IGluIHRoZSByZW50YWwgYnkgaW50ZXJhY3Rpbmcgd2l0aCBpdHMgcHVibGljRmFjZXQgdGhldCBnZXQgZnJvbVxuICogdGhlIGNhdGFsb2cuIFRoZSBSZW50YWwgbW9kdWxlIGhhcyBiZWhhdmlvciBmb3IgaGFuZGxpbmcgcmVzdCBvZiB0aGUgbG9naWMuXG4gKlxuICogVXNlcnMgY2FuIGZvbGxvdyB1cCBvbiB0aGVpciByZWxldmFudCBhY3Rpb25zIGJ5IHVzaW5nIG9uIG9mIHRocmVlIG9iamVjdCBiZWxvdztcbiAqIC0gcmVudGFsS2l0XG4gKiAtIGxlYXNlS2l0XG4gKiAtIGJpZEtpdFxuICpcbiAqIFRoZXNlICpLaXQgb2JqZWN0cyB3cmFwKG9iamVjdHMgd2l0aCBjbG9zdXJlcykgYW5vdGhlciBvYmplY3QgY2FsbGVkICpIb2xkZXIsIHJlc3BlY3RpdmUgdG8gdGhlaXIgbmFtZSBwcmVmaXhpbmcgJ0tpdCdcbiAqIGtleXdvcmQsIHRvIGFjaGlldmUgZHVyYWJpbGl0eSBhY3Jvc3MgdXBncmFkZXMuIFNlZSBiZWxvdyBtb2R1bGVzIGZvciBtb3JlIGRldGFpbGVkIGV4cGxhbmF0aW9uO1xuICogLSByZW50YWxIb2xkZXJcbiAqIC0gbGVhc2VIb2xkZXJcbiAqIC0gYmlkSG9sZGVyXG4gKlxuICogV2UgdXNlZCBodHRwczovL2dpdGh1Yi5jb20vQWdvcmljL2Fnb3JpYy1zZGsvYmxvYi9tYXN0ZXIvcGFja2FnZXMvaW50ZXItcHJvdG9jb2wvc3JjL3ZhdWx0RmFjdG9yeS92YXVsdEhvbGRlci5qcyBhc1xuICogYW4gZXhhbXBsZSBmb3Igb3VyIGhvbGRlciBwYXR0ZXJucy5cbiAqXG4gKiBAcGFyYW0ge1pDRn0gemNmXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vY2F0YWxvZy5qcycpLkNhdGFsb2d9IGNhdGFsb2dGYWNldFxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3RpbWUvc3JjL3R5cGVzLmpzJykuVGltZXJTZXJ2aWNlfSB0aW1lclxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L3JlY29yZGVyLmpzJykuTWFrZVJlY29yZGVyS2l0fSBtYWtlUmVjb3JkZXJLaXRcbiAqL1xuY29uc3QgICAgICAgIHByZXBhcmVSZW50YWw9KFxuemNmLFxuY2F0YWxvZ0ZhY2V0LFxuYmFnZ2FnZSxcbnRpbWVyLFxubWFrZVJlY29yZGVyS2l0KT0+XG57XG5jb25zdCBtYWtlUmVudGFsS2l0PXByZXBhcmVSZW50YWx0S2l0KGJhZ2dhZ2UpO1xuY29uc3QgbWFrZUxlYXNlS2l0PXByZXBhcmVMZWFzZUtpdChiYWdnYWdlKTtcbmNvbnN0IG1ha2VCaWRIYW5kbGU9ZGVmaW5lRHVyYWJsZUhhbmRsZShiYWdnYWdlLCdCaWQnKTtcbmNvbnN0IG1ha2VHcmFjZVBlcmlvZFN0YXJ0SGFuZGxlPWRlZmluZUR1cmFibGVIYW5kbGUoXG5iYWdnYWdlLFxuJ0dyYWNlUGVyaW9kU3RhcnQnKTtcblxuY29uc3QgbWFrZUdyYWNlUGVyaW9kRW5kSGFuZGxlPWRlZmluZUR1cmFibGVIYW5kbGUoXG5iYWdnYWdlLFxuJ0dyYWNlUGVyaW9kRW5kJyk7XG5cbmNvbnN0IG1ha2VCaWRLaXQ9cHJlcGFyZUJpZEtpdChiYWdnYWdlKTtcbmNvbnN0IGtleXdvcmRIZWxwZXI9cHJvdmlkZUJyYW5kVG9LZXl3b3JkSGVscGVyKGJhZ2dhZ2UpO1xuXG4vKipcbiAqXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZW50YWxDb25maWd9IHJlbnRhbENvbmZpZ1xuICogQHBhcmFtIHtTdG9yYWdlTm9kZX0gc3RvcmFnZU5vZGVcbiAqIEBwYXJhbSB7SGFuZGxlPCdSZW50YWwnPn0gcmVudGFsSGFuZGxlXG4gKiBAcGFyYW0ge1hpbXBvcnQoJy4vYmlkc01hbmFnZXIuanMnKS5CaWRzTWFuYWdlclsnbWFuYWdlciddfSBiaWRzTWFuYWdlckZhY2V0XG4gKiBAcmV0dXJucyB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlbnRhbEV4b1N0YXRlfVxuICovXG5jb25zdCBpbml0U3RhdGU9KFxucmVudGFsQ29uZmlnLFxuc3RvcmFnZU5vZGUsXG5yZW50YWxIYW5kbGUsXG5iaWRzTWFuYWdlckZhY2V0KT0+XG57XG5jb25zdCByZW50YWxSZWNvcmRlcktpdD1tYWtlUmVjb3JkZXJLaXQoc3RvcmFnZU5vZGUpO1xuXG4vKiogQHR5cGUge1hpbXBvcnQoJy4vdHlwZXMuanMnKS5SZW50YWxTdGF0ZX0gKi9cbmNvbnN0IHJlbnRhbFN0YXRlPWhhcmRlbih7XG5yZW50YWxIYW5kbGUsXG5jb25maWd1cmF0aW9uOnJlbnRhbENvbmZpZyxcbnBoYXNlOlBoYXNlLkFWQUlMQUJMRSxcbnJlbnRhbEJhbGFuY2U6e30sXG5jb2xsYXRlcmFsQmFsYW5jZTp7fSxcbmxhc3RXaW5uZXJCaWQ6dW5kZWZpbmVkfSk7XG5cblxudm9pZCBFKHJlbnRhbFJlY29yZGVyS2l0LnJlY29yZGVyKS53cml0ZShyZW50YWxTdGF0ZSk7LyogTWF5YmUgYWRkICd2b2lkJyovXG5cbnJldHVybiBoYXJkZW4oe1xucmVudGFsUmVjb3JkZXI6cmVudGFsUmVjb3JkZXJLaXQucmVjb3JkZXIsXG5yZW50YWxSZWNvcmRlcktpdCxcbnJlbnRhbFN0YXRlLFxucmVudGFsU2VhdDp6Y2YubWFrZUVtcHR5U2VhdEtpdCgpLnpjZlNlYXQsXG5jb2xTZWF0OnpjZi5tYWtlRW1wdHlTZWF0S2l0KCkuemNmU2VhdCxcbnJlbnRhbEhhbmRsZSxcbmdyYWNlUGVyaW9kOntcbnN0YXJ0OntcbmNhbmNlbFRva2VuOnVuZGVmaW5lZCxcbndha2VBdDotMW59LFxuXG5lbmQ6e1xuY2FuY2VsVG9rZW46dW5kZWZpbmVkLFxud2FrZUF0Oi0xbn19LFxuXG5cbmJpZHNNYW5hZ2VyRmFjZXR9KTtcblxuIH07XG5cbmNvbnN0IG1ha2VSZW50YWw9cHJlcGFyZUV4b0NsYXNzS2l0KFxuYmFnZ2FnZSxcbidSZW50YWwnLFxue1xuaGVscGVyOkhlbHBlckksXG5zZWxmOlNlbGZJLFxuYXVjdGlvbjpBdWN0aW9uSSxcbnB1YmxpY0ZhY2V0OlB1YmxpY0ksXG5jcmFiYmxlOkNyYWJibGVJfSxcblxuaW5pdFN0YXRlLFxue1xuaGVscGVyOntcbi8qKlxuICogRXNjcm93cyB0aGUgdXRpbGl0eSBORlQgdG8gdGhlIGNvbnRyYWN0LiBDYWxsZWQgd2hlbiB0aGUgcmVudGFsIGlzIGFkZGVkIHRvIHRoZSBwcm90b2NvbC5cbiAqIEBwYXJhbSB7WkNGU2VhdH0gb3duZXJTZWF0XG4gKi9cbmxvY2tVdGlsaXR5KG93bmVyU2VhdCl7XG5jb25zdHtzdGF0ZX09dGhpcztcbmNvbnN0e3JlbnRhbFNlYXR9PXN0YXRlO1xuXG5jb25zdHtcbmdpdmU6e1V0aWxpdHk6dXRpbGl0eUFtb3VudH19PVxub3duZXJTZWF0LmdldFByb3Bvc2FsKCk7XG5cbmNvbnN0IGFjdHVhbFV0aWxpdHlLZXl3b3JkPWtleXdvcmRIZWxwZXIuZ2V0S2V5d29yZCh1dGlsaXR5QW1vdW50KTtcblxuYXRvbWljVHJhbnNmZXIoXG56Y2YsXG5vd25lclNlYXQsXG5yZW50YWxTZWF0LFxue1xuVXRpbGl0eTp1dGlsaXR5QW1vdW50fSxcblxue1xuW2FjdHVhbFV0aWxpdHlLZXl3b3JkXTp1dGlsaXR5QW1vdW50fSk7XG5cblxuXG5vd25lclNlYXQuZXhpdCgpO1xuIH0sXG4vKipcbiAqIFVwZGF0ZXMgdGhlIHN0YXRlLnJlbnRhbFN0YXRlIGFuZCBwdWJsaXNoZXMgdGhlIG5ldyBzdGF0ZS4gUmV0dXJucyBhIHByb21pc2UgdG8gdGhlIHB1Ymxpc2hcbiAqIG9wZXJhdGlvbiBmb3IgZGVidWdnaW5nIGFuZCB0ZXN0aW5nLlxuICogQHBhcmFtIHt7fX0gdXBkYXRlcyAtIFhYWCB0byBkb1xuICovXG51cGRhdGVSZW50YWxTdGF0ZSh1cGRhdGVzKXtcbmNvbnN0e3N0YXRlfT10aGlzO1xuY29uc3R7cmVudGFsUmVjb3JkZXIscmVudGFsU3RhdGUscmVudGFsU2VhdCxjb2xTZWF0fT1zdGF0ZTtcblxuY29uc3QgbmV3U3RhdGU9aGFyZGVuKHtcbi4uLnJlbnRhbFN0YXRlLFxuLi4udXBkYXRlcyxcbnJlbnRhbEJhbGFuY2U6cmVudGFsU2VhdC5nZXRDdXJyZW50QWxsb2NhdGlvbigpLFxuY29sbGF0ZXJhbEJhbGFuY2U6Y29sU2VhdC5nZXRDdXJyZW50QWxsb2NhdGlvbigpfSk7XG5cblxuc3RhdGUucmVudGFsU3RhdGU9bmV3U3RhdGU7XG5cbmNvbnN0IHJlbnRhbFVwZGF0ZVA9RShyZW50YWxSZWNvcmRlcikud3JpdGUoc3RhdGUucmVudGFsU3RhdGUpO1xuLyogY29uc3QgY2F0YWxvZ1VwZGF0ZVAgPSBjYXRhbG9nRmFjZXQucHVibGlzaFVwZGF0ZWRDYXRhbG9ndWUoKTsqL1xuXG5yZXR1cm4gaGFyZGVuKFtyZW50YWxVcGRhdGVQXSk7XG4gfSxcbi8qKlxuICogVXBkYXRlcyB0aGUgc3RhdGUucmVudGFsU3RhdGUuY29uZmlndXJhdGlvbiBhbmQgcHVibGlzaGVzIHRoZSBuZXcgc3RhdGUuIFJldHVybnMgYSBwcm9taXNlIHRvIHRoZSBwdWJsaXNoXG4gKiBvcGVyYXRpb24gZm9yIGRlYnVnZ2luZyBhbmQgdGVzdGluZy5cbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcycpLlJlbnRhbENvbmZpZ30gdXBkYXRlZFJlbnRhbENvbmZpZ1xuICovXG51cGRhdGVSZW50YWxDb25maWcodXBkYXRlZFJlbnRhbENvbmZpZyl7XG5jb25zdHtoZWxwZXJ9PXRoaXMuZmFjZXRzO1xuXG5jb25zdCB1cGRhdGVzPXtjb25maWd1cmF0aW9uOnVwZGF0ZWRSZW50YWxDb25maWd9O1xucmV0dXJuIGhlbHBlci51cGRhdGVSZW50YWxTdGF0ZSh1cGRhdGVzKTtcbiB9LFxuLyoqXG4gKiBVcGRhdGVzIHRoZSBzdGF0ZS5yZW50YWxTdGF0ZS5waGFzZSBhbmQgcHVibGlzaGVzIHRoZSBuZXcgc3RhdGUuIFJldHVybnMgYSBwcm9taXNlIHRvIHRoZSBwdWJsaXNoXG4gKiBvcGVyYXRpb24gZm9yIGRlYnVnZ2luZyBhbmQgdGVzdGluZy5cbiAqIEBwYXJhbSB7WGltcG9ydCgnLi90eXBlcy5qcycpLlJlbnRhbFBoYXNlfSB1cGRhdGVkUGhhc2VcbiAqL1xudXBkYXRlUmVudGFsUGhhc2UodXBkYXRlZFBoYXNlKXtcbmNvbnN0e2hlbHBlcn09dGhpcy5mYWNldHM7XG5cbmNvbnN0IHVwZGF0ZXM9e3BoYXNlOnVwZGF0ZWRQaGFzZX07XG5yZXR1cm4gaGVscGVyLnVwZGF0ZVJlbnRhbFN0YXRlKHVwZGF0ZXMpO1xuIH0sXG4vKipcbiAqIGdyYWNlUGVyaW9kU3RhcnQgPSBub3cgKyByZW50aW5nRHVyYXRpb24uIFVzZXMgRSh0aW1lcikuZ2V0Q3VycmVudFRpbWVzdGFtcCgpIHRvIGdldCB0aGUgY3VycmVudCB0aW1lLlxuICogQHBhcmFtIHtOYXRWYWx1ZX0gcmVudGluZ0R1cmF0aW9uXG4gKi9cbiAgICAgIGFzeW5jIGNhbGN1bGF0ZUdyYWNlUGVyaW9kU3RhcnQocmVudGluZ0R1cmF0aW9uKXtcbmNvbnN0e3N0YXRlfT10aGlzO1xuY29uc3R7cmVudGFsU3RhdGV9PXN0YXRlO1xuY29uc3R7cmVudGluZ0R1cmF0aW9uVW5pdH09cmVudGFsU3RhdGUuY29uZmlndXJhdGlvbjtcblxuY29uc3QgcmVudGluZ0R1cmF0aW9uVW5pdEluU2Vjb25kcz1cblJlbnRpbmdEdXJhdGlvblVuaXRUb1NlY29uZHNbcmVudGluZ0R1cmF0aW9uVW5pdF07XG5cbmNvbnN0IHJlbnRpbmdEdXJhdGlvbkluU2Vjb25kcz1cbnJlbnRpbmdEdXJhdGlvbipyZW50aW5nRHVyYXRpb25Vbml0SW5TZWNvbmRzO1xuXG5jb25zdCBub3c9YXdhaXQgRSh0aW1lcikuZ2V0Q3VycmVudFRpbWVzdGFtcCgpO1xuXG5jb25zdCBncmFjZVBlcmlvZFN0YXJ0PVRpbWVNYXRoLmFkZEFic1JlbChcbm5vdyxcbnJlbnRpbmdEdXJhdGlvbkluU2Vjb25kcyk7XG5cblxucmV0dXJuIGdyYWNlUGVyaW9kU3RhcnQ7XG4gfSxcbi8qKlxuICogZ3JhY2VQZXJpb2RFbmQgPSBncmFjZVBlcmlvZFN0YXJ0ICsgZ3JhY2VQZXJpb2REdXJhdGlvbi5cbiAqIEBwYXJhbSB7YmlnaW50fSBncmFjZVBlcmlvZFN0YXJ0XG4gKi9cbmNhbGN1bGF0ZUdyYWNlUGVyaW9kRW5kKGdyYWNlUGVyaW9kU3RhcnQpe1xuY29uc3R7c3RhdGV9PXRoaXM7XG5jb25zdHtyZW50YWxTdGF0ZX09c3RhdGU7XG5jb25zdHtncmFjZVBlcmlvZER1cmF0aW9ufT1yZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uO1xuXG5jb25zdCBncmFjZVBlcmlvZEVuZD1UaW1lTWF0aC5hZGRBYnNSZWwoXG5ncmFjZVBlcmlvZFN0YXJ0LFxuZ3JhY2VQZXJpb2REdXJhdGlvbik7XG5cblxucmV0dXJuIGdyYWNlUGVyaW9kRW5kO1xuIH0sXG4vKipcbiAqIENhbGN1bGF0ZXMgdGhlIGdyYWNlUGVyaW9kID0geyBncmFjZVBlcmlvZFN0YXJ0LCBncmFjZVBlcmlvZEVuZCB9LiBVcGRhdGVzIHN0YXRlLnJlbnRhbFN0YXRlIGFuZCBwdWJsaXNoZXNcbiAqIG5ldyBzdGF0ZS4gVGhlbiBzY2hlZHVsZXMgdGhlIHdha2V1cCBjYWxscyBhY2NvcmRpbmcgdG8gdGhlIGNhbGN1bGF0ZXMgZ3JhY2VQZXJpb2QgdmFsdWVzLlxuICogQHBhcmFtIHtiaWdpbnR9IHJlbnRhbER1cmF0aW9uXG4gKi9cbiAgICAgIGFzeW5jIHNldFJlbnRhbEdyYWNlUGVyaW9kKHJlbnRhbER1cmF0aW9uKXtcbmNvbnN0e1xuZmFjZXRzOntoZWxwZXJ9LFxuc3RhdGV9PVxudGhpcztcblxuYXdhaXQgaGVscGVyLnNldEdyYWNlUGVyaW9kKHJlbnRhbER1cmF0aW9uKTtcblxuY29uc3QgZ3JhY2VQZXJpb2Q9e1xuZ3JhY2VQZXJpb2RTdGFydDpzdGF0ZS5ncmFjZVBlcmlvZC5zdGFydC53YWtlQXQsXG5ncmFjZVBlcmlvZEVuZDpzdGF0ZS5ncmFjZVBlcmlvZC5lbmQud2FrZUF0fTtcblxuXG5jb25zdCB1cGRhdGVzPXtncmFjZVBlcmlvZH07XG5oZWxwZXIudXBkYXRlUmVudGFsU3RhdGUodXBkYXRlcyk7XG5cbi8qIFhYWCBtYXliZSBhZGQgdm9pZCovXG52b2lkIGhlbHBlci5zY2hlZHVsZVdha2V1cChcbnN0YXRlLmdyYWNlUGVyaW9kLnN0YXJ0Lndha2VBdCxcbnN0YXRlLmdyYWNlUGVyaW9kLnN0YXJ0LmNhbmNlbFRva2VuLFxuaGVscGVyLmdyYWNlUGVyaW9kU3RhcnRDYWxsYmFjaygpKTtcblxudm9pZCBoZWxwZXIuc2NoZWR1bGVXYWtldXAoXG5zdGF0ZS5ncmFjZVBlcmlvZC5lbmQud2FrZUF0LFxuc3RhdGUuZ3JhY2VQZXJpb2QuZW5kLmNhbmNlbFRva2VuLFxuaGVscGVyLmdyYWNlUGVyaW9kRW5kQ2FsbGJhY2soKSk7XG5cbiB9LFxuLyoqXG4gKiBDYWxsZWQgb24gYm9ycm93LiBDcmVhdGVzIGEgcmVjb3JkIHRvIGJlIGhhbmRlZCBvdmVyIHRvIHRoZSBib3Jyb3dlciB0aGF0IGNvbnRhaW5zIGFuIGludml0YXRpb25NYWtlciBmb3JcbiAqIHJldHVybmluZyB0aGUgdXRpbGl0eSBhbmQgYSBzdWJzY3JpYmVyIHRvIGtlZXAgdHJhY2sgb2YgdGhlIHJlbnRhbC5cbiAqL1xuaW5pdExlYXNlS2l0KCl7XG5jb25zdHtmYWNldHN9PXRoaXM7XG5jb25zdHtzZWxmfT1mYWNldHM7XG5jb25zdCBsZWFzZUtpdD1tYWtlTGVhc2VLaXQoc2VsZik7XG5yZXR1cm4gbGVhc2VLaXQ7XG4gfSxcbi8qKlxuICogQ3JlYXRlcyBhIHJlY29yZCB0byBiZSBoYW5kZWQgb3ZlciB0byB0aGUgYmlkZGVyLiBIYXMganVzdCBlbm91Z2ggYmVoYXZpb3IgZm9sbG93IHVwIG9uIHRoZSBiaWQuXG4gKiBAcGFyYW0ge0hhbmRsZTwnQmlkJz59IGJpZEhhbmRsZVxuICovXG5pbml0QmlkS2l0KGJpZEhhbmRsZSl7XG5jb25zdHtmYWNldHN9PXRoaXM7XG5jb25zdHthdWN0aW9ufT1mYWNldHM7XG5jb25zdCBiaWRLaXQ9bWFrZUJpZEtpdChhdWN0aW9uLGJpZEhhbmRsZSk7XG5yZXR1cm4gYmlkS2l0O1xuIH0sXG4vKipcbiAqIE9mZmVySGFuZGxlciBmb3IgdXBkYXRpbmcgcmVudGFsIGNvbmZpZ3VyYXRpb24uXG4gKlxuICogVGhlIG9mZmVyIHJlc3VsdCBpcyBhIHJlY29yZCBjb25zaXN0aW5nIG9mIGEgc3VjY2VzcyBtZXNzYWdlIGFuZCBhIHByb21pc2UgdG8gdGhlIHJlY29yZGVyIGtpdCB3cml0ZSBvcGVyYXRpb24uXG4gKiBJdCdzIHVzZWZ1bCB0ZXN0aW5nIGFuZCBkZWJ1Z2dpbmcgcHVycG9zZXMgYW5kIHRoZSBjbGllbnQgY2FuIG9taXQgaXQuXG4gKiBAcGFyYW0ge3t1cGRhdGVkUmVudGFsQ29uZmlnOiBYaW1wb3J0KCcuL3R5cGVzJykuUmVudGFsQ29uZmlnfSB8IHVuZGVmaW5lZH0gb2ZmZXJBcmdzXG4gKi9cbm1ha2VVcGRhdGVSZW50YWxDb25maWdIb29rKG9mZmVyQXJncyl7XG5hc3NlcnQoXG5vZmZlckFyZ3M/LnVwZGF0ZWRSZW50YWxDb25maWcsXG4ndXBkYXRlZFJlbnRhbENvbmZpZyBub3QgcHJvdmlkZWQnKTtcbi8qIFhYWCB0eXBlZ2F1cmQgaXMgYmV0dGVyISovXG5jb25zdHtmYWNldHMsc3RhdGV9PXRoaXM7XG5jb25zdHtoZWxwZXJ9PWZhY2V0cztcbmNvbnN0e3JlbnRhbFN0YXRlfT1zdGF0ZTtcblxuY29uc3R7dXBkYXRlZFJlbnRhbENvbmZpZ309b2ZmZXJBcmdzO1xuXG5sb2dnZXIoJ0lORk8nLCdVcGRhdGluZyByZW50YWwgY29uZmlndXJhdGlvbi4uLicse1xudXBkYXRlZFJlbnRhbENvbmZpZ30pO1xuXG5cbmNvbnN0e3V0aWxpdHlBbW91bnR9PXVwZGF0ZWRSZW50YWxDb25maWc7XG5cbmFzc2VydFJlbnRhbENvbmZpZyh6Y2YsdXBkYXRlZFJlbnRhbENvbmZpZyk7XG5hc3NlcnRVdGlsaXR5KHJlbnRhbFN0YXRlLmNvbmZpZ3VyYXRpb24sdXRpbGl0eUFtb3VudCk7XG5hc3NlcnRSZW50YWxQaGFzZShyZW50YWxTdGF0ZS5waGFzZSxQaGFzZS5BVkFJTEFCTEUpO1xuXG5jb25zdCBzdGF0ZXM9aGVscGVyLnVwZGF0ZVJlbnRhbENvbmZpZyh1cGRhdGVkUmVudGFsQ29uZmlnKTtcblxubG9nZ2VyKCdJTkZPJywnUmVudGFsIGNvbmZpZ3VyYXRpb24gdXBkYXRlZCBzdWNjZXNzZnVsbHknKTtcbnJldHVybiBoYXJkZW4oe21lc3NhZ2U6J1JlbnRhbENvbmZpZyB1cGRhdGVkJyxzdGF0ZXN9KTtcbiB9LFxuLyoqXG4gKiBBIGhlbHBlciBmb3Igc3dhcHBpbmcgd2hlbiBib3Jyb3dpbmcuXG4gKiBAcGFyYW0ge1pDRlNlYXR9IGJvcnJvd2VyU2VhdFxuICovXG5tYWtlQXRvbWljU3dhcChib3Jyb3dlclNlYXQpe1xuY29uc3R7c3RhdGV9PXRoaXM7XG5jb25zdHtyZW50YWxTZWF0LGNvbFNlYXR9PXN0YXRlO1xuXG5jb25zdHtcbmdpdmU6e0NvbGxhdGVyYWw6Y29sbGF0ZXJhbEFtb3VudCxSZW50YWxGZWU6cmVudGFsRmVlQW1vdW50fSxcbndhbnQ6e1V0aWxpdHk6dXRpbGl0eUFtb3VudFdhbnRlZH19PVxuYm9ycm93ZXJTZWF0LmdldFByb3Bvc2FsKCk7XG5cbi8qKiBAdHlwZSB7WGltcG9ydCgnQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC9hdG9taWNUcmFuc2Zlci5qcycpLlRyYW5zZmVyUGFydH0gKi9cbmNvbnN0IHV0aWxpdHlUb0JvcnJvd2VyVHJhbnNmZXI9W1xucmVudGFsU2VhdCxcbmJvcnJvd2VyU2VhdCxcbntcbltrZXl3b3JkSGVscGVyLmdldEtleXdvcmQodXRpbGl0eUFtb3VudFdhbnRlZCldOlxudXRpbGl0eUFtb3VudFdhbnRlZH0sXG5cbntcblV0aWxpdHk6dXRpbGl0eUFtb3VudFdhbnRlZH1dO1xuXG5cblxuLyoqIEB0eXBlIHtYaW1wb3J0KCdAYWdvcmljL3pvZS9zcmMvY29udHJhY3RTdXBwb3J0L2F0b21pY1RyYW5zZmVyLmpzJykuVHJhbnNmZXJQYXJ0fSAqL1xuY29uc3QgY29sVG9DcmFiYmxlVHJhbnNmZXI9W1xuYm9ycm93ZXJTZWF0LFxuY29sU2VhdCxcbntcbkNvbGxhdGVyYWw6Y29sbGF0ZXJhbEFtb3VudH0sXG5cbntcbltrZXl3b3JkSGVscGVyLmdldEtleXdvcmQoY29sbGF0ZXJhbEFtb3VudCldOmNvbGxhdGVyYWxBbW91bnR9XTtcblxuXG5cbi8qKiBAdHlwZSB7WGltcG9ydCgnQGFnb3JpYy96b2Uvc3JjL2NvbnRyYWN0U3VwcG9ydC9hdG9taWNUcmFuc2Zlci5qcycpLlRyYW5zZmVyUGFydH0gKi9cbmNvbnN0IGZlZVRyYW5zZmVyPVtcbmJvcnJvd2VyU2VhdCxcbnJlbnRhbFNlYXQsXG57XG5SZW50YWxGZWU6cmVudGFsRmVlQW1vdW50fSxcblxue1xuW2tleXdvcmRIZWxwZXIuZ2V0S2V5d29yZChyZW50YWxGZWVBbW91bnQpXTpyZW50YWxGZWVBbW91bnR9XTtcblxuXG5cbmF0b21pY1JlYXJyYW5nZShcbnpjZixcbmhhcmRlbihbXG51dGlsaXR5VG9Cb3Jyb3dlclRyYW5zZmVyLFxuY29sVG9DcmFiYmxlVHJhbnNmZXIsXG5mZWVUcmFuc2Zlcl0pKTtcblxuXG5cbmJvcnJvd2VyU2VhdC5leGl0KCk7XG5cbnJldHVybidBc3NldHMgc3dhcHBlZCBzdWNjZXNzZnVsbHknO1xuIH0sXG4vKipcbiAqIE9mZmVySGFuZGxlciBmb3IgYm9ycm93aW5nIEFkLUhvYy5cbiAqXG4gKiBPdXIgb2ZmZXJSZXN1bGQgPSB7IGxlYXNlS2l0LCBtZXNzYWdlLCBzdGF0ZXMgfVxuICogLSBsZWFzZUtpdDogQSByZWNvcmQgdGhhdCBjb250YWlucyBiZWhhdmlvciBmb3IgYm9ycm93IHRvIHBlcmZvcm0gb3BlcmF0aW9ucyBvbiB0aGUgYm9ycm93ZWQgdXRpbGl0eVxuICogLSBtZXNzYWdlOiBBIHN1Y2Nlc3MgbWVzc2FnZVxuICogLSBzdGF0ZXM6IEFuIGFycmF5IG9mIHByb21pc2VzIHRoYXQgd2lsbCByZXNvbHZlIHdoZW4gdGhlIHJlY29yZGVyS2l0IGNvbXBsZXRlcyB3cml0aW5nLiBUaGlzIGlzIGZvciB0ZXN0aW5nXG4gKiBpbiBTd2luZ1NldCBlbnZpcm9ubWVudC4gQWxzbyBzZWVtcyBsaWtlIGl0IG1pZ2h0IGJlIGdvb2QgZm9yIGRlYnVnZ2luZy4gT25lIHRoaW5nIHRvIGtlZXAgaW4gbWluZCBpcyB0aGF0XG4gKiB0aGlzIHN0cnVjdHVyZSBvZiBhbiBvZmZlciByZXN1bHQgbWlnaHQgYnJlYWsgc21hcnQgd2FsbGV0IGludGVncmF0aW9uLiBFc3BlY2lhbGx5IGZvciBjcmVhdGluZyBpbnZpdGF0aW9uc1xuICogdXNpbmcgYGludml0YXRpb25NYWtlcnNgIHBhdHRlcm4uXG4gKiBAcGFyYW0ge1pDRlNlYXR9IGJvcnJvd2VyU2VhdFxuICogQHBhcmFtIHt7cmVudGluZ0R1cmF0aW9uOiBiaWdpbnR9fSBvZmZlckFyZ3NcbiAqL1xubWFrZUJ1eU91dEhvb2soYm9ycm93ZXJTZWF0LG9mZmVyQXJncyl7XG5jb25zdHtmYWNldHMsc3RhdGV9PXRoaXM7XG5jb25zdHtoZWxwZXJ9PWZhY2V0cztcbmNvbnN0e3JlbnRhbFN0YXRlfT1zdGF0ZTtcblxuY29uc3R7cmVudGluZ0R1cmF0aW9ufT1vZmZlckFyZ3M7XG5cbmxvZ2dlcignSU5GTycsJ1V0aWxpdHkgYmVpbmcgYm9ycm93ZWQgdmlhIEFkLUhvYy4uLicse1xucmVudGluZ0R1cmF0aW9uLFxuVXRpbGl0eTpib3Jyb3dlclNlYXQuZ2V0UHJvcG9zYWwoKS53YW50LlV0aWxpdHksXG5Db2xsYXRlcmFsOmJvcnJvd2VyU2VhdC5nZXRQcm9wb3NhbCgpLmdpdmUuQ29sbGF0ZXJhbCxcblJlbnRhbEZlZTpib3Jyb3dlclNlYXQuZ2V0UHJvcG9zYWwoKS5naXZlLlJlbnRhbEZlZX0pO1xuXG5cbmFzc2VydFJlbnRhbFBoYXNlKHJlbnRhbFN0YXRlLnBoYXNlLFBoYXNlLkFWQUlMQUJMRSk7XG5hc3NlcnRSZW50aW5nVGllcihyZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uLCdBZC1Ib2MnKTtcbmFzc2VydFJlbnRpbmdEdXJhdGlvbihyZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uLHJlbnRpbmdEdXJhdGlvbik7XG5hc3NlcnRSZW50YWxGZWUoXG5yZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uLFxuYm9ycm93ZXJTZWF0LFxucmVudGluZ0R1cmF0aW9uKTtcblxuXG5oZWxwZXIubWFrZUF0b21pY1N3YXAoYm9ycm93ZXJTZWF0KTsvKiBTd2FwIGhlbHBlciovXG5cbmNvbnN0IHVwZGF0ZVA9aGVscGVyLnVwZGF0ZVJlbnRhbFBoYXNlKFBoYXNlLlJFTlRFRCk7XG5jb25zdCBncmFjZVA9aGVscGVyLnNldFJlbnRhbEdyYWNlUGVyaW9kKHJlbnRpbmdEdXJhdGlvbik7XG5cbmNvbnN0IGxlYXNlS2l0PWhlbHBlci5pbml0TGVhc2VLaXQoKTtcblxubG9nZ2VyKCdJTkZPJywnVXRpbGl0eSBib3Jyb3dlZCBzdWNjZXNzZnVsbHkgdmlhIEFkLUhvYycpO1xucmV0dXJue1xuLi4ubGVhc2VLaXQsXG5tZXNzYWdlOidTdWNjZXNzJyxcbnN0YXRlczpbZ3JhY2VQLC4uLnVwZGF0ZVBdfTtcblxuIH0sXG4vKipcbiAqIE9mZmVySGFuZGxlciBmb3IgYmlkZGluZyBvbiBhIHV0aWxpdHkuXG4gKlxuICogT3VyIG9mZmVyUmVzdWxkID0geyBiaWRLaXQsIG1lc3NhZ2UsIHN0YXRlcyB9XG4gKiAtIGJpZEtpdDogQSByZWNvcmQgdGhhdCBjb250YWlucyBiZWhhdmlvciBmb3IgdGhlIGJpZCB0byBmb2xsb3cgdXAgdGhlIHJlbWFpbmluZyBmbG93IGFjY29yZGluZyB0byB0aGUgb3duZXInc1xuICogZGVjaXNpb24uXG4gKiAtIG1lc3NhZ2U6IEEgc3VjY2VzcyBtZXNzYWdlXG4gKiAtIHN0YXRlczogQW4gYXJyYXkgb2YgcHJvbWlzZXMgdGhhdCB3aWxsIHJlc29sdmUgd2hlbiB0aGUgcmVjb3JkZXJLaXQgY29tcGxldGVzIHdyaXRpbmcuIFRoaXMgaXMgZm9yIHRlc3RpbmdcbiAqIGluIFN3aW5nU2V0IGVudmlyb25tZW50LiBBbHNvIHNlZW1zIGxpa2UgaXQgbWlnaHQgYmUgZ29vZCBmb3IgZGVidWdnaW5nLiBPbmUgdGhpbmcgdG8ga2VlcCBpbiBtaW5kIGlzIHRoYXRcbiAqIHRoaXMgc3RydWN0dXJlIG9mIGFuIG9mZmVyIHJlc3VsdCBtaWdodCBicmVhayBzbWFydCB3YWxsZXQgaW50ZWdyYXRpb24uIEVzcGVjaWFsbHkgZm9yIGNyZWF0aW5nIGludml0YXRpb25zXG4gKiB1c2luZyBgaW52aXRhdGlvbk1ha2Vyc2AgcGF0dGVybi5cbiAqIEBwYXJhbSB7eyBiaWRDb25maWc6IFhpbXBvcnQoJy4vdHlwZXMuanMnKS5CaWRDb25maWd9IHwgdW5kZWZpbmVkIH0gb2ZmZXJBcmdzXG4gKi9cbiAgICAgIGFzeW5jIG1ha2VCaWRIb29rKG9mZmVyQXJncyl7XG5hc3NlcnQob2ZmZXJBcmdzPy5iaWRDb25maWcsJ2JpZENvbmZpZyBub3QgcHJvdmlkZWQnKTsvKiBYWFggcGF0dGVybiBtYXRjaGVyIGlzIGJldHRlciBoZXJlISovXG5jb25zdHtmYWNldHMsc3RhdGV9PXRoaXM7XG5jb25zdHtoZWxwZXJ9PWZhY2V0cztcbmNvbnN0e3JlbnRhbFN0YXRlLGJpZHNNYW5hZ2VyRmFjZXR9PXN0YXRlO1xuXG5jb25zdHtiaWRDb25maWd9PW9mZmVyQXJncztcblxubG9nZ2VyKCdJTkZPJywnQmlkIGJlaW5nIHN1Ym1pdHRlZC4uLicse1xuQmlkQ29uZmlnOmJpZENvbmZpZyxcblV0aWxpdHk6cmVudGFsU3RhdGUuY29uZmlndXJhdGlvbi51dGlsaXR5QW1vdW50fSk7XG5cblxuYXNzZXJ0QmlkQ29uZmlnKHpjZixiaWRDb25maWcscmVudGFsU3RhdGUuY29uZmlndXJhdGlvbik7XG5hc3NlcnRSZW50YWxQaGFzZShyZW50YWxTdGF0ZS5waGFzZSxQaGFzZS5BVkFJTEFCTEUpO1xuYXNzZXJ0UmVudGluZ1RpZXIocmVudGFsU3RhdGUuY29uZmlndXJhdGlvbiwnQXVjdGlvbicpO1xuXG4vKiBzdG9yZSBiaWQgYW5kIHVwZGF0ZSBub3RpZmllciovXG5jb25zdCBiaWRIYW5kbGU9bWFrZUJpZEhhbmRsZSgpO1xuXG5sb2dnZXIoXG4nREVCVUcnLFxuJ1dhaXRpbmcgZm9yIGJpZHNNYW5hZ2VyRmFjZXQuYWRkQmlkKCkgdG8gcmVzb2x2ZS4uLicpO1xuXG5jb25zdCBzdGF0ZXM9YXdhaXQgYmlkc01hbmFnZXJGYWNldC5hZGRCaWQoXG5iaWRIYW5kbGUsXG5oYXJkZW4oe1xuLi4uYmlkQ29uZmlnLFxuY29sbGF0ZXJhbElzc3VlcjpnZXRJc3N1ZXJGcm9tQW1vdW50KFxuemNmLFxuYmlkQ29uZmlnLmNvbGxhdGVyYWxBbW91bnQpLFxuXG5yZW50YWxGZWVJc3N1ZXI6Z2V0SXNzdWVyRnJvbUFtb3VudChcbnpjZixcbmJpZENvbmZpZy5yZW50YWxGZWVQZXJVbml0QW1vdW50KX0pKTtcblxuXG5cblxuY29uc3QgYmlkS2l0PWhlbHBlci5pbml0QmlkS2l0KGJpZEhhbmRsZSk7XG5cbmxvZ2dlcignSU5GTycsJ05ldyBiaWQgc3VibWl0dGVkIHN1Y2Nlc3NmdWxseScpO1xucmV0dXJuIGhhcmRlbih7bWVzc2FnZTonU3VjY2Vzcycsc3RhdGVzLC4uLmJpZEtpdH0pO1xuIH0sXG4vKipcbiAqIE9mZmVySGFuZGxlciBmb3IgdXBkYXRpbmcgdGhlIGJpZCBjb25maWd1cmF0aW9uLlxuICpcbiAqIE91ciBvZmZlclJlc3VsZCA9IHsgbWVzc2FnZSwgc3RhdGVzIH1cbiAqIC0gbWVzc2FnZTogQSBzdWNjZXNzIG1lc3NhZ2VcbiAqIC0gc3RhdGVzOiBBbiBhcnJheSBvZiBwcm9taXNlcyB0aGF0IHdpbGwgcmVzb2x2ZSB3aGVuIHRoZSByZWNvcmRlcktpdCBjb21wbGV0ZXMgd3JpdGluZy4gVGhpcyBpcyBmb3IgdGVzdGluZ1xuICogaW4gU3dpbmdTZXQgZW52aXJvbm1lbnQuIEFsc28gc2VlbXMgbGlrZSBpdCBtaWdodCBiZSBnb29kIGZvciBkZWJ1Z2dpbmcuIE9uZSB0aGluZyB0byBrZWVwIGluIG1pbmQgaXMgdGhhdFxuICogdGhpcyBzdHJ1Y3R1cmUgb2YgYW4gb2ZmZXIgcmVzdWx0IG1pZ2h0IGJyZWFrIHNtYXJ0IHdhbGxldCBpbnRlZ3JhdGlvbi4gRXNwZWNpYWxseSBmb3IgY3JlYXRpbmcgaW52aXRhdGlvbnNcbiAqIHVzaW5nIGBpbnZpdGF0aW9uTWFrZXJzYCBwYXR0ZXJuLlxuICogQHBhcmFtIHt7YmlkSGFuZGxlOiBIYW5kbGU8J0JpZCc+LCB1cGRhdGVkQmlkQ29uZmlnOiBYaW1wb3J0KCcuL3R5cGVzJykuQmlkQ29uZmlnfSB8IHVuZGVmaW5lZH0gb2ZmZXJBcmdzXG4gKi9cbiAgICAgIGFzeW5jIG1ha2VVcGRhdGVCaWRIb29rKG9mZmVyQXJncyl7XG5hc3NlcnQoXG5vZmZlckFyZ3M/LmJpZEhhbmRsZSYmb2ZmZXJBcmdzPy51cGRhdGVkQmlkQ29uZmlnLFxuJ29mZmVyQXJncyBub3QgcHJvdmlkZWQnKTtcbi8qIFhYWCBwYXR0ZXJuIG1hdGNoZXIgaXMgYmV0dGVyIGhlcmUhKi9cbmNvbnN0e3N0YXRlfT10aGlzO1xuY29uc3R7cmVudGFsU3RhdGUsYmlkc01hbmFnZXJGYWNldH09c3RhdGU7XG5cbmNvbnN0e2JpZEhhbmRsZSx1cGRhdGVkQmlkQ29uZmlnfT1vZmZlckFyZ3M7XG5cbmxvZ2dlcignSU5GTycsJ0JpZCBjb25maWd1cmF0aW9uIGJlaW5nIHVwZGF0ZWQuLi4nLHtcbkJpZEhhbmRsZTpiaWRIYW5kbGUsXG5VcGRhdGVkQmlkQ29uZmlnOnVwZGF0ZWRCaWRDb25maWcsXG5VdGlsaXR5OnJlbnRhbFN0YXRlLmNvbmZpZ3VyYXRpb24udXRpbGl0eUFtb3VudH0pO1xuXG5cbmFzc2VydChiaWRIYW5kbGUsJ2JpZEhhbmRsZSB3YXMgbm90IHByb3ZpZGVkJyk7XG5hc3NlcnRCaWRDb25maWcoemNmLHVwZGF0ZWRCaWRDb25maWcscmVudGFsU3RhdGUuY29uZmlndXJhdGlvbik7XG5hc3NlcnRSZW50YWxQaGFzZShyZW50YWxTdGF0ZS5waGFzZSxQaGFzZS5BVkFJTEFCTEUpO1xuYXNzZXJ0UmVudGluZ1RpZXIocmVudGFsU3RhdGUuY29uZmlndXJhdGlvbiwnQXVjdGlvbicpO1xuXG5sb2dnZXIoXG4nREVCVUcnLFxuJ1dhaXRpbmcgZm9yIGJpZHNNYW5hZ2VyRmFjZXQudXBkYXRlQmlkKCkgdG8gcmVzb2x2ZS4uLicpO1xuXG5jb25zdCBzdGF0ZXM9YXdhaXQgYmlkc01hbmFnZXJGYWNldC51cGRhdGVCaWQoXG5iaWRIYW5kbGUsXG5oYXJkZW4oe1xuLi4udXBkYXRlZEJpZENvbmZpZyxcbmNvbGxhdGVyYWxJc3N1ZXI6Z2V0SXNzdWVyRnJvbUFtb3VudChcbnpjZixcbnVwZGF0ZWRCaWRDb25maWcuY29sbGF0ZXJhbEFtb3VudCksXG5cbnJlbnRhbEZlZUlzc3VlcjpnZXRJc3N1ZXJGcm9tQW1vdW50KFxuemNmLFxudXBkYXRlZEJpZENvbmZpZy5yZW50YWxGZWVQZXJVbml0QW1vdW50KX0pKTtcblxuXG5cblxubG9nZ2VyKCdJTkZPJywnQmlkIGNvbmZpZ3VyYXRpb24gdXBkYXRlZCBzdWNjZXNzZnVsbHknKTtcbnJldHVybiBoYXJkZW4oe1xubWVzc2FnZTonQmlkIGNvbmZpZ3VyYXRpb24gdXBkYXRlZCBzdWNjZXNzZnVsbHknLFxuc3RhdGVzfSk7XG5cbiB9LFxuLyoqXG4gKiBPZmZlckhhbmRsZXIgZm9yIGNhbmNlbGxpbmcgdGhlIGJpZC5cbiAqXG4gKiBPdXIgb2ZmZXJSZXN1bGQgPSB7IG1lc3NhZ2UsIHN0YXRlcyB9XG4gKiAtIG1lc3NhZ2U6IEEgc3VjY2VzcyBtZXNzYWdlXG4gKiAtIHN0YXRlczogQW4gYXJyYXkgb2YgcHJvbWlzZXMgdGhhdCB3aWxsIHJlc29sdmUgd2hlbiB0aGUgcmVjb3JkZXJLaXQgY29tcGxldGVzIHdyaXRpbmcuIFRoaXMgaXMgZm9yIHRlc3RpbmdcbiAqIGluIFN3aW5nU2V0IGVudmlyb25tZW50LiBBbHNvIHNlZW1zIGxpa2UgaXQgbWlnaHQgYmUgZ29vZCBmb3IgZGVidWdnaW5nLiBPbmUgdGhpbmcgdG8ga2VlcCBpbiBtaW5kIGlzIHRoYXRcbiAqIHRoaXMgc3RydWN0dXJlIG9mIGFuIG9mZmVyIHJlc3VsdCBtaWdodCBicmVhayBzbWFydCB3YWxsZXQgaW50ZWdyYXRpb24uIEVzcGVjaWFsbHkgZm9yIGNyZWF0aW5nIGludml0YXRpb25zXG4gKiB1c2luZyBgaW52aXRhdGlvbk1ha2Vyc2AgcGF0dGVybi5cbiAqIEBwYXJhbSB7eyBiaWRIYW5kbGU6IEhhbmRsZTwnQmlkJz4gfX0gb2ZmZXJBcmdzXG4gKi9cbm1ha2VDYW5jZWxCaWRIb29rKG9mZmVyQXJncyl7XG5jb25zdHtzdGF0ZX09dGhpcztcbmNvbnN0e3JlbnRhbFN0YXRlLGJpZHNNYW5hZ2VyRmFjZXR9PXN0YXRlO1xuXG5jb25zdHtiaWRIYW5kbGV9PW9mZmVyQXJncztcblxubG9nZ2VyKCdJTkZPJywnQmlkIGJlaW5nIGNhbmNlbGVkLi4uJyx7XG5CaWRIYW5kbGU6YmlkSGFuZGxlLFxuVXRpbGl0eTpyZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uLnV0aWxpdHlBbW91bnR9KTtcblxuXG5hc3NlcnQoYmlkSGFuZGxlLCdiaWRIYW5kbGUgd2FzIG5vdCBwcm92aWRlZCcpO1xuYXNzZXJ0UmVudGFsUGhhc2UocmVudGFsU3RhdGUucGhhc2UsUGhhc2UuQVZBSUxBQkxFKTtcbmFzc2VydFJlbnRpbmdUaWVyKHJlbnRhbFN0YXRlLmNvbmZpZ3VyYXRpb24sJ0F1Y3Rpb24nKTtcblxuY29uc3QgYmlkU3RhdGVVcGRhdGVQPWJpZHNNYW5hZ2VyRmFjZXQuY2FuY2VsQmlkKGJpZEhhbmRsZSk7XG5cbmxvZ2dlcignSU5GTycsJ0JpZCBjYW5jZWxlZCBzdWNjZXNzZnVsbHknKTtcbnJldHVybiBoYXJkZW4oe1xubWVzc2FnZTonQmlkIGNhbmNlbGVkIHN1Y2Nlc3NmdWxseScsXG5zdGF0ZXM6W2JpZFN0YXRlVXBkYXRlUF19KTtcblxuIH0sXG4vKipcbiAqIE9mZmVySGFuZGxlciBmb3IgYWNjZXB0aW5nIGEgYmlkLiBPd25lciBtYWtlcyB0aGlzIG9mZmVyLlxuICpcbiAqIE91ciBvZmZlclJlc3VsZCA9IHsgbWVzc2FnZSwgc3RhdGVzIH1cbiAqIC0gbWVzc2FnZTogQSBzdWNjZXNzIG1lc3NhZ2VcbiAqIC0gc3RhdGVzOiBBbiBhcnJheSBvZiBwcm9taXNlcyB0aGF0IHdpbGwgcmVzb2x2ZSB3aGVuIHRoZSByZWNvcmRlcktpdCBjb21wbGV0ZXMgd3JpdGluZy4gVGhpcyBpcyBmb3IgdGVzdGluZ1xuICogaW4gU3dpbmdTZXQgZW52aXJvbm1lbnQuIEFsc28gc2VlbXMgbGlrZSBpdCBtaWdodCBiZSBnb29kIGZvciBkZWJ1Z2dpbmcuIE9uZSB0aGluZyB0byBrZWVwIGluIG1pbmQgaXMgdGhhdFxuICogdGhpcyBzdHJ1Y3R1cmUgb2YgYW4gb2ZmZXIgcmVzdWx0IG1pZ2h0IGJyZWFrIHNtYXJ0IHdhbGxldCBpbnRlZ3JhdGlvbi4gRXNwZWNpYWxseSBmb3IgY3JlYXRpbmcgaW52aXRhdGlvbnNcbiAqIHVzaW5nIGBpbnZpdGF0aW9uTWFrZXJzYCBwYXR0ZXJuLlxuICogQHBhcmFtIHt7IGJpZElEOiBudW1iZXIsIGFjY2VwdGVkV2FpdGluZ1BlcmlvZDogUmVsYXRpdmVUaW1lIH19IG9mZmVyQXJnc1xuICovXG4gICAgICBhc3luYyBtYWtlQWNjZXB0QmlkSG9vayhvZmZlckFyZ3Mpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5jb25zdHtyZW50YWxTdGF0ZSxiaWRzTWFuYWdlckZhY2V0fT1zdGF0ZTtcblxuY29uc3R7YmlkSUQsYWNjZXB0ZWRXYWl0aW5nUGVyaW9kfT1vZmZlckFyZ3M7XG5cbmxvZ2dlcignSU5GTycsJ0JpZCBiZWluZyBhY2NlcHRlZC4uLicse1xuYmlkSUQsXG5hY2NlcHRlZFdhaXRpbmdQZXJpb2QsXG5VdGlsaXR5OnJlbnRhbFN0YXRlLmNvbmZpZ3VyYXRpb24udXRpbGl0eUFtb3VudH0pO1xuXG5cbmFzc2VydFJlbnRhbFBoYXNlKHJlbnRhbFN0YXRlLnBoYXNlLFBoYXNlLkFWQUlMQUJMRSk7XG5hc3NlcnRSZW50aW5nVGllcihyZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uLCdBdWN0aW9uJyk7XG5cbmxvZ2dlcihcbidERUJVRycsXG4nV2FpdGluZyBmb3IgYmlkc01hbmFnZXJGYWNldC5hY2NlcHRCaWQoKSB0byByZXNvbHZlLi4uJyk7XG5cbmNvbnN0IGJpZFN0YXRlcz1hd2FpdCBiaWRzTWFuYWdlckZhY2V0LmFjY2VwdEJpZChcbmJpZElELFxuYWNjZXB0ZWRXYWl0aW5nUGVyaW9kKTtcblxuXG5sb2dnZXIoJ0lORk8nLCdCaWQgYWNjZXB0ZWQgc3VjY2Vzc2Z1bGx5Jyk7XG5jb25zdCByb290U3RhdGVzPWhlbHBlci51cGRhdGVSZW50YWxQaGFzZShQaGFzZS5IT0xEKTtcbnJldHVybiBoYXJkZW4oe1xubWVzc2FnZTonQmlkIGFjY2VwdGVkIHN1Y2Nlc3NmdWxseScsXG5zdGF0ZXM6Wy4uLmJpZFN0YXRlcywuLi5yb290U3RhdGVzXX0pO1xuXG4gfSxcbi8qKlxuICogT2ZmZXJIYW5kbGVyIGZvciBib3Jyb3dpbmcgd2l0aCBhdWN0aW9uIHRpZXIuXG4gKlxuICogT3VyIG9mZmVyUmVzdWx0ID0geyBsZWFzZUtpdCwgbWVzc2FnZSwgc3RhdGVzIH1cbiAqIC0gbGVhc2VLaXQ6IEEgcmVjb3JkIHRoYXQgY29udGFpbnMgYmVoYXZpb3IgZm9yIGJvcnJvdyB0byBwZXJmb3JtIG9wZXJhdGlvbnMgb24gdGhlIGJvcnJvd2VkIHV0aWxpdHlcbiAqIC0gbWVzc2FnZTogQSBzdWNjZXNzIG1lc3NhZ2VcbiAqIC0gc3RhdGVzOiBBbiBhcnJheSBvZiBwcm9taXNlcyB0aGF0IHdpbGwgcmVzb2x2ZSB3aGVuIHRoZSByZWNvcmRlcktpdCBjb21wbGV0ZXMgd3JpdGluZy4gVGhpcyBpcyBmb3IgdGVzdGluZ1xuICogaW4gU3dpbmdTZXQgZW52aXJvbm1lbnQuIEFsc28gc2VlbXMgbGlrZSBpdCBtaWdodCBiZSBnb29kIGZvciBkZWJ1Z2dpbmcuIE9uZSB0aGluZyB0byBrZWVwIGluIG1pbmQgaXMgdGhhdFxuICogdGhpcyBzdHJ1Y3R1cmUgb2YgYW4gb2ZmZXIgcmVzdWx0IG1pZ2h0IGJyZWFrIHNtYXJ0IHdhbGxldCBpbnRlZ3JhdGlvbi4gRXNwZWNpYWxseSBmb3IgY3JlYXRpbmcgaW52aXRhdGlvbnNcbiAqIHVzaW5nIGBpbnZpdGF0aW9uTWFrZXJzYCBwYXR0ZXJuLlxuICogQHBhcmFtIHtaQ0ZTZWF0fSBib3Jyb3dlclNlYXRcbiAqIEBwYXJhbSB7eyBiaWRIYW5kbGU6IEhhbmRsZTwnQmlkJz59fSBvZmZlckFyZ3NcbiAqL1xubWFrZUJvcnJvd0hvb2soYm9ycm93ZXJTZWF0LG9mZmVyQXJncyl7XG5jb25zdHtmYWNldHMsc3RhdGV9PXRoaXM7XG5jb25zdHtoZWxwZXJ9PWZhY2V0cztcbmNvbnN0e3JlbnRhbFN0YXRlLGJpZHNNYW5hZ2VyRmFjZXR9PXN0YXRlO1xuXG5jb25zdHtiaWRIYW5kbGV9PW9mZmVyQXJncztcblxuY29uc3QgYmlkU3RhdGU9Ymlkc01hbmFnZXJGYWNldC5nZXRCaWRCeUhhbmRsZShiaWRIYW5kbGUpO1xuY29uc3R7Y29uZmlndXJhdGlvbjpiaWRDb25maWcsc3RhdHVzfT1iaWRTdGF0ZTtcblxubG9nZ2VyKCdJTkZPJywnVXRpbGl0eSBiZWluZyBib3Jyb3dlZCB2aWEgQXVjdGlvbi4uLicse1xuV2lubmVyQmlkQ29uZmlndXJhdGlvbjpiaWRDb25maWcsXG5SZW50YWxTdGF0dXM6c3RhdHVzLFxuVXRpbGl0eTpib3Jyb3dlclNlYXQuZ2V0UHJvcG9zYWwoKS53YW50LlV0aWxpdHksXG5Db2xsYXRlcmFsOmJvcnJvd2VyU2VhdC5nZXRQcm9wb3NhbCgpLmdpdmUuQ29sbGF0ZXJhbCxcblJlbnRhbEZlZTpib3Jyb3dlclNlYXQuZ2V0UHJvcG9zYWwoKS5naXZlLlJlbnRhbEZlZX0pO1xuXG5cbmFzc2VydChzdGF0dXM9PT1CaWRQaGFzZS5IT0xELCdCaWRTdGF0dXM6IGludmFsaWQgYmlkIHN0YXR1cycpO1xuYXNzZXJ0UmVudGFsUGhhc2UocmVudGFsU3RhdGUucGhhc2UsUGhhc2UuSE9MRCk7XG5hc3NlcnRSZW50aW5nVGllcihyZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uLCdBdWN0aW9uJyk7XG5hc3NlcnRSZW50aW5nRHVyYXRpb24oXG5yZW50YWxTdGF0ZS5jb25maWd1cmF0aW9uLFxuYmlkQ29uZmlnLnJlbnRpbmdEdXJhdGlvbik7XG5cbmFzc2VydENvbGxhdGVyYWwoYmlkQ29uZmlnLGJvcnJvd2VyU2VhdCk7XG5hc3NlcnRSZW50YWxGZWUoYmlkQ29uZmlnLGJvcnJvd2VyU2VhdCxiaWRDb25maWcucmVudGluZ0R1cmF0aW9uKTtcblxuaGVscGVyLm1ha2VBdG9taWNTd2FwKGJvcnJvd2VyU2VhdCk7XG5cbmNvbnN0IHJlbnRhbFBoYXNlUD1oZWxwZXIudXBkYXRlUmVudGFsU3RhdGUoXG5oYXJkZW4oe3BoYXNlOlBoYXNlLlJFTlRFRCxsYXN0V2lubmVyQmlkOmJpZENvbmZpZ30pKTtcblxudm9pZCBoZWxwZXIuc2V0UmVudGFsR3JhY2VQZXJpb2QoYmlkQ29uZmlnLnJlbnRpbmdEdXJhdGlvbik7XG5jb25zdCBhdWN0aW9uRmluaXNoUExpc3Q9XG5iaWRzTWFuYWdlckZhY2V0LmZpbmlzaEF1Y3Rpb25Sb3VuZChiaWRIYW5kbGUpO1xuXG5jb25zdCBsZWFzZUtpdD1oZWxwZXIuaW5pdExlYXNlS2l0KCk7XG5cbmxvZ2dlcignSU5GTycsJ1V0aWxpdHkgYm9ycm93ZWQgc3VjY2Vzc2Z1bGx5IHZpYSBBdWN0aW9uJyk7XG5yZXR1cm57XG5tZXNzYWdlOidTdWNjZXNzJyxcbnN0YXRlczpbLi4ucmVudGFsUGhhc2VQLC4uLmF1Y3Rpb25GaW5pc2hQTGlzdF0sXG4uLi5sZWFzZUtpdH07XG5cbiB9LFxuLyoqXG4gKiBPZmZlckhhbmRsZXIgZm9yIHJldHVybmluZyB0aGUgYm9ycm93ZWQgdXRpbGl0eS5cbiAqXG4gKiBPdXIgb2ZmZXJSZXN1bHQgPSB7IG1lc3NhZ2UsIHN0YXRlcyB9XG4gKiAtIG1lc3NhZ2U6IEEgc3VjY2VzcyBtZXNzYWdlXG4gKiAtIHN0YXRlczogQW4gYXJyYXkgb2YgcHJvbWlzZXMgdGhhdCB3aWxsIHJlc29sdmUgd2hlbiB0aGUgcmVjb3JkZXJLaXQgY29tcGxldGVzIHdyaXRpbmcuIFRoaXMgaXMgZm9yIHRlc3RpbmdcbiAqIGluIFN3aW5nU2V0IGVudmlyb25tZW50LiBBbHNvIHNlZW1zIGxpa2UgaXQgbWlnaHQgYmUgZ29vZCBmb3IgZGVidWdnaW5nLiBPbmUgdGhpbmcgdG8ga2VlcCBpbiBtaW5kIGlzIHRoYXRcbiAqIHRoaXMgc3RydWN0dXJlIG9mIGFuIG9mZmVyIHJlc3VsdCBtaWdodCBicmVhayBzbWFydCB3YWxsZXQgaW50ZWdyYXRpb24uIEVzcGVjaWFsbHkgZm9yIGNyZWF0aW5nIGludml0YXRpb25zXG4gKiB1c2luZyBgaW52aXRhdGlvbk1ha2Vyc2AgcGF0dGVybi5cbiAqIEBwYXJhbSB7WkNGU2VhdH0gYm9ycm93ZXJTZWF0XG4gKi9cbm1ha2VSZXR1cm5VdGlsaXR5SG9vayhib3Jyb3dlclNlYXQpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5jb25zdHtyZW50YWxTZWF0LHJlbnRhbFN0YXRlLGNvbFNlYXR9PXN0YXRlO1xuXG5sb2dnZXIoXG4nSU5GTycsXG4nVXRpbGl0eSBiZWluZyByZXR1cm5lZCBhbmQgQ29sbGF0ZXJhbCBiZWluZyB3aXRoZHJldy4uLicsXG57XG5VdGlsaXR5OmJvcnJvd2VyU2VhdC5nZXRQcm9wb3NhbCgpLmdpdmUuVXRpbGl0eSxcbkNvbGxhdGVyYWw6Ym9ycm93ZXJTZWF0LmdldFByb3Bvc2FsKCkud2FudC5Db2xsYXRlcmFsfSk7XG5cblxuXG5jb25zdHtcbmdpdmU6e1V0aWxpdHk6dXRpbGl0eUFtb3VudH0sXG53YW50OntDb2xsYXRlcmFsOmNvbGxhdGVyYWxBbW91bnR9fT1cbmJvcnJvd2VyU2VhdC5nZXRQcm9wb3NhbCgpO1xuXG5hc3NlcnRSZW50YWxQaGFzZShyZW50YWxTdGF0ZS5waGFzZSxQaGFzZS5HUkFDRV9QRVJJT0QpO1xuXG4vKiogQHR5cGUge1hpbXBvcnQoJ0BhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvYXRvbWljVHJhbnNmZXIuanMnKS5UcmFuc2ZlclBhcnR9ICovXG5jb25zdCByZXR1cm5Db2xsYXRlcmFsVHJhbnNmZXI9W1xuY29sU2VhdCxcbmJvcnJvd2VyU2VhdCxcbntba2V5d29yZEhlbHBlci5nZXRLZXl3b3JkKGNvbGxhdGVyYWxBbW91bnQpXTpjb2xsYXRlcmFsQW1vdW50fSxcbntDb2xsYXRlcmFsOmNvbGxhdGVyYWxBbW91bnR9XTtcblxuXG4vKiogQHR5cGUge1hpbXBvcnQoJ0BhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvYXRvbWljVHJhbnNmZXIuanMnKS5UcmFuc2ZlclBhcnR9ICovXG5jb25zdCByZXR1cm5VdGlsaXR5VHJhbnNmZXI9W1xuYm9ycm93ZXJTZWF0LFxucmVudGFsU2VhdCxcbntVdGlsaXR5OnV0aWxpdHlBbW91bnR9LFxue1trZXl3b3JkSGVscGVyLmdldEtleXdvcmQodXRpbGl0eUFtb3VudCldOnV0aWxpdHlBbW91bnR9XTtcblxuXG5hdG9taWNSZWFycmFuZ2UoXG56Y2YsXG5oYXJkZW4oW3JldHVyblV0aWxpdHlUcmFuc2ZlcixyZXR1cm5Db2xsYXRlcmFsVHJhbnNmZXJdKSk7XG5cblxuYm9ycm93ZXJTZWF0LmV4aXQoKTtcblxuaGVscGVyLnJlc2V0R3JhY2VQZXJpb2QoKTtcbmNvbnN0IHBoYXNlUD1oZWxwZXIudXBkYXRlUmVudGFsUGhhc2UoUGhhc2UuQVZBSUxBQkxFKTtcblxubG9nZ2VyKFxuJ0lORk8nLFxuJ1V0aWxpdHkgcmV0dXJuZWQgYW5kIENvbGxhdGVyYWwgd2l0aGRyZXcgc3VjY2Vzc2Z1bGx5Jyk7XG5cbnJldHVybntcbm1lc3NhZ2U6J1V0aWxpdHkgcmV0dXJuZWQgYW5kIENvbGxhdGVyYWwgd2l0aGRyZXcgc3VjY2Vzc2Z1bGx5JyxcbnN0YXRlczpbLi4ucGhhc2VQXX07XG5cbiB9LFxuLyoqXG4gKiBPZmZlckhhbmRsZXIgZm9yIG93bmVyIHRvIHdpdGhkcmF3IHRoZSB1dGlsaXR5XG4gKlxuICogT3VyIG9mZmVyUmVzdWxkID0geyBtZXNzYWdlLCBzdGF0ZXMgfVxuICogLSBtZXNzYWdlOiBBIHN1Y2Nlc3MgbWVzc2FnZVxuICogLSBzdGF0ZXM6IEFuIGFycmF5IG9mIHByb21pc2VzIHRoYXQgd2lsbCByZXNvbHZlIHdoZW4gdGhlIHJlY29yZGVyS2l0IGNvbXBsZXRlcyB3cml0aW5nLiBUaGlzIGlzIGZvciB0ZXN0aW5nXG4gKiBpbiBTd2luZ1NldCBlbnZpcm9ubWVudC4gQWxzbyBzZWVtcyBsaWtlIGl0IG1pZ2h0IGJlIGdvb2QgZm9yIGRlYnVnZ2luZy4gT25lIHRoaW5nIHRvIGtlZXAgaW4gbWluZCBpcyB0aGF0XG4gKiB0aGlzIHN0cnVjdHVyZSBvZiBhbiBvZmZlciByZXN1bHQgbWlnaHQgYnJlYWsgc21hcnQgd2FsbGV0IGludGVncmF0aW9uLiBFc3BlY2lhbGx5IGZvciBjcmVhdGluZyBpbnZpdGF0aW9uc1xuICogdXNpbmcgYGludml0YXRpb25NYWtlcnNgIHBhdHRlcm4uXG4gKiBAcGFyYW0ge1pDRlNlYXR9IG93bmVyU2VhdFxuICovXG5tYWtlV2l0aGRyYXdVdGlsaXR5SG9vayhvd25lclNlYXQpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5jb25zdHtyZW50YWxTZWF0LHJlbnRhbFN0YXRlfT1zdGF0ZTtcblxubG9nZ2VyKCdJTkZPJywnVXRpbGl0eSBiZWluZyB3aXRoZHJldy4uLicse1xuVXRpbGl0eTpvd25lclNlYXQuZ2V0UHJvcG9zYWwoKS53YW50LlV0aWxpdHl9KTtcblxuXG5jb25zdHtcbndhbnQ6e1V0aWxpdHk6dXRpbGl0eUFtb3VudFdhbnRlZH19PVxub3duZXJTZWF0LmdldFByb3Bvc2FsKCk7XG5jb25zdHtcbltrZXl3b3JkSGVscGVyLmdldEtleXdvcmQodXRpbGl0eUFtb3VudFdhbnRlZCldOlxudXRpbGl0eUFtb3VudEFjdHVhbH09XG5yZW50YWxTZWF0LmdldEN1cnJlbnRBbGxvY2F0aW9uKCk7XG5cbmFzc2VydFJlbnRhbFBoYXNlKHJlbnRhbFN0YXRlLnBoYXNlLFBoYXNlLkFWQUlMQUJMRSk7XG4vKiBhc3NlcnRBbW91bnROb3RFbXB0eSh1dGlsaXR5QW1vdW50QWN0dWFsKTsqL1xuXG5hdG9taWNUcmFuc2ZlcihcbnpjZixcbnJlbnRhbFNlYXQsXG5vd25lclNlYXQsXG57XG5ba2V5d29yZEhlbHBlci5nZXRLZXl3b3JkKHV0aWxpdHlBbW91bnRXYW50ZWQpXTpcbnV0aWxpdHlBbW91bnRBY3R1YWx9LFxuXG57XG5VdGlsaXR5OnV0aWxpdHlBbW91bnRBY3R1YWx9KTtcblxuXG5vd25lclNlYXQuZXhpdCgpO1xuXG5jb25zdHtyZW50YWxIYW5kbGV9PXN0YXRlO1xuY29uc3R7cmVtb3ZlUmVudGFsRnJvbUNhdGFsb2d9PWNhdGFsb2dGYWNldDtcbnJlbW92ZVJlbnRhbEZyb21DYXRhbG9nKHJlbnRhbEhhbmRsZSk7XG5cbmNvbnN0IHBoYXNlVXBkYXRlUD1oZWxwZXIudXBkYXRlUmVudGFsUGhhc2UoUGhhc2UuUkVNT1ZFRCk7XG5cbmxvZ2dlcignSU5GTycsJ1V0aWxpdHkgd2l0aGRyZXcgc3VjY2Vzc2Z1bGx5Jyk7XG5yZXR1cm57XG5tZXNzYWdlOidVdGlsaXR5IHdpdGhkcmV3IHN1Y2Nlc3NmdWxseScsXG5zdGF0ZXM6Wy4uLnBoYXNlVXBkYXRlUF19O1xuXG4gfSxcbi8qKlxuICogT2ZmZXJIYW5kbGVyIGZvciBvd25lciB0byB3aXRoZHJhdyB0aGUgcmVudGFsIGZlZVxuICpcbiAqIE91ciBvZmZlclJlc3VsZCA9IHsgbWVzc2FnZSB9XG4gKiAtIG1lc3NhZ2U6IEEgc3VjY2VzcyBtZXNzYWdlXG4gKiBAcGFyYW0ge1pDRlNlYXR9IG93bmVyU2VhdFxuICovXG5tYWtlV2l0aGRyYXdSZW50YWxGZWVIb29rKG93bmVyU2VhdCl7XG5jb25zdHtcbnN0YXRlLFxuZmFjZXRzOntoZWxwZXJ9fT1cbnRoaXM7XG5jb25zdHtyZW50YWxTZWF0fT1zdGF0ZTtcblxubG9nZ2VyKCdJTkZPJywnUmVudGFsRmVlIGJlaW5nIHdpdGhkcmV3Li4uJyx7XG5SZW50YWxGZWVfUmVxdWVzdGVkOm93bmVyU2VhdC5nZXRQcm9wb3NhbCgpLndhbnQuUmVudGFsRmVlfSk7XG5cblxuY29uc3R7XG53YW50OntSZW50YWxGZWU6cmVudGFsRmVlRHVtbXlBbW91bnR9fT1cbm93bmVyU2VhdC5nZXRQcm9wb3NhbCgpO1xuY29uc3R7XG5ba2V5d29yZEhlbHBlci5nZXRLZXl3b3JkKHJlbnRhbEZlZUR1bW15QW1vdW50KV06XG5yZW50YWxGZWVBY3R1YWxBbW91bnR9PVxucmVudGFsU2VhdC5nZXRDdXJyZW50QWxsb2NhdGlvbigpO1xuYXNzZXJ0QW1vdW50Tm90RW1wdHkocmVudGFsRmVlQWN0dWFsQW1vdW50KTtcblxuYXRvbWljVHJhbnNmZXIoXG56Y2YsXG5yZW50YWxTZWF0LFxub3duZXJTZWF0LFxue1xuW2tleXdvcmRIZWxwZXIuZ2V0S2V5d29yZChyZW50YWxGZWVEdW1teUFtb3VudCldOlxucmVudGFsRmVlQWN0dWFsQW1vdW50fSxcblxue1xuUmVudGFsRmVlOnJlbnRhbEZlZUFjdHVhbEFtb3VudH0pO1xuXG5cblxuaGVscGVyLnVwZGF0ZVJlbnRhbFN0YXRlKHt9KTtcblxub3duZXJTZWF0LmV4aXQoKTtcblxubG9nZ2VyKCdJTkZPJywnUmVudGFsRmVlIHdpdGhkcmV3IHN1Y2Nlc3NmdWxseScse1xuUmVudGFsRmVlX0dpdmVuOnJlbnRhbEZlZUFjdHVhbEFtb3VudH0pO1xuXG5yZXR1cm4nUmVudGFsRmVlIHdpdGhkcmV3IHN1Y2Nlc3NmdWxseSc7XG4gfSxcbi8qKlxuICogT2ZmZXJIYW5kbGVyIGZvciBvd25lciB0byB3aXRoZHJhdyB0aGUgY29sbGF0ZXJhbCB3aGVuIHRoZSBib3Jyb3dlciBkb2VzIG5vdCByZXR1cm4gdGhlIHV0aWxpdHkuXG4gKlxuICogT3VyIG9mZmVyUmVzdWxkID0geyBtZXNzYWdlLCBzdGF0ZXMgfVxuICogLSBtZXNzYWdlOiBBIHN1Y2Nlc3MgbWVzc2FnZVxuICogLSBzdGF0ZXM6IEFuIGFycmF5IG9mIHByb21pc2VzIHRoYXQgd2lsbCByZXNvbHZlIHdoZW4gdGhlIHJlY29yZGVyS2l0IGNvbXBsZXRlcyB3cml0aW5nLiBUaGlzIGlzIGZvciB0ZXN0aW5nXG4gKiBpbiBTd2luZ1NldCBlbnZpcm9ubWVudC4gQWxzbyBzZWVtcyBsaWtlIGl0IG1pZ2h0IGJlIGdvb2QgZm9yIGRlYnVnZ2luZy4gT25lIHRoaW5nIHRvIGtlZXAgaW4gbWluZCBpcyB0aGF0XG4gKiB0aGlzIHN0cnVjdHVyZSBvZiBhbiBvZmZlciByZXN1bHQgbWlnaHQgYnJlYWsgc21hcnQgd2FsbGV0IGludGVncmF0aW9uLiBFc3BlY2lhbGx5IGZvciBjcmVhdGluZyBpbnZpdGF0aW9uc1xuICogdXNpbmcgYGludml0YXRpb25NYWtlcnNgIHBhdHRlcm4uXG4gKiBAcGFyYW0ge1pDRlNlYXR9IG93bmVyU2VhdFxuICovXG5tYWtlV2l0aGRyYXdDb2xsYXRlcmFsSG9vayhvd25lclNlYXQpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5jb25zdHtyZW50YWxTdGF0ZSxjb2xTZWF0fT1zdGF0ZTtcblxubG9nZ2VyKCdJTkZPJywnQ29sbGF0ZXJhbCBiZWluZyB3aXRoZHJldy4uLicse1xuQ29sbGF0ZXJhbF9XYW50ZWQ6b3duZXJTZWF0LmdldFByb3Bvc2FsKCkud2FudC5Db2xsYXRlcmFsfSk7XG5cblxuY29uc3R7XG53YW50OntDb2xsYXRlcmFsOmNvbGxhdGVyYWxXYW50ZWR9fT1cbm93bmVyU2VhdC5nZXRQcm9wb3NhbCgpO1xuY29uc3R7XG5ba2V5d29yZEhlbHBlci5nZXRLZXl3b3JkKGNvbGxhdGVyYWxXYW50ZWQpXTpjb2xsYXRlcmFsQWN0dWFsfT1cbmNvbFNlYXQuZ2V0Q3VycmVudEFsbG9jYXRpb24oKTtcblxuYXNzZXJ0UmVudGFsUGhhc2UocmVudGFsU3RhdGUucGhhc2UsUGhhc2UuTElRVUlEQVRJT04pO1xuYXNzZXJ0QW1vdW50Tm90RW1wdHkoY29sbGF0ZXJhbEFjdHVhbCk7XG5cbmF0b21pY1RyYW5zZmVyKFxuemNmLFxuY29sU2VhdCxcbm93bmVyU2VhdCxcbntcbltrZXl3b3JkSGVscGVyLmdldEtleXdvcmQoY29sbGF0ZXJhbFdhbnRlZCldOmNvbGxhdGVyYWxBY3R1YWx9LFxuXG57XG5Db2xsYXRlcmFsOmNvbGxhdGVyYWxBY3R1YWx9KTtcblxuXG5vd25lclNlYXQuZXhpdCgpO1xuXG5jb25zdHtyZW50YWxIYW5kbGV9PXN0YXRlO1xuY29uc3R7cmVtb3ZlUmVudGFsRnJvbUNhdGFsb2d9PWNhdGFsb2dGYWNldDtcbnJlbW92ZVJlbnRhbEZyb21DYXRhbG9nKHJlbnRhbEhhbmRsZSk7XG5cbmNvbnN0IHBoYXNlVXBkYXRlUD1oZWxwZXIudXBkYXRlUmVudGFsUGhhc2UoUGhhc2UuUkVNT1ZFRCk7XG5cbmxvZ2dlcignSU5GTycsJ0NvbGxhdGVyYWwgd2l0aGRyZXcgc3VjY2Vzc2Z1bGx5Jyx7XG5Db2xsYXRlcmFsX0dpdmVuOmNvbGxhdGVyYWxBY3R1YWx9KTtcblxucmV0dXJue1xubWVzc2FnZTonQ29sbGF0ZXJhbCB3aXRoZHJldyBzdWNjZXNzZnVsbHknLFxuc3RhdGVzOlsuLi5waGFzZVVwZGF0ZVBdfTtcblxuIH0sXG4vKipcbiAqIEEgaGVscGVyIG1ldGhvZCBmb3Igc2NoZWR1bGluZyBhIHdha2V1cCBjYWxsIGZyb20gdGhlIHRpbWVyIHNlcnZpY2VcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy90aW1lJykuVGltZXN0YW1wVmFsdWV9IHdha2V1cFRpbWVcbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy90aW1lL3NyYy90eXBlcy5qcycpLkNhbmNlbFRva2VuIHwgdW5kZWZpbmVkfSBjYW5jZWxUb2tlblxuICogQHBhcmFtIHt7Y2FsbDogKCkgPT4gdm9pZH19IGNhbGxiYWNrXG4gKi9cbnNjaGVkdWxlV2FrZXVwKHdha2V1cFRpbWUsY2FuY2VsVG9rZW4sY2FsbGJhY2spe1xucmV0dXJuIEUodGltZXIpLnNldFdha2V1cChcbndha2V1cFRpbWUsXG5GYXIoJ3N0YXJ0IGdyYWNlIHBlcmlvZCBoYW5kbGVyJyx7XG4gICAgICBhc3luYyB3YWtlKCl7XG5jb25zb2xlLmxvZygnV2FraW5nIFVQISEhJyk7XG52b2lkIEUoY2FsbGJhY2spLmNhbGwoKTtcbiB9fSksXG5cbmNhbmNlbFRva2VuKTtcblxuIH0sXG4vKipcbiAqIFVwZGF0ZSB0aGUgYXBwbGljYXRpb24gc3RhdGUgYnkgY2FsY3VsYXRpbmcgdGhlIG5ldyBncmFjZVBlcmlvZC5cbiAqIEBwYXJhbSB7WGltcG9ydCgnQGFnb3JpYy90aW1lJykuUmVsYXRpdmVUaW1lVmFsdWV9IHJlbnRhbER1cmF0aW9uXG4gKi9cbiAgICAgIGFzeW5jIHNldEdyYWNlUGVyaW9kKHJlbnRhbER1cmF0aW9uKXtcbmNvbnN0e1xuZmFjZXRzOntoZWxwZXJ9LFxuc3RhdGV9PVxudGhpcztcbmNvbnN0IHRlbXBHcmFjZVBlcmlvZD1cbmF3YWl0IGhlbHBlci5jYWxjdWxhdGVHcmFjZVBlcmlvZFN0YXJ0KHJlbnRhbER1cmF0aW9uKTtcblxuc3RhdGUuZ3JhY2VQZXJpb2Q9aGFyZGVuKHtcbnN0YXJ0OntcbmNhbmNlbFRva2VuOm1ha2VHcmFjZVBlcmlvZFN0YXJ0SGFuZGxlKCksXG53YWtlQXQ6dGVtcEdyYWNlUGVyaW9kfSxcblxuZW5kOntcbmNhbmNlbFRva2VuOm1ha2VHcmFjZVBlcmlvZEVuZEhhbmRsZSgpLFxud2FrZUF0OmhlbHBlci5jYWxjdWxhdGVHcmFjZVBlcmlvZEVuZCh0ZW1wR3JhY2VQZXJpb2QpfX0pO1xuXG5cbiB9LFxuLyoqXG4gKiBTaG91bGQgcmVzZXQgdGhlIGdyYWNlUGVyaW9kIHdoZW4gdGhlIHV0aWxpdHkgaXMgcmV0dXJuZWQgb3IgYSBsaXF1aWRhdGlvbiBvY2N1cnMuXG4gKi9cbnJlc2V0R3JhY2VQZXJpb2QoKXtcbmNvbnN0e1xuc3RhdGU6e2dyYWNlUGVyaW9kfX09XG50aGlzO1xuYXNzZXJ0R3JhY2VQZXJpb2QoZ3JhY2VQZXJpb2QpO1xuLyogQHRzLWV4cGVjdC1lcnJvciBGSVhNRSwgc2hvdWxkIGJlIHVucmVhY2hhYmxlIGlmIGNhbmNlbFRva2VucyBhcmUgZGVmaW5lZCovXG52b2lkIEUodGltZXIpLmNhbmNlbChncmFjZVBlcmlvZC5zdGFydC5jYW5jZWxUb2tlbik7XG4vKiBAdHMtZXhwZWN0LWVycm9yIEZJWE1FLCBzaG91bGQgYmUgdW5yZWFjaGFibGUgaWYgY2FuY2VsVG9rZW5zIGFyZSBkZWZpbmVkKi9cbnZvaWQgRSh0aW1lcikuY2FuY2VsKGdyYWNlUGVyaW9kLmVuZC5jYW5jZWxUb2tlbik7XG5cbi8qKiBAdHlwZSB7WGltcG9ydCgnLi90eXBlcy5qcycpLkdyYWNlUGVyaW9kfSAqL1xudGhpcy5zdGF0ZS5ncmFjZVBlcmlvZD1oYXJkZW4oe1xuc3RhcnQ6e1xud2FrZUF0Oi0xbixcbmNhbmNlbFRva2VuOnVuZGVmaW5lZH0sXG5cbmVuZDp7XG53YWtlQXQ6LTFuLFxuY2FuY2VsVG9rZW46dW5kZWZpbmVkfX0pO1xuXG5cbiB9LFxuLyoqXG4gKiBEdXJpbmcgdGhlIHVwZ3JhZGUgcHJvY2VzcyB3aGVuIHRoZSBjdXJyZW50IHZhdCBpcyBraWxsZWQgd2UgbG9zZSB0aGUgcmVmZXJlbmNlIHRvIG91ciB3YWtldXAgY2FsbGJhY2ssIHNvIHdlXG4gKiBuZWVkIHRvIHJlZ2lzdGVyIGl0IGFnYWluIHdoZW4gd2UncmUgYm9vdGluZyB0aGUgbmV3IHZhdC4gVGhpcyBtZXRob2QgaGFuZGxlcyB0aGF0LlxuICovXG4gICAgICBhc3luYyByZWNvdmVyRnJvbVVwZ3JhZGUoKXtcbmNvbnN0e1xuc3RhdGU6e2dyYWNlUGVyaW9kfSxcbmZhY2V0czp7aGVscGVyfX09XG50aGlzO1xuYXNzZXJ0R3JhY2VQZXJpb2QoZ3JhY2VQZXJpb2QpO1xuXG5hd2FpdCBQcm9taXNlLmFsbChbXG4vKiBAdHMtZXhwZWN0LWVycm9yIEZJWE1FLCBzaG91bGQgYmUgdW5yZWFjaGVkIGlmIGNhbmNlbFRva2VucyBhcmUgZGVmaW5lZCovXG5FKHRpbWVyKS5jYW5jZWwoZ3JhY2VQZXJpb2Quc3RhcnQuY2FuY2VsVG9rZW4pLFxuLyogQHRzLWV4cGVjdC1lcnJvciBGSVhNRSwgc2hvdWxkIGJlIHVucmVhY2hlZCBpZiBjYW5jZWxUb2tlbnMgYXJlIGRlZmluZWQqL1xuRSh0aW1lcikuY2FuY2VsKGdyYWNlUGVyaW9kLmVuZC5jYW5jZWxUb2tlbildKTtcblxuXG5jb25zdCBncmFjZVBlcmlvZFN0YXJ0U2NoZWR1bGVQPWhlbHBlci5zY2hlZHVsZVdha2V1cChcbmdyYWNlUGVyaW9kLnN0YXJ0Lndha2VBdCxcbmdyYWNlUGVyaW9kLnN0YXJ0LmNhbmNlbFRva2VuLFxuaGVscGVyLmdyYWNlUGVyaW9kU3RhcnRDYWxsYmFjaygpKTtcblxuY29uc3QgZ3JhY2VQZXJpb2RFbmRTY2hlZHVsZVA9aGVscGVyLnNjaGVkdWxlV2FrZXVwKFxuZ3JhY2VQZXJpb2QuZW5kLndha2VBdCxcbmdyYWNlUGVyaW9kLmVuZC5jYW5jZWxUb2tlbixcbmhlbHBlci5ncmFjZVBlcmlvZEVuZENhbGxiYWNrKCkpO1xuXG5cbnJldHVybltncmFjZVBlcmlvZFN0YXJ0U2NoZWR1bGVQLGdyYWNlUGVyaW9kRW5kU2NoZWR1bGVQXTtcbiB9LFxuLyoqXG4gKiBDYWxsYmFjayB0byBiZSBleGVjdXRlZCB3aGVuIHRoZSBncmFjZSBwZXJpb2Qgc3RhcnRzLlxuICovXG5ncmFjZVBlcmlvZFN0YXJ0Q2FsbGJhY2soKXtcbnJldHVybiBGYXIoJ1N0YXJ0Jyx7XG5jYWxsOigpPT5cbnRoaXMuZmFjZXRzLmhlbHBlci51cGRhdGVSZW50YWxQaGFzZShQaGFzZS5HUkFDRV9QRVJJT0QpfSk7XG5cbiB9LFxuLyoqXG4gKiAgQ2FsbGJhY2sgdG8gYmUgZXhlY3V0ZWQgd2hlbiB0aGUgZ3JhY2UgcGVyaW9kIGVuZHMuXG4gKi9cbmdyYWNlUGVyaW9kRW5kQ2FsbGJhY2soKXtcbnJldHVybiBGYXIoJ0VuZCcse1xuY2FsbDooKT0+e1xudGhpcy5mYWNldHMuaGVscGVyLnJlc2V0R3JhY2VQZXJpb2QoKTtcbnRoaXMuZmFjZXRzLmhlbHBlci51cGRhdGVSZW50YWxQaGFzZShQaGFzZS5MSVFVSURBVElPTik7XG4gfX0pO1xuXG4gfX0sXG5cbi8qKlxuICogV2UgdXNlIHRoaXMgZmFjZXQgdG8gaW50ZXJmYWNlIHdpdGggcmVudGFsSG9sZGVyXG4gKi9cbnNlbGY6e1xuZ2V0UHVibGljVG9waWNzKCl7XG5jb25zdHtyZW50YWxSZWNvcmRlcktpdH09dGhpcy5zdGF0ZTtcbnJldHVybiBtYWtlUmVjb3JkZXJUb3BpYygnUmVudGFsIFN0YXRlJyxoYXJkZW4ocmVudGFsUmVjb3JkZXJLaXQpKTtcbiB9LFxuXG5tYWtlVXBkYXRlUmVudGFsQ29uZmlnSW52aXRhdGlvbigpe1xuY29uc3R7ZmFjZXRzfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5cbnJldHVybiB6Y2YubWFrZUludml0YXRpb24oXG4vKiBAdHMtZXhwZWN0LWVycm9yIEZJWE1FIHVuY2hlY2tlZCBvZmZlckFyZ3MgdHlwZSovXG4oX3NlYXQsb2ZmZXJBcmdzKT0+aGVscGVyLm1ha2VVcGRhdGVSZW50YWxDb25maWdIb29rKG9mZmVyQXJncyksXG4nbWFrZSB1cGRhdGUgUmVudGFsIGNvbmZpZ3VyYXRpb24gb2ZmZXInKTtcblxuIH0sXG5cbm1ha2VSZXR1cm5VdGlsaXR5SW52aXRhdGlvbigpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5cbnJldHVybiB6Y2YubWFrZUludml0YXRpb24oXG4oc2VhdCk9PmhlbHBlci5tYWtlUmV0dXJuVXRpbGl0eUhvb2soc2VhdCksXG4nbWFrZSByZXR1cm4gVXRpbGl0eSBvZmZlcicsXG51bmRlZmluZWQsXG5tYWtlUmV0dXJuVXRpbGl0eVBhdHRlcm5NYXRjaGVyKHN0YXRlLnJlbnRhbFN0YXRlKSk7XG5cbiB9LFxuXG5tYWtlV2l0aGRyYXdVdGlsaXR5SW52aXRhdGlvbigpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5cbnJldHVybiB6Y2YubWFrZUludml0YXRpb24oXG4oc2VhdCk9PmhlbHBlci5tYWtlV2l0aGRyYXdVdGlsaXR5SG9vayhzZWF0KSxcbidtYWtlIHdpdGhkcmF3IFV0aWxpdHkgb2ZmZXInLFxudW5kZWZpbmVkLFxubWFrZVdpdGhkcmF3VXRpbGl0eVBhdHRlcm5NYXRjaGVyKHN0YXRlLnJlbnRhbFN0YXRlKSk7XG5cbiB9LFxuXG5tYWtlV2l0aGRyYXdSZW50YWxGZWVJbnZpdGF0aW9uKCl7XG5jb25zdHtmYWNldHMsc3RhdGV9PXRoaXM7XG5jb25zdHtoZWxwZXJ9PWZhY2V0cztcblxucmV0dXJuIHpjZi5tYWtlSW52aXRhdGlvbihcbihzZWF0KT0+aGVscGVyLm1ha2VXaXRoZHJhd1JlbnRhbEZlZUhvb2soc2VhdCksXG4nbWFrZSB3aXRoZHJhdyByZW50YWxGZWUgb2ZmZXInLFxudW5kZWZpbmVkLFxubWFrZVdpdGhkcmF3UmVudGFsRmVlUGF0dGVybk1hdGNoZXIoXG5zdGF0ZS5yZW50YWxTZWF0LFxuc3RhdGUucmVudGFsU3RhdGUsXG5rZXl3b3JkSGVscGVyKSk7XG5cblxuIH0sXG5cbm1ha2VXaXRoZHJhd0NvbGxhdGVyYWxJbnZpdGF0aW9uKCl7XG5jb25zdHtmYWNldHMsc3RhdGV9PXRoaXM7XG5jb25zdHtoZWxwZXJ9PWZhY2V0cztcblxucmV0dXJuIHpjZi5tYWtlSW52aXRhdGlvbihcbihzZWF0KT0+aGVscGVyLm1ha2VXaXRoZHJhd0NvbGxhdGVyYWxIb29rKHNlYXQpLFxuJ21ha2Ugd2l0aGRyYXcgY29sbGF0ZXJhbCBvZmZlcicsXG51bmRlZmluZWQsXG5tYWtlV2l0aGRyYXdDb2xsYXRlcmFsUGF0dGVybk1hdGNoZXIoc3RhdGUucmVudGFsU3RhdGUpKTtcblxuIH0sXG4vKipcbiAqIFJlZ2lzdGVycyB0aW1lciBzZXJ2aWNlIHdha2V1cCBjYWxscyB3aGVuIHRoZSBuZXcgdmF0IHN0YXJ0c1xuICovXG5zdGFydCgpe1xuY29uc3R7XG5zdGF0ZSxcbmZhY2V0czp7aGVscGVyfX09XG50aGlzO1xuXG5pZihcbnN0YXRlLnJlbnRhbFN0YXRlLnBoYXNlPT09UGhhc2UuUkVOVEVEfHxcbnN0YXRlLnJlbnRhbFN0YXRlLnBoYXNlPT09UGhhc2UuR1JBQ0VfUEVSSU9EKVxue1xudm9pZCBoZWxwZXIucmVjb3ZlckZyb21VcGdyYWRlKCk7XG4gfVxuXG5zdGF0ZS5iaWRzTWFuYWdlckZhY2V0LnN0YXJ0KCk7XG4gfX0sXG5cbi8qKlxuICogSGFzIHRoZSBhdWN0aW9uIHRpZXIgbWV0aG9kcy4gV2UgdXNlIHRoaXMgZmFjZXQgdG8gaW50ZXJmYWNlIHdpdGggdGhlIGJpZEhvbGRlci5cbiAqL1xuYXVjdGlvbjp7XG5nZXRPcGVuQmlkc1N1YnNjcmliZXIoKXtcbmNvbnN0e3N0YXRlfT10aGlzO1xuY29uc3R7Ymlkc01hbmFnZXJGYWNldH09c3RhdGU7XG5cbnJldHVybiBiaWRzTWFuYWdlckZhY2V0LmdldE9wZW5CaWRzU3Vic2NyaWJlcigpO1xuIH0sXG5cbmdldFdpbm5lckJpZHNTdWJzY3JpYmVyKCl7XG5jb25zdHtzdGF0ZX09dGhpcztcbmNvbnN0e2JpZHNNYW5hZ2VyRmFjZXR9PXN0YXRlO1xuXG5yZXR1cm4gYmlkc01hbmFnZXJGYWNldC5nZXRXaW5uZXJCaWRzU3Vic2NyaWJlcigpO1xuIH0sXG4vKiogQHBhcmFtIHtudW1iZXJ9IGJpZElEICovXG5nZXRCaWRCeUlEKGJpZElEKXtcbmNvbnN0e3N0YXRlfT10aGlzO1xuY29uc3R7Ymlkc01hbmFnZXJGYWNldH09c3RhdGU7XG5cbnJldHVybiBiaWRzTWFuYWdlckZhY2V0LmdldEJpZEJ5SUQoYmlkSUQpO1xuIH0sXG4vKiogQHBhcmFtIHtIYW5kbGU8J0JpZCc+fSBiaWRIYW5kbGUgKi9cbmdldEJpZEJ5SGFuZGxlKGJpZEhhbmRsZSl7XG5jb25zdHtzdGF0ZX09dGhpcztcbmNvbnN0e2JpZHNNYW5hZ2VyRmFjZXR9PXN0YXRlO1xuXG5yZXR1cm4gYmlkc01hbmFnZXJGYWNldC5nZXRCaWRCeUhhbmRsZShiaWRIYW5kbGUpO1xuIH0sXG4vKiogQHBhcmFtIHtudW1iZXJ9IGJpZElEICovXG5nZXRXaW5uZXJCaWRCeUlEKGJpZElEKXtcbmNvbnN0e3N0YXRlfT10aGlzO1xuY29uc3R7Ymlkc01hbmFnZXJGYWNldH09c3RhdGU7XG5cbnJldHVybiBiaWRzTWFuYWdlckZhY2V0LmdldFdpbm5lckJpZEJ5SUQoYmlkSUQpO1xuIH0sXG4vKiogQHBhcmFtIHtIYW5kbGU8J0JpZCc+fSBiaWRIYW5kbGUgKi9cbm1ha2VVcGRhdGVCaWRJbnZpdGF0aW9uKGJpZEhhbmRsZSl7XG5jb25zdHtmYWNldHN9PXRoaXM7XG5jb25zdHtoZWxwZXJ9PWZhY2V0cztcblxucmV0dXJuIHpjZi5tYWtlSW52aXRhdGlvbihcbihfc2VhdCxvZmZlckFyZ3MpPT5cbi8qIEB0cy1leHBlY3QtZXJyb3IgRklYTUUgdW5jaGVja2VkIG9mZmVyQXJncyB0eXBlKi9cbmhlbHBlci5tYWtlVXBkYXRlQmlkSG9vayh7YmlkSGFuZGxlLC4uLm9mZmVyQXJnc30pLFxuJ01ha2UgdXBkYXRlIGJpZCBvZmZlcicpO1xuXG4gfSxcbi8qKiBAcGFyYW0ge0hhbmRsZTwnQmlkJz59IGJpZEhhbmRsZSAqL1xubWFrZUNhbmNlbEJpZEludml0YXRpb24oYmlkSGFuZGxlKXtcbmNvbnN0e2ZhY2V0c309dGhpcztcbmNvbnN0e2hlbHBlcn09ZmFjZXRzO1xuXG5yZXR1cm4gemNmLm1ha2VJbnZpdGF0aW9uKFxuKF9zZWF0LG9mZmVyQXJncyk9PlxuaGVscGVyLm1ha2VDYW5jZWxCaWRIb29rKHtiaWRIYW5kbGUsLi4ub2ZmZXJBcmdzfSksXG4nTWFrZSBjYW5jZWwgYmlkIG9mZmVyJyk7XG5cbiB9LFxuXG5tYWtlQWNjZXB0QmlkSW52aXRhdGlvbigpe1xuY29uc3R7ZmFjZXRzfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5cbnJldHVybiB6Y2YubWFrZUludml0YXRpb24oXG4vKiBAdHMtZXhwZWN0LWVycm9yIEZJWE1FIHVuY2hlY2tlZCBvZmZlckFyZ3MgdHlwZSovXG4oX3NlYXQsb2ZmZXJBcmdzKT0+aGVscGVyLm1ha2VBY2NlcHRCaWRIb29rKG9mZmVyQXJncyksXG4nTWFrZSBhY2NlcHQgYmlkIG9mZmVyJyk7XG5cbiB9LFxuLyoqIEBwYXJhbSB7SGFuZGxlPCdCaWQnPn0gYmlkSGFuZGxlICovXG5tYWtlQm9ycm93SW52aXRhdGlvbihiaWRIYW5kbGUpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5cbnJldHVybiB6Y2YubWFrZUludml0YXRpb24oXG4oc2VhdCxvZmZlckFyZ3MpPT5cbmhlbHBlci5tYWtlQm9ycm93SG9vayhzZWF0LHtiaWRIYW5kbGUsLi4ub2ZmZXJBcmdzfSksXG4nTWFrZSBib3Jyb3cgb2ZmZXInLFxudW5kZWZpbmVkLFxubWFrZUJvcnJvd1BhdHRlcm5NYXRjaGVyKFxuc3RhdGUucmVudGFsU3RhdGUsXG5zdGF0ZS5iaWRzTWFuYWdlckZhY2V0LFxuYmlkSGFuZGxlKSk7XG5cblxuIH19LFxuXG4vKipcbiAqIE1ldGhvZHMgd2UgZXhwb3NlIHRvIG91dHNpZGUgd29ybGQuXG4gKi9cbnB1YmxpY0ZhY2V0OntcbmdldFB1YmxpY1RvcGljcygpe1xucmV0dXJuIHRoaXMuZmFjZXRzLnNlbGYuZ2V0UHVibGljVG9waWNzKCk7XG4gfSxcblxuZ2V0Q2F0YWxvZ0RhdGEoKXtcbmNvbnN0e1xuc3RhdGU6e1xucmVudGFsU3RhdGU6e3JlbnRhbEhhbmRsZSxjb25maWd1cmF0aW9uLHBoYXNlfX19PVxuXG50aGlzO1xuXG5yZXR1cm57cmVudGFsSGFuZGxlLGNvbmZpZ3VyYXRpb24scGhhc2V9O1xuIH0sXG5cbmdldE9wZW5CaWRzU3Vic2NyaWJlcigpe1xuY29uc3R7ZmFjZXRzfT10aGlzO1xuY29uc3R7YXVjdGlvbn09ZmFjZXRzO1xuXG5yZXR1cm4gYXVjdGlvbi5nZXRPcGVuQmlkc1N1YnNjcmliZXIoKTtcbiB9LFxuXG5nZXRXaW5uZXJCaWRzU3Vic2NyaWJlcigpe1xuY29uc3R7YXVjdGlvbn09dGhpcy5mYWNldHM7XG5cbnJldHVybiBhdWN0aW9uLmdldFdpbm5lckJpZHNTdWJzY3JpYmVyKCk7XG4gfSxcbi8qKiBAcGFyYW0ge251bWJlcn0gYmlkSUQgKi9cbmdldEJpZEJ5SUQoYmlkSUQpe1xuY29uc3R7ZmFjZXRzfT10aGlzO1xuY29uc3R7YXVjdGlvbn09ZmFjZXRzO1xuXG5yZXR1cm4gYXVjdGlvbi5nZXRCaWRCeUlEKGJpZElEKTtcbiB9LFxuXG5tYWtlQnV5T3V0SW52aXRhdGlvbigpe1xuY29uc3R7ZmFjZXRzLHN0YXRlfT10aGlzO1xuY29uc3R7aGVscGVyfT1mYWNldHM7XG5cbnJldHVybiB6Y2YubWFrZUludml0YXRpb24oXG4vKiBAdHMtZXhwZWN0LWVycm9yIEZJWE1FIHVuY2hlY2tlZCBvZmZlckFyZ3MgdHlwZSovXG4oc2VhdCxvZmZlckFyZ3MpPT5oZWxwZXIubWFrZUJ1eU91dEhvb2soc2VhdCxvZmZlckFyZ3MpLFxuJ01ha2UgYnV5b3V0IG9mZmVyJyxcbnVuZGVmaW5lZCxcbm1ha2VCdXlPdXRQYXR0ZXJuTWF0Y2hlcihzdGF0ZS5yZW50YWxTdGF0ZSkpO1xuXG4gfSxcblxubWFrZUJpZEludml0YXRpb24oKXtcbmNvbnN0e2ZhY2V0c309dGhpcztcbmNvbnN0e2hlbHBlcn09ZmFjZXRzO1xuXG5yZXR1cm4gemNmLm1ha2VJbnZpdGF0aW9uKFxuLyogQHRzLWV4cGVjdC1lcnJvciBGSVhNRSB1bmNoZWNrZWQgb2ZmZXJBcmdzIHR5cGUqL1xuKHNlYXQsb2ZmZXJBcmdzKT0+aGVscGVyLm1ha2VCaWRIb29rKG9mZmVyQXJncyksXG4nTWFrZSBiaWQgb2ZmZXInKTtcblxuIH19LFxuXG5cbmNyYWJibGU6e1xuLyoqXG4gKiBDYWxsZWQgd2hlbiBhbiBvd25lciBhZGRzIGEgbmV3IHJlbnRhbC4gTWlnaHQgbW92ZSB0aGlzIHRvIHRoZSBoZWxwZXIgZmFjZWV0IGFzIHdlbGwuXG4gKiBAcGFyYW0ge1pDRlNlYXR9IG93bmVyU2VhdFxuICovXG5pbml0UmVudGFsS2l0KG93bmVyU2VhdCl7XG5jb25zdHtoZWxwZXIsc2VsZixhdWN0aW9ufT10aGlzLmZhY2V0cztcbmhlbHBlci5sb2NrVXRpbGl0eShvd25lclNlYXQpO1xuXG5jb25zdCByZW50YWxLaXQ9bWFrZVJlbnRhbEtpdCh7c2VsZixhdWN0aW9ufSk7XG5oZWxwZXIudXBkYXRlUmVudGFsU3RhdGUoe30pO1xuXG5yZXR1cm4gcmVudGFsS2l0O1xuIH19fSk7XG5cblxuXG5yZXR1cm4gbWFrZVJlbnRhbDtcbiB9O1xuLyoqIEB0eXBlZGVmIHtBd2FpdGVkPFJldHVyblR5cGU8UmV0dXJuVHlwZTx0eXBlb2YgcHJlcGFyZVJlbnRhbD4+Pn0gUmVudGFsICovXG5cbi8qKlxuICpcbiAqIEBwYXJhbSB7WkNGfSB6Y2ZcbiAqIEBwYXJhbSB7WGltcG9ydCgnLi9jYXRhbG9nLmpzJykuQ2F0YWxvZ30gY2F0YWxvZ0ZhY2V0XG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdGltZS9zcmMvdHlwZXMuanMnKS5UaW1lclNlcnZpY2V9IHRpbWVyXG4gKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvem9lL3NyYy9jb250cmFjdFN1cHBvcnQvcmVjb3JkZXIuanMnKS5NYWtlUmVjb3JkZXJLaXR9IG1ha2VSZWNvcmRlcktpdFxuICovJGjigI1fb25jZS5wcmVwYXJlUmVudGFsKHByZXBhcmVSZW50YWwpO1xuY29uc3QgICAgICAgIHByZXBhcmVSZW50YWxIZWxwZXI9KFxuemNmLFxuY2F0YWxvZ0ZhY2V0LFxuYmFnZ2FnZSxcbnRpbWVyLFxubWFrZVJlY29yZGVyS2l0KT0+XG57XG5jb25zdCBtYWtlUmVudGFsPXByZXBhcmVSZW50YWwoXG56Y2YsXG5jYXRhbG9nRmFjZXQsXG5iYWdnYWdlLFxudGltZXIsXG5tYWtlUmVjb3JkZXJLaXQpO1xuXG5jb25zdCBtYWtlQmlkc01hbmFnZXI9cHJlcGFyZUJpZHNNYW5hZ2VyKGJhZ2dhZ2UsdGltZXIpO1xuXG5jb25zdCBtYWtlUmVudGFsSGFuZGxlPWRlZmluZUR1cmFibGVIYW5kbGUoYmFnZ2FnZSwnUmVudGFsJyk7XG5cbi8qKlxuICogQSB3cmFwcGVyIHRoYXQgY3JlYXRlcyBkZXBlbmRlbmNpZXMgbmVlZGVkIGJ5IHRoZSBuZXcgcmVudGFsIGFuZCBhZGRzIHRoZSBuZXcgcmVudGFsIHRvIHRoZSBjYXRhbG9nLlxuICogQHBhcmFtIHtTdG9yYWdlTm9kZX0gc3RvcmFnZU5vZGVcbiAqIEBwYXJhbSB7bnVtYmVyfSByZW50YWxDb3VudFxuICogQHBhcmFtIHtYaW1wb3J0KCcuL3R5cGVzLmpzJykuUmVudGFsQ29uZmlnfSByZW50YWxDb25maWdcbiAqL1xuY29uc3QgbWFrZVJlbnRhbEhlbHBlcj1hc3luYyhzdG9yYWdlTm9kZSxyZW50YWxDb3VudCxyZW50YWxDb25maWcpPT57XG5jb25zdCByZW50YWxTdG9yYWdlTm9kZT1hd2FpdCBFKHN0b3JhZ2VOb2RlKS5tYWtlQ2hpbGROb2RlKFxuIGByZW50YWwke3JlbnRhbENvdW50fWApO1xuXG5jb25zdCBvcGVuQmlkc1N0b3JhZ2VOb2RlPVxuYXdhaXQgRShyZW50YWxTdG9yYWdlTm9kZSkubWFrZUNoaWxkTm9kZSggYG9wZW5CaWRzYCk7XG5jb25zdCB3aW5uZXJCaWRzU3RvcmFnZU5vZGU9XG5hd2FpdCBFKHJlbnRhbFN0b3JhZ2VOb2RlKS5tYWtlQ2hpbGROb2RlKCBgd2lubmVyQmlkc2ApO1xuY29uc3QgcmVudGFsSGFuZGxlPW1ha2VSZW50YWxIYW5kbGUoKTtcbmNvbnN0e21hbmFnZXI6Ymlkc01hbmFnZXJ9PW1ha2VCaWRzTWFuYWdlcihcbm1ha2VSZWNvcmRlcktpdCxcbm9wZW5CaWRzU3RvcmFnZU5vZGUsXG53aW5uZXJCaWRzU3RvcmFnZU5vZGUsXG5yZW50YWxDb3VudCk7XG5cbmNvbnN0IHJlbnRhbD1tYWtlUmVudGFsKFxucmVudGFsQ29uZmlnLFxucmVudGFsU3RvcmFnZU5vZGUsXG5yZW50YWxIYW5kbGUsXG5iaWRzTWFuYWdlcik7XG5cblxucmV0dXJue3JlbnRhbCxyZW50YWxIYW5kbGV9O1xuIH07XG5cbnJldHVybiBoYXJkZW4obWFrZVJlbnRhbEhlbHBlcik7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVSZW50YWxIZWxwZXIocHJlcGFyZVJlbnRhbEhlbHBlcik7XG5oYXJkZW4ocHJlcGFyZVJlbnRhbEhlbHBlcik7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsicHJlcGFyZVJlbnRhbCI6WyJwcmVwYXJlUmVudGFsIl0sInByZXBhcmVSZW50YWxIZWxwZXIiOlsicHJlcGFyZVJlbnRhbEhlbHBlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACS64SZ5QgAAOUIAAArAAAAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL3JlbnRhbEhvbGRlci5qc3siaW1wb3J0cyI6WyJAYWdvcmljL3ZhdC1kYXRhIl0sImV4cG9ydHMiOlsicHJlcGFyZVJlbnRhbEhvbGRlciJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgIGxldCBNLHByZXBhcmVFeG9DbGFzc0tpdDskaOKAjV9pbXBvcnRzKFtbXCJAYWdvcmljL3ZhdC1kYXRhXCIsIFtbXCJNXCIsIFskaOKAjV9hID0+IChNID0gJGjigI1fYSldXSxbXCJwcmVwYXJlRXhvQ2xhc3NLaXRcIiwgWyRo4oCNX2EgPT4gKHByZXBhcmVFeG9DbGFzc0tpdCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cbi8qKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlICovXG5jb25zdCAgICAgICAgcHJlcGFyZVJlbnRhbEhvbGRlcj0oYmFnZ2FnZSk9PntcbmNvbnN0IG1ha2VSZW50YWxIb2xkZXI9cHJlcGFyZUV4b0NsYXNzS2l0KFxuYmFnZ2FnZSxcbidSZW50YWwgSG9sZGVyJyxcbntcbnB1YmxpY1RvcGljczpNLmludGVyZmFjZSgnUHVibGljU3Vic2NyaWJlcnMnLHtcbmdldFB1YmxpY1N1YnNjcmliZXJzOk0uY2FsbCgpLnJldHVybnMoTS5hbnkoKSl9KSxcblxuaW52aXRhdGlvbk1ha2VyczpNLmludGVyZmFjZSgnSW52aXRhdGlvbk1ha2Vycycse1xudXBkYXRlUmVudGFsQ29uZmlnOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxud2l0aGRyYXdVdGlsaXR5Ok0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxud2l0aGRyYXdSZW50YWxGZWU6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG53aXRoZHJhd0NvbGxhdGVyYWw6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5nZXRCaWRCeUlEOk0uY2FsbCgpLnJldHVybnMoTS5yZWNvcmQoKSksXG5hY2NlcHRCaWQ6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSl9KX0sXG5cblxuLyoqXG4gKiBAcGFyYW0ge1BpY2s8WGltcG9ydCgnLi9yZW50YWwuanMnKS5SZW50YWwsICdzZWxmJyB8ICdhdWN0aW9uJz59IHJlbnRhbCBTZWxmIGZhY2V0IG9mIHRoZSByZW50YWwgbW9kdWxlXG4gKi9cbihyZW50YWwpPT57XG5yZXR1cm4gaGFyZGVuKHtyZW50YWx9KTtcbiB9LFxue1xucHVibGljVG9waWNzOntcbmdldFB1YmxpY1N1YnNjcmliZXJzKCl7XG5jb25zdCBwdWJsaWNUb3BpY3M9dGhpcy5zdGF0ZS5yZW50YWwuc2VsZi5nZXRQdWJsaWNUb3BpY3MoKTtcbnJldHVybntcbnJlbnRhbDp7XG4uLi5wdWJsaWNUb3BpY3N9fTtcblxuXG4gfX0sXG5cbi8qKlxuICogU2V0IG9mIGFjdGlvbnMgdGhlIG93bmVyIGlzIGFsbG93ZWQgdG8gdGFrZSBmb3IgdGhlIHV0aWxpdHkgTkZUIHRoZXkgbGlzdCB0byBiZSByZW50ZWQuXG4gKi9cbmludml0YXRpb25NYWtlcnM6e1xudXBkYXRlUmVudGFsQ29uZmlnKCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5yZW50YWwuc2VsZi5tYWtlVXBkYXRlUmVudGFsQ29uZmlnSW52aXRhdGlvbigpO1xuIH0sXG53aXRoZHJhd1V0aWxpdHkoKXtcbnJldHVybiB0aGlzLnN0YXRlLnJlbnRhbC5zZWxmLm1ha2VXaXRoZHJhd1V0aWxpdHlJbnZpdGF0aW9uKCk7XG4gfSxcbndpdGhkcmF3UmVudGFsRmVlKCl7XG5yZXR1cm4gdGhpcy5zdGF0ZS5yZW50YWwuc2VsZi5tYWtlV2l0aGRyYXdSZW50YWxGZWVJbnZpdGF0aW9uKCk7XG4gfSxcbndpdGhkcmF3Q29sbGF0ZXJhbCgpe1xucmV0dXJuIHRoaXMuc3RhdGUucmVudGFsLnNlbGYubWFrZVdpdGhkcmF3Q29sbGF0ZXJhbEludml0YXRpb24oKTtcbiB9LFxuXG4vKiogQHBhcmFtIHtudW1iZXJ9IGJpZElEICovXG5nZXRCaWRCeUlEKGJpZElEKXtcbnJldHVybiB0aGlzLnN0YXRlLnJlbnRhbC5hdWN0aW9uLmdldEJpZEJ5SUQoYmlkSUQpO1xuIH0sXG5cbmFjY2VwdEJpZCgpe1xucmV0dXJuIHRoaXMuc3RhdGUucmVudGFsLmF1Y3Rpb24ubWFrZUFjY2VwdEJpZEludml0YXRpb24oKTtcbiB9fX0pO1xuXG5cblxuXG5yZXR1cm4gbWFrZVJlbnRhbEhvbGRlcjtcbiB9OyRo4oCNX29uY2UucHJlcGFyZVJlbnRhbEhvbGRlcihwcmVwYXJlUmVudGFsSG9sZGVyKTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJwcmVwYXJlUmVudGFsSG9sZGVyIjpbInByZXBhcmVSZW50YWxIb2xkZXIiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAs4zUAdsEAADbBAAAKAAAAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9yZW50YWxLaXQuanN7ImltcG9ydHMiOlsiLi9yZW50YWxIb2xkZXIuanMiLCJAYWdvcmljL3pvZS9leHBvcnRlZC5qcyJdLCJleHBvcnRzIjpbInByZXBhcmVSZW50YWx0S2l0Il0sInJlZXhwb3J0cyI6W10sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgbGV0IHByZXBhcmVSZW50YWxIb2xkZXI7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy96b2UvZXhwb3J0ZWQuanNcIiwgW11dLFtcIi4vcmVudGFsSG9sZGVyLmpzXCIsIFtbXCJwcmVwYXJlUmVudGFsSG9sZGVyXCIsIFskaOKAjV9hID0+IChwcmVwYXJlUmVudGFsSG9sZGVyID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG4vKiogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gYmFnZ2FnZSAqL1xuY29uc3QgICAgICAgIHByZXBhcmVSZW50YWx0S2l0PShiYWdnYWdlKT0+e1xuLyogUHJlcGFyZSB0aGUgcmVudGFsSG9sZGVyKi9cbmNvbnN0IG1ha2VSZW50YWxIb2xkZXI9cHJlcGFyZVJlbnRhbEhvbGRlcihiYWdnYWdlKTtcblxuLyoqXG4gKiBDcmVhdGUgYSBraXQgb2YgdXRpbGl0aWVzIGZvciB1c2Ugb2YgdGhlIHJlbnRhbC5cbiAqXG4gKiBAcGFyYW0ge1BpY2s8WGltcG9ydCgnLi9yZW50YWwuanMnKS5SZW50YWwsICdzZWxmJyB8ICdhdWN0aW9uJz59IHJlbnRhbFxuICovXG5jb25zdCBtYWtlUmVudGFsS2l0PShyZW50YWwpPT57XG5jb25zdHtpbnZpdGF0aW9uTWFrZXJzLHB1YmxpY1RvcGljc309bWFrZVJlbnRhbEhvbGRlcihyZW50YWwpO1xuXG5jb25zdCBwdWJsaWNTdWJzY3JpYmVycz1wdWJsaWNUb3BpY3MuZ2V0UHVibGljU3Vic2NyaWJlcnMoKTtcblxuY29uc3QgcmVudGFsS2l0PWhhcmRlbih7XG5wdWJsaWNTdWJzY3JpYmVycyxcbmludml0YXRpb25NYWtlcnN9KTtcblxucmV0dXJuIHJlbnRhbEtpdDtcbiB9O1xucmV0dXJuIG1ha2VSZW50YWxLaXQ7XG4gfTskaOKAjV9vbmNlLnByZXBhcmVSZW50YWx0S2l0KHByZXBhcmVSZW50YWx0S2l0KTtcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6eyJwcmVwYXJlUmVudGFsdEtpdCI6WyJwcmVwYXJlUmVudGFsdEtpdCJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAADqNVgfcSEAAHEhAAApAAAAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL3R5cGVHdWFyZHMuanN7ImltcG9ydHMiOlsiLi9jb25zdGFudHMuanMiLCJAYWdvcmljL2VydHAiLCJAYWdvcmljL25vdGlmaWVyIiwiQGFnb3JpYy90aW1lIiwiQGFnb3JpYy92YXQtZGF0YSIsIkBhZ29yaWMvem9lL3NyYy90eXBlR3VhcmRzLmpzIl0sImV4cG9ydHMiOlsiQXVjdGlvbkkiLCJCYXNlUmVudGFsQ29uZmlnR3VhcmQiLCJCaWRzTWFuYWdlckhlbHBlckkiLCJCaWRzTWFuYWdlckkiLCJDcmFiYmxlSSIsIkhlbHBlckkiLCJQdWJsaWNJIiwiU2VsZkkiLCJtYWtlQWRIb2NSZW50YWxDb25maWdHdWFyZCIsIm1ha2VBdWN0aW9uUmVudGFsQ29uZmlnR3VhcmQiLCJtYWtlQmlkQ29uZmlnR3VhcmQiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgTSxJbnN0YW5jZUhhbmRsZVNoYXBlLFNlYXRTaGFwZSxBc3NldEtpbmQsVGltZXN0YW1wU2hhcGUsU3Vic2NyaWJlclNoYXBlLEJJRF9FWFBJUkFUSU9OX1VOSVQ7JGjigI1faW1wb3J0cyhbW1wiQGFnb3JpYy92YXQtZGF0YVwiLCBbW1wiTVwiLCBbJGjigI1fYSA9PiAoTSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3pvZS9zcmMvdHlwZUd1YXJkcy5qc1wiLCBbW1wiSW5zdGFuY2VIYW5kbGVTaGFwZVwiLCBbJGjigI1fYSA9PiAoSW5zdGFuY2VIYW5kbGVTaGFwZSA9ICRo4oCNX2EpXV0sW1wiU2VhdFNoYXBlXCIsIFskaOKAjV9hID0+IChTZWF0U2hhcGUgPSAkaOKAjV9hKV1dXV0sW1wiQGFnb3JpYy9lcnRwXCIsIFtbXCJBc3NldEtpbmRcIiwgWyRo4oCNX2EgPT4gKEFzc2V0S2luZCA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL3RpbWVcIiwgW1tcIlRpbWVzdGFtcFNoYXBlXCIsIFskaOKAjV9hID0+IChUaW1lc3RhbXBTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCJAYWdvcmljL25vdGlmaWVyXCIsIFtbXCJTdWJzY3JpYmVyU2hhcGVcIiwgWyRo4oCNX2EgPT4gKFN1YnNjcmliZXJTaGFwZSA9ICRo4oCNX2EpXV1dXSxbXCIuL2NvbnN0YW50cy5qc1wiLCBbW1wiQklEX0VYUElSQVRJT05fVU5JVFwiLCBbJGjigI1fYSA9PiAoQklEX0VYUElSQVRJT05fVU5JVCA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cblxuXG5jb25zdCAgICAgICAgSGVscGVyST1NLmludGVyZmFjZSgnaGVscGVyRmFjZXRJJyx7XG5sb2NrVXRpbGl0eTpNLmNhbGwoU2VhdFNoYXBlKS5yZXR1cm5zKCksXG51cGRhdGVSZW50YWxDb25maWc6TS5jYWxsKE0ucmVjb3JkKCkpLnJldHVybnMoTS5hcnJheSgpKSxcbnVwZGF0ZVJlbnRhbFBoYXNlOk0uY2FsbChNLnN0cmluZygpKS5yZXR1cm5zKE0uYXJyYXkoKSksXG51cGRhdGVSZW50YWxTdGF0ZTpNLmNhbGwoTS5yZWNvcmQoKSkucmV0dXJucyhNLmFycmF5KCkpLFxuY2FsY3VsYXRlR3JhY2VQZXJpb2RTdGFydDpNLmNhbGwoTS5iaWdpbnQoKSkucmV0dXJucyhNLnByb21pc2UoKSksXG5jYWxjdWxhdGVHcmFjZVBlcmlvZEVuZDpNLmNhbGwoTS5hbnkoKSkucmV0dXJucyhNLmFueSgpKSxcbnNldFJlbnRhbEdyYWNlUGVyaW9kOk0uY2FsbChNLmJpZ2ludCgpKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmluaXRMZWFzZUtpdDpNLmNhbGwoKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxubWFrZVVwZGF0ZVJlbnRhbENvbmZpZ0hvb2s6TS5jYWxsKE0ucmVjb3JkKCkpLnJldHVybnMoTS5yZWNvcmQoKSksXG5pbml0QmlkS2l0Ok0uY2FsbCgpLnJldHVybnMoTS5yZWNvcmQoKSksXG5tYWtlQXRvbWljU3dhcDpNLmNhbGwoU2VhdFNoYXBlKS5yZXR1cm5zKE0uc3RyaW5nKCkpLFxubWFrZUJ1eU91dEhvb2s6TS5jYWxsKFNlYXRTaGFwZSxNLnJlY29yZCgpKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxubWFrZVJldHVyblV0aWxpdHlIb29rOk0uY2FsbChTZWF0U2hhcGUpLnJldHVybnMoTS5yZWNvcmQoKSksXG5tYWtlV2l0aGRyYXdVdGlsaXR5SG9vazpNLmNhbGwoU2VhdFNoYXBlKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxubWFrZUJpZEhvb2s6TS5jYWxsKE0ucmVjb3JkKCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxubWFrZVVwZGF0ZUJpZEhvb2s6TS5jYWxsKE0ucmVjb3JkKCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxubWFrZUNhbmNlbEJpZEhvb2s6TS5jYWxsKE0ucmVjb3JkKCkpLnJldHVybnMoTS5yZWNvcmQoKSksXG5tYWtlQWNjZXB0QmlkSG9vazpNLmNhbGwoTS5yZWNvcmQoKSkucmV0dXJucyhNLnByb21pc2UoKSksXG5tYWtlQm9ycm93SG9vazpNLmNhbGwoU2VhdFNoYXBlLE0ucmVjb3JkKCkpLnJldHVybnMoTS5yZWNvcmQoKSksXG5tYWtlV2l0aGRyYXdSZW50YWxGZWVIb29rOk0uY2FsbChTZWF0U2hhcGUpLnJldHVybnMoTS5zdHJpbmcoKSksXG5tYWtlV2l0aGRyYXdDb2xsYXRlcmFsSG9vazpNLmNhbGwoU2VhdFNoYXBlKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxuc2NoZWR1bGVXYWtldXA6TS5jYWxsKFRpbWVzdGFtcFNoYXBlLE0uYW55KCksTS5yZW1vdGFibGUoKSkucmV0dXJucyhcbk0ucHJvbWlzZSgpKSxcblxuc2V0R3JhY2VQZXJpb2Q6TS5jYWxsKE0uYmlnaW50KCkpLnJldHVybnMoTS5wcm9taXNlKCkpLFxucmVzZXRHcmFjZVBlcmlvZDpNLmNhbGwoKS5yZXR1cm5zKCksXG5yZWNvdmVyRnJvbVVwZ3JhZGU6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5ncmFjZVBlcmlvZFN0YXJ0Q2FsbGJhY2s6TS5jYWxsKCkucmV0dXJucyhNLnJlbW90YWJsZSgpKSxcbmdyYWNlUGVyaW9kRW5kQ2FsbGJhY2s6TS5jYWxsKCkucmV0dXJucyhNLnJlbW90YWJsZSgpKX0pOyRo4oCNX29uY2UuSGVscGVySShIZWxwZXJJKTtcblxuXG5jb25zdCAgICAgICAgU2VsZkk9TS5pbnRlcmZhY2UoJ3NlbGZGYWNldEknLHtcbmdldFB1YmxpY1RvcGljczpNLmNhbGwoKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxubWFrZVVwZGF0ZVJlbnRhbENvbmZpZ0ludml0YXRpb246TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5tYWtlUmV0dXJuVXRpbGl0eUludml0YXRpb246TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5tYWtlV2l0aGRyYXdVdGlsaXR5SW52aXRhdGlvbjpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbm1ha2VXaXRoZHJhd1JlbnRhbEZlZUludml0YXRpb246TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5tYWtlV2l0aGRyYXdDb2xsYXRlcmFsSW52aXRhdGlvbjpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbnN0YXJ0Ok0uY2FsbCgpLnJldHVybnMoKX0pOyRo4oCNX29uY2UuU2VsZkkoU2VsZkkpO1xuXG5cbmNvbnN0ICAgICAgICBBdWN0aW9uST1NLmludGVyZmFjZSgnYXVjdGlvbkZhY2V0SScse1xuZ2V0T3BlbkJpZHNTdWJzY3JpYmVyOk0uY2FsbCgpLnJldHVybnMoTS5yZW1vdGFibGUoKSksXG5nZXRXaW5uZXJCaWRzU3Vic2NyaWJlcjpNLmNhbGwoKS5yZXR1cm5zKE0ucmVtb3RhYmxlKCkpLFxuZ2V0QmlkQnlJRDpNLmNhbGwoKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxuZ2V0V2lubmVyQmlkQnlJRDpNLmNhbGwoKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxuZ2V0QmlkQnlIYW5kbGU6TS5jYWxsKCkucmV0dXJucyhNLnJlY29yZCgpKSxcbm1ha2VVcGRhdGVCaWRJbnZpdGF0aW9uOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpLFxubWFrZUNhbmNlbEJpZEludml0YXRpb246TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5tYWtlQWNjZXB0QmlkSW52aXRhdGlvbjpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbm1ha2VCb3Jyb3dJbnZpdGF0aW9uOk0uY2FsbCgpLnJldHVybnMoTS5wcm9taXNlKCkpfSk7JGjigI1fb25jZS5BdWN0aW9uSShBdWN0aW9uSSk7XG5cblxuY29uc3QgICAgICAgIFB1YmxpY0k9TS5pbnRlcmZhY2UoJ3B1YmxpY0ZhY2V0SScse1xuZ2V0UHVibGljVG9waWNzOk0uY2FsbCgpLnJldHVybnMoTS5yZWNvcmQoKSksXG5nZXRDYXRhbG9nRGF0YTpNLmNhbGwoKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxuZ2V0QmlkQnlJRDpNLmNhbGwoKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxuZ2V0T3BlbkJpZHNTdWJzY3JpYmVyOk0uY2FsbCgpLnJldHVybnMoTS5yZW1vdGFibGUoKSksXG5nZXRXaW5uZXJCaWRzU3Vic2NyaWJlcjpNLmNhbGwoKS5yZXR1cm5zKE0ucmVtb3RhYmxlKCkpLFxubWFrZUJ1eU91dEludml0YXRpb246TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5tYWtlQmlkSW52aXRhdGlvbjpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKX0pOyRo4oCNX29uY2UuUHVibGljSShQdWJsaWNJKTtcblxuXG5jb25zdCAgICAgICAgQ3JhYmJsZUk9TS5pbnRlcmZhY2UoJ2NyYWJibGVGYWNldEknLHtcbmluaXRSZW50YWxLaXQ6TS5jYWxsKFNlYXRTaGFwZSkucmV0dXJucyhNLnJlY29yZCgpKX0pOyRo4oCNX29uY2UuQ3JhYmJsZUkoQ3JhYmJsZUkpO1xuXG5cbmNvbnN0ICAgICAgICBCaWRzTWFuYWdlckk9TS5pbnRlcmZhY2UoJ0JpZHNNYW5hZ2VySW50ZXJmYWNlJyx7XG5nZXRPcGVuQmlkc1N1YnNjcmliZXI6TS5jYWxsKCkucmV0dXJucyhTdWJzY3JpYmVyU2hhcGUpLFxuZ2V0V2lubmVyQmlkc1N1YnNjcmliZXI6TS5jYWxsKCkucmV0dXJucyhTdWJzY3JpYmVyU2hhcGUpLFxuZ2V0QmlkQnlJRDpNLmNhbGwoKS5yZXR1cm5zKE0ucmVjb3JkKCkpLFxuZ2V0QmlkQnlIYW5kbGU6TS5jYWxsKCkucmV0dXJucyhNLnJlY29yZCgpKSxcbmdldFdpbm5lckJpZEJ5SUQ6TS5jYWxsKCkucmV0dXJucyhNLnJlY29yZCgpKSxcbmFkZEJpZDpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbnVwZGF0ZUJpZDpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmNhbmNlbEJpZDpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmFjY2VwdEJpZDpNLmNhbGwoKS5yZXR1cm5zKE0ucHJvbWlzZSgpKSxcbmZpbmlzaEF1Y3Rpb25Sb3VuZDpNLmNhbGwoKS5yZXR1cm5zKE0uYXJyYXkoKSksXG5zdGFydDpNLmNhbGwoKS5yZXR1cm5zKCl9KTskaOKAjV9vbmNlLkJpZHNNYW5hZ2VySShCaWRzTWFuYWdlckkpO1xuXG5cbmNvbnN0ICAgICAgICBCaWRzTWFuYWdlckhlbHBlckk9TS5pbnRlcmZhY2UoJ0hlbHBlcicse1xucHVibGlzaEJpZFN0b3JhZ2U6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG5wdWJsaXNoV2lubmVyQmlkc1N0b3JhZ2U6TS5jYWxsKCkucmV0dXJucyhNLnByb21pc2UoKSksXG51cGRhdGVCaWRTdGF0ZTpNLmNhbGwoSW5zdGFuY2VIYW5kbGVTaGFwZSxNLmFueSgpLE0uYW55KCkpLnJldHVybnMoKSxcbm1ha2VDYW5jZWxUb2tlbjpNLmNhbGwoSW5zdGFuY2VIYW5kbGVTaGFwZSkucmV0dXJucyhNLnJlbW90YWJsZSgpKSxcbnNldEV4cGlyYXRpb25UaW1lcjpNLmNhbGwoSW5zdGFuY2VIYW5kbGVTaGFwZSkucmV0dXJucyhNLnByb21pc2UoKSksXG5jYWxjdWxhdGVEZWFkbGluZTpNLmNhbGwoTS5iaWdpbnQoKSkucmV0dXJucyhNLnByb21pc2UoKSl9KTskaOKAjV9vbmNlLkJpZHNNYW5hZ2VySGVscGVySShCaWRzTWFuYWdlckhlbHBlckkpO1xuXG5cbmNvbnN0ICAgICAgICBCYXNlUmVudGFsQ29uZmlnR3VhcmQ9aGFyZGVuKHtcbnV0aWxpdHlUaXRsZTpNLnN0cmluZyh7c3RyaW5nTGVuZ3RoTGltaXQ6NjR9KSxcbnV0aWxpdHlEZXNjcmlwdGlvbjpNLnN0cmluZyh7c3RyaW5nTGVuZ3RoTGltaXQ6MjAwfSksXG5yZW50aW5nVGllcjpNLm9yKCdBZC1Ib2MnLCdBdWN0aW9uJyksXG5yZW50aW5nRHVyYXRpb25Vbml0Ok0ub3IoJ21pbnV0ZScsJ2hvdXInLCdkYXknLCd3ZWVrJyksXG5taW5SZW50aW5nRHVyYXRpb25Vbml0czpNLmd0KDBuKSxcbm1heFJlbnRpbmdEdXJhdGlvblVuaXRzOk0uZ3QoMG4pLFxuZ3JhY2VQZXJpb2REdXJhdGlvbjpNLmd0KDBuKX0pO1xuXG5cbi8qKiBAcGFyYW0ge3sgYnJhbmRzOiBTdGFuZGFyZFRlcm1zWydicmFuZHMnXSB9fSB0ZXJtcyAgKi8kaOKAjV9vbmNlLkJhc2VSZW50YWxDb25maWdHdWFyZChCYXNlUmVudGFsQ29uZmlnR3VhcmQpO1xuY29uc3QgbWFrZUJyYW5kS25vd25HdWFyZD0oe2JyYW5kc30pPT57XG5yZXR1cm4gaGFyZGVuKHtcbmJyYW5kOk0ub3IoLi4uT2JqZWN0LnZhbHVlcyhicmFuZHMpKX0pO1xuXG4gfTtcblxuLyoqIEBwYXJhbSB7QXNzZXRLaW5kfSBbYXNzZXRLaW5kXSAqL1xuY29uc3QgbWFrZVZhbHVlR3VhcmQ9KGFzc2V0S2luZCk9PntcbmlmKGFzc2V0S2luZD09PUFzc2V0S2luZC5OQVQpcmV0dXJuIGhhcmRlbih7dmFsdWU6TS5uYXQoKX0pO2Vsc2VcbmlmKFxuYXNzZXRLaW5kPT09QXNzZXRLaW5kLlNFVHx8XG5hc3NldEtpbmQ9PT1Bc3NldEtpbmQuQ09QWV9TRVR8fFxuYXNzZXRLaW5kPT09QXNzZXRLaW5kLkNPUFlfQkFHKVxuXG5yZXR1cm4gaGFyZGVuKHt2YWx1ZTpNLmFycmF5KCl9KTtcbnJldHVybiBoYXJkZW4oe3ZhbHVlOk0ub3IoTS5hcnJheSgpLE0ubmF0KCkpfSk7XG4gfTtcblxuLyoqIEBwYXJhbSB7WkNGfSB6Y2YgKi9cbmNvbnN0ICAgICAgICBtYWtlQWRIb2NSZW50YWxDb25maWdHdWFyZD0oemNmKT0+e1xuY29uc3QgdGVybXM9emNmLmdldFRlcm1zKCk7XG5jb25zdCBicmFuZEtub3duR3VhcmQ9bWFrZUJyYW5kS25vd25HdWFyZCh0ZXJtcyk7XG5yZXR1cm4gaGFyZGVuKHtcbi4uLkJhc2VSZW50YWxDb25maWdHdWFyZCxcbnV0aWxpdHlBbW91bnQ6aGFyZGVuKHtcbi4uLmJyYW5kS25vd25HdWFyZCxcbi4uLm1ha2VWYWx1ZUd1YXJkKEFzc2V0S2luZC5TRVQpfSksXG5cbmNvbGxhdGVyYWxBbW91bnQ6aGFyZGVuKHtcbi4uLmJyYW5kS25vd25HdWFyZCxcbi4uLm1ha2VWYWx1ZUd1YXJkKCl9KSxcblxucmVudGFsRmVlUGVyVW5pdEFtb3VudDpoYXJkZW4oe1xuLi4uYnJhbmRLbm93bkd1YXJkLFxuLi4ubWFrZVZhbHVlR3VhcmQoQXNzZXRLaW5kLk5BVCl9KX0pO1xuXG5cbiB9O1xuXG4vKiogQHBhcmFtIHtaQ0Z9IHpjZiAqLyRo4oCNX29uY2UubWFrZUFkSG9jUmVudGFsQ29uZmlnR3VhcmQobWFrZUFkSG9jUmVudGFsQ29uZmlnR3VhcmQpO1xuY29uc3QgICAgICAgIG1ha2VBdWN0aW9uUmVudGFsQ29uZmlnR3VhcmQ9KHpjZik9PntcbmNvbnN0IHRlcm1zPXpjZi5nZXRUZXJtcygpO1xuY29uc3QgYnJhbmRLbm93bkd1YXJkPW1ha2VCcmFuZEtub3duR3VhcmQodGVybXMpO1xucmV0dXJuIGhhcmRlbih7XG4uLi5CYXNlUmVudGFsQ29uZmlnR3VhcmQsXG51dGlsaXR5QW1vdW50OmhhcmRlbih7XG4uLi5icmFuZEtub3duR3VhcmQsXG4uLi5tYWtlVmFsdWVHdWFyZChBc3NldEtpbmQuU0VUKX0pLFxuXG5jb2xsYXRlcmFsQW1vdW50OnVuZGVmaW5lZCxcbnJlbnRhbEZlZVBlclVuaXRBbW91bnQ6dW5kZWZpbmVkfSk7XG5cbiB9O1xuXG4vKiogQHBhcmFtIHtaQ0Z9IHpjZiAqLyRo4oCNX29uY2UubWFrZUF1Y3Rpb25SZW50YWxDb25maWdHdWFyZChtYWtlQXVjdGlvblJlbnRhbENvbmZpZ0d1YXJkKTtcbmNvbnN0ICAgICAgICBtYWtlQmlkQ29uZmlnR3VhcmQ9KHpjZik9PntcbmNvbnN0IHRlcm1zPXpjZi5nZXRUZXJtcygpO1xuY29uc3QgYnJhbmRLbm93bkd1YXJkPW1ha2VCcmFuZEtub3duR3VhcmQodGVybXMpO1xuXG5yZXR1cm4gaGFyZGVuKHtcbnV0aWxpdHlUaXRsZTpNLnN0cmluZyh7c3RyaW5nTGVuZ3RoTGltaXQ6NjR9KSxcbnV0aWxpdHlEZXNjcmlwdGlvbjpNLnN0cmluZyh7c3RyaW5nTGVuZ3RoTGltaXQ6MjAwfSksXG5jb2xsYXRlcmFsQW1vdW50OmhhcmRlbih7XG4uLi5icmFuZEtub3duR3VhcmQsXG4uLi5tYWtlVmFsdWVHdWFyZCgpfSksXG5cbnJlbnRhbEZlZVBlclVuaXRBbW91bnQ6aGFyZGVuKHtcbi4uLmJyYW5kS25vd25HdWFyZCxcbi4uLm1ha2VWYWx1ZUd1YXJkKEFzc2V0S2luZC5OQVQpfSksXG5cbnJlbnRpbmdEdXJhdGlvbjpNLm5hdCgpLFxuZXhwaXJhdGlvblRpbWU6TS5ndGUoQklEX0VYUElSQVRJT05fVU5JVCkvKiBjaGFpblRpbWVyU2VydmljZSBvcGVyYXRlcyBpbiBzZWNvbmRzLCAxMCBtaW5zIG1pbmltdW0qL30pO1xuXG4gfTskaOKAjV9vbmNlLm1ha2VCaWRDb25maWdHdWFyZChtYWtlQmlkQ29uZmlnR3VhcmQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7IkhlbHBlckkiOlsiSGVscGVySSJdLCJTZWxmSSI6WyJTZWxmSSJdLCJBdWN0aW9uSSI6WyJBdWN0aW9uSSJdLCJQdWJsaWNJIjpbIlB1YmxpY0kiXSwiQ3JhYmJsZUkiOlsiQ3JhYmJsZUkiXSwiQmlkc01hbmFnZXJJIjpbIkJpZHNNYW5hZ2VySSJdLCJCaWRzTWFuYWdlckhlbHBlckkiOlsiQmlkc01hbmFnZXJIZWxwZXJJIl0sIkJhc2VSZW50YWxDb25maWdHdWFyZCI6WyJCYXNlUmVudGFsQ29uZmlnR3VhcmQiXSwibWFrZUFkSG9jUmVudGFsQ29uZmlnR3VhcmQiOlsibWFrZUFkSG9jUmVudGFsQ29uZmlnR3VhcmQiXSwibWFrZUF1Y3Rpb25SZW50YWxDb25maWdHdWFyZCI6WyJtYWtlQXVjdGlvblJlbnRhbENvbmZpZ0d1YXJkIl0sIm1ha2VCaWRDb25maWdHdWFyZCI6WyJtYWtlQmlkQ29uZmlnR3VhcmQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAATLLlG5gMAACYDAAAJAAAAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy91dGlscy5qc3siaW1wb3J0cyI6WyIuL2NvbnN0YW50cy5qcyIsIkBhZ29yaWMvdmF0LWRhdGEiLCJAYWdvcmljL3pvZS9leHBvcnRlZC5qcyIsIkBlbmRvL2V2ZW50dWFsLXNlbmQiXSwiZXhwb3J0cyI6WyJnZXRJc3N1ZXJGcm9tQW1vdW50IiwiaW5pdElzc3VlcnMiLCJsb2dnZXIiLCJwcm92aWRlQnJhbmRUb0tleXdvcmRIZWxwZXIiLCJwcm92aWRlQnJhbmRUb0tleXdvcmRNYXAiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgRSxwcm92aWRlRHVyYWJsZU1hcFN0b3JlLEJSQU5EX1RPX0tFWVdPUkRfS0VZOyRo4oCNX2ltcG9ydHMoW1tcIkBhZ29yaWMvem9lL2V4cG9ydGVkLmpzXCIsIFtdXSxbXCJAZW5kby9ldmVudHVhbC1zZW5kXCIsIFtbXCJFXCIsIFskaOKAjV9hID0+IChFID0gJGjigI1fYSldXV1dLFtcIkBhZ29yaWMvdmF0LWRhdGFcIiwgW1tcInByb3ZpZGVEdXJhYmxlTWFwU3RvcmVcIiwgWyRo4oCNX2EgPT4gKHByb3ZpZGVEdXJhYmxlTWFwU3RvcmUgPSAkaOKAjV9hKV1dXV0sW1wiLi9jb25zdGFudHMuanNcIiwgW1tcIkJSQU5EX1RPX0tFWVdPUkRfS0VZXCIsIFskaOKAjV9hID0+IChCUkFORF9UT19LRVlXT1JEX0tFWSA9ICRo4oCNX2EpXV1dXV0pOyAgIFxuXG5cblxuXG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdHMnKS5OYW1lSHVifSBhZ29yaWNOYW1lc1xuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICovXG5jb25zdCBpbml0SXNzdWVycz1hc3luYyhhZ29yaWNOYW1lcyx6Y2YpPT57XG5jb25zdCBzYXZlUHJvbWlzZXM9W107XG5jb25zdCBpc3N1ZXJFbnRyaWVzPWF3YWl0IEUoRShhZ29yaWNOYW1lcykubG9va3VwKCdpc3N1ZXInKSkuZW50cmllcygpO1xuXG5mb3IoY29uc3Rba2V5d29yZCxpc3N1ZXJdb2YgaXNzdWVyRW50cmllcyl7XG50cnl7XG56Y2YuYXNzZXJ0VW5pcXVlS2V5d29yZChrZXl3b3JkKTtcbnNhdmVQcm9taXNlcy5wdXNoKHpjZi5zYXZlSXNzdWVyKGlzc3VlcixrZXl3b3JkKSk7XG4gfWNhdGNoKGUpe1xuY29uc29sZS5sb2coJ0VSUk9SJyxlKTtcbiB9XG4gfVxucmV0dXJuIFByb21pc2UuYWxsKHNhdmVQcm9taXNlcyk7XG4gfTskaOKAjV9vbmNlLmluaXRJc3N1ZXJzKGluaXRJc3N1ZXJzKTtcbmhhcmRlbihpbml0SXNzdWVycyk7XG5cbi8qKlxuICogQHBhcmFtIHtYaW1wb3J0KCdAYWdvcmljL3ZhdC1kYXRhJykuQmFnZ2FnZX0gYmFnZ2FnZVxuICogQHBhcmFtIHtaQ0Z9IHpjZlxuICovXG5jb25zdCBwcm92aWRlQnJhbmRUb0tleXdvcmRNYXA9KGJhZ2dhZ2UsemNmKT0+e1xuY29uc3QgYnJhbmRUb0tleXdvcmQ9cHJvdmlkZUR1cmFibGVNYXBTdG9yZShiYWdnYWdlLEJSQU5EX1RPX0tFWVdPUkRfS0VZKTtcbmNvbnN0IHRlcm1zPXpjZi5nZXRUZXJtcygpO1xuXG5mb3IoY29uc3Rba2V5d29yZCxicmFuZF1vZiBPYmplY3QuZW50cmllcyh0ZXJtcy5icmFuZHMpKXtcbmlmKCFicmFuZFRvS2V5d29yZC5oYXMoYnJhbmQpKWJyYW5kVG9LZXl3b3JkLmluaXQoYnJhbmQsa2V5d29yZCk7XG4gfVxuXG5yZXR1cm4gYnJhbmRUb0tleXdvcmQ7XG4gfTskaOKAjV9vbmNlLnByb3ZpZGVCcmFuZFRvS2V5d29yZE1hcChwcm92aWRlQnJhbmRUb0tleXdvcmRNYXApO1xuaGFyZGVuKHByb3ZpZGVCcmFuZFRvS2V5d29yZE1hcCk7XG5cbi8qKiBAcGFyYW0ge1hpbXBvcnQoJ0BhZ29yaWMvdmF0LWRhdGEnKS5CYWdnYWdlfSBiYWdnYWdlICovXG5jb25zdCBwcm92aWRlQnJhbmRUb0tleXdvcmRIZWxwZXI9KGJhZ2dhZ2UpPT57XG5jb25zdCBicmFuZFRvS2V5d29yZD1wcm92aWRlRHVyYWJsZU1hcFN0b3JlKGJhZ2dhZ2UsQlJBTkRfVE9fS0VZV09SRF9LRVkpO1xuXG4vKiogQHBhcmFtIHtBbW91bnR9IGFtb3VudCAqL1xuY29uc3QgZ2V0S2V5d29yZD0oYW1vdW50KT0+e1xuYXNzZXJ0KGJyYW5kVG9LZXl3b3JkLmhhcyhhbW91bnQuYnJhbmQpLCdCcmFuZCBpcyB1bmtub3duIHRvIENyYWJibGUuJyk7XG5yZXR1cm4gYnJhbmRUb0tleXdvcmQuZ2V0KGFtb3VudC5icmFuZCk7XG4gfTtcblxucmV0dXJuIGhhcmRlbih7XG5nZXRLZXl3b3JkfSk7XG5cbiB9O1xuXG4vKipcbiAqIEBwYXJhbSB7WkNGfSB6Y2ZcbiAqIEBwYXJhbSB7QW1vdW50fSBhbW91bnRcbiAqIEByZXR1cm5zIHtJc3N1ZXI8QXNzZXRLaW5kPiB8IHVuZGVmaW5lZH1cbiAqLyRo4oCNX29uY2UucHJvdmlkZUJyYW5kVG9LZXl3b3JkSGVscGVyKHByb3ZpZGVCcmFuZFRvS2V5d29yZEhlbHBlcik7XG5jb25zdCBnZXRJc3N1ZXJGcm9tQW1vdW50PSh6Y2YsYW1vdW50KT0+e1xuY29uc3R7YnJhbmRzLGlzc3VlcnN9PXpjZi5nZXRUZXJtcygpO1xuXG5mb3IoY29uc3Qga2V5d29yZCBpbiBicmFuZHMpe1xuaWYoYnJhbmRzW2tleXdvcmRdPT09YW1vdW50LmJyYW5kKXtcbnJldHVybiBoYXJkZW4oaXNzdWVyc1trZXl3b3JkXSk7XG4gfVxuIH1cbiB9OyRo4oCNX29uY2UuZ2V0SXNzdWVyRnJvbUFtb3VudChnZXRJc3N1ZXJGcm9tQW1vdW50KTtcbmhhcmRlbihnZXRJc3N1ZXJGcm9tQW1vdW50KTtcblxuLyoqXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IGxldmVsXG4gKiBAcGFyYW0ge3N0cmluZ30gbWVzc2FnZVxuICogQHBhcmFtIHt1bmtub3dufSBbYm9keV1cbiAqL1xuY29uc3QgbG9nZ2VyPShsZXZlbCxtZXNzYWdlLGJvZHkpPT57XG5pZihib2R5PT09dW5kZWZpbmVkKXtcbmJvZHk9Jyc7XG4gfVxuXG5jb25zb2xlLmxvZyggYENyYWJibGUgJHtsZXZlbH06ICR7bWVzc2FnZX1gLGJvZHkpO1xuIH07JGjigI1fb25jZS5sb2dnZXIobG9nZ2VyKTtcbmhhcmRlbihsb2dnZXIpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImluaXRJc3N1ZXJzIjpbImluaXRJc3N1ZXJzIl0sInByb3ZpZGVCcmFuZFRvS2V5d29yZE1hcCI6WyJwcm92aWRlQnJhbmRUb0tleXdvcmRNYXAiXSwicHJvdmlkZUJyYW5kVG9LZXl3b3JkSGVscGVyIjpbInByb3ZpZGVCcmFuZFRvS2V5d29yZEhlbHBlciJdLCJnZXRJc3N1ZXJGcm9tQW1vdW50IjpbImdldElzc3VlckZyb21BbW91bnQiXSwibG9nZ2VyIjpbImxvZ2dlciJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACLuoeSrQEAAK0BAAAcAAAAamVzc2llLmpzLXYwLjMuMi9zcmMvbWFpbi5qc3siaW1wb3J0cyI6WyIuL3JpbmcwL21haW4uanMiLCIuL3JpbmcxL21haW4uanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL3JpbmcwL21haW4uanMiLCIuL3JpbmcxL21haW4uanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL3JpbmcwL21haW4uanNcIiwgW11dLFtcIi4vcmluZzEvbWFpbi5qc1wiLCBbXV1dKTsgICBcbn0pXG4iLCJfX2xpdmVFeHBvcnRNYXBfXyI6e30sIl9fcmVleHBvcnRNYXBfXyI6e30sIl9fZml4ZWRFeHBvcnRNYXBfXyI6e30sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAnc8TiV0BAABdAQAAHwAAAGplc3NpZS5qcy12MC4zLjIvc3JjL3JpbmcwL0UuanN7ImltcG9ydHMiOlsiQGVuZG8vZmFyIl0sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOlsiQGVuZG8vZmFyIl0sIl9fc3luY01vZHVsZVByb2dyYW1fXyI6IigoeyAgIGltcG9ydHM6ICRo4oCNX2ltcG9ydHMsICAgbGl2ZVZhcjogJGjigI1fbGl2ZSwgICBvbmNlVmFyOiAkaOKAjV9vbmNlLCAgIGltcG9ydE1ldGE6ICRo4oCNX19fX21ldGEsICB9KSA9PiB7ICAgJGjigI1faW1wb3J0cyhbW1wiQGVuZG8vZmFyXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAAD4tMm/qQMAAKkDAAAsAAAAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzAvYXN5bmMtZ2VuZXJhdGUuanN7ImltcG9ydHMiOltdLCJleHBvcnRzIjpbImFzeW5jR2VuZXJhdGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtdKTsgICAvKiBAdHMtY2hlY2sqL1xuXG4vKipcbiAqIFJldHVybiBhbiBhc3luYyBpdGVyYWJsZSB0aGF0IHByb2R1Y2VzIGl0ZXJhdG9yIHJlc3VsdHMgdmlhIGBuZXh0YC5cbiAqXG4gKiBUaGlzIHdvcmtzIGFyb3VuZCBKZXNzaWUncyBmb3JiaWRkYW5jZSBvZiBTeW1ib2wuXG4gKlxuICogQHRlbXBsYXRlIFQsVFJldHVyblxuICogQHBhcmFtIHsoKSA9PiBJdGVyYXRvclJlc3VsdDxULCBUUmV0dXJuPiB8XG4gKiAgICAgICAgICAgICAgIFByb21pc2U8SXRlcmF0b3JSZXN1bHQ8VCwgVFJldHVybj4+XG4gKiB9IG5leHQgcHJvZHVjZSBhIHNpbmdsZS1zdGVwIGl0ZXJhdG9yIHJlc3VsdFxuICogQHJldHVybnMge0FzeW5jSXRlcmFibGU8VD59XG4gKi9cbmNvbnN0ICAgICAgICBhc3luY0dlbmVyYXRlPShuZXh0KT0+e1xucmV0dXJuIGhhcmRlbih7XG5bU3ltYm9sLmFzeW5jSXRlcmF0b3JdOigpPT57XG5yZXR1cm4gaGFyZGVuKHtcbm5leHQ6YXN5bmMoKT0+aGFyZGVuKG5leHQoKSl9KTtcblxuIH19KTtcblxuIH07JGjigI1fb25jZS5hc3luY0dlbmVyYXRlKGFzeW5jR2VuZXJhdGUpO1xuaGFyZGVuKGFzeW5jR2VuZXJhdGUpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7ImFzeW5jR2VuZXJhdGUiOlsiYXN5bmNHZW5lcmF0ZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACX11Tt0AEAANABAAAiAAAAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzAvbWFpbi5qc3siaW1wb3J0cyI6WyIuL0UuanMiLCIuL2FzeW5jLWdlbmVyYXRlLmpzIiwiLi9tYWtlcnMuanMiXSwiZXhwb3J0cyI6W10sInJlZXhwb3J0cyI6WyIuL0UuanMiLCIuL2FzeW5jLWdlbmVyYXRlLmpzIiwiLi9tYWtlcnMuanMiXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICAkaOKAjV9pbXBvcnRzKFtbXCIuL0UuanNcIiwgW11dLFtcIi4vbWFrZXJzLmpzXCIsIFtdXSxbXCIuL2FzeW5jLWdlbmVyYXRlLmpzXCIsIFtdXV0pOyAgIFxufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7fSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAABvm3ti4wgAAOMIAAAkAAAAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzAvbWFrZXJzLmpzeyJpbXBvcnRzIjpbXSwiZXhwb3J0cyI6WyJtYWtlTWFwIiwibWFrZVByb21pc2UiLCJtYWtlU2V0IiwibWFrZVdlYWtNYXAiLCJtYWtlV2Vha1NldCJdLCJyZWV4cG9ydHMiOltdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW10pOyAgIC8qIEB0cy1jaGVjayovXG4vKiBUaGVzZSB3b3JrIGFyb3VuZCBKZXNzaWUncyBmb3JiaWRkYW5jZSBvZiBgbmV3YC4qL1xuLyovIDxyZWZlcmVuY2UgdHlwZXM9XCJzZXNcIiAvPiovXG5cbi8qKiBAdHlwZSB7PFQ+KGV4ZWN1dG9yOiAocmVzb2x2ZTogKHZhbHVlOiBUKSA9PiB2b2lkLCByZWplY3Q6IChyZWFzb24/OiBhbnkpID0+XG4gKiB2b2lkKSA9PiB2b2lkKSA9PiBQcm9taXNlPFQ+fSAqL1xuY29uc3QgICAgICAgIG1ha2VQcm9taXNlPShleGVjdXRvcik9PmhhcmRlbihuZXcgUHJvbWlzZShleGVjdXRvcikpOyRo4oCNX29uY2UubWFrZVByb21pc2UobWFrZVByb21pc2UpO1xuaGFyZGVuKG1ha2VQcm9taXNlKTtcblxuLyoqIEB0eXBlZGVmIHs8SywgVj4oZW50cmllcz86IHJlYWRvbmx5IChyZWFkb25seSBbSywgVl0pW10pID0+IE1hcDxLLCBWPn0gTWFwRnJvbUVudHJpZXMgKi9cbi8qKiBAdHlwZWRlZiB7PEssIFY+KGl0ZXJhYmxlOiBJdGVyYWJsZTxyZWFkb25seSBbSywgVl0+KSA9PiBNYXA8SywgVj59IE1hcEZyb21JdGVyYWJsZSAqL1xuXG4vKiogQHR5cGUge01hcEZyb21FbnRyaWVzICYgTWFwRnJvbUl0ZXJhYmxlfSAqL1xuY29uc3QgICAgICAgIG1ha2VNYXA9KGVudHJpZXNPckl0ZXJhYmxlKT0+aGFyZGVuKG5ldyBNYXAoZW50cmllc09ySXRlcmFibGUpKTskaOKAjV9vbmNlLm1ha2VNYXAobWFrZU1hcCk7XG5oYXJkZW4obWFrZU1hcCk7XG5cbi8qKiBAdHlwZWRlZiB7PFQ+KHZhbHVlcz86IHJlYWRvbmx5IFRbXSkgPT4gU2V0PFQ+fSBTZXRGcm9tVmFsdWVzICovXG4vKiogQHR5cGVkZWYgezxUPihpdGVyYWJsZTogSXRlcmFibGU8VD4pID0+IFNldDxUPn0gU2V0RnJvbUl0ZXJhYmxlICovXG4vKiogQHR5cGUge1NldEZyb21WYWx1ZXMgJiBTZXRGcm9tSXRlcmFibGV9ICovXG5jb25zdCAgICAgICAgbWFrZVNldD0odmFsdWVzKT0+aGFyZGVuKG5ldyBTZXQodmFsdWVzKSk7JGjigI1fb25jZS5tYWtlU2V0KG1ha2VTZXQpO1xuaGFyZGVuKG1ha2VTZXQpO1xuXG4vKiogQHR5cGVkZWYgezxLIGV4dGVuZHMge30sIFYgPSBhbnk+KGVudHJpZXM/OiByZWFkb25seSBbSywgVl1bXSB8IG51bGwpID0+IFdlYWtNYXA8SywgVj59IFdlYWtNYXBGcm9tRW50cmllcyAqL1xuLyoqIEB0eXBlZGVmIHs8SyBleHRlbmRzIHt9LCBWPihpdGVyYWJsZTogSXRlcmFibGU8W0ssIFZdPikgPT4gV2Vha01hcDxLLCBWPn0gV2Vha01hcEZyb21JdGVyYWJsZSAqL1xuLyoqIEB0eXBlIHtXZWFrTWFwRnJvbUVudHJpZXMgJiBXZWFrTWFwRnJvbUl0ZXJhYmxlfSAqL1xuY29uc3QgICAgICAgIG1ha2VXZWFrTWFwPShlbnRyaWVzKT0+aGFyZGVuKG5ldyBXZWFrTWFwKGVudHJpZXMpKTskaOKAjV9vbmNlLm1ha2VXZWFrTWFwKG1ha2VXZWFrTWFwKTtcbmhhcmRlbihtYWtlV2Vha01hcCk7XG5cbi8qKiBAdHlwZWRlZiB7PFQgZXh0ZW5kcyB7fT4odmFsdWVzPzogcmVhZG9ubHkgVFtdKSA9PiBXZWFrU2V0PFQ+fSBXZWFrU2V0RnJvbVZhbHVlcyAqL1xuLyoqIEB0eXBlZGVmIHs8VCBleHRlbmRzIHt9PihpdGVyYWJsZTogSXRlcmFibGU8VD4pID0+IFdlYWtTZXQ8VD59IFdlYWtTZXRGcm9tSXRlcmFibGUgKi9cbi8qKiBAdHlwZSB7V2Vha1NldEZyb21WYWx1ZXMgJiBXZWFrU2V0RnJvbUl0ZXJhYmxlfSAqL1xuY29uc3QgICAgICAgIG1ha2VXZWFrU2V0PSh2YWx1ZXMpPT5oYXJkZW4obmV3IFdlYWtTZXQodmFsdWVzKSk7JGjigI1fb25jZS5tYWtlV2Vha1NldChtYWtlV2Vha1NldCk7XG5oYXJkZW4obWFrZVdlYWtTZXQpO1xufSlcbiIsIl9fbGl2ZUV4cG9ydE1hcF9fIjp7fSwiX19yZWV4cG9ydE1hcF9fIjp7fSwiX19maXhlZEV4cG9ydE1hcF9fIjp7Im1ha2VQcm9taXNlIjpbIm1ha2VQcm9taXNlIl0sIm1ha2VNYXAiOlsibWFrZU1hcCJdLCJtYWtlU2V0IjpbIm1ha2VTZXQiXSwibWFrZVdlYWtNYXAiOlsibWFrZVdlYWtNYXAiXSwibWFrZVdlYWtTZXQiOlsibWFrZVdlYWtTZXQiXX0sIl9fbmVlZHNJbXBvcnRNZXRhX18iOmZhbHNlfVBLAwQKAAAAAAAAAAAAtCz1mP4EAAD+BAAAKQAAAGplc3NpZS5qcy12MC4zLjIvc3JjL3JpbmcxL2FzeW5jLXRvb2xzLmpzeyJpbXBvcnRzIjpbIi4uL3JpbmcwL21haW4uanMiXSwiZXhwb3J0cyI6WyJhc3luY0RvV2hpbGUiXSwicmVleHBvcnRzIjpbXSwiX19zeW5jTW9kdWxlUHJvZ3JhbV9fIjoiKCh7ICAgaW1wb3J0czogJGjigI1faW1wb3J0cywgICBsaXZlVmFyOiAkaOKAjV9saXZlLCAgIG9uY2VWYXI6ICRo4oCNX29uY2UsICAgaW1wb3J0TWV0YTogJGjigI1fX19fbWV0YSwgIH0pID0+IHsgICBsZXQgbWFrZVByb21pc2U7JGjigI1faW1wb3J0cyhbW1wiLi4vcmluZzAvbWFpbi5qc1wiLCBbW1wibWFrZVByb21pc2VcIiwgWyRo4oCNX2EgPT4gKG1ha2VQcm9taXNlID0gJGjigI1fYSldXV1dXSk7ICAgXG5cblxuXG4vKipcbiAqIFJlc29sdmUgcmV0dXJuZWQgcHJvbWlzZSB3aXRoIHVuZGVmaW5lZCB3aGVuIGBib2R5YCByZXR1cm5zIGZhbHN5LlxuICpcbiAqIFRoaXMgd29ya3MgYXJvdW5kIEplc3NpZSdzIGZvcmJpZGRhbmNlIG9mIGBhd2FpdGAgbm90IGF0IHRoZSBmdW5jdGlvbi1sZXZlbC5cbiAqXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHsoKSA9PiBUIHwgUHJvbWlzZTxUPn0gYm9keSBwZXJmb3JtIHNpZGUtZWZmZWN0cywgYW5kIHJldHVybiB0cnV0aHkgaWZcbiAqIHdlIHNob3VsZCBydW4gYWdhaW5cbiAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fVxuICovXG5jb25zdCAgICAgICAgYXN5bmNEb1doaWxlPShib2R5KT0+e1xuY29uc3QgbG9vcD1hc3luYyhyZXNvbHZlLHJlamVjdCk9PntcbmNvbnN0IGRvQ29udGludWU9YXdhaXQgYm9keSgpO1xuaWYoIWRvQ29udGludWUpe1xuLyogUmVzb2x2ZSB0aGUgb3V0ZXJtb3N0IHByb21pc2UuKi9cbnJlc29sdmUodW5kZWZpbmVkKTtcbnJldHVybjtcbiB9XG5cbi8qIERvIHRoZSBsb29wIGFnYWluLiAgV2UgYXJlIGNhcmVmdWwgbm90IHRvIGF3YWl0IHNvIHRoYXQgd2UgZG9uJ3QgY3JlYXRlIGEqL1xuLyogcHJvbWlzZSBjaGFpbi4qL1xubG9vcChyZXNvbHZlLHJlamVjdCkuY2F0Y2gocmVqZWN0KTtcbiB9O1xuXG5yZXR1cm4gbWFrZVByb21pc2UoKHJlc29sdmUscmVqZWN0KT0+bG9vcChyZXNvbHZlLHJlamVjdCkuY2F0Y2gocmVqZWN0KSk7XG4gfTskaOKAjV9vbmNlLmFzeW5jRG9XaGlsZShhc3luY0RvV2hpbGUpO1xuaGFyZGVuKGFzeW5jRG9XaGlsZSk7XG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnsiYXN5bmNEb1doaWxlIjpbImFzeW5jRG9XaGlsZSJdfSwiX19uZWVkc0ltcG9ydE1ldGFfXyI6ZmFsc2V9UEsDBAoAAAAAAAAAAACWE0KycgEAAHIBAAAiAAAAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzEvbWFpbi5qc3siaW1wb3J0cyI6WyIuL2FzeW5jLXRvb2xzLmpzIl0sImV4cG9ydHMiOltdLCJyZWV4cG9ydHMiOlsiLi9hc3luYy10b29scy5qcyJdLCJfX3N5bmNNb2R1bGVQcm9ncmFtX18iOiIoKHsgICBpbXBvcnRzOiAkaOKAjV9pbXBvcnRzLCAgIGxpdmVWYXI6ICRo4oCNX2xpdmUsICAgb25jZVZhcjogJGjigI1fb25jZSwgICBpbXBvcnRNZXRhOiAkaOKAjV9fX19tZXRhLCAgfSkgPT4geyAgICRo4oCNX2ltcG9ydHMoW1tcIi4vYXN5bmMtdG9vbHMuanNcIiwgW11dXSk7ICAgXG59KVxuIiwiX19saXZlRXhwb3J0TWFwX18iOnt9LCJfX3JlZXhwb3J0TWFwX18iOnt9LCJfX2ZpeGVkRXhwb3J0TWFwX18iOnt9LCJfX25lZWRzSW1wb3J0TWV0YV9fIjpmYWxzZX1QSwECHgMKAAAAAAAAAAAAslo2wNGkAQDRpAEAFAAAAAAAAAAAAAAApIEAAAAAY29tcGFydG1lbnQtbWFwLmpzb25QSwECHgMKAAAAAAAAAAAAOYpWAjsLAAA7CwAAIwAAAAAAAAAAAAAApIEDpQEAQGFnb3JpYy9hc3NlcnQtdjAuNi4wL3NyYy9hc3NlcnQuanNQSwECHgMKAAAAAAAAAAAABbmH7NouAADaLgAAIgAAAAAAAAAAAAAApIF/sAEAQGFnb3JpYy9hc3NlcnQtdjAuNi4wL3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAACriiOmbAEAAGwBAAAmAAAAAAAAAAAAAACkgZnfAQBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9leHBvcnRlZC5qc1BLAQIeAwoAAAAAAAAAAABT9YW/RjcAAEY3AAAsAAAAAAAAAAAAAACkgUnhAQBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvYW1vdW50TWF0aC5qc1BLAQIeAwoAAAAAAAAAAABKlADt1QUAANUFAAAtAAAAAAAAAAAAAACkgdkYAgBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvZGlzcGxheUluZm8uanNQSwECHgMKAAAAAAAAAAAAQzB73OgBAADoAQAAJwAAAAAAAAAAAAAApIH5HgIAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAADVdwSiYIAAAmCAAACsAAAAAAAAAAAAAAKSBJiECAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9pc3N1ZXJLaXQuanNQSwECHgMKAAAAAAAAAAAAgMhu7rMFAACzBQAAQAAAAAAAAAAAAAAApIEHQgIAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL21hdGhIZWxwZXJzL2NvcHlCYWdNYXRoSGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAABx52I9xwUAAMcFAABAAAAAAAAAAAAAAACkgRhIAgBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvbWF0aEhlbHBlcnMvY29weVNldE1hdGhIZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAAP/csPsqBgAAKgYAADwAAAAAAAAAAAAAAKSBPU4CAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy9tYXRoSGVscGVycy9uYXRNYXRoSGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAAAmmZgvnwcAAJ8HAAA8AAAAAAAAAAAAAACkgcFUAgBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvbWF0aEhlbHBlcnMvc2V0TWF0aEhlbHBlcnMuanNQSwECHgMKAAAAAAAAAAAAsDioH6UEAAClBAAAKQAAAAAAAAAAAAAApIG6XAIAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL3BheW1lbnQuanNQSwECHgMKAAAAAAAAAAAAD9fo7usxAADrMQAALwAAAAAAAAAAAAAApIGmYQIAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL3BheW1lbnRMZWRnZXIuanNQSwECHgMKAAAAAAAAAAAAokVFQsAPAADADwAAJwAAAAAAAAAAAAAApIHekwIAQGFnb3JpYy9lcnRwLXYwLjE2LjMtdTExLjAvc3JjL3B1cnNlLmpzUEsBAh4DCgAAAAAAAAAAAC5JY6kUBgAAFAYAADMAAAAAAAAAAAAAAKSB46MCAEBhZ29yaWMvZXJ0cC12MC4xNi4zLXUxMS4wL3NyYy90cmFuc2llbnROb3RpZmllci5qc1BLAQIeAwoAAAAAAAAAAAAo7p4+EicAABInAAAsAAAAAAAAAAAAAACkgUiqAgBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvdHlwZUd1YXJkcy5qc1BLAQIeAwoAAAAAAAAAAAAsz6lRcD8AAHA/AAAvAAAAAAAAAAAAAACkgaTRAgBAYWdvcmljL2VydHAtdjAuMTYuMy11MTEuMC9zcmMvdHlwZXMtYW1iaWVudC5qc1BLAQIeAwoAAAAAAAAAAAD3qap29AMAAPQDAAAxAAAAAAAAAAAAAACkgWERAwBAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29uc3RhbnRzLmpzUEsBAh4DCgAAAAAAAAAAADeWcIX8CwAA/AsAAEUAAAAAAAAAAAAAAKSBpBUDAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvYXNzZXJ0aW9ucy5qc1BLAQIeAwoAAAAAAAAAAACiI0DydREAAHURAABEAAAAAAAAAAAAAACkgQMiAwBAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkFwaS5qc1BLAQIeAwoAAAAAAAAAAAAb7V7Kqw8AAKsPAABHAAAAAAAAAAAAAACkgdozAwBAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVybkZpbHRlci5qc1BLAQIeAwoAAAAAAAAAAABGD4o1SBYAAEgWAABGAAAAAAAAAAAAAACkgepDAwBAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvY29udHJhY3RHb3Zlcm5hbmNlL2dvdmVyblBhcmFtLmpzUEsBAh4DCgAAAAAAAAAAAGNT23sHQgAAB0IAAEcAAAAAAAAAAAAAAKSBlloDAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvcGFyYW1NYW5hZ2VyLmpzUEsBAh4DCgAAAAAAAAAAAEOoxGbnFwAA5xcAAEwAAAAAAAAAAAAAAKSBAp0DAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9jb250cmFjdEdvdmVybmFuY2UvdHlwZWRQYXJhbU1hbmFnZXIuanNQSwECHgMKAAAAAAAAAAAAUJiUmA8jAAAPIwAAOAAAAAAAAAAAAAAApIFTtQMAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJub3IuanNQSwECHgMKAAAAAAAAAAAAa2BKrnsdAAB7HQAAOwAAAAAAAAAAAAAApIG42AMAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0R292ZXJub3JLaXQuanNQSwECHgMKAAAAAAAAAAAAxQIp4JMrAACTKwAANgAAAAAAAAAAAAAApIGM9gMAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL2NvbnRyYWN0SGVscGVyLmpzUEsBAh4DCgAAAAAAAAAAAPn/ZW0vCgAALwoAAC0AAAAAAAAAAAAAAKSBcyIEAEBhZ29yaWMvZ292ZXJuYW5jZS12MC4xMC40LXUxMS4wL3NyYy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAABZt2/Ypw8AAKcPAAAwAAAAAAAAAAAAAACkge0sBABAYWdvcmljL2dvdmVybmFuY2UtdjAuMTAuNC11MTEuMC9zcmMvcXVlc3Rpb24uanNQSwECHgMKAAAAAAAAAAAAntDSEyg7AAAoOwAAMgAAAAAAAAAAAAAApIHiPAQAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL3R5cGVHdWFyZHMuanNQSwECHgMKAAAAAAAAAAAAPWNrkWNhAABjYQAANQAAAAAAAAAAAAAApIFaeAQAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL3R5cGVzLWFtYmllbnQuanNQSwECHgMKAAAAAAAAAAAA6FEl/WMKAABjCgAAMgAAAAAAAAAAAAAApIEQ2gQAQGFnb3JpYy9nb3Zlcm5hbmNlLXYwLjEwLjQtdTExLjAvc3JjL3ZhbGlkYXRvcnMuanNQSwECHgMKAAAAAAAAAAAAbdthCl4oAABeKAAALQAAAAAAAAAAAAAApIHD5AQAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL2NhbGxiYWNrLmpzUEsBAh4DCgAAAAAAAAAAAKqP3UYiBgAAIgYAACsAAAAAAAAAAAAAAKSBbA0FAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy9jb25maWcuanNQSwECHgMKAAAAAAAAAAAAF8kzgMgEAADIBAAAKgAAAAAAAAAAAAAApIHXEwUAQGFnb3JpYy9pbnRlcm5hbC12MC4zLjMtdTExLjAvc3JjL2RlYnVnLmpzUEsBAh4DCgAAAAAAAAAAAG4VmJ9DAgAAQwIAACoAAAAAAAAAAAAAAKSB5xgFAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAABtyjjrCS4AAAkuAAA1AAAAAAAAAAAAAACkgXIbBQBAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvbGliLWNoYWluU3RvcmFnZS5qc1BLAQIeAwoAAAAAAAAAAABp8sRAJw8AACcPAAAxAAAAAAAAAAAAAACkgc5JBQBAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvbWV0aG9kLXRvb2xzLmpzUEsBAh4DCgAAAAAAAAAAAOpD4SXeAwAA3gMAADIAAAAAAAAAAAAAAKSBRFkFAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy90ZXN0aW5nLXV0aWxzLmpzUEsBAh4DCgAAAAAAAAAAAFQ5+hEtAgAALQIAAC8AAAAAAAAAAAAAAKSBcl0FAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy90eXBlR3VhcmRzLmpzUEsBAh4DCgAAAAAAAAAAAN7GoowrBwAAKwcAADAAAAAAAAAAAAAAAKSB7F8FAEBhZ29yaWMvaW50ZXJuYWwtdjAuMy4zLXUxMS4wL3NyYy91cGdyYWRlLWFwaS5qc1BLAQIeAwoAAAAAAAAAAACi6bGS4zwAAOM8AAAqAAAAAAAAAAAAAACkgWVnBQBAYWdvcmljL2ludGVybmFsLXYwLjMuMy11MTEuMC9zcmMvdXRpbHMuanNQSwECHgMKAAAAAAAAAAAAq4ojpmwBAABsAQAAKQAAAAAAAAAAAAAApIGQpAUAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvZXhwb3J0ZWQuanNQSwECHgMKAAAAAAAAAAAAZ9DFitUSAADVEgAAOQAAAAAAAAAAAAAApIFDpgUAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL2FzeW5jSXRlcmFibGVBZGFwdG9yLmpzUEsBAh4DCgAAAAAAAAAAALC+L08cBwAAHAcAACoAAAAAAAAAAAAAAKSBb7kFAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAADysAhlWhgAAFoYAAAtAAAAAAAAAAAAAACkgdPABQBAYWdvcmljL25vdGlmaWVyLXYwLjYuMy11MTEuMC9zcmMvbm90aWZpZXIuanNQSwECHgMKAAAAAAAAAAAAVn+HSH44AAB+OAAAMAAAAAAAAAAAAAAApIF42QUAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3B1Ymxpc2gta2l0LmpzUEsBAh4DCgAAAAAAAAAAAL4BMCSDCgAAgwoAADQAAAAAAAAAAAAAAKSBRBIGAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9zdG9yZWQtbm90aWZpZXIuanNQSwECHgMKAAAAAAAAAAAA6z5UarAiAACwIgAALQAAAAAAAAAAAAAApIEZHQYAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3N0b3Jlc3ViLmpzUEsBAh4DCgAAAAAAAAAAAHVi4yhuJAAAbiQAAC4AAAAAAAAAAAAAAKSBFEAGAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy9zdWJzY3JpYmUuanNQSwECHgMKAAAAAAAAAAAAJ7I7I8ULAADFCwAALwAAAAAAAAAAAAAApIHOZAYAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3N1YnNjcmliZXIuanNQSwECHgMKAAAAAAAAAAAAIYEWcgwGAAAMBgAAKgAAAAAAAAAAAAAApIHgcAYAQGFnb3JpYy9ub3RpZmllci12MC42LjMtdTExLjAvc3JjL3RvcGljLmpzUEsBAh4DCgAAAAAAAAAAAPhRDxM/MAAAPzAAADIAAAAAAAAAAAAAAKSBNHcGAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3NyYy90eXBlcy1hbWJpZW50LmpzUEsBAh4DCgAAAAAAAAAAANhcAn32BgAA9gYAADMAAAAAAAAAAAAAAKSBw6cGAEBhZ29yaWMvbm90aWZpZXItdjAuNi4zLXUxMS4wL3Rvb2xzL3Rlc3RTdXBwb3J0cy5qc1BLAQIeAwoAAAAAAAAAAAA+Ylw2XAEAAFwBAAAmAAAAAAAAAAAAAACkgQqvBgBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9leHBvcnRlZC5qc1BLAQIeAwoAAAAAAAAAAABqgKjv3AsAANwLAAAnAAAAAAAAAAAAAACkgaqwBgBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAA4q+AfUYLAABGCwAAMgAAAAAAAAAAAAAApIHLvAYAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL2xlZ2FjeS9sZWdhY3lNYXAuanNQSwECHgMKAAAAAAAAAAAApoNNtMIGAADCBgAANgAAAAAAAAAAAAAApIFhyAYAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL2xlZ2FjeS9sZWdhY3lXZWFrTWFwLmpzUEsBAh4DCgAAAAAAAAAAAJoDutcWFgAAFhYAADcAAAAAAAAAAAAAAKSBd88GAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy9zdG9yZXMvc2NhbGFyTWFwU3RvcmUuanNQSwECHgMKAAAAAAAAAAAAnQOWIEEPAABBDwAANwAAAAAAAAAAAAAApIHi5QYAQGFnb3JpYy9zdG9yZS12MC45LjMtdTExLjAvc3JjL3N0b3Jlcy9zY2FsYXJTZXRTdG9yZS5qc1BLAQIeAwoAAAAAAAAAAAAZQWnY4xIAAOMSAAA7AAAAAAAAAAAAAACkgXj1BgBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3NjYWxhcldlYWtNYXBTdG9yZS5qc1BLAQIeAwoAAAAAAAAAAABtrD+9hA4AAIQOAAA7AAAAAAAAAAAAAACkgbQIBwBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3NjYWxhcldlYWtTZXRTdG9yZS5qc1BLAQIeAwoAAAAAAAAAAACy12MInRkAAJ0ZAAA0AAAAAAAAAAAAAACkgZEXBwBAYWdvcmljL3N0b3JlLXYwLjkuMy11MTEuMC9zcmMvc3RvcmVzL3N0b3JlLXV0aWxzLmpzUEsBAh4DCgAAAAAAAAAAAMUArIJYKgAAWCoAACcAAAAAAAAAAAAAAKSBgDEHAEBhZ29yaWMvc3RvcmUtdjAuOS4zLXUxMS4wL3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAuAAAAAAAAAAAAAACkgR1cBwBAYWdvcmljL3N3aW5nc2V0LXZhdC12MC4zMi4zLXUxMS4wL2V4cG9ydGVkLmpzUEsBAh4DCgAAAAAAAAAAAI5QuynZFQAA2RUAADwAAAAAAAAAAAAAAKSBnV0HAEBhZ29yaWMvc3dpbmdzZXQtdmF0LXYwLjMyLjMtdTExLjAvc3JjL3ZhdHMvbmV0d29yay90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAAhmCHYvwEAAL8BAAAiAAAAAAAAAAAAAACkgdBzBwBAYWdvcmljL3RpbWUtdjAuMy4zLXUxMS4wL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAMBAN+aoIgAAqCIAACkAAAAAAAAAAAAAAKSBz3UHAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3RpbWVNYXRoLmpzUEsBAh4DCgAAAAAAAAAAAG6zHqqnBwAApwcAACsAAAAAAAAAAAAAAKSBvpgHAEBhZ29yaWMvdGltZS12MC4zLjMtdTExLjAvc3JjL3R5cGVHdWFyZHMuanNQSwECHgMKAAAAAAAAAAAAvtREY2MoAABjKAAALgAAAAAAAAAAAAAApIGuoAcAQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAvc3JjL2V4by11dGlscy5qc1BLAQIeAwoAAAAAAAAAAAA74z2IkggAAJIIAAAqAAAAAAAAAAAAAACkgV3JBwBAYWdvcmljL3ZhdC1kYXRhLXYwLjUuMy11MTEuMC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAA3vSPIFMoAABTKAAANgAAAAAAAAAAAAAApIE30gcAQGFnb3JpYy92YXQtZGF0YS12MC41LjMtdTExLjAvc3JjL3ZhdC1kYXRhLWJpbmRpbmdzLmpzUEsBAh4DCgAAAAAAAAAAACivt2jAAwAAwAMAACUAAAAAAAAAAAAAAKSB3voHAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvZXhwb3J0ZWQuanNQSwECHgMKAAAAAAAAAAAAcY284kAcAABAHAAALgAAAAAAAAAAAAAApIHh/gcAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY2xlYW5Qcm9wb3NhbC5qc1BLAQIeAwoAAAAAAAAAAACaqDlCvBAAALwQAAA6AAAAAAAAAAAAAACkgW0bCABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdEZhY2V0L29mZmVyU2FmZXR5LmpzUEsBAh4DCgAAAAAAAAAAACn3kkENDwAADQ8AAEEAAAAAAAAAAAAAAKSBgSwIAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0RmFjZXQvcmlnaHRzQ29uc2VydmF0aW9uLmpzUEsBAh4DCgAAAAAAAAAAAGWaQ76SJQAAkiUAADQAAAAAAAAAAAAAAKSB7TsIAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0RmFjZXQvdHlwZXMuanNQSwECHgMKAAAAAAAAAAAAYL1DMS4cAAAuHAAAPwAAAAAAAAAAAAAApIHRYQgAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L2F0b21pY1RyYW5zZmVyLmpzUEsBAh4DCgAAAAAAAAAAAHVUCAW+GwAAvhsAAD4AAAAAAAAAAAAAAKSBXH4IAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9ib25kaW5nQ3VydmVzLmpzUEsBAh4DCgAAAAAAAAAAALLT47GtEgAArRIAADsAAAAAAAAAAAAAAKSBdpoIAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9kdXJhYmlsaXR5LmpzUEsBAh4DCgAAAAAAAAAAAFVcfJ7fCQAA3wkAADYAAAAAAAAAAAAAAKSBfK0IAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAA6/4CpqCsAAKgrAAA/AAAAAAAAAAAAAACkga+3CABAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvcHJpY2VBdXRob3JpdHkuanNQSwECHgMKAAAAAAAAAAAAiB7sqfQIAAD0CAAAOwAAAAAAAAAAAAAApIG04wgAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L3ByaWNlUXVvdGUuanNQSwECHgMKAAAAAAAAAAAArcVdS7w2AAC8NgAANgAAAAAAAAAAAAAApIEB7QgAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L3JhdGlvLmpzUEsBAh4DCgAAAAAAAAAAAPM8Lm46JgAAOiYAADkAAAAAAAAAAAAAAKSBESQJAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC9yZWNvcmRlci5qc1BLAQIeAwoAAAAAAAAAAADoaR+3tgYAALYGAAA5AAAAAAAAAAAAAACkgaJKCQBAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvc2FmZU1hdGguanNQSwECHgMKAAAAAAAAAAAAa4MaC5oEAACaBAAAPQAAAAAAAAAAAAAApIGvUQkAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RTdXBwb3J0L3N0YXRlTWFjaGluZS5qc1BLAQIeAwoAAAAAAAAAAAB+bWltfwUAAH8FAAA7AAAAAAAAAAAAAACkgaRWCQBAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvc3RhdGlzdGljcy5qc1BLAQIeAwoAAAAAAAAAAAA+y33fnQcAAJ0HAAA3AAAAAAAAAAAAAACkgXxcCQBAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvdG9waWNzLmpzUEsBAh4DCgAAAAAAAAAAAGUEwhbaCwAA2gsAADYAAAAAAAAAAAAAAKSBbmQJAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2NvbnRyYWN0U3VwcG9ydC90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAA0sXcatDgAALQ4AAA7AAAAAAAAAAAAAACkgZxwCQBAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdFN1cHBvcnQvem9lSGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAADyMHSDVwcAAFcHAAA7AAAAAAAAAAAAAACkgampCQBAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdHMvY2FsbFNwcmVhZC90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAApC6TJuAEAALgBAAAzAAAAAAAAAAAAAACkgVmxCQBAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3NyYy9jb250cmFjdHMvZXhwb3J0ZWQuanNQSwECHgMKAAAAAAAAAAAA6dHsNaMaAACjGgAANQAAAAAAAAAAAAAApIFiswkAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RzL2xvYW4vdHlwZXMuanNQSwECHgMKAAAAAAAAAAAAOFm6YtILAADSCwAAMAAAAAAAAAAAAAAApIFYzgkAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvY29udHJhY3RzL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAG0xO1m5JwAAuScAAC8AAAAAAAAAAAAAAKSBeNoJAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL2ludGVybmFsLXR5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAKCkFjVWCAAAVggAACsAAAAAAAAAAAAAAKSBfgIKAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL21ha2VIYW5kbGUuanNQSwECHgMKAAAAAAAAAAAAxvqXB6IFAACiBQAAMwAAAAAAAAAAAAAApIEdCwoAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvb2JqQXJyYXlDb252ZXJzaW9uLmpzUEsBAh4DCgAAAAAAAAAAAOWxCczbQwAA20MAACsAAAAAAAAAAAAAAKSBEBEKAEBhZ29yaWMvem9lLXYwLjI2LjMtdTExLjAvc3JjL3R5cGVHdWFyZHMuanNQSwECHgMKAAAAAAAAAAAA6Q0Ba5YHAACWBwAAJgAAAAAAAAAAAAAApIE0VQoAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvdHlwZXMuanNQSwECHgMKAAAAAAAAAAAAalWnPiwtAAAsLQAAMQAAAAAAAAAAAAAApIEOXQoAQGFnb3JpYy96b2UtdjAuMjYuMy11MTEuMC9zcmMvem9lU2VydmljZS90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAADY7Y2slxYAAJcWAAAwAAAAAAAAAAAAAACkgYmKCgBAYWdvcmljL3pvZS12MC4yNi4zLXUxMS4wL3Rvb2xzL3R5cGVzLWFtYmllbnQuanNQSwECHgMKAAAAAAAAAAAAt8K8e+IGAADiBgAAJQAAAAAAAAAAAAAApIFuoQoAQGFnb3JpYy96b25lLXYwLjIuMy11MTEuMC9zcmMvaGVhcC5qc1BLAQIeAwoAAAAAAAAAAADY9BkwjwkAAI8JAAAmAAAAAAAAAAAAAACkgZOoCgBAYWdvcmljL3pvbmUtdjAuMi4zLXUxMS4wL3NyYy9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAAAeKPu0fgEAAH4BAAAhAAAAAAAAAAAAAACkgWayCgBAZW5kby9lbnYtb3B0aW9ucy12MC4xLjQvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAshzifZgMAACYDAAAKwAAAAAAAAAAAAAApIEjtAoAQGVuZG8vZW52LW9wdGlvbnMtdjAuMS40L3NyYy9lbnYtb3B0aW9ucy5qc1BLAQIeAwoAAAAAAAAAAADO3bE+kAsAAJALAAAkAAAAAAAAAAAAAACkgQTBCgBAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE0Ljgvc3JjL0UuanNQSwECHgMKAAAAAAAAAAAAaUorAR0CAAAdAgAAKgAAAAAAAAAAAAAApIHWzAoAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNC44L3NyYy9uby1zaGltLmpzUEsBAh4DCgAAAAAAAAAAAOt99Ld7DAAAewwAAC4AAAAAAAAAAAAAAKSBO88KAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTQuOC9zcmMvdHJhY2stdHVybnMuanNQSwECHgMKAAAAAAAAAAAAfiRuLdIRAADSEQAAJAAAAAAAAAAAAAAApIEC3AoAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy4yL3NyYy9FLmpzUEsBAh4DCgAAAAAAAAAAADcL7U8fAgAAHwIAACoAAAAAAAAAAAAAAKSBFu4KAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuMi9zcmMvbm8tc2hpbS5qc1BLAQIeAwoAAAAAAAAAAAChWCM/jxAAAI8QAAAuAAAAAAAAAAAAAACkgX3wCgBAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjIvc3JjL3RyYWNrLXR1cm5zLmpzUEsBAh4DCgAAAAAAAAAAALQvi4IHLgAABy4AACQAAAAAAAAAAAAAAKSBWAELAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuNi9zcmMvRS5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAqAAAAAAAAAAAAAACkgaEvCwBAZW5kby9ldmVudHVhbC1zZW5kLXYwLjE3LjYvc3JjL2V4cG9ydHMuanNQSwECHgMKAAAAAAAAAAAA+xh03UUCAABFAgAAKgAAAAAAAAAAAAAApIEdMQsAQGVuZG8vZXZlbnR1YWwtc2VuZC12MC4xNy42L3NyYy9uby1zaGltLmpzUEsBAh4DCgAAAAAAAAAAAOqhHXSXEAAAlxAAAC4AAAAAAAAAAAAAAKSBqjMLAEBlbmRvL2V2ZW50dWFsLXNlbmQtdjAuMTcuNi9zcmMvdHJhY2stdHVybnMuanNQSwECHgMKAAAAAAAAAAAAOlKtTRwCAAAcAgAAGQAAAAAAAAAAAAAApIGNRAsAQGVuZG8vZXhvLXYwLjIuMi9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAADGt+tWYxgAAGMYAAAiAAAAAAAAAAAAAACkgeBGCwBAZW5kby9leG8tdjAuMi4yL3NyYy9leG8tbWFrZXJzLmpzUEsBAh4DCgAAAAAAAAAAADGwrfJxJgAAcSYAACEAAAAAAAAAAAAAAKSBg18LAEBlbmRvL2V4by12MC4yLjIvc3JjL2V4by10b29scy5qc1BLAQIeAwoAAAAAAAAAAABBDDOUQAIAAEACAAAeAAAAAAAAAAAAAACkgTOGCwBAZW5kby9mYXItdjAuMi4xOC9zcmMvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAQQwzlEACAABAAgAAHgAAAAAAAAAAAAAApIGviAsAQGVuZG8vZmFyLXYwLjIuMjIvc3JjL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAKWPOvdKBwAASgcAAB0AAAAAAAAAAAAAAKSBK4sLAEBlbmRvL21hcnNoYWwtdjAuOC41L2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAA0IJnuUDQAAlA0AACsAAAAAAAAAAAAAAKSBsJILAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9kZWVwbHlGdWxmaWxsZWQuanNQSwECHgMKAAAAAAAAAAAAO3LPgOQ/AADkPwAAKgAAAAAAAAAAAAAApIGNoAsAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL2VuY29kZVBhc3NhYmxlLmpzUEsBAh4DCgAAAAAAAAAAAMRTp/D8PwAA/D8AACsAAAAAAAAAAAAAAKSBueALAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9lbmNvZGVUb0NhcERhdGEuanNQSwECHgMKAAAAAAAAAAAAs173a8U7AADFOwAALQAAAAAAAAAAAAAApIH+IAwAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL2VuY29kZVRvU21hbGxjYXBzLmpzUEsBAh4DCgAAAAAAAAAAAAhCkv2sKgAArCoAACoAAAAAAAAAAAAAAKSBDl0MAEBlbmRvL21hcnNoYWwtdjAuOC41L3NyYy9tYXJzaGFsLWp1c3Rpbi5qc1BLAQIeAwoAAAAAAAAAAAAT09Ub3AYAANwGAAAtAAAAAAAAAAAAAACkgQKIDABAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvbWFyc2hhbC1zdHJpbmdpZnkuanNQSwECHgMKAAAAAAAAAAAAvp5pSuwyAADsMgAAIwAAAAAAAAAAAAAApIEpjwwAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL21hcnNoYWwuanNQSwECHgMKAAAAAAAAAAAAV0RkCn5AAAB+QAAAJQAAAAAAAAAAAAAApIFWwgwAQGVuZG8vbWFyc2hhbC12MC44LjUvc3JjL3JhbmtPcmRlci5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAhAAAAAAAAAAAAAACkgRcDDQBAZW5kby9tYXJzaGFsLXYwLjguNS9zcmMvdHlwZXMuanNQSwECHgMKAAAAAAAAAAAAJR6bvc8LAADPCwAAHgAAAAAAAAAAAAAApIGKBA0AQGVuZG8vbmF0LXY0LjEuMjcvc3JjL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAGXyjBp8CAAAfAgAACAAAAAAAAAAAAAAAKSBlRANAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAN5GtqqTBwAAkwcAACgAAAAAAAAAAAAAAKSBTxkNAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9jb3B5QXJyYXkuanNQSwECHgMKAAAAAAAAAAAAg/XbLM8HAADPBwAAKQAAAAAAAAAAAAAApIEoIQ0AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2NvcHlSZWNvcmQuanNQSwECHgMKAAAAAAAAAAAA06A4cZ0RAACdEQAAJAAAAAAAAAAAAAAApIE+KQ0AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL2Vycm9yLmpzUEsBAh4DCgAAAAAAAAAAAEo7ZoNVCAAAVQgAACsAAAAAAAAAAAAAAKSBHTsNAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9pdGVyLWhlbHBlcnMuanNQSwECHgMKAAAAAAAAAAAAYk1nA04aAABOGgAAJwAAAAAAAAAAAAAApIG7Qw0AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL21ha2UtZmFyLmpzUEsBAh4DCgAAAAAAAAAAAAKRe+UdBAAAHQQAACkAAAAAAAAAAAAAAKSBTl4NAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9tYWtlVGFnZ2VkLmpzUEsBAh4DCgAAAAAAAAAAABlAKMb1GQAA9RkAADAAAAAAAAAAAAAAAKSBsmINAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9wYXNzU3R5bGUtaGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAAAubrENgxsAAIMbAAAqAAAAAAAAAAAAAACkgfV8DQBAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvcGFzc1N0eWxlT2YuanNQSwECHgMKAAAAAAAAAAAAFLGifcMhAADDIQAAKAAAAAAAAAAAAAAApIHAmA0AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3JlbW90YWJsZS5qc1BLAQIeAwoAAAAAAAAAAAA14k6Kmg8AAJoPAAArAAAAAAAAAAAAAACkgcm6DQBAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvc2FmZS1wcm9taXNlLmpzUEsBAh4DCgAAAAAAAAAAAMcf1VBHEgAARxIAACUAAAAAAAAAAAAAAKSBrMoNAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS4zL3NyYy9zeW1ib2wuanNQSwECHgMKAAAAAAAAAAAAJbxc+/0HAAD9BwAAJQAAAAAAAAAAAAAApIE23Q0AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjMvc3JjL3RhZ2dlZC5qc1BLAQIeAwoAAAAAAAAAAAB6oH5oEg0AABINAAApAAAAAAAAAAAAAACkgXblDQBAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvdHlwZUd1YXJkcy5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAkAAAAAAAAAAAAAACkgc/yDQBAZW5kby9wYXNzLXN0eWxlLXYwLjEuMy9zcmMvdHlwZXMuanNQSwECHgMKAAAAAAAAAAAAZfKMGnwIAAB8CAAAIAAAAAAAAAAAAAAApIFF9A0AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvaW5kZXguanNQSwECHgMKAAAAAAAAAAAA3ka2qpMHAACTBwAAKAAAAAAAAAAAAAAApIH//A0AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL2NvcHlBcnJheS5qc1BLAQIeAwoAAAAAAAAAAACD9dsszwcAAM8HAAApAAAAAAAAAAAAAACkgdgEDgBAZW5kby9wYXNzLXN0eWxlLXYwLjEuNy9zcmMvY29weVJlY29yZC5qc1BLAQIeAwoAAAAAAAAAAABqd7sZSxIAAEsSAAAkAAAAAAAAAAAAAACkge4MDgBAZW5kby9wYXNzLXN0eWxlLXYwLjEuNy9zcmMvZXJyb3IuanNQSwECHgMKAAAAAAAAAAAASjtmg1UIAABVCAAAKwAAAAAAAAAAAAAApIF7Hw4AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL2l0ZXItaGVscGVycy5qc1BLAQIeAwoAAAAAAAAAAAD6Vf/NMhoAADIaAAAnAAAAAAAAAAAAAACkgRkoDgBAZW5kby9wYXNzLXN0eWxlLXYwLjEuNy9zcmMvbWFrZS1mYXIuanNQSwECHgMKAAAAAAAAAAAAApF75R0EAAAdBAAAKQAAAAAAAAAAAAAApIGQQg4AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL21ha2VUYWdnZWQuanNQSwECHgMKAAAAAAAAAAAAGUAoxvUZAAD1GQAAMAAAAAAAAAAAAAAApIH0Rg4AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL3Bhc3NTdHlsZS1oZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAAHnfzczXHgAA1x4AACoAAAAAAAAAAAAAAKSBN2EOAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy9wYXNzU3R5bGVPZi5qc1BLAQIeAwoAAAAAAAAAAAAUsaJ9wyEAAMMhAAAoAAAAAAAAAAAAAACkgVaADgBAZW5kby9wYXNzLXN0eWxlLXYwLjEuNy9zcmMvcmVtb3RhYmxlLmpzUEsBAh4DCgAAAAAAAAAAADXiToqaDwAAmg8AACsAAAAAAAAAAAAAAKSBX6IOAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy9zYWZlLXByb21pc2UuanNQSwECHgMKAAAAAAAAAAAAxx/VUEcSAABHEgAAJQAAAAAAAAAAAAAApIFCsg4AQGVuZG8vcGFzcy1zdHlsZS12MC4xLjcvc3JjL3N5bWJvbC5qc1BLAQIeAwoAAAAAAAAAAAAlvFz7/QcAAP0HAAAlAAAAAAAAAAAAAACkgczEDgBAZW5kby9wYXNzLXN0eWxlLXYwLjEuNy9zcmMvdGFnZ2VkLmpzUEsBAh4DCgAAAAAAAAAAAHqgfmgSDQAAEg0AACkAAAAAAAAAAAAAAKSBDM0OAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy90eXBlR3VhcmRzLmpzUEsBAh4DCgAAAAAAAAAAAJgZO7M0AQAANAEAACQAAAAAAAAAAAAAAKSBZdoOAEBlbmRvL3Bhc3Mtc3R5bGUtdjAuMS43L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAACwnEJ+4goAAOIKAAAeAAAAAAAAAAAAAACkgdvbDgBAZW5kby9wYXR0ZXJucy12MC4yLjIvaW5kZXguanNQSwECHgMKAAAAAAAAAAAAyxcZ4KRGAACkRgAAKgAAAAAAAAAAAAAApIH55g4AQGVuZG8vcGF0dGVybnMtdjAuMi4yL3NyYy9rZXlzL2NoZWNrS2V5LmpzUEsBAh4DCgAAAAAAAAAAAPfmwlF3GgAAdxoAAC0AAAAAAAAAAAAAAKSB5S0PAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMva2V5cy9jb21wYXJlS2V5cy5qc1BLAQIeAwoAAAAAAAAAAABVIML9KhQAACoUAAApAAAAAAAAAAAAAACkgadIDwBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvY29weUJhZy5qc1BLAQIeAwoAAAAAAAAAAAAKHf6/oxAAAKMQAAApAAAAAAAAAAAAAACkgRhdDwBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvY29weVNldC5qc1BLAQIeAwoAAAAAAAAAAAALKJ5teSUAAHklAAA1AAAAAAAAAAAAAACkgQJuDwBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvbWVyZ2UtYmFnLW9wZXJhdG9ycy5qc1BLAQIeAwoAAAAAAAAAAAAi9nVSnigAAJ4oAAA1AAAAAAAAAAAAAACkgc6TDwBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL2tleXMvbWVyZ2Utc2V0LW9wZXJhdG9ycy5qc1BLAQIeAwoAAAAAAAAAAACJDDsFM8MAADPDAAA1AAAAAAAAAAAAAACkgb+8DwBAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL3BhdHRlcm5zL3BhdHRlcm5NYXRjaGVycy5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAiAAAAAAAAAAAAAACkgUWAEABAZW5kby9wYXR0ZXJucy12MC4yLjIvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAJYe98fqGgAA6hoAACIAAAAAAAAAAAAAAKSBuYEQAEBlbmRvL3BhdHRlcm5zLXYwLjIuMi9zcmMvdXRpbHMuanNQSwECHgMKAAAAAAAAAAAAClK+n3AJAABwCQAAIgAAAAAAAAAAAAAApIHjnBAAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi41Ni9pbmRleC5qc1BLAQIeAwoAAAAAAAAAAACIfYGs3wIAAN8CAAArAAAAAAAAAAAAAACkgZOmEABAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy9pcy1wcm9taXNlLmpzUEsBAh4DCgAAAAAAAAAAAB2nTeu+EgAAvhIAACoAAAAAAAAAAAAAAKSBu6kQAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNTYvc3JjL21lbW8tcmFjZS5qc1BLAQIeAwoAAAAAAAAAAADTQ7DuaQcAAGkHAAA1AAAAAAAAAAAAAACkgcG8EABAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy9wcm9taXNlLWV4ZWN1dG9yLWtpdC5qc1BLAQIeAwoAAAAAAAAAAACYGTuzNAEAADQBAAAmAAAAAAAAAAAAAACkgX3EEABAZW5kby9wcm9taXNlLWtpdC12MC4yLjU2L3NyYy90eXBlcy5qc1BLAQIeAwoAAAAAAAAAAAAKUr6fcAkAAHAJAAAiAAAAAAAAAAAAAACkgfXFEABAZW5kby9wcm9taXNlLWtpdC12MC4yLjYwL2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAIh9gazfAgAA3wIAACsAAAAAAAAAAAAAAKSBpc8QAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAvc3JjL2lzLXByb21pc2UuanNQSwECHgMKAAAAAAAAAAAAHadN674SAAC+EgAAKgAAAAAAAAAAAAAApIHN0hAAQGVuZG8vcHJvbWlzZS1raXQtdjAuMi42MC9zcmMvbWVtby1yYWNlLmpzUEsBAh4DCgAAAAAAAAAAANNDsO5pBwAAaQcAADUAAAAAAAAAAAAAAKSB0+UQAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAvc3JjL3Byb21pc2UtZXhlY3V0b3Ita2l0LmpzUEsBAh4DCgAAAAAAAAAAAJgZO7M0AQAANAEAACYAAAAAAAAAAAAAAKSBj+0QAEBlbmRvL3Byb21pc2Uta2l0LXYwLjIuNjAvc3JjL3R5cGVzLmpzUEsBAh4DCgAAAAAAAAAAAAyuJeT0GAAA9BgAAB0AAAAAAAAAAAAAAKSBB+8QAEBlbmRvL3N0cmVhbS12MC4zLjI1L2luZGV4LmpzUEsBAh4DCgAAAAAAAAAAAKmyMNG0HAAAtBwAAC8AAAAAAAAAAAAAAKSBNggRAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9hc3NlcnRpb25IZWxwZXJzLmpzUEsBAh4DCgAAAAAAAAAAAOhdG/1ICQAASAkAACgAAAAAAAAAAAAAAKSBNyURAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9iaWRIb2xkZXIuanNQSwECHgMKAAAAAAAAAAAAr+80mcoFAADKBQAAJQAAAAAAAAAAAAAApIHFLhEAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL2JpZEtpdC5qc1BLAQIeAwoAAAAAAAAAAABa3eZikC0AAJAtAAAqAAAAAAAAAAAAAACkgdI0EQBjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvYmlkc01hbmFnZXIuanNQSwECHgMKAAAAAAAAAAAAvKhQlZkMAACZDAAAJgAAAAAAAAAAAAAApIGqYhEAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL2NhdGFsb2cuanNQSwECHgMKAAAAAAAAAAAAwKtv7DAIAAAwCAAAKAAAAAAAAAAAAAAApIGHbxEAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL2NvbnN0YW50cy5qc1BLAQIeAwoAAAAAAAAAAABsnaEGYx4AAGMeAAAmAAAAAAAAAAAAAACkgf13EQBjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvY3JhYmJsZS5qc1BLAQIeAwoAAAAAAAAAAABpvrIybQUAAG0FAAAqAAAAAAAAAAAAAACkgaSWEQBjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvbGVhc2VIb2xkZXIuanNQSwECHgMKAAAAAAAAAAAAmkt4aacEAACnBAAAJwAAAAAAAAAAAAAApIFZnBEAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL2xlYXNlS2l0LmpzUEsBAh4DCgAAAAAAAAAAAOXRWmVzEQAAcxEAADQAAAAAAAAAAAAAAKSBRaERAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9wYXR0ZXJuTWF0Y2hlckhlbHBlcnMuanNQSwECHgMKAAAAAAAAAAAAqMnhssigAADIoAAAJQAAAAAAAAAAAAAApIEKsxEAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL3JlbnRhbC5qc1BLAQIeAwoAAAAAAAAAAACS64SZ5QgAAOUIAAArAAAAAAAAAAAAAACkgRVUEgBjcmFiYmxlLWNvbnRyYWN0LXYwLjEuMC9zcmMvcmVudGFsSG9sZGVyLmpzUEsBAh4DCgAAAAAAAAAAALOM1AHbBAAA2wQAACgAAAAAAAAAAAAAAKSBQ10SAGNyYWJibGUtY29udHJhY3QtdjAuMS4wL3NyYy9yZW50YWxLaXQuanNQSwECHgMKAAAAAAAAAAAA6jVYH3EhAABxIQAAKQAAAAAAAAAAAAAApIFkYhIAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL3R5cGVHdWFyZHMuanNQSwECHgMKAAAAAAAAAAAATLLlG5gMAACYDAAAJAAAAAAAAAAAAAAApIEchBIAY3JhYmJsZS1jb250cmFjdC12MC4xLjAvc3JjL3V0aWxzLmpzUEsBAh4DCgAAAAAAAAAAAIu6h5KtAQAArQEAABwAAAAAAAAAAAAAAKSB9pASAGplc3NpZS5qcy12MC4zLjIvc3JjL21haW4uanNQSwECHgMKAAAAAAAAAAAAnc8TiV0BAABdAQAAHwAAAAAAAAAAAAAApIHdkhIAamVzc2llLmpzLXYwLjMuMi9zcmMvcmluZzAvRS5qc1BLAQIeAwoAAAAAAAAAAAD4tMm/qQMAAKkDAAAsAAAAAAAAAAAAAACkgXeUEgBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMC9hc3luYy1nZW5lcmF0ZS5qc1BLAQIeAwoAAAAAAAAAAACX11Tt0AEAANABAAAiAAAAAAAAAAAAAACkgWqYEgBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMC9tYWluLmpzUEsBAh4DCgAAAAAAAAAAAG+be2LjCAAA4wgAACQAAAAAAAAAAAAAAKSBepoSAGplc3NpZS5qcy12MC4zLjIvc3JjL3JpbmcwL21ha2Vycy5qc1BLAQIeAwoAAAAAAAAAAAC0LPWY/gQAAP4EAAApAAAAAAAAAAAAAACkgZ+jEgBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMS9hc3luYy10b29scy5qc1BLAQIeAwoAAAAAAAAAAACWE0KycgEAAHIBAAAiAAAAAAAAAAAAAACkgeSoEgBqZXNzaWUuanMtdjAuMy4yL3NyYy9yaW5nMS9tYWluLmpzUEsFBgAAAADOAM4AOUkAAJaqEgAAAA==","endoZipBase64Sha512":"3af8183538129ce433d368dc0bdb6082733fc0fa6449c18d5f212f104f971d8ea8b033074067b807bffd5eb2f17821c5e2e9b26ba312795368ae8e7446606b85"} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/bundle-governor.json b/proposals/c:crabble-start/assets/bundle-governor.json similarity index 97% rename from proposals/64:crabble-start/assets/bundle-governor.json rename to proposals/c:crabble-start/assets/bundle-governor.json index c03a99e5..a52f8299 100644 --- a/proposals/64:crabble-start/assets/bundle-governor.json +++ b/proposals/c:crabble-start/assets/bundle-governor.json @@ -1 +1 @@ -{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"d67b9ac5100bf45a3369d393fe2cb38e0718f770cac936292a18270ed331865ffa817719f5c6ceacdb1a580572d71084db0545e8e13efaee38c7df76f51f756c"} \ No newline at end of file +{"moduleFormat":"endoZipBase64","endoZipBase64":"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","endoZipBase64Sha512":"0bfb8a189cda652bc43c488e079e6362870e49039a247156f9430f4f0dfa054970f01c108b79c476baddc8b814546ad88578358452fe2919d11fdcc224bbe4b3"} \ No newline at end of file diff --git a/proposals/64:crabble-start/assets/crabble-permit.json b/proposals/c:crabble-start/assets/crabble-permit.json similarity index 100% rename from proposals/64:crabble-start/assets/crabble-permit.json rename to proposals/c:crabble-start/assets/crabble-permit.json diff --git a/proposals/64:crabble-start/assets/crabbleCoreEval.js b/proposals/c:crabble-start/assets/crabbleCoreEval.js similarity index 95% rename from proposals/64:crabble-start/assets/crabbleCoreEval.js rename to proposals/c:crabble-start/assets/crabbleCoreEval.js index 328839b1..8f8d88e8 100644 --- a/proposals/64:crabble-start/assets/crabbleCoreEval.js +++ b/proposals/c:crabble-start/assets/crabbleCoreEval.js @@ -130,8 +130,8 @@ const startCommittee = async ( * }>} committeeInfoP */ const startCrabble = async (powers, config, crabbleNode, committeeInfoP) => { - const contractBundleID = "b1-145f84363c784c96bc5a5d456edf1853bf2bb04388a250f010a53234b333af46d8d08e3c58d6e3bac61c45b18e82a09199938466616016a22d9191448f8e505c"; - const governorBundleID = "b1-d67b9ac5100bf45a3369d393fe2cb38e0718f770cac936292a18270ed331865ffa817719f5c6ceacdb1a580572d71084db0545e8e13efaee38c7df76f51f756c"; + const contractBundleID = "b1-3af8183538129ce433d368dc0bdb6082733fc0fa6449c18d5f212f104f971d8ea8b033074067b807bffd5eb2f17821c5e2e9b26ba312795368ae8e7446606b85"; + const governorBundleID = "b1-0bfb8a189cda652bc43c488e079e6362870e49039a247156f9430f4f0dfa054970f01c108b79c476baddc8b814546ad88578358452fe2919d11fdcc224bbe4b3"; const { consume: { diff --git a/proposals/64:crabble-start/assets/gov-permit.json b/proposals/c:crabble-start/assets/gov-permit.json similarity index 100% rename from proposals/64:crabble-start/assets/gov-permit.json rename to proposals/c:crabble-start/assets/gov-permit.json diff --git a/proposals/64:crabble-start/assets/govStarting.js b/proposals/c:crabble-start/assets/govStarting.js similarity index 100% rename from proposals/64:crabble-start/assets/govStarting.js rename to proposals/c:crabble-start/assets/govStarting.js diff --git a/proposals/64:crabble-start/core-eval-support.js b/proposals/c:crabble-start/core-eval-support.js similarity index 100% rename from proposals/64:crabble-start/core-eval-support.js rename to proposals/c:crabble-start/core-eval-support.js diff --git a/proposals/64:crabble-start/eval.sh b/proposals/c:crabble-start/eval.sh similarity index 100% rename from proposals/64:crabble-start/eval.sh rename to proposals/c:crabble-start/eval.sh diff --git a/proposals/64:crabble-start/package.json b/proposals/c:crabble-start/package.json similarity index 100% rename from proposals/64:crabble-start/package.json rename to proposals/c:crabble-start/package.json diff --git a/proposals/64:crabble-start/test-crabble-start.js b/proposals/c:crabble-start/test-crabble-start.js similarity index 100% rename from proposals/64:crabble-start/test-crabble-start.js rename to proposals/c:crabble-start/test-crabble-start.js diff --git a/proposals/64:crabble-start/test.sh b/proposals/c:crabble-start/test.sh similarity index 100% rename from proposals/64:crabble-start/test.sh rename to proposals/c:crabble-start/test.sh diff --git a/proposals/64:crabble-start/use.sh b/proposals/c:crabble-start/use.sh similarity index 100% rename from proposals/64:crabble-start/use.sh rename to proposals/c:crabble-start/use.sh diff --git a/proposals/64:crabble-start/yarn.lock b/proposals/c:crabble-start/yarn.lock similarity index 100% rename from proposals/64:crabble-start/yarn.lock rename to proposals/c:crabble-start/yarn.lock