faastjs
Version:
Serverless batch computing made simple.
626 lines • 87.9 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CostAnalyzer = exports.CostSnapshot = exports.CostMetric = void 0;
const Listr = require("listr");
const util_1 = require("util");
const index_1 = require("../index");
const shared_1 = require("./shared");
const throttle_1 = require("./throttle");
/**
* A line item in the cost estimate, including the resource usage metric
* measured and its pricing.
* @public
*/
class CostMetric {
/** @internal */
constructor(arg) {
this.name = arg.name;
this.pricing = arg.pricing;
this.unit = arg.unit;
this.measured = arg.measured;
this.unitPlural = arg.unitPlural;
this.comment = arg.comment;
this.informationalOnly = arg.informationalOnly;
}
/**
* The cost contribution of this cost metric. Equal to
* {@link CostMetric.pricing} * {@link CostMetric.measured}.
*/
cost() {
return this.pricing * this.measured;
}
/**
* Return a string with the cost estimate for this metric, omitting
* comments.
*/
describeCostOnly() {
const p = (n, precision = 8) => Number.isInteger(n) ? String(n) : n.toFixed(precision);
const getUnit = (n) => {
if (n > 1) {
return (this.unitPlural ||
(!this.unit.match(/[A-Z]$/) ? this.unit + "s" : this.unit));
}
else {
return this.unit;
}
};
const cost = `$${p(this.cost())}`;
const pricing = `$${p(this.pricing)}/${this.unit}`;
const metric = p(this.measured, this.unit === "second" ? 1 : 8);
const unit = getUnit(this.measured);
return `${this.name.padEnd(21)} ${pricing.padEnd(20)} ${metric.padStart(12)} ${unit.padEnd(10)} ${cost.padEnd(14)}`;
}
/** Describe this cost metric, including comments. */
toString() {
return `${this.describeCostOnly()}${(this.comment && `// ${this.comment}`) || ""}`;
}
}
exports.CostMetric = CostMetric;
/**
* A summary of the costs incurred by a faast.js module at a point in time.
* Output of {@link FaastModule.costSnapshot}.
* @remarks
* Cost information provided by faast.js is an estimate. It is derived from
* internal faast.js measurements and not by consulting data provided by your
* cloud provider.
*
* **Faast.js does not guarantee the accuracy of cost estimates.**
*
* **Use at your own risk.**
*
* Example using AWS:
* ```typescript
* const faastModule = await faast("aws", m);
* try {
* // Invoke faastModule.functions.*
* } finally {
* await faastModule.cleanup();
* console.log(`Cost estimate:`);
* console.log(`${await faastModule.costSnapshot()}`);
* }
* ```
*
* AWS example output:
* ```text
* Cost estimate:
* functionCallDuration $0.00002813/second 0.6 second $0.00001688 68.4% [1]
* sqs $0.00000040/request 9 requests $0.00000360 14.6% [2]
* sns $0.00000050/request 5 requests $0.00000250 10.1% [3]
* functionCallRequests $0.00000020/request 5 requests $0.00000100 4.1% [4]
* outboundDataTransfer $0.09000000/GB 0.00000769 GB $0.00000069 2.8% [5]
* logIngestion $0.50000000/GB 0 GB $0 0.0% [6]
* ---------------------------------------------------------------------------------------
* $0.00002467 (USD)
*
* * Estimated using highest pricing tier for each service. Limitations apply.
* ** Does not account for free tier.
* [1]: https://aws.amazon.com/lambda/pricing (rate = 0.00001667/(GB*second) * 1.6875 GB = 0.00002813/second)
* [2]: https://aws.amazon.com/sqs/pricing
* [3]: https://aws.amazon.com/sns/pricing
* [4]: https://aws.amazon.com/lambda/pricing
* [5]: https://aws.amazon.com/ec2/pricing/on-demand/#Data_Transfer
* [6]: https://aws.amazon.com/cloudwatch/pricing/ - Log ingestion costs not currently included.
* ```
*
* A cost snapshot contains several {@link CostMetric} values. Each `CostMetric`
* summarizes one component of the overall cost of executing the functions so
* far. Some cost metrics are common to all faast providers, and other metrics
* are provider-specific. The common metrics are:
*
* - `functionCallDuration`: the estimated billed CPU time (rounded to the next
* 100ms) consumed by completed cloud function calls. This is the metric that
* usually dominates cost.
*
* - `functionCallRequests`: the number of invocation requests made. Most
* providers charge for each invocation.
*
* Provider-specific metrics vary. For example, AWS has the following additional
* metrics:
*
* - `sqs`: AWS Simple Queueing Service. This metric captures the number of
* queue requests made to insert and retrieve queued results (each 64kb chunk
* is counted as an additional request). SQS is used even if
* {@link CommonOptions.mode} is not set to `"queue"`, because it is necessary
* for monitoring cloud function invocations.
*
* - `sns`: AWS Simple Notification Service. SNS is used to invoke Lambda
* functions when {@link CommonOptions.mode} is `"queue"`.
*
* - `outboundDataTransfer`: an estimate of the network data transferred out
* from the cloud provider for this faast.js module. This estimate only counts
* data returned from cloud function invocations and infrastructure that
* faast.js sets up. It does not count any outbound data sent by your cloud
* functions that are not known to faast.js. Note that if you run faast.js on
* EC2 in the same region (see {@link AwsOptions.region}), then the data
* transfer costs will be zero (however, the cost snapshot will not include
* EC2 costs). Also note that if your cloud function transfers data from/to S3
* buckets in the same region, there is no cost as long as that data is not
* returned from the function.
*
* - `logIngestion`: this cost metric is always zero for AWS. It is present to
* remind the user that AWS charges for log data ingested by CloudWatch Logs
* that are not measured by faast.js. Log entries may arrive significantly
* after function execution completes, and there is no way for faast.js to
* know exactly how long to wait, therefore it does not attempt to measure
* this cost. In practice, if your cloud functions do not perform extensive
* logging on all invocations, log ingestion costs from faast.js are likely to
* be low or fall within the free tier.
*
* For Google, extra metrics include `outboundDataTransfer` similar to AWS, and
* `pubsub`, which combines costs that are split into `sns` and `sqs` on AWS.
*
* The Local provider has no extra metrics.
*
* Prices are retrieved dynamically from AWS and Google and cached locally.
* Cached prices expire after 24h. For each cost metric, faast.js uses the
* highest price tier to compute estimated pricing.
*
* Cost estimates do not take free tiers into account.
* @public
*/
class CostSnapshot {
/** @internal */
constructor(
/** The {@link Provider}, e.g. "aws" or "google" */
provider,
/**
* The options used to initialize the faast.js module where this cost
* snapshot was generated.
*/
options, stats, costMetrics = []) {
this.provider = provider;
this.options = options;
/**
* The cost metric components for this cost snapshot. See
* {@link CostMetric}.
*/
this.costMetrics = [];
this.stats = stats.clone();
this.costMetrics = [...costMetrics];
}
/** Sum of cost metrics. */
total() {
return (0, shared_1.sum)(this.costMetrics.map(metric => metric.cost()));
}
/** A summary of all cost metrics and prices in this cost snapshot. */
toString() {
let rv = "";
this.costMetrics.sort((a, b) => b.cost() - a.cost());
const total = this.total();
const comments = [];
const percent = (entry) => ((entry.cost() / total) * 100).toFixed(1).padStart(5) + "% ";
for (const entry of this.costMetrics) {
let commentIndex = "";
if (entry.comment) {
comments.push(entry.comment);
commentIndex = ` [${comments.length}]`;
}
rv += `${entry.describeCostOnly()}${percent(entry)}${commentIndex}\n`;
}
rv +=
"---------------------------------------------------------------------------------------\n";
rv += `$${this.total().toFixed(8)}`.padStart(78) + " (USD)\n\n";
rv += ` * Estimated using highest pricing tier for each service. Limitations apply.\n`;
rv += ` ** Does not account for free tier.\n`;
rv += comments.map((c, i) => `[${i + 1}]: ${c}`).join("\n");
return rv;
}
/**
* Comma separated value output for a cost snapshot.
* @remarks
* The format is "metric,unit,pricing,measured,cost,percentage,comment".
*
* Example output:
* ```text
* metric,unit,pricing,measured,cost,percentage,comment
* functionCallDuration,second,0.00002813,0.60000000,0.00001688,64.1% ,"https://aws.amazon.com/lambda/pricing (rate = 0.00001667/(GB*second) * 1.6875 GB = 0.00002813/second)"
* functionCallRequests,request,0.00000020,5,0.00000100,3.8% ,"https://aws.amazon.com/lambda/pricing"
* outboundDataTransfer,GB,0.09000000,0.00000844,0.00000076,2.9% ,"https://aws.amazon.com/ec2/pricing/on-demand/#Data_Transfer"
* sqs,request,0.00000040,13,0.00000520,19.7% ,"https://aws.amazon.com/sqs/pricing"
* sns,request,0.00000050,5,0.00000250,9.5% ,"https://aws.amazon.com/sns/pricing"
* logIngestion,GB,0.50000000,0,0,0.0% ,"https://aws.amazon.com/cloudwatch/pricing/ - Log ingestion costs not currently included."
* ```
*/
csv() {
let rv = "";
rv += "metric,unit,pricing,measured,cost,percentage,comment\n";
const total = this.total();
const p = (n) => (Number.isInteger(n) ? n : n.toFixed(8));
const percent = (entry) => ((entry.cost() / total) * 100).toFixed(1) + "% ";
for (const entry of this.costMetrics) {
rv += `${entry.name},${entry.unit},${p(entry.pricing)},${p(entry.measured)},${p(entry.cost())},${percent(entry)},"${(entry.comment || "").replace('"', '""')}"\n`;
}
return rv;
}
/** @internal */
push(metric) {
this.costMetrics.push(metric);
}
/**
* Find a specific cost metric by name.
* @returns a {@link CostMetric} if found, otherwise `undefined`.
*/
find(name) {
return this.costMetrics.find(m => m.name === name);
}
}
exports.CostSnapshot = CostSnapshot;
/**
* Analyze the cost of a workload across many provider configurations.
* @public
*/
var CostAnalyzer;
(function (CostAnalyzer) {
/**
* Default AWS cost analyzer configurations include all memory sizes for AWS
* Lambda.
* @remarks
* The default AWS cost analyzer configurations include every memory size
* from 128MB to 3008MB in 64MB increments. Each configuration has the
* following settings:
*
* ```typescript
* {
* provider: "aws",
* options: {
* mode: "https",
* memorySize,
* timeout: 300,
* gc: "off",
* childProcess: true
* }
* }
* ```
*
* Use `Array.map` to change or `Array.filter` to remove some of these
* configurations. For example:
*
* ```typescript
* const configsWithAtLeast1GB = awsConfigurations.filter(c => c.memorySize > 1024)
* const shorterTimeout = awsConfigurations.map(c => ({...c, timeout: 60 }));
* ```
* @public
*/
CostAnalyzer.awsConfigurations = (() => {
const rv = [];
for (let memorySize = 128; memorySize <= 3008; memorySize += 64) {
rv.push({
provider: "aws",
options: {
mode: "https",
memorySize,
timeout: 300,
gc: "off",
childProcess: true
}
});
}
return rv;
})();
/**
* Default Google Cloud Functions cost analyzer configurations include all
* available memory sizes.
* @remarks
* Each google cost analyzer configuration follows this template:
*
* ```typescript
* {
* provider: "google",
* options: {
* mode: "https",
* memorySize,
* timeout: 300,
* gc: "off",
* childProcess: true
* }
* }
* ```
*
* where `memorySize` is in `[128, 256, 512, 1024, 2048]`.
* @public
*/
CostAnalyzer.googleConfigurations = (() => {
const rv = [];
for (const memorySize of [128, 256, 512, 1024, 2048]) {
rv.push({
provider: "google",
options: {
mode: "https",
memorySize,
timeout: 300,
gc: "off",
childProcess: true
}
});
}
return rv;
})();
const workloadDefaults = {
configurations: CostAnalyzer.awsConfigurations,
summarize: summarizeMean,
format: defaultFormat,
formatCSV: defaultFormatCSV,
silent: false,
repetitions: 10,
concurrency: 64
};
function defaultFormat(attr, value) {
return `${attr}:${(0, shared_1.f1)(value)}`;
}
function defaultFormatCSV(_, value) {
return (0, shared_1.f1)(value);
}
const ps = (n) => (n / 1000).toFixed(3);
function summarizeMean(attributes) {
const stats = {};
attributes.forEach(a => (0, shared_1.keysOf)(a).forEach(attr => {
if (!(attr in stats)) {
stats[attr] = new shared_1.Statistics();
}
stats[attr].update(a[attr]);
}));
const result = {};
(0, shared_1.keysOf)(stats).forEach(attr => {
result[attr] = stats[attr].mean;
});
return result;
}
async function estimate(workload, config) {
const { provider, options } = config;
const faastModule = await (0, index_1.faast)(provider, workload.funcs, options);
const { repetitions, concurrency: repetitionConcurrency } = workload;
const doWork = (0, throttle_1.throttle)({ concurrency: repetitionConcurrency }, workload.work);
const results = [];
for (let i = 0; i < repetitions; i++) {
results.push(doWork(faastModule).catch(_ => { }));
}
const rv = (await Promise.all(results)).filter(r => r);
await faastModule.cleanup();
const costSnapshot = await faastModule.costSnapshot();
const extraMetrics = workload.summarize(rv);
return { costSnapshot, config, extraMetrics };
}
/**
* Estimate the cost of a workload using multiple configurations and
* providers.
* @param userWorkload - a {@link CostAnalyzer.Workload} object specifying
* the workload to run and additional parameters.
* @returns A promise for a {@link CostAnalyzer.Result}
* @public
* @remarks
* It can be deceptively difficult to set optimal parameters for AWS Lambda
* and similar services. On the surface there appears to be only one
* parameter: memory size. Choosing more memory also gives more CPU
* performance, but it's unclear how much. It's also unclear where single
* core performance stops getting better. The workload cost analyzer solves
* these problems by making it easy to run cost experiments.
* ```text
* (AWS)
* ┌───────┐
* ┌────▶│ 128MB │
* │ └───────┘
* │ ┌───────┐
* ┌─────────────────┐ ├────▶│ 256MB │
* ┌──────────────┐ │ │ │ └───────┘
* │ workload │───▶│ │ │ ...
* └──────────────┘ │ │ │ ┌───────┐
* │ cost analyzer │─────┼────▶│3008MB │
* ┌──────────────┐ │ │ │ └───────┘
* │configurations│───▶│ │ │
* └──────────────┘ │ │ │ (Google)
* └─────────────────┘ │ ┌───────┐
* ├────▶│ 128MB │
* │ └───────┘
* │ ┌───────┐
* └────▶│ 256MB │
* └───────┘
* ```
* `costAnalyzer` is the entry point. It automatically runs this workload
* against multiple configurations in parallel. Then it uses faast.js' cost
* snapshot mechanism to automatically determine the price of running the
* workload with each configuration.
*
* Example:
*
* ```typescript
* // functions.ts
* export function randomNumbers(n: number) {
* let sum = 0;
* for (let i = 0; i < n; i++) {
* sum += Math.random();
* }
* return sum;
* }
*
* // cost-analyzer-example.ts
* import { writeFileSync } from "fs";
* import { CostAnalyzer, FaastModule } from "faastjs";
* import * as funcs from "./functions";
*
* async function work(faastModule: FaastModule<typeof funcs>) {
* await faastModule.functions.randomNumbers(100000000);
* }
*
* async function main() {
* const results = await CostAnalyzer.analyze({ funcs, work });
* writeFileSync("cost.csv", results.csv());
* }
*
* main();
* ```
*
* Example output (this is printed to `console.log` unless the
* {@link CostAnalyzer.Workload.silent} is `true`):
* ```text
* ✔ aws 128MB queue 15.385s 0.274σ $0.00003921
* ✔ aws 192MB queue 10.024s 0.230σ $0.00003576
* ✔ aws 256MB queue 8.077s 0.204σ $0.00003779
* ▲ ▲ ▲ ▲ ▲ ▲
* │ │ │ │ │ │
* provider │ mode │ stdev average
* │ │ execution estimated
* memory │ time cost
* size │
* average cloud
* execution time
* ```
*
* The output lists the provider, memory size, ({@link CommonOptions.mode}),
* average time of a single execution of the workload, the standard
* deviation (in seconds) of the execution time, and average estimated cost
* for a single run of the workload.
*
* The "execution time" referenced here is not wall clock time, but rather
* execution time in the cloud function. The execution time does not include
* any time the workload spends waiting locally. If the workload invokes
* multiple cloud functions, their execution times will be summed even if
* they happen concurrently. This ensures the execution time and cost are
* aligned.
*/
async function analyze(userWorkload) {
const scheduleEstimate = (0, throttle_1.throttle)({
concurrency: 8,
rate: 4,
burst: 1,
retry: 3
}, estimate);
const { concurrency = workloadDefaults.concurrency } = userWorkload;
const workload = {
...workloadDefaults,
...userWorkload,
work: (0, throttle_1.throttle)({ concurrency }, userWorkload.work)
};
const { configurations } = workload;
const promises = configurations.map(config => scheduleEstimate(workload, config));
const format = workload.format || defaultFormat;
const renderer = workload.silent ? "silent" : "default";
const list = new Listr(promises.map((promise, i) => {
const { provider, options } = configurations[i];
const { memorySize, mode } = options;
return {
title: `${provider} ${memorySize}MB ${mode}`,
task: async (_, task) => {
const { costSnapshot, extraMetrics } = await promise;
const total = (costSnapshot.total() / workload.repetitions).toFixed(8);
const { errors } = costSnapshot.stats;
const { executionTime } = costSnapshot.stats;
const message = `${ps(executionTime.mean)}s ${ps(executionTime.stdev)}σ $${total}`;
const errMessage = errors > 0 ? ` (${errors} errors)` : "";
const extra = (0, shared_1.keysOf)(extraMetrics)
.map(k => format(k, extraMetrics[k]))
.join(" ");
task.title = `${task.title} ${message}${errMessage} ${extra}`;
}
};
}), { concurrent: 8, nonTTYRenderer: renderer, renderer });
await list.run();
const results = await Promise.all(promises);
results.sort((a, b) => a.costSnapshot.options.memorySize - b.costSnapshot.options.memorySize);
return new Result(workload, results);
}
CostAnalyzer.analyze = analyze;
/**
* Cost analyzer results for each workload and configuration.
* @remarks
* The `estimates` property has the cost estimates for each configuration.
* See {@link CostAnalyzer.Estimate}.
* @public
*/
class Result {
/** @internal */
constructor(
/** The workload analyzed. */
workload,
/**
* Cost estimates for each configuration of the workload. See
* {@link CostAnalyzer.Estimate}.
*/
estimates) {
this.workload = workload;
this.estimates = estimates;
}
/**
* Comma-separated output of cost analyzer. One line per cost analyzer
* configuration.
* @remarks
* The columns are:
*
* - `memory`: The memory size allocated.
*
* - `cloud`: The cloud provider.
*
* - `mode`: See {@link CommonOptions.mode}.
*
* - `options`: A string summarizing other faast.js options applied to the
* `workload`. See {@link CommonOptions}.
*
* - `completed`: Number of repetitions that successfully completed.
*
* - `errors`: Number of invocations that failed.
*
* - `retries`: Number of retries that were attempted.
*
* - `cost`: The average cost of executing the workload once.
*
* - `executionTime`: the aggregate time spent executing on the provider for
* all cloud function invocations in the workload. This is averaged across
* repetitions.
*
* - `executionTimeStdev`: The standard deviation of `executionTime`.
*
* - `billedTime`: the same as `exectionTime`, except rounded up to the next
* 100ms for each invocation. Usually very close to `executionTime`.
*/
csv() {
const attributes = new Set();
this.estimates.forEach(est => (0, shared_1.keysOf)(est.extraMetrics).forEach(key => attributes.add(key)));
const columns = [
"memory",
"cloud",
"mode",
"options",
"completed",
"errors",
"retries",
"cost",
"executionTime",
"executionTimeStdev",
"billedTime",
...attributes
];
let rv = columns.join(",") + "\n";
this.estimates.forEach(({ costSnapshot, extraMetrics }) => {
const { memorySize, mode, ...rest } = costSnapshot.options;
const options = `"${(0, util_1.inspect)(rest).replace('"', '""')}"`;
const { completed, errors, retries, executionTime, estimatedBilledTime } = costSnapshot.stats;
const cost = (costSnapshot.total() / this.workload.repetitions).toFixed(8);
const formatter = this.workload.formatCSV || defaultFormatCSV;
const metrics = {};
for (const attr of attributes) {
metrics[attr] = formatter(attr, extraMetrics[attr]);
}
const row = {
memory: memorySize,
cloud: costSnapshot.provider,
mode,
options,
completed,
errors,
retries,
cost: `$${cost}`,
executionTime: ps(executionTime.mean),
executionTimeStdev: ps(executionTime.stdev),
billedTime: ps(estimatedBilledTime.mean),
...metrics
};
rv += (0, shared_1.keysOf)(row)
.map(k => String(row[k]))
.join(",");
rv += "\n";
});
return rv;
}
}
CostAnalyzer.Result = Result;
})(CostAnalyzer = exports.CostAnalyzer || (exports.CostAnalyzer = {}));
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb3N0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLCtCQUErQjtBQUMvQiwrQkFBK0I7QUFDL0Isb0NBQThDO0FBSTlDLHFDQUF1RDtBQUN2RCx5Q0FBc0M7QUFHdEM7Ozs7R0FJRztBQUNILE1BQWEsVUFBVTtJQTBCbkIsZ0JBQWdCO0lBQ2hCLFlBQVksR0FBOEM7UUFDdEQsSUFBSSxDQUFDLElBQUksR0FBRyxHQUFHLENBQUMsSUFBSSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxPQUFPLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQztRQUMzQixJQUFJLENBQUMsSUFBSSxHQUFHLEdBQUcsQ0FBQyxJQUFJLENBQUM7UUFDckIsSUFBSSxDQUFDLFFBQVEsR0FBRyxHQUFHLENBQUMsUUFBUSxDQUFDO1FBQzdCLElBQUksQ0FBQyxVQUFVLEdBQUcsR0FBRyxDQUFDLFVBQVUsQ0FBQztRQUNqQyxJQUFJLENBQUMsT0FBTyxHQUFHLEdBQUcsQ0FBQyxPQUFPLENBQUM7UUFDM0IsSUFBSSxDQUFDLGlCQUFpQixHQUFHLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQztJQUNuRCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsSUFBSTtRQUNBLE9BQU8sSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDO0lBQ3hDLENBQUM7SUFFRDs7O09BR0c7SUFDSCxnQkFBZ0I7UUFDWixNQUFNLENBQUMsR0FBRyxDQUFDLENBQVMsRUFBRSxTQUFTLEdBQUcsQ0FBQyxFQUFFLEVBQUUsQ0FDbkMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQzNELE1BQU0sT0FBTyxHQUFHLENBQUMsQ0FBUyxFQUFFLEVBQUU7WUFDMUIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFO2dCQUNQLE9BQU8sQ0FDSCxJQUFJLENBQUMsVUFBVTtvQkFDZixDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQzdELENBQUM7YUFDTDtpQkFBTTtnQkFDSCxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUM7YUFDcEI7UUFDTCxDQUFDLENBQUM7UUFFRixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxDQUFDO1FBQ2xDLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDbkQsTUFBTSxNQUFNLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLElBQUksS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDaEUsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUVwQyxPQUFPLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSxNQUFNLENBQUMsUUFBUSxDQUNuRSxFQUFFLENBQ0wsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQztJQUM5QyxDQUFDO0lBRUQscURBQXFEO0lBQ3JELFFBQVE7UUFDSixPQUFPLEdBQUcsSUFBSSxDQUFDLGdCQUFnQixFQUFFLEdBQzdCLENBQUMsSUFBSSxDQUFDLE9BQU8sSUFBSSxNQUFNLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxJQUFJLEVBQzlDLEVBQUUsQ0FBQztJQUNQLENBQUM7Q0FDSjtBQS9FRCxnQ0ErRUM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FxR0c7QUFDSCxNQUFhLFlBQVk7SUFRckIsZ0JBQWdCO0lBQ2hCO0lBQ0ksbURBQW1EO0lBQzFDLFFBQWdCO0lBQ3pCOzs7T0FHRztJQUNNLE9BQW1ELEVBQzVELEtBQW9CLEVBQ3BCLGNBQTRCLEVBQUU7UUFQckIsYUFBUSxHQUFSLFFBQVEsQ0FBUTtRQUtoQixZQUFPLEdBQVAsT0FBTyxDQUE0QztRQWJoRTs7O1dBR0c7UUFDTSxnQkFBVyxHQUFpQixFQUFFLENBQUM7UUFhcEMsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDM0IsSUFBSSxDQUFDLFdBQVcsR0FBRyxDQUFDLEdBQUcsV0FBVyxDQUFDLENBQUM7SUFDeEMsQ0FBQztJQUVELDJCQUEyQjtJQUMzQixLQUFLO1FBQ0QsT0FBTyxJQUFBLFlBQUcsRUFBQyxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVELHNFQUFzRTtJQUN0RSxRQUFRO1FBQ0osSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDO1FBQ1osSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7UUFDckQsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzNCLE1BQU0sUUFBUSxHQUFHLEVBQUUsQ0FBQztRQUNwQixNQUFNLE9BQU8sR0FBRyxDQUFDLEtBQWlCLEVBQUUsRUFBRSxDQUNsQyxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxHQUFHLEtBQUssQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDO1FBQ2pFLEtBQUssTUFBTSxLQUFLLElBQUksSUFBSSxDQUFDLFdBQVcsRUFBRTtZQUNsQyxJQUFJLFlBQVksR0FBRyxFQUFFLENBQUM7WUFDdEIsSUFBSSxLQUFLLENBQUMsT0FBTyxFQUFFO2dCQUNmLFFBQVEsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO2dCQUM3QixZQUFZLEdBQUcsS0FBSyxRQUFRLENBQUMsTUFBTSxHQUFHLENBQUM7YUFDMUM7WUFDRCxFQUFFLElBQUksR0FBRyxLQUFLLENBQUMsZ0JBQWdCLEVBQUUsR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsWUFBWSxJQUFJLENBQUM7U0FDekU7UUFDRCxFQUFFO1lBQ0UsMkZBQTJGLENBQUM7UUFDaEcsRUFBRSxJQUFJLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsR0FBRyxZQUFZLENBQUM7UUFDaEUsRUFBRSxJQUFJLGlGQUFpRixDQUFDO1FBQ3hGLEVBQUUsSUFBSSx1Q0FBdUMsQ0FBQztRQUM5QyxFQUFFLElBQUksUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUM1RCxPQUFPLEVBQUUsQ0FBQztJQUNkLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7Ozs7O09BZUc7SUFDSCxHQUFHO1FBQ0MsSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDO1FBQ1osRUFBRSxJQUFJLHdEQUF3RCxDQUFDO1FBQy9ELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMzQixNQUFNLENBQUMsR0FBRyxDQUFDLENBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNsRSxNQUFNLE9BQU8sR0FBRyxDQUFDLEtBQWlCLEVBQUUsRUFBRSxDQUNsQyxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxHQUFHLEtBQUssQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUM7UUFDckQsS0FBSyxNQUFNLEtBQUssSUFBSSxJQUFJLENBQUMsV0FBVyxFQUFFO1lBQ2xDLEVBQUUsSUFBSSxHQUFHLEtBQUssQ0FBQyxJQUFJLElBQUksS0FBSyxDQUFDLElBQUksSUFBSSxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FDdEQsS0FBSyxDQUFDLFFBQVEsQ0FDakIsSUFBSSxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLElBQUksT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQ3BFLEdBQUcsRUFDSCxJQUFJLENBQ1AsS0FBSyxDQUFDO1NBQ1Y7UUFDRCxPQUFPLEVBQUUsQ0FBQztJQUNkLENBQUM7SUFFRCxnQkFBZ0I7SUFDaEIsSUFBSSxDQUFDLE1BQWtCO1FBQ25CLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRDs7O09BR0c7SUFDSCxJQUFJLENBQUMsSUFBWTtRQUNiLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLLElBQUksQ0FBQyxDQUFDO0lBQ3ZELENBQUM7Q0FDSjtBQXBHRCxvQ0FvR0M7QUFFRDs7O0dBR0c7QUFDSCxJQUFpQixZQUFZLENBbWhCNUI7QUFuaEJELFdBQWlCLFlBQVk7SUFpQnpCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztPQTZCRztJQUNVLDhCQUFpQixHQUFvQixDQUFDLEdBQUcsRUFBRTtRQUNwRCxNQUFNLEVBQUUsR0FBb0IsRUFBRSxDQUFDO1FBQy9CLEtBQUssSUFBSSxVQUFVLEdBQUcsR0FBRyxFQUFFLFVBQVUsSUFBSSxJQUFJLEVBQUUsVUFBVSxJQUFJLEVBQUUsRUFBRTtZQUM3RCxFQUFFLENBQUMsSUFBSSxDQUFDO2dCQUNKLFFBQVEsRUFBRSxLQUFLO2dCQUNmLE9BQU8sRUFBRTtvQkFDTCxJQUFJLEVBQUUsT0FBTztvQkFDYixVQUFVO29CQUNWLE9BQU8sRUFBRSxHQUFHO29CQUNaLEVBQUUsRUFBRSxLQUFLO29CQUNULFlBQVksRUFBRSxJQUFJO2lCQUNyQjthQUNKLENBQUMsQ0FBQztTQUNOO1FBQ0QsT0FBTyxFQUFFLENBQUM7SUFDZCxDQUFDLENBQUMsRUFBRSxDQUFDO0lBRUw7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztPQXFCRztJQUNVLGlDQUFvQixHQUFvQixDQUFDLEdBQUcsRUFBRTtRQUN2RCxNQUFNLEVBQUUsR0FBb0IsRUFBRSxDQUFDO1FBQy9CLEtBQUssTUFBTSxVQUFVLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLEVBQUU7WUFDbEQsRUFBRSxDQUFDLElBQUksQ0FBQztnQkFDSixRQUFRLEVBQUUsUUFBUTtnQkFDbEIsT0FBTyxFQUFFO29CQUNMLElBQUksRUFBRSxPQUFPO29CQUNiLFVBQVU7b0JBQ1YsT0FBTyxFQUFFLEdBQUc7b0JBQ1osRUFBRSxFQUFFLEtBQUs7b0JBQ1QsWUFBWSxFQUFFLElBQUk7aUJBQ3JCO2FBQ0osQ0FBQyxDQUFDO1NBQ047UUFDRCxPQUFPLEVBQUUsQ0FBQztJQUNkLENBQUMsQ0FBQyxFQUFFLENBQUM7SUErRUwsTUFBTSxnQkFBZ0IsR0FBRztRQUNyQixjQUFjLEVBQUUsYUFBQSxpQkFBaUI7UUFDakMsU0FBUyxFQUFFLGFBQWE7UUFDeEIsTUFBTSxFQUFFLGFBQWE7UUFDckIsU0FBUyxFQUFFLGdCQUFnQjtRQUMzQixNQUFNLEVBQUUsS0FBSztRQUNiLFdBQVcsRUFBRSxFQUFFO1FBQ2YsV0FBVyxFQUFFLEVBQUU7S0FDbEIsQ0FBQztJQUVGLFNBQVMsYUFBYSxDQUFDLElBQVksRUFBRSxLQUFhO1FBQzlDLE9BQU8sR0FBRyxJQUFJLElBQUksSUFBQSxXQUFFLEVBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztJQUNsQyxDQUFDO0lBRUQsU0FBUyxnQkFBZ0IsQ0FBQyxDQUFTLEVBQUUsS0FBYTtRQUM5QyxPQUFPLElBQUEsV0FBRSxFQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxNQUFNLEVBQUUsR0FBRyxDQUFDLENBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRWhELFNBQVMsYUFBYSxDQUFtQixVQUFrQztRQUN2RSxNQUFNLEtBQUssR0FBbUMsRUFBRSxDQUFDO1FBQ2pELFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FDbkIsSUFBQSxlQUFNLEVBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQ3JCLElBQUksQ0FBQyxDQUFDLElBQUksSUFBSSxLQUFLLENBQUMsRUFBRTtnQkFDbEIsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLElBQUksbUJBQVUsRUFBRSxDQUFDO2FBQ2xDO1lBQ0QsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUNoQyxDQUFDLENBQUMsQ0FDTCxDQUFDO1FBQ0YsTUFBTSxNQUFNLEdBQUcsRUFBUyxDQUFDO1FBQ3pCLElBQUEsZUFBTSxFQUFDLEtBQUssQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUN6QixNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQztRQUNwQyxDQUFDLENBQUMsQ0FBQztRQUNILE9BQU8sTUFBTSxDQUFDO0lBQ2xCLENBQUM7SUF3QkQsS0FBSyxVQUFVLFFBQVEsQ0FDbkIsUUFBa0MsRUFDbEMsTUFBcUI7UUFFckIsTUFBTSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsR0FBRyxNQUFNLENBQUM7UUFDckMsTUFBTSxXQUFXLEdBQUcsTUFBTSxJQUFBLGFBQUssRUFBQyxRQUFRLEVBQUUsUUFBUSxDQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNuRSxNQUFNLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxxQkFBcUIsRUFBRSxHQUFHLFFBQVEsQ0FBQztRQUNyRSxNQUFNLE1BQU0sR0FBRyxJQUFBLG1CQUFRLEVBQUMsRUFBRSxXQUFXLEVBQUUscUJBQXFCLEVBQUUsRUFBRSxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDL0UsTUFBTSxPQUFPLEdBQTJDLEVBQUUsQ0FBQztRQUMzRCxLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsV0FBVyxFQUFFLENBQUMsRUFBRSxFQUFFO1lBQ2xDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7U0FDcEQ7UUFDRCxNQUFNLEVBQUUsR0FBRyxDQUFDLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBMkIsQ0FBQztRQUNqRixNQUFNLFdBQVcsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUM1QixNQUFNLFlBQVksR0FBRyxNQUFNLFdBQVcsQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUN0RCxNQUFNLFlBQVksR0FBRyxRQUFRLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQzVDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxDQUFDO0lBQ2xELENBQUM7SUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O09BZ0dHO0lBQ0ksS0FBSyxVQUFVLE9BQU8sQ0FDekIsWUFBNEI7UUFFNUIsTUFBTSxnQkFBZ0IsR0FBRyxJQUFBLG1CQUFRLEVBSTdCO1lBQ0ksV0FBVyxFQUFFLENBQUM7WUFDZCxJQUFJLEVBQUUsQ0FBQztZQUNQLEtBQUssRUFBRSxDQUFDO1lBQ1IsS0FBSyxFQUFFLENBQUM7U0FDWCxFQUNELFFBQVEsQ0FDWCxDQUFDO1FBRUYsTUFBTSxFQUFFLFdBQVcsR0FBRyxnQkFBZ0IsQ0FBQyxXQUFXLEVBQUUsR0FBRyxZQUFZLENBQUM7UUFDcEUsTUFBTSxRQUFRLEdBQTZCO1lBQ3ZDLEdBQUcsZ0JBQWdCO1lBQ25CLEdBQUcsWUFBWTtZQUNmLElBQUksRUFBRSxJQUFBLG1CQUFRLEVBQUMsRUFBRSxXQUFXLEVBQUUsRUFBRSxZQUFZLENBQUMsSUFBSSxDQUFDO1NBQ3JELENBQUM7UUFFRixNQUFNLEVBQUUsY0FBYyxFQUFFLEdBQUcsUUFBUSxDQUFDO1FBQ3BDLE1BQU0sUUFBUSxHQUFHLGNBQWMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUVsRixNQUFNLE1BQU0sR0FBRyxRQUFRLENBQUMsTUFBTSxJQUFJLGFBQWEsQ0FBQztRQUVoRCxNQUFNLFFBQVEsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUV4RCxNQUFNLElBQUksR0FBRyxJQUFJLEtBQUssQ0FDbEIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDLEVBQUUsRUFBRTtZQUN4QixNQUFNLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxHQUFHLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNoRCxNQUFNLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxHQUFHLE9BQU8sQ0FBQztZQUVyQyxPQUFPO2dCQUNILEtBQUssRUFBRSxHQUFHLFFBQVEsSUFBSSxVQUFVLE1BQU0sSUFBSSxFQUFFO2dCQUM1QyxJQUFJLEVBQUUsS0FBSyxFQUFFLENBQU0sRUFBRSxJQUE0QixFQUFFLEVBQUU7b0JBQ2pELE1BQU0sRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLEdBQUcsTUFBTSxPQUFPLENBQUM7b0JBQ3JELE1BQU0sS0FBSyxHQUFHLENBQ1YsWUFBWSxDQUFDLEtBQUssRUFBRSxHQUFHLFFBQVEsQ0FBQyxXQUFXLENBQzlDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO29CQUNiLE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxZQUFZLENBQUMsS0FBSyxDQUFDO29CQUN0QyxNQUFNLEVBQUUsYUFBYSxFQUFFLEdBQUcsWUFBWSxDQUFDLEtBQUssQ0FBQztvQkFDN0MsTUFBTSxPQUFPLEdBQUcsR0FBRyxFQUFFLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FDNUMsYUFBYSxDQUFDLEtBQUssQ0FDdEIsTUFBTSxLQUFLLEVBQUUsQ0FBQztvQkFDZixNQUFNLFVBQVUsR0FBRyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLE1BQU0sVUFBVSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7b0JBQzNELE1BQU0sS0FBSyxHQUFHLElBQUEsZUFBTSxFQUFDLFlBQVksQ0FBQzt5QkFDN0IsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxZQUFZLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQzt5QkFDcEMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO29CQUNmLElBQUksQ0FBQyxLQUFLLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxJQUFJLE9BQU8sR0FBRyxVQUFVLElBQUksS0FBSyxFQUFFLENBQUM7Z0JBQ2xFLENBQUM7YUFDSixDQUFDO1FBQ04sQ0FBQyxDQUFDLEVBQ0YsRUFBRSxVQUFVLEVBQUUsQ0FBQyxFQUFFLGNBQWMsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLENBQ3hELENBQUM7UUFFRixNQUFNLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNqQixNQUFNLE9BQU8sR0FBRyxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDNUMsT0FBTyxDQUFDLElBQUksQ0FDUixDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUNMLENBQUMsQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLFVBQVcsR0FBRyxDQUFDLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxVQUFXLENBQzlFLENBQUM7UUFDRixPQUFPLElBQUksTUFBTSxDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBakVxQixvQkFBTyxVQWlFNUIsQ0FBQTtJQUVEOzs7Ozs7T0FNRztJQUNILE1BQWEsTUFBTTtRQUNmLGdCQUFnQjtRQUNoQjtRQUNJLDZCQUE2QjtRQUNwQixRQUFrQztRQUMzQzs7O1dBR0c7UUFDTSxTQUF3QjtZQUx4QixhQUFRLEdBQVIsUUFBUSxDQUEwQjtZQUtsQyxjQUFTLEdBQVQsU0FBUyxDQUFlO1FBQ2xDLENBQUM7UUFFSjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztXQStCRztRQUNILEdBQUc7WUFDQyxNQUFNLFVBQVUsR0FBRyxJQUFJLEdBQUcsRUFBSyxDQUFDO1lBQ2hDLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQ3pCLElBQUEsZUFBTSxFQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQy9ELENBQUM7WUFDRixNQUFNLE9BQU8sR0FBRztnQkFDWixRQUFRO2dCQUNSLE9BQU87Z0JBQ1AsTUFBTTtnQkFDTixTQUFTO2dCQUNULFdBQVc7Z0JBQ1gsUUFBUTtnQkFDUixTQUFTO2dCQUNULE1BQU07Z0JBQ04sZUFBZTtnQkFDZixvQkFBb0I7Z0JBQ3BCLFlBQVk7Z0JBQ1osR0FBRyxVQUFVO2FBQ2hCLENBQUM7WUFDRixJQUFJLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQztZQUVsQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUU7Z0JBQ3RELE1BQU0sRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLEdBQUcsSUFBSSxFQUFFLEdBQUcsWUFBWSxDQUFDLE9BQU8sQ0FBQztnQkFDM0QsTUFBTSxPQUFPLEdBQUcsSUFBSSxJQUFBLGNBQU8sRUFBQyxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxHQUFHLENBQUM7Z0JBQ3hELE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxhQUFhLEVBQUUsbUJBQW1CLEVBQUUsR0FDcEUsWUFBWSxDQUFDLEtBQUssQ0FBQztnQkFDdkIsTUFBTSxJQUFJLEdBQUcsQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsQ0FBQyxPQUFPLENBQ25FLENBQUMsQ0FDSixDQUFDO2dCQUNGLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUyxJQUFJLGdCQUFnQixDQUFDO2dCQUU5RCxNQUFNLE9BQU8sR0FBaUMsRUFBRSxDQUFDO2dCQUNqRCxLQUFLLE1BQU0sSUFBSSxJQUFJLFVBQVUsRUFBRTtvQkFDM0IsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FBQyxJQUFJLEVBQUUsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7aUJBQ3ZEO2dCQUNELE1BQU0sR0FBRyxHQUFHO29CQUNSLE1BQU0sRUFBRSxVQUFVO29CQUNsQixLQUFLLEVBQUUsWUFBWSxDQUFDLFFBQVE7b0JBQzVCLElBQUk7b0JBQ0osT0FBTztvQkFDUCxTQUFTO29CQUNULE1BQU07b0JBQ04sT0FBTztvQkFDUCxJQUFJLEVBQUUsSUFBSSxJQUFJLEVBQUU7b0JBQ2hCLGFBQWEsRUFBRSxFQUFFLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQztvQkFDckMsa0JBQWtCLEVBQUUsRUFBRSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUM7b0JBQzNDLFVBQVUsRUFBRSxFQUFFLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDO29CQUN4QyxHQUFHLE9BQU87aUJBQ2IsQ0FBQztnQkFFRixFQUFFLElBQUksSUFBQSxlQUFNLEVBQUMsR0FBRyxDQUFDO3FCQUNaLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztxQkFDeEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2dCQUNmLEVBQUUsSUFBSSxJQUFJLENBQUM7WUFDZixDQUFDLENBQUMsQ0FBQztZQUNILE9BQU8sRUFBRSxDQUFDO1FBQ2QsQ0FBQztLQUNKO0lBckdZLG1CQUFNLFNBcUdsQixDQUFBO0FBQ0wsQ0FBQyxFQW5oQmdCLFlBQVksR0FBWixvQkFBWSxLQUFaLG9CQUFZLFFBbWhCNUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBMaXN0ciBmcm9tIFwibGlzdHJcIjtcbmltcG9ydCB7IGluc3BlY3QgfSBmcm9tIFwidXRpbFwiO1xuaW1wb3J0IHsgZmFhc3QsIEZhYXN0TW9kdWxlIH0gZnJvbSBcIi4uL2luZGV4XCI7XG5pbXBvcnQgeyBBd3NPcHRpb25zIH0gZnJvbSBcIi4vYXdzL2F3cy1mYWFzdFwiO1xuaW1wb3J0IHsgR29vZ2xlT3B0aW9ucyB9IGZyb20gXCIuL2dvb2dsZS9nb29nbGUtZmFhc3RcIjtcbmltcG9ydCB7IEZ1bmN0aW9uU3RhdHMsIENvbW1vbk9wdGlvbnMgfSBmcm9tIFwiLi9wcm92aWRlclwiO1xuaW1wb3J0IHsgZjEsIGtleXNPZiwgU3RhdGlzdGljcywgc3VtIH0gZnJvbSBcIi4vc2hhcmVkXCI7XG5pbXBvcnQgeyB0aHJvdHRsZSB9IGZyb20gXCIuL3Rocm90dGxlXCI7XG5pbXBvcnQgeyBQcm9wZXJ0aWVzRXhjZXB0LCBBbnlGdW5jdGlvbiB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbi8qKlxuICogQSBsaW5lIGl0ZW0gaW4gdGhlIGNvc3QgZXN0aW1hdGUsIGluY2x1ZGluZyB0aGUgcmVzb3VyY2UgdXNhZ2UgbWV0cmljXG4gKiBtZWFzdXJlZCBhbmQgaXRzIHByaWNpbmcuXG4gKiBAcHVibGljXG4gKi9cbmV4cG9ydCBjbGFzcyBDb3N0TWV0cmljIHtcbiAgICAvKiogVGhlIG5hbWUgb2YgdGhlIGNvc3QgbWV0cmljLCBlLmcuIGBmdW5jdGlvbkNhbGxEdXJhdGlvbmAgKi9cbiAgICByZWFkb25seSBuYW1lOiBzdHJpbmc7XG4gICAgLyoqIFRoZSBwcmljZSBpbiBVU0QgcGVyIHVuaXQgbWVhc3VyZWQuICovXG4gICAgcmVhZG9ubHkgcHJpY2luZzogbnVtYmVyO1xuICAgIC8qKiBUaGUgbmFtZSBvZiB0aGUgdW5pdHMgdGhhdCBwcmljaW5nIGlzIG1lYXN1cmVkIGluIGZvciB0aGlzIG1ldHJpYy4gKi9cbiAgICByZWFkb25seSB1bml0OiBzdHJpbmc7XG4gICAgLyoqIFRoZSBtZWFzdXJlZCB2YWx1ZSBvZiB0aGUgY29zdCBtZXRyaWMsIGluIHVuaXRzLiAqL1xuICAgIHJlYWRvbmx5IG1lYXN1cmVkOiBudW1iZXI7XG4gICAgLyoqXG4gICAgICogVGhlIHBsdXJhbCBmb3JtIG9mIHRoZSB1bml0IG5hbWUuIEJ5IGRlZmF1bHQgdGhlIHBsdXJhbCBmb3JtIHdpbGwgYmUgdGhlXG4gICAgICogbmFtZSBvZiB0aGUgdW5pdCB3aXRoIFwic1wiIGFwcGVuZGVkIGF0IHRoZSBlbmQsIHVubGVzcyB0aGUgbGFzdCBsZXR0ZXIgaXNcbiAgICAgKiBjYXBpdGFsaXplZCwgaW4gd2hpY2ggY2FzZSB0aGVyZSBpcyBubyBwbHVyYWwgZm9ybSAoZS5nLiBcIkdCXCIpLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHVuaXRQbHVyYWw/OiBzdHJpbmc7XG4gICAgLyoqXG4gICAgICogQW4gb3B0aW9uYWwgY29tbWVudCwgdXN1YWxseSBwcm92aWRpbmcgYSBsaW5rIHRvIHRoZSBwcm92aWRlcidzIHByaWNpbmdcbiAgICAgKiBwYWdlIGFuZCBvdGhlciBkYXRhLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IGNvbW1lbnQ/OiBzdHJpbmc7XG4gICAgLyoqXG4gICAgICogVHJ1ZSBpZiB0aGlzIGNvc3QgbWV0cmljIGlzIG9ubHkgZm9yIGluZm9ybWF0aW9uYWwgcHVycG9zZXMgKGUuZy4gQVdTJ3NcbiAgICAgKiBgbG9nSW5nZXN0aW9uYCkgYW5kIGRvZXMgbm90IGNvbnRyaWJ1dGUgY29zdC5cbiAgICAgKi9cbiAgICByZWFkb25seSBpbmZvcm1hdGlvbmFsT25seT86IGJvb2xlYW47XG5cbiAgICAvKiogQGludGVybmFsICovXG4gICAgY29uc3RydWN0b3IoYXJnOiBQcm9wZXJ0aWVzRXhjZXB0PENvc3RNZXRyaWMsIEFueUZ1bmN0aW9uPikge1xuICAgICAgICB0aGlzLm5hbWUgPSBhcmcubmFtZTtcbiAgICAgICAgdGhpcy5wcmljaW5nID0gYXJnLnByaWNpbmc7XG4gICAgICAgIHRoaXMudW5pdCA9IGFyZy51bml0O1xuICAgICAgICB0aGlzLm1lYXN1cmVkID0gYXJnLm1lYXN1cmVkO1xuICAgICAgICB0aGlzLnVuaXRQbHVyYWwgPSBhcmcudW5pdFBsdXJhbDtcbiAgICAgICAgdGhpcy5jb21tZW50ID0gYXJnLmNvbW1lbnQ7XG4gICAgICAgIHRoaXMuaW5mb3JtYXRpb25hbE9ubHkgPSBhcmcuaW5mb3JtYXRpb25hbE9ubHk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogVGhlIGNvc3QgY29udHJpYnV0aW9uIG9mIHRoaXMgY29zdCBtZXRyaWMuIEVxdWFsIHRvXG4gICAgICoge0BsaW5rIENvc3RNZXRyaWMucHJpY2luZ30gKiB7QGxpbmsgQ29zdE1ldHJpYy5tZWFzdXJlZH0uXG4gICAgICovXG4gICAgY29zdCgpIHtcbiAgICAgICAgcmV0dXJuIHRoaXMucHJpY2luZyAqIHRoaXMubWVhc3VyZWQ7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogUmV0dXJuIGEgc3RyaW5nIHdpdGggdGhlIGNvc3QgZXN0aW1hdGUgZm9yIHRoaXMgbWV0cmljLCBvbWl0dGluZ1xuICAgICAqIGNvbW1lbnRzLlxuICAgICAqL1xuICAgIGRlc2NyaWJlQ29zdE9ubHkoKSB7XG4gICAgICAgIGNvbnN0IHAgPSAobjogbnVtYmVyLCBwcmVjaXNpb24gPSA4KSA9PlxuICAgICAgICAgICAgTnVtYmVyLmlzSW50ZWdlcihuKSA/IFN0cmluZyhuKSA6IG4udG9GaXhlZChwcmVjaXNpb24pO1xuICAgICAgICBjb25zdCBnZXRVbml0ID0gKG46IG51bWJlcikgPT4ge1xuICAgICAgICAgICAgaWYgKG4gPiAxKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIChcbiAgICAgICAgICAgICAgICAgICAgdGhpcy51bml0UGx1cmFsIHx8XG4gICAgICAgICAgICAgICAgICAgICghdGhpcy51bml0Lm1hdGNoKC9bQS1aXSQvKSA/IHRoaXMudW5pdCArIFwic1wiIDogdGhpcy51bml0KVxuICAgICAgICAgICAgICAgICk7XG4gICAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgICAgIHJldHVybiB0aGlzLnVuaXQ7XG4gICAgICAgICAgICB9XG4gICAgICAgIH07XG5cbiAgICAgICAgY29uc3QgY29zdCA9IGAkJHtwKHRoaXMuY29zdCgpKX1gO1xuICAgICAgICBjb25zdCBwcmljaW5nID0gYCQke3AodGhpcy5wcmljaW5nKX0vJHt0aGlzLnVuaXR9YDtcbiAgICAgICAgY29uc3QgbWV0cmljID0gcCh0aGlzLm1lYXN1cmVkLCB0aGlzLnVuaXQgPT09IFwic2Vjb25kXCIgPyAxIDogOCk7XG4gICAgICAgIGNvbnN0IHVuaXQgPSBnZXRVbml0KHRoaXMubWVhc3VyZWQpO1xuXG4gICAgICAgIHJldHVybiBgJHt0aGlzLm5hbWUucGFkRW5kKDIxKX0gJHtwcmljaW5nLnBhZEVuZCgyMCl9ICR7bWV0cmljLnBhZFN0YXJ0KFxuICAgICAgICAgICAgMTJcbiAgICAgICAgKX0gJHt1bml0LnBhZEVuZCgxMCl9ICR7Y29zdC5wYWRFbmQoMTQpfWA7XG4gICAgfVxuXG4gICAgLyoqIERlc2NyaWJlIHRoaXMgY29zdCBtZXRyaWMsIGluY2x1ZGluZyBjb21tZW50cy4gKi9cbiAgICB0b1N0cmluZygpIHtcbiAgICAgICAgcmV0dXJuIGAke3RoaXMuZGVzY3JpYmVDb3N0T25seSgpfSR7XG4gICAgICAgICAgICAodGhpcy5jb21tZW50ICYmIGAvLyAke3RoaXMuY29tbWVudH1gKSB8fCBcIlwiXG4gICAgICAgIH1gO1xuICAgIH1cbn1cblxuLyoqXG4gKiBBIHN1bW1hcnkgb2YgdGhlIGNvc3RzIGluY3VycmVkIGJ5IGEgZmFhc3QuanMgbW9kdWxlIGF0IGEgcG9pbnQgaW4gdGltZS5cbiAqIE91dHB1dCBvZiB7QGxpbmsgRmFhc3RNb2R1bGUuY29zdFNuYXBzaG90fS5cbiAqIEByZW1hcmtzXG4gKiBDb3N0IGluZm9ybWF0aW9uIHByb3ZpZGVkIGJ5IGZhYXN0LmpzIGlzIGFuIGVzdGltYXRlLiBJdCBpcyBkZXJpdmVkIGZyb21cbiAqIGludGVybmFsIGZhYXN0LmpzIG1lYXN1cmVtZW50cyBhbmQgbm90IGJ5IGNvbnN1bHRpbmcgZGF0YSBwcm92aWRlZCBieSB5b3VyXG4gKiBjbG91ZCBwcm92aWRlci5cbiAqXG4gKiAqKkZhYXN0LmpzIGRvZXMgbm90IGd1YXJhbnRlZSB0aGUgYWNjdXJhY3kgb2YgY29zdCBlc3RpbWF0ZXMuKipcbiAqXG4gKiAqKlVzZSBhdCB5b3VyIG93biByaXNrLioqXG4gKlxuICogRXhhbXBsZSB1c2luZyBBV1M6XG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBmYWFzdE1vZHVsZSA9IGF3YWl0IGZhYXN0KFwiYXdzXCIsIG0pO1xuICogdHJ5IHtcbiAqICAgICAvLyBJbnZva2UgZmFhc3RNb2R1bGUuZnVuY3Rpb25zLipcbiAqIH0gZmluYWxseSB7XG4gKiAgICAgYXdhaXQgZmFhc3RNb2R1bGUuY2xlYW51cCgpO1xuICogICAgIGNvbnNvbGUubG9nKGBDb3N0IGVzdGltYXRlOmApO1xuICogICAgIGNvbnNvbGUubG9nKGAke2F3YWl0IGZhYXN0TW9kdWxlLmNvc3RTbmFwc2hvdCgpfWApO1xuICogfVxuICogYGBgXG4gKlxuICogQVdTIGV4YW1wbGUgb3V0cHV0OlxuICogYGBgdGV4dFxuICogQ29zdCBlc3RpbWF0ZTpcbiAqIGZ1bmN0aW9uQ2FsbER1cmF0aW9uICAkMC4wMDAwMjgxMy9zZWNvbmQgICAgICAgICAgICAwLjYgc2Vjb25kICAgICAkMC4wMDAwMTY4OCAgICA2OC40JSAgWzFdXG4gKiBzcXMgICAgICAgICAgICAgICAgICAgJDAuMDAwMDAwNDAvcmVxdWVzdCAgICAgICAgICAgICA5IHJlcXVlc3RzICAgJDAuMDAwMDAzNjAgICAgMTQuNiUgIFsyXVxuICogc25zICAgICAgICAgICAgICAgICAgICQwLjAwMDAwMDUwL3JlcXVlc3QgICAgICAgICAgICAgNSByZXF1ZXN0cyAgICQwLjAwMDAwMjUwICAgIDEwLjElICBbM11cbiAqIGZ1bmN0aW9uQ2FsbFJlcXVlc3RzICAkMC4wMDAwMDAyMC9yZXF1ZXN0ICAgICAgICAgICAgIDUgcmVxdWVzdHMgICAkMC4wMDAwMDEwMCAgICAgNC4xJSAgWzRdXG4gKiBvdXRib3VuZERhdGFUcmFuc2ZlciAgJDAuMDkwMDAwMDAvR0IgICAgICAgICAwLjAwMDAwNzY5IEdCICAgICAgICAgJDAuMDAwMDAwNjkgICAgIDIuOCUgIFs1XVxuICogbG9nSW5nZXN0aW9uICAgICAgICAgICQwLjUwMDAwMDAwL0dCICAgICAgICAgICAgICAgICAgMCBHQiAgICAgICAgICQwICAgICAgICAgICAgICAwLjAlICBbNl1cbiAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICQwLjAwMDAyNDY3IChVU0QpXG4gKlxuICogICAqIEVzdGltYXRlZCB1c2luZyBoaWdoZXN0IHByaWNpbmcgdGllciBmb3IgZWFjaCBzZXJ2aWNlLiBMaW1pdGF0aW9ucyBhcHBseS5cbiAqICAqKiBEb2VzIG5vdCBhY2NvdW50IGZvciBmcmVlIHRpZXIuXG4gKiBbMV06IGh0dHBzOi8vYXdzLmFtYXpvbi5jb20vbGFtYmRhL3ByaWNpbmcgKHJhdGUgPSAwLjAwMDAxNjY3LyhHQipzZWNvbmQpICogMS42ODc1IEdCID0gMC4wMDAwMjgxMy9zZWNvbmQpXG4gKiBbMl06IGh0dHBzOi8vYXdzLmFtYXpvbi5jb20vc3FzL3ByaWNpbmdcbiAqIFszXTogaHR0cHM6Ly9hd3MuYW1hem9uLmNvbS9zbnMvcHJpY2luZ1xuICogWzRdOiBodHRwczovL2F3cy5hbWF6b24uY29tL2xhbWJkYS9wcmljaW5nXG4gKiBbNV06IGh0dHBzOi8vYXdzLmFtYXpvbi5jb20vZWMyL3ByaWNpbmcvb24tZGVtYW5kLyNEYXRhX1RyYW5zZmVyXG4gKiBbNl06IGh0dHBzOi8vYXdzLmFtYXpvbi5jb20vY2xvdWR3YXRjaC9wcmljaW5nLyAtIExvZyBpbmdlc3Rpb24gY29zdHMgbm90IGN1cnJlbnRseSBpbmNsdWRlZC5cbiAqIGBgYFxuICpcbiAqIEEgY29zdCBzbmFwc2hvdCBjb250YWlucyBzZXZlcmFsIHtAbGluayBDb3N0TWV0cmljfSB2YWx1ZXMuIEVhY2ggYENvc3RNZXRyaWNgXG4gKiBzdW1tYXJpemVzIG9uZSBjb21wb25lbnQgb2YgdGhlIG92ZXJhbGwgY29zdCBvZiBleGVjdXRpbmcgdGhlIGZ1bmN0aW9ucyBzb1xuICogZmFyLiBTb21lIGNvc3QgbWV0cmljcyBhcmUgY29tbW9uIHRvIGFsbCBmYWFzdCBwcm92aWRlcnMsIGFuZCBvdGhlciBtZXRyaWNzXG4gKiBhcmUgcHJvdmlkZXItc3BlY2lmaWMuIFRoZSBjb21tb24gbWV0cmljcyBhcmU6XG4gKlxuICogLSBgZnVuY3Rpb25DYWxsRHVyYXRpb25gOiB0aGUgZXN0aW1hdGVkIGJpbGxlZCBDUFUgdGltZSAocm91bmRlZCB0byB0aGUgbmV4dFxuICogICAxMDBtcykgY29uc3VtZWQgYnkgY29tcGxldGVkIGNsb3VkIGZ1bmN0aW9uIGNhbGxzLiBUaGlzIGlzIHRoZSBtZXRyaWMgdGhhdFxuICogICB1c3VhbGx5IGRvbWluYXRlcyBjb3N0LlxuICpcbiAqIC0gYGZ1bmN0aW9uQ2FsbFJlcXVlc3RzYDogdGhlIG51bWJlciBvZiBpbnZvY2F0aW9uIHJlcXVlc3RzIG1hZGUuIE1vc3RcbiAqICAgcHJvdmlkZXJzIGNoYXJnZSBmb3IgZWFjaCBpbnZvY2F0aW9uLlxuICpcbiAqIFByb3ZpZGVyLXNwZWNpZmljIG1ldHJpY3MgdmFyeS4gRm9yIGV4YW1wbGUsIEFXUyBoYXMgdGhlIGZvbGxvd2luZyBhZGRpdGlvbmFsXG4gKiBtZXRyaWNzOlxuICpcbiAqIC0gYHNxc2A6IEFXUyBTaW1wbGUgUXVldWVpbmcgU2VydmljZS4gVGhpcyBtZXRyaWMgY2FwdHVyZXMgdGhlIG51bWJlciBvZlxuICogICBxdWV1ZSByZXF1ZXN0cyBtYWRlIHRvIGluc2VydCBhbmQgcmV0cmlldmUgcXVldWVkIHJlc3VsdHMgKGVhY2ggNjRrYiBjaHVua1xuICogICBpcyBjb3VudGVkIGFzIGFuIGFkZGl0aW9uYWwgcmVxdWVzdCkuIF