@mitre/hdf-mappings 3.7.1 → 3.7.2-rc.2

package/README.md

@@ -21,6 +21,8 @@ and `tags.cci` fields in HDF output.
 | ScoutSuite | NIST SP 800-53 | Rule name string |
 | AWS Config | NIST SP 800-53 | Rule identifier or rule name |
 | Hipcheck | NIST SP 800-53 Rev 5 | Analysis name (`binary`, `mitre/binary`) |
+| Hadolint | NIST SP 800-53 Rev 5 | Rule code string (`DL3002`, `SC2154`) |
+| Checkov | CCI + NIST SP 800-53 Rev 5 | Check ID string (`CKV_AWS_1`) |
 
 Go equivalents are available in `go/` subdirectories (see below).
 
@@ -140,6 +142,7 @@ NIST-emitting converter honors the requested revision, not just aws-config:
 | cci | 4 | DISA refs incl. Appendix J privacy controls; translated with statement suffixes |
 | nikto, owasp, scoutsuite | 4 | content identical at both revisions today; a test guards that invariant |
 | hipcheck | 5 | SR-family controls have no Rev 4 equivalent and drop at Rev 4 |
+| hadolint | 5 | SR-3 expands and SR-4 drops at Rev 4; callers treat an empty result as unmapped |
 
 Translation semantics: statement-style suffixes ("AC-1 a") survive identity and
 are dropped on redirects; controls with no equivalent at the requested revision
@@ -331,6 +334,73 @@ const analyses = getAllHipcheckAnalyses();
 > mappings, these are candidate control associations for triage, not evidence a
 > control is assessed or satisfied.
 
+### Hadolint
+
+Maps hadolint rule codes to NIST 800-53 Rev 5 controls. One table covers both
+hadolint's own `DL` rules and the `SC` rules it surfaces from its embedded
+shellcheck, because both arrive in the same hadolint report.
+
+```typescript
+import {
+  getHadolintNistMapping,
+  hadolintRuleExists,
+  getAllHadolintRuleIds,
+  getHadolintMappingProvenance,
+} from '@mitre/hdf-mappings';
+
+const mapping = getHadolintNistMapping('DL3002');
+// Returns: {nist: ['AC-6']}
+
+getHadolintNistMapping('SC2154');
+// Returns: {nist: ['SA-11']} — shellcheck rules share the table
+
+if (hadolintRuleExists('DL1000')) { /* false: the parse-error pseudo-rule is unmapped */ }
+
+const rules = getAllHadolintRuleIds();
+// Returns the 105 mapped rule codes, sorted
+
+const {source, nistRevision} = getHadolintMappingProvenance();
+// source.commit pins the upstream file; nistRevision is 5
+```
+
+A mapped rule can still come back with an empty `nist` list: the table is
+authored at Rev 5, and `SR-4` has no Rev 4 equivalent. Callers must treat an
+empty list the same as an unmapped rule and apply their own fallback, rather
+than emit an empty `nist` tag.
+
+> **Provenance.** Hadolint publishes no rule-to-controls crosswalk, so this
+> table is a curated mapping ported verbatim from mitre/heimdall2 — the source
+> file, commit and SHA-256 are recorded in the dataset's own `$comment` and
+> `source` blocks, along with the re-port procedure. As with the other mappings,
+> these are candidate control associations for triage, not evidence a control is
+> assessed or satisfied.
+
+### Checkov
+
+Maps Checkov check IDs to CCIs and NIST 800-53 Rev 5 controls. A check maps to
+both at once, so a Checkov finding can carry the same `cci` and `nist` tags the
+STIG-derived converters carry.
+
+```typescript
+import {
+  getCheckovCciNistMapping,
+  checkovCheckExists,
+  getAllCheckovCheckIds,
+  getCheckovMappingProvenance,
+} from '@mitre/hdf-mappings';
+
+const mapping = getCheckovCciNistMapping('CKV_AWS_1');
+// Returns: {cci: ['CCI-000235', 'CCI-000226'], nist: ['AC-6(10)', 'AC-6(1)']}
+
+if (checkovCheckExists('CKV_NOPE_1')) { /* false: an unmapped check */ }
+
+const ids = getAllCheckovCheckIds();
+// Returns the 1341 mapped check IDs, sorted
+
+const {source, checkovVersion, nistRevision} = getCheckovMappingProvenance();
+// source pins the published package the table was ported from; nistRevision is 5
+```
+
 ## Go API
 
 Each mapping is also available as a Go package:
@@ -343,6 +413,8 @@ hdf-mappings/go/
   nessus/     — Nessus plugin→NIST lookups (NISTControls, with family+pluginID)
   nikto/      — Nikto test→NIST lookups (NISTControl, NISTControlByInt)
   hipcheck/   — Hipcheck analysis→NIST lookups (NISTControls, Exists, AllAnalyses)
+  hadolint/   — Hadolint rule→NIST lookups (Lookup, LookupForRevision, Exists, AllRuleIDs)
+  checkov/    — Checkov check→CCI+NIST lookups (Lookup, LookupForRevision, Exists, AllCheckIDs, GetProvenance)
   scoutsuite/ — ScoutSuite rule→NIST lookups (NISTControls)
   awsconfig/  — AWS Config→NIST lookups (NISTControls, GetByRuleName, GetByIdentifier)
   nist/       — revision selection (Revision, SetRevision) + Rev 4↔5 crosswalk (Translate, TranslateControls)
@@ -397,6 +469,7 @@ translated, unmapped := nist.TranslateControls([]string{"AC-1", "IR-10", "SC-19"
 | Nessus→NIST | heimdall2 mapping tables |
 | Nikto→NIST | heimdall2 mapping tables |
 | ScoutSuite→NIST | heimdall2 mapping tables |
+| Hadolint→NIST | heimdall2 mapping tables |
 | AWS Config→NIST | AWS Config OBP for NIST 800-53 docs + Security Hub NIST r5 standard + derived (see Coverage tiers) |
 | NIST Rev 4↔5 crosswalk | NIST SP 800-53 Rev 4→Rev 5 comparison workbook + Appendix J comparison (csrc.nist.gov, Rev 5 final) |
 

package/dist/index.d.ts

@@ -684,5 +684,47 @@ export declare function getAllHipcheckAnalyses(): string[];
 /** Get all Hipcheck to NIST mappings. */
 export declare function getAllHipcheckMappings(): HipcheckNistMappings;
 //#endregion
-export type { AwsConfigNistMapping, AwsConfigNistMappings, AwsConfigSuppression, AwsConfigSuppressions, CCIItem, CCIMappings, CheckovCciNistMapping, CheckovCciNistMappings, CheckovMappingDataset, CheckovMappingProvenance, CweNistMapping, CweNistMappings, HipcheckNistMapping, HipcheckNistMappings, NISTDescriptions, NessusNistMapping, NessusNistMappings, NiktoNistMappings, NistCCIMappings, NistControlTranslation, NistCrosswalkRelation, OwaspNistMapping, OwaspNistMappings, ScoutsuiteNistMapping, ScoutsuiteNistMappings };
+//#region src/hadolint/types.d.ts
+/**
+ * TypeScript types for hadolint rule code to NIST mappings
+ */
+interface HadolintNistMapping {
+  nist: string[];
+}
+type HadolintNistMappings = Record<string, HadolintNistMapping>;
+interface HadolintMappingProvenance {
+  source: {
+    repository: string;
+    path: string;
+    commit: string;
+    sha256: string;
+  };
+  updated: string;
+  nistRevision: number;
+}
+interface HadolintMappingDataset extends HadolintMappingProvenance {
+  $comment: string[];
+  mappings: HadolintNistMappings;
+}
+//#endregion
+//#region src/hadolint/index.d.ts
+/**
+ * Get the NIST controls for a hadolint rule code, translated to the given
+ * revision.
+ *
+ * A rule whose controls do not survive translation comes back mapped but with
+ * an empty list — SR-4 has no Rev 4 equivalent — so a caller must treat an
+ * empty list the same as an absent mapping and apply its own fallback.
+ *
+ * @returns a copy of the control list, or undefined if the rule is unmapped
+ */
+export declare function getHadolintNistMapping(ruleId: string, rev?: number): HadolintNistMapping | undefined;
+/** Check whether a hadolint rule code has a mapping. */
+export declare function hadolintRuleExists(ruleId: string): boolean;
+/** Get all mapped hadolint rule codes, sorted. */
+export declare function getAllHadolintRuleIds(): string[];
+/** Get the dataset's upstream source and native NIST revision. */
+export declare function getHadolintMappingProvenance(): HadolintMappingProvenance;
+//#endregion
+export type { AwsConfigNistMapping, AwsConfigNistMappings, AwsConfigSuppression, AwsConfigSuppressions, CCIItem, CCIMappings, CheckovCciNistMapping, CheckovCciNistMappings, CheckovMappingDataset, CheckovMappingProvenance, CweNistMapping, CweNistMappings, HadolintMappingDataset, HadolintMappingProvenance, HadolintNistMapping, HadolintNistMappings, HipcheckNistMapping, HipcheckNistMappings, NISTDescriptions, NessusNistMapping, NessusNistMappings, NiktoNistMappings, NistCCIMappings, NistControlTranslation, NistCrosswalkRelation, OwaspNistMapping, OwaspNistMappings, ScoutsuiteNistMapping, ScoutsuiteNistMappings };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/cci/types.ts","../src/cci/index.ts","../src/nist/normalize.ts","../src/nist/crosswalk.ts","../src/nist/types.ts","../src/nist/index.ts","../src/owasp/types.ts","../src/owasp/index.ts","../src/cwe/types.ts","../src/cwe/index.ts","../src/checkov/types.ts","../src/checkov/index.ts","../src/nessus/types.ts","../src/nessus/index.ts","../src/nikto/types.ts","../src/nikto/index.ts","../src/scoutsuite/types.ts","../src/scoutsuite/index.ts","../src/awsconfig/types.ts","../src/awsconfig/index.ts","../src/hipcheck/types.ts","../src/hipcheck/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/cci/types.ts","../src/cci/index.ts","../src/nist/normalize.ts","../src/nist/crosswalk.ts","../src/nist/types.ts","../src/nist/index.ts","../src/owasp/types.ts","../src/owasp/index.ts","../src/cwe/types.ts","../src/cwe/index.ts","../src/checkov/types.ts","../src/checkov/index.ts","../src/nessus/types.ts","../src/nessus/index.ts","../src/nikto/types.ts","../src/nikto/index.ts","../src/scoutsuite/types.ts","../src/scoutsuite/index.ts","../src/awsconfig/types.ts","../src/awsconfig/index.ts","../src/hipcheck/types.ts","../src/hipcheck/index.ts","../src/hadolint/types.ts","../src/hadolint/index.ts"],"mappings":"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"}

package/dist/index.js

@@ -29140,7 +29140,7 @@ function getAllOwaspMappings() {
 }
 //#endregion
 //#region src/cwe/index.ts
-const mappings$6 = [
+const mappings$7 = [
 	{
 		"CWE-ID": 5,
 		"CWE Name": "J2EE Misconfiguration: Data Transmission Without Encryption",
@@ -31971,7 +31971,7 @@ const mappings$6 = [
 	}
 ];
 const byRev = /* @__PURE__ */ new Map();
-for (const m of mappings$6) {
+for (const m of mappings$7) {
 	let idx = byRev.get(m.Rev);
 	if (!idx) {
 		idx = /* @__PURE__ */ new Map();
@@ -32004,11 +32004,11 @@ function cweExists(cweId, rev = getCurrentNistRevision()) {
 }
 /** Get all CWE to NIST mappings (all revisions). */
 function getAllCweMappings() {
-	return [...mappings$6];
+	return [...mappings$7];
 }
 //#endregion
 //#region src/checkov/index.ts
-const dataset = {
+const dataset$1 = {
 	$comment: [
 		"Checkov check_id -> DISA CCI + NIST SP 800-53 mapping, ported verbatim (entry order and list order preserved) from the published @mitre/hdf-converters 2.14.0 package. Do not hand-edit entries; correct a mapping upstream and re-port.",
 		"Upstream methodology, quoted from the source file header (updated 2026-04-04): \"Use `checkov --list` to get starting baseline document. Using generative AI (Opus 4.6), mapped from Checkov v3.2.506 to CIS v8 rule IDs to NIST control families to DISA CCI. Results were peer reviewed by two personnel after for completeness. Total checks mapped: 1341\"",
@@ -37392,7 +37392,7 @@ const dataset = {
 		}
 	}
 };
-const byCheckId = new Map(Object.entries(dataset.mappings));
+const byCheckId = new Map(Object.entries(dataset$1.mappings));
 /**
 * Get the CCI and NIST controls for a Checkov check ID, with NIST controls
 * translated to the given revision. CCIs are revision-independent.
@@ -37403,7 +37403,7 @@ function getCheckovCciNistMapping(checkId, rev = getCurrentNistRevision()) {
 	if (!m) return void 0;
 	return {
 		cci: [...m.cci],
-		nist: nistControlsAtRevision([...m.nist], dataset.nistRevision, rev)
+		nist: nistControlsAtRevision([...m.nist], dataset$1.nistRevision, rev)
 	};
 }
 /** Check whether a Checkov check ID has a mapping. */
@@ -37417,10 +37417,10 @@ function getAllCheckovCheckIds() {
 /** Get the dataset's source package, Checkov version and native NIST revision. */
 function getCheckovMappingProvenance() {
 	return {
-		source: { ...dataset.source },
-		checkovVersion: dataset.checkovVersion,
-		updated: dataset.updated,
-		nistRevision: dataset.nistRevision
+		source: { ...dataset$1.source },
+		checkovVersion: dataset$1.checkovVersion,
+		updated: dataset$1.updated,
+		nistRevision: dataset$1.nistRevision
 	};
 }
 //#endregion
@@ -37861,7 +37861,7 @@ var nessus_nist_mappings_default = [
 //#region src/nessus/index.ts
 const NATIVE_REVISION$3 = 4;
 const atCurrentRevision$2 = (nistId) => nistControlsAtRevision(nistId.split("|"), NATIVE_REVISION$3, getCurrentNistRevision()).join("|");
-const mappings$4 = nessus_nist_mappings_default;
+const mappings$5 = nessus_nist_mappings_default;
 /**
 * Get the NIST control ID for a Nessus plugin family and plugin ID
 * @param pluginFamily - The Nessus plugin family
@@ -37869,9 +37869,9 @@ const mappings$4 = nessus_nist_mappings_default;
 * @returns The NIST control ID or undefined if not found
 */
 function getNessusNistControl(pluginFamily, pluginId = "*") {
-	const exactMatch = mappings$4.find((m) => m.pluginFamily === pluginFamily && String(m.pluginID) === pluginId);
+	const exactMatch = mappings$5.find((m) => m.pluginFamily === pluginFamily && String(m.pluginID) === pluginId);
 	if (exactMatch) return atCurrentRevision$2(exactMatch["NIST-ID"]);
-	const wildcardMatch = mappings$4.find((m) => m.pluginFamily === pluginFamily && String(m.pluginID) === "*");
+	const wildcardMatch = mappings$5.find((m) => m.pluginFamily === pluginFamily && String(m.pluginID) === "*");
 	return wildcardMatch ? atCurrentRevision$2(wildcardMatch["NIST-ID"]) : void 0;
 }
 /**
@@ -37880,14 +37880,14 @@ function getNessusNistControl(pluginFamily, pluginId = "*") {
 * @returns Array of mappings for the plugin family
 */
 function getNessusPluginFamilyMappings(pluginFamily) {
-	return mappings$4.filter((m) => m.pluginFamily === pluginFamily);
+	return mappings$5.filter((m) => m.pluginFamily === pluginFamily);
 }
 /**
 * Get all plugin families
 * @returns Array of all plugin families
 */
 function getAllNessusPluginFamilies() {
-	const families = new Set(mappings$4.map((m) => m.pluginFamily));
+	const families = new Set(mappings$5.map((m) => m.pluginFamily));
 	return Array.from(families);
 }
 /**
@@ -37896,14 +37896,14 @@ function getAllNessusPluginFamilies() {
 * @returns True if the plugin family exists
 */
 function nessusPluginFamilyExists(pluginFamily) {
-	return mappings$4.some((m) => m.pluginFamily === pluginFamily);
+	return mappings$5.some((m) => m.pluginFamily === pluginFamily);
 }
 /**
 * Get all Nessus to NIST mappings
 * @returns Array of all mappings
 */
 function getAllNessusMappings() {
-	return [...mappings$4];
+	return [...mappings$5];
 }
 //#endregion
 //#region src/data/nikto-nist-mappings.json
@@ -46854,7 +46854,7 @@ var nikto_nist_mappings_default = {
 //#region src/nikto/index.ts
 const NATIVE_REVISION$2 = 4;
 const atCurrentRevision$1 = (nistId) => nistControlsAtRevision(nistId.split("|"), NATIVE_REVISION$2, getCurrentNistRevision()).join("|");
-const mappings$3 = nikto_nist_mappings_default;
+const mappings$4 = nikto_nist_mappings_default;
 /**
 * Get the NIST control ID for a Nikto test ID
 * @param niktoId - The Nikto test ID (string or number)
@@ -46862,7 +46862,7 @@ const mappings$3 = nikto_nist_mappings_default;
 */
 function getNiktoNistControl(niktoId) {
 	const id = typeof niktoId === "number" ? niktoId.toString() : niktoId;
-	const control = mappings$3[id];
+	const control = mappings$4[id];
 	return control === void 0 ? void 0 : atCurrentRevision$1(control);
 }
 /**
@@ -46870,7 +46870,7 @@ function getNiktoNistControl(niktoId) {
 * @returns Array of all Nikto test IDs
 */
 function getAllNiktoIds() {
-	return Object.keys(mappings$3);
+	return Object.keys(mappings$4);
 }
 /**
 * Check if a Nikto test ID exists in the mappings
@@ -46878,14 +46878,14 @@ function getAllNiktoIds() {
 * @returns True if the Nikto test ID exists
 */
 function niktoExists(niktoId) {
-	return (typeof niktoId === "number" ? niktoId.toString() : niktoId) in mappings$3;
+	return (typeof niktoId === "number" ? niktoId.toString() : niktoId) in mappings$4;
 }
 /**
 * Get all Nikto to NIST mappings
 * @returns Object mapping Nikto test IDs to NIST control IDs
 */
 function getAllNiktoMappings() {
-	return { ...mappings$3 };
+	return { ...mappings$4 };
 }
 //#endregion
 //#region src/data/scoutsuite-nist-mappings.json
@@ -47451,8 +47451,8 @@ var scoutsuite_nist_mappings_default = [
 //#region src/scoutsuite/index.ts
 const NATIVE_REVISION$1 = 4;
 const atCurrentRevision = (nistId) => nistControlsAtRevision(nistId.split("|"), NATIVE_REVISION$1, getCurrentNistRevision()).join("|");
-const mappings$2 = scoutsuite_nist_mappings_default;
-const indexByRule = new Map(mappings$2.map((m) => [m.RULE, m]));
+const mappings$3 = scoutsuite_nist_mappings_default;
+const indexByRule = new Map(mappings$3.map((m) => [m.RULE, m]));
 /**
 * Get the full mapping for a ScoutSuite rule
 * @param rule - The ScoutSuite rule name
@@ -47490,7 +47490,7 @@ function scoutsuiteRuleExists(rule) {
 * @returns Array of all mappings
 */
 function getAllScoutsuiteMappings() {
-	return [...mappings$2];
+	return [...mappings$3];
 }
 //#endregion
 //#region src/data/awsconfig-mappings.json
@@ -53203,7 +53203,7 @@ var awsconfig_suppressions_default = [
 ];
 //#endregion
 //#region src/awsconfig/index.ts
-const mappings$1 = awsconfig_mappings_default;
+const mappings$2 = awsconfig_mappings_default;
 /**
 * The maintainer-reviewed (rule, control) removals the generator applied to
 * the mapping table — exposed so a consumer can distinguish "removed by
@@ -53212,7 +53212,7 @@ const mappings$1 = awsconfig_mappings_default;
 const awsConfigSuppressions = awsconfig_suppressions_default;
 const byIdentifier = /* @__PURE__ */ new Map();
 const byRuleName = /* @__PURE__ */ new Map();
-for (const m of mappings$1) {
+for (const m of mappings$2) {
 	if (!byIdentifier.has(m.Rev)) {
 		byIdentifier.set(m.Rev, /* @__PURE__ */ new Map());
 		byRuleName.set(m.Rev, /* @__PURE__ */ new Map());
@@ -53294,7 +53294,7 @@ function awsConfigMappedRevisions(identifier, ruleName) {
 }
 /** Get all AWS Config to NIST mappings (all revisions). */
 function getAllAwsConfigMappings() {
-	return [...mappings$1];
+	return [...mappings$2];
 }
 //#endregion
 //#region src/data/hipcheck-nist-mappings.json
@@ -53357,9 +53357,9 @@ var hipcheck_nist_mappings_default = [
 //#endregion
 //#region src/hipcheck/index.ts
 const NATIVE_REVISION = 5;
-const mappings = hipcheck_nist_mappings_default;
+const mappings$1 = hipcheck_nist_mappings_default;
 const byAnalysis = /* @__PURE__ */ new Map();
-for (const m of mappings) byAnalysis.set(m.Analysis, m);
+for (const m of mappings$1) byAnalysis.set(m.Analysis, m);
 /**
 * Strip a plugin publisher prefix ("mitre/binary" -> "binary") so lookups key
 * on the analysis name regardless of publisher.
@@ -53388,9 +53388,167 @@ function getAllHipcheckAnalyses() {
 }
 /** Get all Hipcheck to NIST mappings. */
 function getAllHipcheckMappings() {
-	return [...mappings];
+	return [...mappings$1];
+}
+//#endregion
+//#region src/hadolint/index.ts
+const dataset = {
+	$comment: [
+		"Hadolint rule code -> NIST SP 800-53 mapping, ported verbatim (entry order preserved) from mitre/heimdall2. Keys are hadolint's own DL#### rules and the SC#### rules hadolint surfaces from its embedded shellcheck; one table covers both because both arrive in the same hadolint report. Do not hand-edit; re-port per the procedure below.",
+		"Hadolint publishes no NIST crosswalk. This table is a curated mapping authored upstream, not an authoritative control association, and is candidate triage material rather than evidence that a control is assessed or satisfied.",
+		"nistRevision is 5 because the table uses SR-3 and SR-4, which exist only at Rev 5; lookups translate to the process-wide NIST revision. SR-4 has no Rev 4 equivalent and translates to an empty list, so callers must fall back to their static-analysis default rather than emit an empty nist tag.",
+		"Coverage gaps: hadolint rules added after the port, and the DL1000 parse-error pseudo-rule, are absent and fall back to the caller's static-analysis default. List current rules at https://github.com/hadolint/hadolint#rules and compare against these keys.",
+		"Re-port: fetch libs/hdf-converters/src/mappings/HadolintNistMappingData.ts from mitre/heimdall2 at the commit recorded in source, confirm its sha256 matches source.sha256, then transcribe each 'RULE': 'CONTROL' pair into mappings in file order as {\"nist\": [\"CONTROL\"]}."
+	],
+	source: {
+		"repository": "https://github.com/mitre/heimdall2",
+		"path": "libs/hdf-converters/src/mappings/HadolintNistMappingData.ts",
+		"commit": "68b34a03b8746311925766da8bbb7a7490a39cb1",
+		"sha256": "779d72e615b115cb4d885e6719c4fe9c99705a41ae83a4895e22c2bc173cbe00"
+	},
+	updated: "2026-09-28",
+	nistRevision: 5,
+	mappings: {
+		"DL1001": { "nist": ["CM-3"] },
+		"DL3000": { "nist": ["CM-6"] },
+		"DL3001": { "nist": ["CM-7"] },
+		"DL3002": { "nist": ["AC-6"] },
+		"DL3003": { "nist": ["CM-6"] },
+		"DL3004": { "nist": ["AC-6"] },
+		"DL3006": { "nist": ["CM-2"] },
+		"DL3007": { "nist": ["CM-2"] },
+		"DL3008": { "nist": ["CM-2"] },
+		"DL3009": { "nist": ["CM-7"] },
+		"DL3010": { "nist": ["CM-6"] },
+		"DL3011": { "nist": ["CM-6"] },
+		"DL3012": { "nist": ["SI-4"] },
+		"DL3013": { "nist": ["CM-2"] },
+		"DL3014": { "nist": ["CM-6"] },
+		"DL3015": { "nist": ["CM-7"] },
+		"DL3016": { "nist": ["CM-2"] },
+		"DL3018": { "nist": ["CM-2"] },
+		"DL3019": { "nist": ["CM-7"] },
+		"DL3020": { "nist": ["CM-6"] },
+		"DL3021": { "nist": ["CM-6"] },
+		"DL3022": { "nist": ["SA-10"] },
+		"DL3023": { "nist": ["SA-10"] },
+		"DL3024": { "nist": ["SA-10"] },
+		"DL3025": { "nist": ["CM-6"] },
+		"DL3026": { "nist": ["SR-3"] },
+		"DL3027": { "nist": ["CM-6"] },
+		"DL3028": { "nist": ["CM-2"] },
+		"DL3029": { "nist": ["CM-2"] },
+		"DL3030": { "nist": ["CM-6"] },
+		"DL3032": { "nist": ["CM-7"] },
+		"DL3033": { "nist": ["CM-2"] },
+		"DL3034": { "nist": ["CM-6"] },
+		"DL3035": { "nist": ["CM-2"] },
+		"DL3036": { "nist": ["CM-7"] },
+		"DL3037": { "nist": ["CM-2"] },
+		"DL3038": { "nist": ["CM-6"] },
+		"DL3040": { "nist": ["CM-7"] },
+		"DL3041": { "nist": ["CM-2"] },
+		"DL3042": { "nist": ["CM-7"] },
+		"DL3043": { "nist": ["CM-6"] },
+		"DL3044": { "nist": ["CM-6"] },
+		"DL3045": { "nist": ["CM-6"] },
+		"DL3046": { "nist": ["CM-7"] },
+		"DL3047": { "nist": ["AU-4"] },
+		"DL3048": { "nist": ["CM-8"] },
+		"DL3049": { "nist": ["CM-8"] },
+		"DL3050": { "nist": ["CM-8"] },
+		"DL3051": { "nist": ["CM-8"] },
+		"DL3052": { "nist": ["CM-8"] },
+		"DL3053": { "nist": ["CM-8"] },
+		"DL3054": { "nist": ["CM-8"] },
+		"DL3055": { "nist": ["SR-4"] },
+		"DL3056": { "nist": ["CM-8"] },
+		"DL3057": { "nist": ["SI-4"] },
+		"DL3058": { "nist": ["CM-8"] },
+		"DL3059": { "nist": ["CM-7"] },
+		"DL3060": { "nist": ["CM-7"] },
+		"DL3061": { "nist": ["CM-6"] },
+		"DL3062": { "nist": ["CM-2"] },
+		"DL3063": { "nist": ["CM-6"] },
+		"DL3064": { "nist": ["SC-28"] },
+		"DL3066": { "nist": ["AC-6"] },
+		"DL3067": { "nist": ["CM-7"] },
+		"DL4000": { "nist": ["CM-8"] },
+		"DL4001": { "nist": ["CM-7"] },
+		"DL4003": { "nist": ["CM-6"] },
+		"DL4004": { "nist": ["CM-6"] },
+		"DL4005": { "nist": ["CM-6"] },
+		"DL4006": { "nist": ["SA-11"] },
+		"SC1000": { "nist": ["SA-11"] },
+		"SC1001": { "nist": ["SA-11"] },
+		"SC1007": { "nist": ["SA-11"] },
+		"SC1010": { "nist": ["SA-11"] },
+		"SC1018": { "nist": ["SA-11"] },
+		"SC1035": { "nist": ["SA-11"] },
+		"SC1045": { "nist": ["SA-11"] },
+		"SC1065": { "nist": ["SA-11"] },
+		"SC1066": { "nist": ["SA-11"] },
+		"SC1068": { "nist": ["SA-11"] },
+		"SC1077": { "nist": ["SA-11"] },
+		"SC1078": { "nist": ["SA-11"] },
+		"SC1079": { "nist": ["SA-11"] },
+		"SC1081": { "nist": ["SA-11"] },
+		"SC1083": { "nist": ["SA-11"] },
+		"SC1086": { "nist": ["SA-11"] },
+		"SC1087": { "nist": ["SA-11"] },
+		"SC1091": { "nist": ["SA-11"] },
+		"SC1095": { "nist": ["SA-11"] },
+		"SC1097": { "nist": ["SA-11"] },
+		"SC1098": { "nist": ["SA-11"] },
+		"SC1099": { "nist": ["SA-11"] },
+		"SC2002": { "nist": ["SA-11"] },
+		"SC2015": { "nist": ["SA-11"] },
+		"SC2026": { "nist": ["SA-11"] },
+		"SC2028": { "nist": ["SA-11"] },
+		"SC2035": { "nist": ["SA-11"] },
+		"SC2039": { "nist": ["SA-11"] },
+		"SC2046": { "nist": ["SA-11"] },
+		"SC2086": { "nist": ["SA-11"] },
+		"SC2140": { "nist": ["SA-11"] },
+		"SC2154": { "nist": ["SA-11"] },
+		"SC2155": { "nist": ["SA-11"] },
+		"SC2164": { "nist": ["SA-11"] },
+		"DL3065": { "nist": ["CM-2"] }
+	}
+};
+const byRuleId = new Map(Object.entries(dataset.mappings));
+/**
+* Get the NIST controls for a hadolint rule code, translated to the given
+* revision.
+*
+* A rule whose controls do not survive translation comes back mapped but with
+* an empty list — SR-4 has no Rev 4 equivalent — so a caller must treat an
+* empty list the same as an absent mapping and apply its own fallback.
+*
+* @returns a copy of the control list, or undefined if the rule is unmapped
+*/
+function getHadolintNistMapping(ruleId, rev = getCurrentNistRevision()) {
+	const m = byRuleId.get(ruleId);
+	if (!m) return void 0;
+	return { nist: nistControlsAtRevision([...m.nist], dataset.nistRevision, rev) };
+}
+/** Check whether a hadolint rule code has a mapping. */
+function hadolintRuleExists(ruleId) {
+	return byRuleId.has(ruleId);
+}
+/** Get all mapped hadolint rule codes, sorted. */
+function getAllHadolintRuleIds() {
+	return [...byRuleId.keys()].sort();
+}
+/** Get the dataset's upstream source and native NIST revision. */
+function getHadolintMappingProvenance() {
+	return {
+		source: { ...dataset.source },
+		updated: dataset.updated,
+		nistRevision: dataset.nistRevision
+	};
 }
 //#endregion
-export { DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS, DEFAULT_CONFIG_MANAGEMENT_NIST_TAGS, DEFAULT_NIST_REVISION, DEFAULT_REMEDIATION_NIST_TAGS, DEFAULT_STATIC_ANALYSIS_NIST_TAGS, SUPPORTED_NIST_REVISIONS, awsConfigIdentifierExists, awsConfigMappedRevisions, awsConfigRuleNameExists, awsConfigSuppressions, cciExists, checkovCheckExists, cweExists, getAllAwsConfigIdentifiers, getAllAwsConfigMappings, getAllAwsConfigRuleNames, getAllCCIIds, getAllCheckovCheckIds, getAllCweIds, getAllCweMappings, getAllHipcheckAnalyses, getAllHipcheckMappings, getAllNISTIds, getAllNessusMappings, getAllNessusPluginFamilies, getAllNiktoIds, getAllNiktoMappings, getAllOwaspIds, getAllOwaspMappings, getAllScoutsuiteMappings, getAllScoutsuiteRules, getAwsConfigNistControlByIdentifier, getAwsConfigNistControlByName, getAwsConfigNistControlsBySubstring, getAwsConfigNistMappingByIdentifier, getAwsConfigNistMappingByName, getCCIDescription, getCCINistMappings, getCheckovCciNistMapping, getCheckovMappingProvenance, getCurrentNistRevision, getCweName, getCweNistControl, getCweNistMapping, getHipcheckNistControls, getNISTDescription, getNISTFamily, getNessusNistControl, getNessusPluginFamilyMappings, getNiktoNistControl, getNistCCIMappings, getOwaspName, getOwaspNistControl, getOwaspNistMapping, getScoutsuiteNistControl, getScoutsuiteNistMapping, hipcheckAnalysisExists, isNistStrict, nessusPluginFamilyExists, niktoExists, nistControlsAtRevision, nistExists, nistRosterSize, nistToCci, normalizeNistId, owaspExists, resetNistRevision, scoutsuiteRuleExists, setCurrentNistRevision, setNistStrict, translateNistControl, translateNistControls };
+export { DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS, DEFAULT_CONFIG_MANAGEMENT_NIST_TAGS, DEFAULT_NIST_REVISION, DEFAULT_REMEDIATION_NIST_TAGS, DEFAULT_STATIC_ANALYSIS_NIST_TAGS, SUPPORTED_NIST_REVISIONS, awsConfigIdentifierExists, awsConfigMappedRevisions, awsConfigRuleNameExists, awsConfigSuppressions, cciExists, checkovCheckExists, cweExists, getAllAwsConfigIdentifiers, getAllAwsConfigMappings, getAllAwsConfigRuleNames, getAllCCIIds, getAllCheckovCheckIds, getAllCweIds, getAllCweMappings, getAllHadolintRuleIds, getAllHipcheckAnalyses, getAllHipcheckMappings, getAllNISTIds, getAllNessusMappings, getAllNessusPluginFamilies, getAllNiktoIds, getAllNiktoMappings, getAllOwaspIds, getAllOwaspMappings, getAllScoutsuiteMappings, getAllScoutsuiteRules, getAwsConfigNistControlByIdentifier, getAwsConfigNistControlByName, getAwsConfigNistControlsBySubstring, getAwsConfigNistMappingByIdentifier, getAwsConfigNistMappingByName, getCCIDescription, getCCINistMappings, getCheckovCciNistMapping, getCheckovMappingProvenance, getCurrentNistRevision, getCweName, getCweNistControl, getCweNistMapping, getHadolintMappingProvenance, getHadolintNistMapping, getHipcheckNistControls, getNISTDescription, getNISTFamily, getNessusNistControl, getNessusPluginFamilyMappings, getNiktoNistControl, getNistCCIMappings, getOwaspName, getOwaspNistControl, getOwaspNistMapping, getScoutsuiteNistControl, getScoutsuiteNistMapping, hadolintRuleExists, hipcheckAnalysisExists, isNistStrict, nessusPluginFamilyExists, niktoExists, nistControlsAtRevision, nistExists, nistRosterSize, nistToCci, normalizeNistId, owaspExists, resetNistRevision, scoutsuiteRuleExists, setCurrentNistRevision, setNistStrict, translateNistControl, translateNistControls };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["rawCrosswalk","rawNistDataRev4","rawNistDataRev5","NATIVE_REVISION","rawCCIData","rawNistCCIData","NATIVE_REVISION","atCurrentRevision","rawOwaspData","mappings","rawMappings","rawDataset","NATIVE_REVISION","atCurrentRevision","mappings","rawMappings","NATIVE_REVISION","atCurrentRevision","mappings","rawMappings","NATIVE_REVISION","mappings","rawMappings","mappings","rawMappings","rawSuppressions","rawMappings"],"sources":["../src/data/cci-mappings.json","../src/data/nist-cci-mappings.json","../src/nist/normalize.ts","../go/nist/nist-descriptions.json","../go/nist/nist-descriptions-rev5.json","../src/data/nist-revision-crosswalk.json","../src/nist/crosswalk.ts","../src/nist/index.ts","../src/cci/index.ts","../src/data/owasp-nist-mappings.json","../src/owasp/index.ts","../src/data/cwe-nist-mappings.json","../src/cwe/index.ts","../go/checkov/checkov-cci-nist-mappings.json","../src/checkov/index.ts","../src/data/nessus-nist-mappings.json","../src/nessus/index.ts","../src/data/nikto-nist-mappings.json","../src/nikto/index.ts","../src/data/scoutsuite-nist-mappings.json","../src/scoutsuite/index.ts","../src/data/awsconfig-mappings.json","../src/data/awsconfig-suppressions.json","../src/awsconfig/index.ts","../src/data/hipcheck-nist-mappings.json","../src/hipcheck/index.ts"],"sourcesContent":["","","/**\n * NIST SP 800-53 identifier spelling normalization.\n *\n * Mirrors NormalizeID in go/nist/exists.go; both are pinned by the shared case\n * table go/nist/testdata/nist-id-spelling-cases.json.\n */\n\n// Family, control number, then any run of enhancement numbers or statement\n// letters, each written as \" 3\", \"(3)\" or \" (3)\", in any letter case. Keep identical to the Go pattern.\nconst NIST_ID = /^([A-Za-z]{2})-(\\d{1,2})((?: ?\\((?:\\d{1,2}|[A-Za-z])\\)| (?:\\d{1,2}|[A-Za-z]))*)$/;\nconst NIST_ID_TOKEN = /\\d+|[A-Za-z]/g;\n\nfunction padNumber(token: string): string {\n  return /^\\d/.test(token) ? token.padStart(2, '0') : token;\n}\n\n/**\n * Normalize a NIST SP 800-53 identifier to the description-table spelling:\n * uppercase family, lowercase statement letters, zero-padded numbers and\n * space-separated parts.\n *\n * @param nistId - An identifier such as 'AC-2', 'AC-2(3)', 'AC-2 (3)', 'AC-02 03', 'AC-1 a 1' or 'ac-2'\n * @returns The table spelling (e.g. 'AC-02 03'), or undefined if the input is not\n *   a NIST identifier spelling. A defined result is not proof NIST defines the\n *   control; use nistExists for that.\n *\n * @example\n * ```typescript\n * normalizeNistId('AC-2 (3)');  // 'AC-02 03'\n * normalizeNistId('AC-2(3)(a)'); // 'AC-02 03 a'\n * normalizeNistId('SV-230221'); // undefined\n * ```\n */\nexport function normalizeNistId(nistId: string): string | undefined {\n  if (typeof nistId !== 'string') {\n    return undefined;\n  }\n  const match = NIST_ID.exec(nistId);\n  if (!match) {\n    return undefined;\n  }\n  const [, family, control, parts] = match;\n  const tokens = parts!.match(NIST_ID_TOKEN) ?? [];\n  return [\n    `${family!.toUpperCase()}-${padNumber(control!)}`,\n    ...tokens.map((token) => padNumber(token.toLowerCase())),\n  ].join(' ');\n}\n","","","","/**\n * NIST SP 800-53 Rev 4 <-> Rev 5 control crosswalk, generated from NIST's own\n * comparison workbooks (see scripts/generate-nist-crosswalk.mjs). Identity is\n * implicit: a control present in both revisions translates to itself; edges\n * cover only non-identity cases (withdrawn, moved, incorporated, Appendix J\n * pointers, and controls new in Rev 5).\n */\n\nimport rawCrosswalk from '../data/nist-revision-crosswalk.json';\n\n/**\n * Relations a translation can carry. `identity` means the control exists at\n * both revisions under the same ID; `moved`/`incorporated`/`pointer`/`family`\n * come from NIST's comparison workbooks; `none` means NIST names no successor;\n * `unknown` means the control is not part of the source revision's catalog (or\n * the revision pair is unsupported).\n */\nexport type NistCrosswalkRelation =\n  | 'identity'\n  | 'moved'\n  | 'incorporated'\n  | 'pointer'\n  | 'family'\n  | 'none'\n  | 'unknown';\n\nexport interface NistControlTranslation {\n  control: string;\n  targets: string[];\n  relation: NistCrosswalkRelation;\n  /**\n   * Set only for relation `family` (\"incorporated into <XX> family\"): a\n   * marker, deliberately never expanded into member controls.\n   */\n  family?: string;\n  /** NIST's raw comparison text for redirects. */\n  detail?: string;\n}\n\ninterface CrosswalkEdge {\n  from: number;\n  control: string;\n  targets: string[];\n  relation: string;\n  family?: string;\n  detail: string;\n}\n\ninterface CrosswalkFile {\n  rosters: Record<string, string[]>;\n  edges: CrosswalkEdge[];\n}\n\nconst crosswalk = rawCrosswalk as unknown as CrosswalkFile;\n\nconst rosters = new Map<number, Set<string>>(\n  Object.entries(crosswalk.rosters).map(([rev, ids]) => [Number(rev), new Set(ids)])\n);\n\nconst edges = new Map<number, Map<string, CrosswalkEdge>>();\nfor (const edge of crosswalk.edges) {\n  let byControl = edges.get(edge.from);\n  if (!byControl) {\n    byControl = new Map();\n    edges.set(edge.from, byControl);\n  }\n  byControl.set(edge.control, edge);\n}\n\nconst SUPPORTED = new Set([4, 5]);\n/** A trailing single-letter statement part, e.g. \"AC-2(j)\". */\nconst STATEMENT_LETTER = /^(.*)\\(([a-z])\\)$/;\n\nfunction fromEdge(control: string, edge: CrosswalkEdge): NistControlTranslation {\n  const tr: NistControlTranslation = {\n    control,\n    targets: [...edge.targets],\n    relation: edge.relation as NistCrosswalkRelation,\n    detail: edge.detail,\n  };\n  if (edge.family) tr.family = edge.family;\n  return tr;\n}\n\nfunction identity(control: string): NistControlTranslation {\n  return { control, targets: [control], relation: 'identity' };\n}\n\n/**\n * Translates one NIST control ID between 800-53 revisions 4 and 5. A control\n * present in both revisions translates to itself (identity); withdrawn, moved,\n * incorporated, and Appendix J controls follow NIST's published successors; a\n * control with no equivalent at the target revision gets relation `none` and\n * no targets. Statement-letter suffixes (\"AC-2(j)\") survive identity\n * translation and are dropped on redirects.\n */\nexport function translateNistControl(\n  control: string,\n  from: number,\n  to: number\n): NistControlTranslation {\n  if (!control || !SUPPORTED.has(from) || !SUPPORTED.has(to)) {\n    return { control, targets: [], relation: 'unknown' };\n  }\n  if (from === to) return identity(control);\n\n  const edge = edges.get(from)?.get(control);\n  if (edge) return fromEdge(control, edge);\n  if (rosters.get(from)?.has(control) && rosters.get(to)?.has(control)) {\n    return identity(control);\n  }\n\n  const base = STATEMENT_LETTER.exec(control)?.[1];\n  if (base) {\n    const baseEdge = edges.get(from)?.get(base);\n    if (baseEdge) return fromEdge(control, baseEdge);\n    if (rosters.get(from)?.has(base) && rosters.get(to)?.has(base)) {\n      return identity(control);\n    }\n  }\n  return { control, targets: [], relation: 'unknown' };\n}\n\n/**\n * Translates a list of control IDs between revisions, flattening redirect\n * targets and deduplicating while preserving first-seen order. Controls with\n * no target at the destination revision (withdrawn without successor,\n * family-level, or unknown) are returned in `unmapped`, in input order, so\n * callers can surface them instead of silently dropping.\n */\nexport function translateNistControls(\n  controls: string[],\n  from: number,\n  to: number\n): { translated: string[]; unmapped: NistControlTranslation[] } {\n  const translated: string[] = [];\n  const unmapped: NistControlTranslation[] = [];\n  const seen = new Set<string>();\n  for (const control of controls) {\n    const tr = translateNistControl(control, from, to);\n    if (tr.targets.length === 0) {\n      unmapped.push(tr);\n      continue;\n    }\n    for (const target of tr.targets) {\n      if (!seen.has(target)) {\n        seen.add(target);\n        translated.push(target);\n      }\n    }\n  }\n  return { translated, unmapped };\n}\n\n/**\n * Number of control IDs in the crosswalk's catalog for the given revision, or\n * 0 for unsupported revisions.\n */\nexport function nistRosterSize(rev: number): number {\n  return rosters.get(rev)?.size ?? 0;\n}\n\n/**\n * A NIST-shaped base at the start of a longer reference, e.g. \"AC-1 a\",\n * \"AC-1.2 (i)\", \"SA-12 b 1\" — DISA-CCI statement-reference styles.\n */\nconst BASE_CONTROL = /^([A-Z]{2}-\\d+(?:\\(\\d+\\))?)/;\n\n/**\n * Translates a control list authored against `nativeRev` into `rev`. Identity\n * when the revisions are equal (or either is unsupported). Per token: the\n * crosswalk redirect is followed when one exists; statement-style suffixes\n * (\"AC-1 a\", \"AC-1.2 (i)\") are kept on identity and dropped on redirects;\n * tokens with no equivalent at the target revision are dropped (the analog of\n * the awsconfig empty-NIST-ID marker); tokens outside both NIST catalogs\n * (tool placeholders like \"UM-1\") pass through unchanged — they are not ours\n * to drop. Output is deduplicated preserving first-seen order.\n */\nexport function nistControlsAtRevision(\n  controls: string[],\n  nativeRev: number,\n  rev: number\n): string[] {\n  if (nativeRev === rev || !SUPPORTED.has(nativeRev) || !SUPPORTED.has(rev)) {\n    return controls;\n  }\n  const seen = new Set<string>();\n  const out: string[] = [];\n  const add = (c: string): void => {\n    if (c && !seen.has(c)) {\n      seen.add(c);\n      out.push(c);\n    }\n  };\n  for (const c of controls) {\n    const tr = translateNistControl(c, nativeRev, rev);\n    if (tr.relation !== 'unknown') {\n      tr.targets.forEach(add);\n      continue;\n    }\n    const base = BASE_CONTROL.exec(c)?.[1];\n    if (base && base !== c) {\n      const btr = translateNistControl(base, nativeRev, rev);\n      if (btr.relation === 'identity') {\n        add(c);\n        continue;\n      }\n      if (btr.relation !== 'unknown') {\n        btr.targets.forEach(add);\n        continue;\n      }\n    }\n    add(c);\n  }\n  return out;\n}\n","/**\n * NIST SP 800-53 control description functions\n */\n\nimport type { NISTDescriptions } from './types.js';\nimport { normalizeNistId } from './normalize.js';\n// The JSON files the Go nist package embeds, imported so both languages read one copy.\nimport rawNistDataRev4 from '../../go/nist/nist-descriptions.json';\nimport rawNistDataRev5 from '../../go/nist/nist-descriptions-rev5.json';\n\nexport { normalizeNistId };\n\n// Descriptions are revision-specific: Rev 5 renamed titles (\"... POLICY AND\n// PROCEDURES\" -> \"Policy and Procedures\"), added the SR and PT families, and\n// withdrew Rev 4 controls (AU-15, IR-10, SA-12, ...). Each revision has its own\n// dataset; lookups select by the (optionally overridden) global revision.\nconst nistDataByRev: Record<number, NISTDescriptions> = {\n  4: rawNistDataRev4 as NISTDescriptions,\n  5: rawNistDataRev5 as NISTDescriptions,\n};\n\n/**\n * NIST SP 800-53 revision selection.\n *\n * The revision is a module-global default that every NIST-emitting mapping\n * consults through its default lookups. Set it once at startup (the CLI's\n * `--nist-rev` flag does this) to switch the catalog all converters target.\n * For explicit, side-effect-free per-call selection, pass an explicit `rev` to\n * the mapping lookups instead of mutating this.\n */\n\n/** The revision mappings emit when nothing overrides it. */\nexport const DEFAULT_NIST_REVISION = 5;\n\n/**\n * The description dataset for a revision, falling back to the default revision's\n * data (then an empty set) for an unsupported revision.\n */\nfunction descriptionsFor(rev: number): NISTDescriptions {\n  return nistDataByRev[rev] ?? nistDataByRev[DEFAULT_NIST_REVISION] ?? {};\n}\n\n/** Revisions every NIST-emitting mapping table has rows for. */\nexport const SUPPORTED_NIST_REVISIONS: readonly number[] = [4, 5];\n\nlet currentNistRevision = DEFAULT_NIST_REVISION;\n\n/** Get the module-global default NIST revision. */\nexport function getCurrentNistRevision(): number {\n  return currentNistRevision;\n}\n\n/**\n * Set the module-global default NIST revision. Throws (without mutating state)\n * if the revision has no mapping data.\n */\nexport function setCurrentNistRevision(rev: number): void {\n  if (!SUPPORTED_NIST_REVISIONS.includes(rev)) {\n    throw new Error(\n      `unsupported NIST revision ${rev} (supported: ${SUPPORTED_NIST_REVISIONS.join(', ')})`\n    );\n  }\n  currentNistRevision = rev;\n}\n\n/** Restore the default revision. Intended for cleanup and tests. */\nexport function resetNistRevision(): void {\n  currentNistRevision = DEFAULT_NIST_REVISION;\n}\n\nlet nistStrict = false;\n\n/** Report whether strict NIST revision alignment is enabled. */\nexport function isNistStrict(): boolean {\n  return nistStrict;\n}\n\n/**\n * Toggle strict NIST revision alignment. When enabled, revision-divergent\n * mappings treat a rule mapped only at another revision as a hard error rather\n * than a silent omission.\n */\nexport function setNistStrict(strict: boolean): void {\n  nistStrict = strict;\n}\n\n/**\n * Get the description for a NIST control ID at the selected revision.\n *\n * @param nistId - The NIST control ID, in any spelling normalizeNistId accepts\n *   ('AC-1', 'AC-01 a', 'AC-2 (1)', 'AC-02 01', ...)\n * @param rev - NIST revision to look up; defaults to the module-global revision\n * @returns The control's Rev-specific description, or undefined if not found at\n *   that revision (e.g. a Rev 5-only SR/PT control at Rev 4, or a Rev 4 control\n *   withdrawn in Rev 5)\n *\n * @example\n * ```typescript\n * getNISTDescription('AC-01');    // Rev 5 default -> \"Policy and Procedures\"\n * getNISTDescription('AC-1', 4);  // -> \"ACCESS CONTROL POLICY AND PROCEDURES\"\n * ```\n */\nexport function getNISTDescription(\n  nistId: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  const key = normalizeNistId(nistId);\n  return key === undefined ? undefined : descriptionsFor(rev)[key];\n}\n\n/**\n * Get all NIST control IDs present at the selected revision.\n *\n * @param rev - NIST revision to enumerate; defaults to the module-global revision\n * @returns Array of NIST control IDs for that revision (Rev 5 includes the\n *   SR/PT families; Rev 4 includes controls withdrawn in Rev 5)\n *\n * @example\n * ```typescript\n * const ids = getAllNISTIds();\n * // Returns: ['AC-01', 'AC-01 a', 'AC-02', ...]\n * ```\n */\nexport function getAllNISTIds(rev: number = getCurrentNistRevision()): string[] {\n  return Object.keys(descriptionsFor(rev));\n}\n\n/**\n * Check if a NIST control ID exists at the selected revision.\n *\n * @param nistId - The NIST control ID to check, in any spelling normalizeNistId\n *   accepts ('AC-2', 'AC-2(3)', 'AC-2 (3)', 'AC-02 03', 'AC-01 a 01', ...)\n * @param rev - NIST revision to check against; defaults to the module-global revision\n * @returns true if the control exists at that revision (e.g. an SR/PT control is\n *   present at Rev 5 but not Rev 4)\n *\n * @example\n * ```typescript\n * nistExists('AC-2 (3)');   // true\n * nistExists('SR-3', 4);    // false: the SR family is Rev 5-only\n * nistExists('SV-230221');  // false\n * ```\n */\nexport function nistExists(nistId: string, rev: number = getCurrentNistRevision()): boolean {\n  const key = normalizeNistId(nistId);\n  return key !== undefined && key in descriptionsFor(rev);\n}\n\n/**\n * Extract the NIST family from a NIST control ID, if that family exists at the\n * selected revision.\n *\n * @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a')\n * @param rev - NIST revision to validate against; defaults to the module-global revision\n * @returns The NIST family code (e.g., 'AC'), or undefined if invalid or the\n *   family is absent at that revision (the SR/PT families are Rev 5-only)\n *\n * @example\n * ```typescript\n * const family = getNISTFamily('AC-01');\n * // Returns: 'AC'\n *\n * const family2 = getNISTFamily('AC-01 a 01');\n * // Returns: 'AC'\n * ```\n */\nexport function getNISTFamily(\n  nistId: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  if (!nistId || typeof nistId !== 'string') {\n    return undefined;\n  }\n\n  // Extract family from format like \"AC-01\" or \"AC-01 a\"\n  const match = nistId.match(/^([A-Z]{2})-/);\n  if (!match) {\n    return undefined;\n  }\n\n  const family = match[1];\n\n  // Validate that this family exists at the selected revision by checking\n  // if any controls start with this family (the SR/PT families are Rev 5-only).\n  const familyPrefix = `${family}-`;\n  const hasFamily = Object.keys(descriptionsFor(rev)).some((key) => key.startsWith(familyPrefix));\n\n  return hasFamily ? family : undefined;\n}\n\n/**\n * Canonical NIST 800-53 fallback tags for converters when a finding has no\n * CWE or the CWE has no NIST mapping. Categories match heimdall2's global.ts.\n *\n * - SA-11: Developer Security Testing and Evaluation\n * - RA-5: Vulnerability Monitoring and Scanning\n * - SI-2: Flaw Remediation\n * - CM-8: System Component Inventory\n */\n\n/** Static analysis and vulnerability scanning tools (SA-11 + RA-5). */\nexport const DEFAULT_STATIC_ANALYSIS_NIST_TAGS: string[] = ['SA-11', 'RA-5'];\n\n/** Tools that identify outdated packages or flaws requiring patching (SI-2 + RA-5). */\nexport const DEFAULT_REMEDIATION_NIST_TAGS: string[] = ['SI-2', 'RA-5'];\n\n/** Dependency/inventory management tools (CM-8). */\nexport const DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS: string[] = ['CM-8'];\n\n/** Configuration-compliance checks with no specific mapping (CM-6: Configuration Settings). */\nexport const DEFAULT_CONFIG_MANAGEMENT_NIST_TAGS: string[] = ['CM-6'];\n\n// Rev 4 <-> Rev 5 crosswalk\nexport {\n  translateNistControl,\n  translateNistControls,\n  nistRosterSize,\n  nistControlsAtRevision,\n} from './crosswalk.js';\nexport type { NistControlTranslation, NistCrosswalkRelation } from './crosswalk.js';\n\n// Re-export types\nexport type { NISTDescriptions } from './types.js';\n","/**\n * CCI (Control Correlation Identifier) mapping functions\n */\n\nimport type { CCIMappings, NistCCIMappings } from './types.js';\nimport rawCCIData from '../data/cci-mappings.json';\nimport rawNistCCIData from '../data/nist-cci-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// The DISA CCI list's NIST references are Rev 4-era (they include Appendix J\n// privacy controls and SA-12/SA-19, all withdrawn or relocated in Rev 5).\n// getCCINistMappings translates to the current module-global revision.\nconst NATIVE_REVISION = 4;\n\nconst cciData = rawCCIData as CCIMappings;\nconst nistCCIData = rawNistCCIData as NistCCIMappings;\n\n/**\n * Get the definition/description for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns The CCI definition, or undefined if not found\n *\n * @example\n * ```typescript\n * const def = getCCIDescription('CCI-000001');\n * // Returns: \"The organization develops an access control policy...\"\n * ```\n */\nexport function getCCIDescription(cciId: string): string | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  return item?.def;\n}\n\n/**\n * Get the NIST control mappings for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns Array of NIST control references, or undefined if not found\n *\n * @example\n * ```typescript\n * const mappings = getCCINistMappings('CCI-000001');\n * // Returns: ['AC-1 a', 'AC-1.1 (i and ii)', 'AC-1 a 1']\n * ```\n */\nexport function getCCINistMappings(cciId: string): string[] | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  if (!item) return undefined;\n  return nistControlsAtRevision(item.nist, NATIVE_REVISION, getCurrentNistRevision());\n}\n\n/**\n * Get all CCI IDs available in the database.\n *\n * @returns Array of all CCI IDs\n *\n * @example\n * ```typescript\n * const ids = getAllCCIIds();\n * // Returns: ['CCI-000001', 'CCI-000002', ...]\n * ```\n */\nexport function getAllCCIIds(): string[] {\n  return Object.keys(cciData);\n}\n\n/**\n * Check if a CCI ID exists in the database.\n *\n * @param cciId - The CCI ID to check\n * @returns true if the CCI exists, false otherwise\n *\n * @example\n * ```typescript\n * if (cciExists('CCI-000001')) {\n *   console.log('CCI found');\n * }\n * ```\n */\nexport function cciExists(cciId: string): boolean {\n  if (!cciId || typeof cciId !== 'string') {\n    return false;\n  }\n\n  return cciId in cciData;\n}\n\n/**\n * Extract the base NIST control identifier from a potentially qualified string.\n * For example, \"SI-10 a 1\" → \"SI-10\", \"AC-3 (2)\" → \"AC-3\".\n */\nfunction baseNistControl(control: string): string {\n  const idx = control.search(/[ (.]/);\n  return idx === -1 ? control : control.slice(0, idx);\n}\n\n/**\n * Get CCI IDs for a NIST control using the curated mapping table.\n * The input is normalized to its base control before lookup.\n *\n * @param nistControl - NIST control string (e.g., 'SI-10', 'AC-3 (2)')\n * @returns Array of CCI IDs, or undefined if not found\n *\n * @example\n * ```typescript\n * const ccis = getNistCCIMappings('SI-10');\n * // Returns: ['CCI-001310']\n * ```\n */\nexport function getNistCCIMappings(nistControl: string): string[] | undefined {\n  if (!nistControl || typeof nistControl !== 'string') {\n    return undefined;\n  }\n  const base = baseNistControl(nistControl);\n  return nistCCIData[base];\n}\n\n/**\n * Map NIST 800-53 controls to their CCI IDs using the curated mapping table.\n * Results are deduplicated and sorted.\n *\n * @param nistControls - Array of NIST control strings\n * @returns Deduplicated, sorted array of CCI IDs (empty array if no mappings found)\n *\n * @example\n * ```typescript\n * const ccis = nistToCci(['AC-3', 'SI-10']);\n * // Returns: ['CCI-000213', 'CCI-001310']\n * ```\n */\nexport function nistToCci(nistControls: string[]): string[] {\n  const seen = new Set<string>();\n  for (const control of nistControls) {\n    const ccis = getNistCCIMappings(control);\n    if (ccis) {\n      for (const cciId of ccis) {\n        seen.add(cciId);\n      }\n    }\n  }\n  return Array.from(seen).sort();\n}\n\n// Re-export types\nexport type { CCIItem, CCIMappings, NistCCIMappings } from './types.js';\n","","/**\n * OWASP Top 10 to NIST mapping functions\n */\n\nimport type { OwaspNistMappings, OwaspNistMapping } from './types.js';\nimport rawOwaspData from '../data/owasp-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 4 (declared Rev: 4 in the data; every control it\n// carries is identical at both revisions today — a test guards that\n// invariant). Lookups translate to the current module-global revision.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst owaspData = rawOwaspData as OwaspNistMappings;\nconst owaspIndex = new Map<string, OwaspNistMapping>(\n  owaspData.map(item => [item['OWASP-ID'], item])\n);\n\n/**\n * Get the NIST mapping for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The mapping object, or undefined if not found\n *\n * @example\n * ```typescript\n * const mapping = getOwaspNistMapping('A1');\n * // Returns: { 'OWASP-ID': 'A1', 'OWASP Name': 'Injection', 'NIST-ID': 'SI-10', ... }\n * ```\n */\nexport function getOwaspNistMapping(owaspId: string): OwaspNistMapping | undefined {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return undefined;\n  }\n\n  return owaspIndex.get(owaspId);\n}\n\n/**\n * Get the NIST control ID for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The NIST control ID, or undefined if not found\n *\n * @example\n * ```typescript\n * const nistId = getOwaspNistControl('A1');\n * // Returns: 'SI-10'\n * ```\n */\nexport function getOwaspNistControl(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping ? atCurrentRevision(mapping['NIST-ID']) : undefined;\n}\n\n/**\n * Get the OWASP vulnerability name for an OWASP ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The OWASP vulnerability name, or undefined if not found\n *\n * @example\n * ```typescript\n * const name = getOwaspName('A1');\n * // Returns: 'Injection'\n * ```\n */\nexport function getOwaspName(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping?.['OWASP Name'];\n}\n\n/**\n * Get all OWASP IDs available in the database.\n *\n * @returns Array of all OWASP IDs\n *\n * @example\n * ```typescript\n * const ids = getAllOwaspIds();\n * // Returns: ['A1', 'A2', 'A3', ..., 'A10']\n * ```\n */\nexport function getAllOwaspIds(): string[] {\n  return Array.from(owaspIndex.keys());\n}\n\n/**\n * Check if an OWASP ID exists in the database.\n *\n * @param owaspId - The OWASP ID to check\n * @returns true if the OWASP ID exists, false otherwise\n *\n * @example\n * ```typescript\n * if (owaspExists('A1')) {\n *   console.log('OWASP ID found');\n * }\n * ```\n */\nexport function owaspExists(owaspId: string): boolean {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return false;\n  }\n\n  return owaspIndex.has(owaspId);\n}\n\n/**\n * Get all OWASP to NIST mappings.\n *\n * @returns Array of all mappings\n *\n * @example\n * ```typescript\n * const mappings = getAllOwaspMappings();\n * // Returns all 10 OWASP Top 10 mappings\n * ```\n */\nexport function getAllOwaspMappings(): OwaspNistMappings {\n  return owaspData;\n}\n\n// Re-export types\nexport type { OwaspNistMapping, OwaspNistMappings } from './types.js';\n","","/**\n * Query functions for CWE to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { CweNistMapping, CweNistMappings } from './types.js';\nimport { getCurrentNistRevision } from '../nist/index.js';\nimport rawMappings from '../data/cwe-nist-mappings.json';\n\nconst mappings = rawMappings as CweNistMappings;\n\n// revision → (CWE-ID → mapping)\nconst byRev = new Map<number, Map<number, CweNistMapping>>();\nfor (const m of mappings) {\n  let idx = byRev.get(m.Rev);\n  if (!idx) {\n    idx = new Map<number, CweNistMapping>();\n    byRev.set(m.Rev, idx);\n  }\n  idx.set(m['CWE-ID'], m);\n}\n\nfunction indexFor(rev: number): Map<number, CweNistMapping> {\n  return byRev.get(rev) ?? new Map<number, CweNistMapping>();\n}\n\n/** Get the full mapping for a CWE ID at the given NIST revision. */\nexport function getCweNistMapping(\n  cweId: number,\n  rev: number = getCurrentNistRevision()\n): CweNistMapping | undefined {\n  return indexFor(rev).get(cweId);\n}\n\n/** Get the NIST control ID for a CWE ID at the given NIST revision. */\nexport function getCweNistControl(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['NIST-ID'];\n}\n\n/** Get the CWE name for a CWE ID at the given NIST revision. */\nexport function getCweName(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['CWE Name'];\n}\n\n/** Get all CWE IDs present at the given NIST revision. */\nexport function getAllCweIds(rev: number = getCurrentNistRevision()): number[] {\n  return Array.from(indexFor(rev).keys());\n}\n\n/** Check whether a CWE ID exists at the given NIST revision. */\nexport function cweExists(cweId: number, rev: number = getCurrentNistRevision()): boolean {\n  return indexFor(rev).has(cweId);\n}\n\n/** Get all CWE to NIST mappings (all revisions). */\nexport function getAllCweMappings(): CweNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Checkov check ID to CCI/NIST mappings.\n *\n * The dataset is the JSON file the Go loader embeds (go/checkov/), imported\n * directly so both languages read one file; the bundler inlines it into dist.\n */\n\nimport type { CheckovCciNistMapping, CheckovMappingDataset, CheckovMappingProvenance } from './types.js';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\nimport rawDataset from '../../go/checkov/checkov-cci-nist-mappings.json';\n\nconst dataset = rawDataset as CheckovMappingDataset;\n\n// A Map, not the raw object, so ids like \"constructor\" never hit the prototype.\nconst byCheckId = new Map<string, CheckovCciNistMapping>(Object.entries(dataset.mappings));\n\n/**\n * Get the CCI and NIST controls for a Checkov check ID, with NIST controls\n * translated to the given revision. CCIs are revision-independent.\n * @returns copies of both lists, or undefined if the check is unmapped\n */\nexport function getCheckovCciNistMapping(\n  checkId: string,\n  rev: number = getCurrentNistRevision()\n): CheckovCciNistMapping | undefined {\n  const m = byCheckId.get(checkId);\n  if (!m) return undefined;\n  return {\n    cci: [...m.cci],\n    nist: nistControlsAtRevision([...m.nist], dataset.nistRevision, rev),\n  };\n}\n\n/** Check whether a Checkov check ID has a mapping. */\nexport function checkovCheckExists(checkId: string): boolean {\n  return byCheckId.has(checkId);\n}\n\n/** Get all mapped Checkov check IDs, sorted. */\nexport function getAllCheckovCheckIds(): string[] {\n  return Array.from(byCheckId.keys()).sort();\n}\n\n/** Get the dataset's source package, Checkov version and native NIST revision. */\nexport function getCheckovMappingProvenance(): CheckovMappingProvenance {\n  return {\n    source: { ...dataset.source },\n    checkovVersion: dataset.checkovVersion,\n    updated: dataset.updated,\n    nistRevision: dataset.nistRevision,\n  };\n}\n","","/**\n * Query functions for Nessus to NIST mappings\n */\n\nimport type { NessusNistMappings } from './types.js';\nimport rawMappings from '../data/nessus-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// The table was authored against NIST 800-53 Rev 4 (heimdall2's mapping; it\n// carries AU-8(1), withdrawn in Rev 5). Lookups translate to the current\n// module-global revision via the NIST crosswalk.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst mappings = rawMappings as NessusNistMappings;\n\n/**\n * Get the NIST control ID for a Nessus plugin family and plugin ID\n * @param pluginFamily - The Nessus plugin family\n * @param pluginId - The Nessus plugin ID (optional, defaults to \"*\")\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNessusNistControl(\n  pluginFamily: string,\n  pluginId = '*'\n): string | undefined {\n  // The mapping data carries numeric plugin IDs alongside the \"*\" wildcard, so\n  // compare on the string form — a strict === against the raw value never\n  // matches a scan's (string) plugin ID.\n  const exactMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === pluginId\n  );\n  if (exactMatch) {\n    return atCurrentRevision(exactMatch['NIST-ID']);\n  }\n\n  // Fall back to wildcard match\n  const wildcardMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === '*'\n  );\n  return wildcardMatch ? atCurrentRevision(wildcardMatch['NIST-ID']) : undefined;\n}\n\n/**\n * Get all mappings for a plugin family\n * @param pluginFamily - The Nessus plugin family\n * @returns Array of mappings for the plugin family\n */\nexport function getNessusPluginFamilyMappings(\n  pluginFamily: string\n): NessusNistMappings {\n  return mappings.filter((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all plugin families\n * @returns Array of all plugin families\n */\nexport function getAllNessusPluginFamilies(): string[] {\n  const families = new Set(mappings.map((m) => m.pluginFamily));\n  return Array.from(families);\n}\n\n/**\n * Check if a plugin family exists in the mappings\n * @param pluginFamily - The plugin family to check\n * @returns True if the plugin family exists\n */\nexport function nessusPluginFamilyExists(pluginFamily: string): boolean {\n  return mappings.some((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all Nessus to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllNessusMappings(): NessusNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Nikto to NIST mappings\n */\n\nimport type { NiktoNistMappings } from './types.js';\nimport rawMappings from '../data/nikto-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 4 (heimdall2's mapping; every control it carries is\n// identical at both revisions today — a test guards that invariant). Lookups\n// translate to the current module-global revision.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst mappings = rawMappings as NiktoNistMappings;\n\n/**\n * Get the NIST control ID for a Nikto test ID\n * @param niktoId - The Nikto test ID (string or number)\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNiktoNistControl(niktoId: string | number): string | undefined {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  const control = mappings[id];\n  return control === undefined ? undefined : atCurrentRevision(control);\n}\n\n/**\n * Get all Nikto test IDs\n * @returns Array of all Nikto test IDs\n */\nexport function getAllNiktoIds(): string[] {\n  return Object.keys(mappings);\n}\n\n/**\n * Check if a Nikto test ID exists in the mappings\n * @param niktoId - The Nikto test ID to check\n * @returns True if the Nikto test ID exists\n */\nexport function niktoExists(niktoId: string | number): boolean {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  return id in mappings;\n}\n\n/**\n * Get all Nikto to NIST mappings\n * @returns Object mapping Nikto test IDs to NIST control IDs\n */\nexport function getAllNiktoMappings(): NiktoNistMappings {\n  return { ...mappings };\n}\n","","/**\n * Query functions for ScoutSuite to NIST mappings\n */\n\nimport type { ScoutsuiteNistMapping, ScoutsuiteNistMappings } from './types.js';\nimport rawMappings from '../data/scoutsuite-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 4 (heimdall2's mapping; every control it carries is\n// identical at both revisions today — a test guards that invariant). Lookups\n// translate to the current module-global revision.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst mappings = rawMappings as ScoutsuiteNistMappings;\nconst indexByRule = new Map<string, ScoutsuiteNistMapping>(\n  mappings.map(m => [m.RULE, m])\n);\n\n/**\n * Get the full mapping for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The mapping object or undefined if not found\n */\nexport function getScoutsuiteNistMapping(rule: string): ScoutsuiteNistMapping | undefined {\n  return indexByRule.get(rule);\n}\n\n/**\n * Get the NIST control ID for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The NIST control ID or undefined if not found\n */\nexport function getScoutsuiteNistControl(rule: string): string | undefined {\n  const mapping = getScoutsuiteNistMapping(rule);\n  return mapping ? atCurrentRevision(mapping['NIST-ID']) : undefined;\n}\n\n/**\n * Get all ScoutSuite rule names\n * @returns Array of all rule names\n */\nexport function getAllScoutsuiteRules(): string[] {\n  return Array.from(indexByRule.keys());\n}\n\n/**\n * Check if a ScoutSuite rule exists in the mappings\n * @param rule - The rule name to check\n * @returns True if the rule exists\n */\nexport function scoutsuiteRuleExists(rule: string): boolean {\n  return indexByRule.has(rule);\n}\n\n/**\n * Get all ScoutSuite to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllScoutsuiteMappings(): ScoutsuiteNistMappings {\n  return [...mappings];\n}\n","","","/**\n * Query functions for AWS Config to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { AwsConfigNistMapping, AwsConfigNistMappings, AwsConfigSuppressions } from './types.js';\nimport { getCurrentNistRevision, SUPPORTED_NIST_REVISIONS } from '../nist/index.js';\nimport rawMappings from '../data/awsconfig-mappings.json';\nimport rawSuppressions from '../data/awsconfig-suppressions.json';\n\nconst mappings = rawMappings as AwsConfigNistMappings;\n\n/**\n * The maintainer-reviewed (rule, control) removals the generator applied to\n * the mapping table — exposed so a consumer can distinguish \"removed by\n * review\" from \"never mapped by the sources\".\n */\nexport const awsConfigSuppressions = rawSuppressions as AwsConfigSuppressions;\n\n// revision → (key → mapping), for both source-identifier and rule-name lookup\nconst byIdentifier = new Map<number, Map<string, AwsConfigNistMapping>>();\nconst byRuleName = new Map<number, Map<string, AwsConfigNistMapping>>();\nfor (const m of mappings) {\n  if (!byIdentifier.has(m.Rev)) {\n    byIdentifier.set(m.Rev, new Map());\n    byRuleName.set(m.Rev, new Map());\n  }\n  byIdentifier.get(m.Rev)!.set(m.AwsConfigRuleSourceIdentifier, m);\n  byRuleName.get(m.Rev)!.set(m.AwsConfigRuleName, m);\n}\n\nfunction idIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byIdentifier.get(rev) ?? new Map();\n}\nfunction nameIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byRuleName.get(rev) ?? new Map();\n}\n\n/** Get the full mapping for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistMappingByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return idIndex(rev).get(identifier);\n}\n\n/** Get the full mapping for an AWS Config rule by rule name. */\nexport function getAwsConfigNistMappingByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return nameIndex(rev).get(ruleName);\n}\n\n/** Get the NIST control ID for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistControlByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByIdentifier(identifier, rev)?.['NIST-ID'];\n}\n\n/** Get the NIST control ID for an AWS Config rule by rule name. */\nexport function getAwsConfigNistControlByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByName(ruleName, rev)?.['NIST-ID'];\n}\n\n/**\n * Resolve NIST controls for a decorated rule name such as Security Hub's\n * \"securityhub-<canonical>-<hash>\", where an exact lookup fails. Returns the\n * split controls of the canonical rule whose name is contained in the given\n * name; the longest such match wins. Returns [] if none match.\n */\nexport function getAwsConfigNistControlsBySubstring(\n  name: string,\n  rev: number = getCurrentNistRevision()\n): string[] {\n  if (!name) return [];\n  const lower = name.toLowerCase();\n  let best: AwsConfigNistMapping | undefined;\n  let bestLen = 0;\n  for (const [key, m] of nameIndex(rev)) {\n    if (key && key.length > bestLen && lower.includes(key.toLowerCase())) {\n      best = m;\n      bestLen = key.length;\n    }\n  }\n  if (!best) return [];\n  return best['NIST-ID']\n    .split('|')\n    .map((s) => s.trim())\n    .filter(Boolean);\n}\n\n/** Get all AWS Config rule source identifiers present at the given revision. */\nexport function getAllAwsConfigIdentifiers(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(idIndex(rev).keys());\n}\n\n/** Get all AWS Config rule names present at the given revision. */\nexport function getAllAwsConfigRuleNames(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(nameIndex(rev).keys());\n}\n\n/** Check if an AWS Config rule exists by source identifier at the given revision. */\nexport function awsConfigIdentifierExists(identifier: string, rev: number = getCurrentNistRevision()): boolean {\n  return idIndex(rev).has(identifier);\n}\n\n/** Check if an AWS Config rule exists by rule name at the given revision. */\nexport function awsConfigRuleNameExists(ruleName: string, rev: number = getCurrentNistRevision()): boolean {\n  return nameIndex(rev).has(ruleName);\n}\n\n/**\n * Get the supported NIST revisions at which the rule resolves (by source\n * identifier or rule name), sorted ascending. Mirrors the resolution\n * buildNistTags performs, so a revision is included exactly when a conversion\n * at that revision would emit NIST tags. Empty means unmapped everywhere — a\n * coverage gap, not a revision mismatch.\n */\nexport function awsConfigMappedRevisions(identifier: string, ruleName: string): number[] {\n  const revs: number[] = [];\n  for (const rev of SUPPORTED_NIST_REVISIONS) {\n    const byId = identifier ? getAwsConfigNistControlByIdentifier(identifier, rev) : undefined;\n    const byName = ruleName ? getAwsConfigNistControlByName(ruleName, rev) : undefined;\n    if (byId || byName) {\n      revs.push(rev);\n    }\n  }\n  return revs;\n}\n\n/** Get all AWS Config to NIST mappings (all revisions). */\nexport function getAllAwsConfigMappings(): AwsConfigNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Hipcheck analysis to NIST 800-53 Rev 5 mappings.\n *\n * The mapping is a hand-curated, RMF-reviewed table (Hipcheck publishes no\n * analysis-to-controls crosswalk). The data file is byte-identical to its Go\n * peer at hdf-mappings/go/hipcheck/hipcheck-nist-mappings.json.\n */\n\nimport type { HipcheckNistMapping, HipcheckNistMappings } from './types.js';\nimport rawMappings from '../data/hipcheck-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 5 (declared Rev: 5 in the data; it carries SR-family\n// controls that do not exist at Rev 4). Lookups translate to the current\n// module-global revision.\nconst NATIVE_REVISION = 5;\n\nconst mappings = rawMappings as HipcheckNistMappings;\n\nconst byAnalysis = new Map<string, HipcheckNistMapping>();\nfor (const m of mappings) {\n  byAnalysis.set(m.Analysis, m);\n}\n\n/**\n * Strip a plugin publisher prefix (\"mitre/binary\" -> \"binary\") so lookups key\n * on the analysis name regardless of publisher.\n */\nfunction bareName(analysis: string): string {\n  const i = analysis.lastIndexOf('/');\n  return i >= 0 ? analysis.slice(i + 1) : analysis;\n}\n\n/**\n * Get the NIST 800-53 controls for a Hipcheck analysis name.\n * Accepts bare (\"binary\") or publisher-prefixed (\"mitre/binary\") names.\n * @returns array of control IDs, or [] if the analysis has no mapping\n */\nexport function getHipcheckNistControls(analysis: string): string[] {\n  const m = byAnalysis.get(bareName(analysis));\n  if (!m) return [];\n  const controls = m['NIST-ID']\n    .split('|')\n    .map((s) => s.trim())\n    .filter(Boolean);\n  return nistControlsAtRevision(controls, NATIVE_REVISION, getCurrentNistRevision());\n}\n\n/** Check whether a Hipcheck analysis name has a NIST mapping. */\nexport function hipcheckAnalysisExists(analysis: string): boolean {\n  return byAnalysis.has(bareName(analysis));\n}\n\n/** Get all mapped Hipcheck analysis names, sorted. */\nexport function getAllHipcheckAnalyses(): string[] {\n  return Array.from(byAnalysis.keys()).sort();\n}\n\n/** Get all Hipcheck to NIST mappings. */\nexport function getAllHipcheckMappings(): HipcheckNistMappings {\n  return [...mappings];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AESA,MAAM,UAAU;AAChB,MAAM,gBAAgB;AAEtB,SAAS,UAAU,OAAuB;CACxC,OAAO,MAAM,KAAK,KAAK,IAAI,MAAM,SAAS,GAAG,GAAG,IAAI;AACtD;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,gBAAgB,QAAoC;CAClE,IAAI,OAAO,WAAW,UACpB;CAEF,MAAM,QAAQ,QAAQ,KAAK,MAAM;CACjC,IAAI,CAAC,OACH;CAEF,MAAM,GAAG,QAAQ,SAAS,SAAS;CACnC,MAAM,SAAS,MAAO,MAAM,aAAa,KAAK,CAAC;CAC/C,OAAO,CACL,GAAG,OAAQ,YAAY,EAAE,GAAG,UAAU,OAAQ,KAC9C,GAAG,OAAO,KAAK,UAAU,UAAU,MAAM,YAAY,CAAC,CAAC,CACzD,CAAC,CAAC,KAAK,GAAG;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AIMA,MAAM,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAA;AAGjB,MAAM,wBAAQ,IAAI,IAAyC;AAC3D,KAAK,MAAM,KAAKD,YAAU;CACxB,IAAI,MAAM,MAAM,IAAI,EAAE,GAAG;CACzB,IAAI,CAAC,KAAK;EACR,sBAAM,IAAI,IAA4B;EACtC,MAAM,IAAI,EAAE,KAAK,GAAG;CACtB;CACA,IAAI,IAAI,EAAE,WAAW,CAAC;AACxB;AAEA,SAAS,SAAS,KAA0C;CAC1D,OAAO,MAAM,IAAI,GAAG,qBAAK,IAAI,IAA4B;AAC3D;;AAGA,SAAgB,kBACd,OACA,MAAc,uBAAuB,GACT;CAC5B,OAAO,SAAS,GAAG,CAAC,CAAC,IAAI,KAAK;AAChC;;AAGA,SAAgB,kBAAkB,OAAe,MAAc,uBAAuB,GAAuB;CAC3G,OAAO,kBAAkB,OAAO,GAAG,CAAC,GAAG;AACzC;;AAGA,SAAgB,WAAW,OAAe,MAAc,uBAAuB,GAAuB;CACpG,OAAO,kBAAkB,OAAO,GAAG,CAAC,GAAG;AACzC;;AAGA,SAAgB,aAAa,MAAc,uBAAuB,GAAa;CAC7E,OAAO,MAAM,KAAK,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC;AACxC;;AAGA,SAAgB,UAAU,OAAe,MAAc,uBAAuB,GAAY;CACxF,OAAO,SAAS,GAAG,CAAC,CAAC,IAAI,KAAK;AAChC;;AAGA,SAAgB,oBAAqC;CACnD,OAAO,CAAC,GAAGA,UAAQ;AACrB;;;AEhDA,MAAM,UAAUE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AEpEA,MAAME,oBAAkB;AACxB,MAAMC,uBAAqB,WACzB,uBAAuB,OAAO,MAAM,GAAG,GAAGD,mBAAiB,uBAAuB,CAAC,CAAC,CAAC,KAAK,GAAG;AAE/F,MAAME,aAAWC;;;;;;AAOjB,SAAgB,oBAAoB,SAA8C;CAChF,MAAM,KAAK,OAAO,YAAY,WAAW,QAAQ,SAAS,IAAI;CAC9D,MAAM,UAAUD,WAAS;CACzB,OAAO,YAAY,KAAA,IAAY,KAAA,IAAYD,oBAAkB,OAAO;AACtE;;;;;AAMA,SAAgB,iBAA2B;CACzC,OAAO,OAAO,KAAKC,UAAQ;AAC7B;;;;;;AAOA,SAAgB,YAAY,SAAmC;CAE7D,QADW,OAAO,YAAY,WAAW,QAAQ,SAAS,IAAI,YACjDA;AACf;;;;;AAMA,SAAgB,sBAAyC;CACvD,OAAO,EAAE,GAAGA,WAAS;AACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AEzCA,MAAME,oBAAkB;AACxB,MAAM,qBAAqB,WACzB,uBAAuB,OAAO,MAAM,GAAG,GAAGA,mBAAiB,uBAAuB,CAAC,CAAC,CAAC,KAAK,GAAG;AAE/F,MAAMC,aAAWC;AACjB,MAAM,cAAc,IAAI,IACtBD,WAAS,KAAI,MAAK,CAAC,EAAE,MAAM,CAAC,CAAC,CAC/B;;;;;;AAOA,SAAgB,yBAAyB,MAAiD;CACxF,OAAO,YAAY,IAAI,IAAI;AAC7B;;;;;;AAOA,SAAgB,yBAAyB,MAAkC;CACzE,MAAM,UAAU,yBAAyB,IAAI;CAC7C,OAAO,UAAU,kBAAkB,QAAQ,UAAU,IAAI,KAAA;AAC3D;;;;;AAMA,SAAgB,wBAAkC;CAChD,OAAO,MAAM,KAAK,YAAY,KAAK,CAAC;AACtC;;;;;;AAOA,SAAgB,qBAAqB,MAAuB;CAC1D,OAAO,YAAY,IAAI,IAAI;AAC7B;;;;;AAMA,SAAgB,2BAAmD;CACjE,OAAO,CAAC,GAAGA,UAAQ;AACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"index.js","names":["rawCrosswalk","rawNistDataRev4","rawNistDataRev5","NATIVE_REVISION","rawCCIData","rawNistCCIData","NATIVE_REVISION","atCurrentRevision","rawOwaspData","mappings","rawMappings","dataset","rawDataset","NATIVE_REVISION","atCurrentRevision","mappings","rawMappings","NATIVE_REVISION","atCurrentRevision","mappings","rawMappings","NATIVE_REVISION","mappings","rawMappings","mappings","rawMappings","rawSuppressions","mappings","rawMappings","rawDataset"],"sources":["../src/data/cci-mappings.json","../src/data/nist-cci-mappings.json","../src/nist/normalize.ts","../go/nist/nist-descriptions.json","../go/nist/nist-descriptions-rev5.json","../src/data/nist-revision-crosswalk.json","../src/nist/crosswalk.ts","../src/nist/index.ts","../src/cci/index.ts","../src/data/owasp-nist-mappings.json","../src/owasp/index.ts","../src/data/cwe-nist-mappings.json","../src/cwe/index.ts","../go/checkov/checkov-cci-nist-mappings.json","../src/checkov/index.ts","../src/data/nessus-nist-mappings.json","../src/nessus/index.ts","../src/data/nikto-nist-mappings.json","../src/nikto/index.ts","../src/data/scoutsuite-nist-mappings.json","../src/scoutsuite/index.ts","../src/data/awsconfig-mappings.json","../src/data/awsconfig-suppressions.json","../src/awsconfig/index.ts","../src/data/hipcheck-nist-mappings.json","../src/hipcheck/index.ts","../go/hadolint/hadolint-nist-mappings.json","../src/hadolint/index.ts"],"sourcesContent":["","","/**\n * NIST SP 800-53 identifier spelling normalization.\n *\n * Mirrors NormalizeID in go/nist/exists.go; both are pinned by the shared case\n * table go/nist/testdata/nist-id-spelling-cases.json.\n */\n\n// Family, control number, then any run of enhancement numbers or statement\n// letters, each written as \" 3\", \"(3)\" or \" (3)\", in any letter case. Keep identical to the Go pattern.\nconst NIST_ID = /^([A-Za-z]{2})-(\\d{1,2})((?: ?\\((?:\\d{1,2}|[A-Za-z])\\)| (?:\\d{1,2}|[A-Za-z]))*)$/;\nconst NIST_ID_TOKEN = /\\d+|[A-Za-z]/g;\n\nfunction padNumber(token: string): string {\n  return /^\\d/.test(token) ? token.padStart(2, '0') : token;\n}\n\n/**\n * Normalize a NIST SP 800-53 identifier to the description-table spelling:\n * uppercase family, lowercase statement letters, zero-padded numbers and\n * space-separated parts.\n *\n * @param nistId - An identifier such as 'AC-2', 'AC-2(3)', 'AC-2 (3)', 'AC-02 03', 'AC-1 a 1' or 'ac-2'\n * @returns The table spelling (e.g. 'AC-02 03'), or undefined if the input is not\n *   a NIST identifier spelling. A defined result is not proof NIST defines the\n *   control; use nistExists for that.\n *\n * @example\n * ```typescript\n * normalizeNistId('AC-2 (3)');  // 'AC-02 03'\n * normalizeNistId('AC-2(3)(a)'); // 'AC-02 03 a'\n * normalizeNistId('SV-230221'); // undefined\n * ```\n */\nexport function normalizeNistId(nistId: string): string | undefined {\n  if (typeof nistId !== 'string') {\n    return undefined;\n  }\n  const match = NIST_ID.exec(nistId);\n  if (!match) {\n    return undefined;\n  }\n  const [, family, control, parts] = match;\n  const tokens = parts!.match(NIST_ID_TOKEN) ?? [];\n  return [\n    `${family!.toUpperCase()}-${padNumber(control!)}`,\n    ...tokens.map((token) => padNumber(token.toLowerCase())),\n  ].join(' ');\n}\n","","","","/**\n * NIST SP 800-53 Rev 4 <-> Rev 5 control crosswalk, generated from NIST's own\n * comparison workbooks (see scripts/generate-nist-crosswalk.mjs). Identity is\n * implicit: a control present in both revisions translates to itself; edges\n * cover only non-identity cases (withdrawn, moved, incorporated, Appendix J\n * pointers, and controls new in Rev 5).\n */\n\nimport rawCrosswalk from '../data/nist-revision-crosswalk.json';\n\n/**\n * Relations a translation can carry. `identity` means the control exists at\n * both revisions under the same ID; `moved`/`incorporated`/`pointer`/`family`\n * come from NIST's comparison workbooks; `none` means NIST names no successor;\n * `unknown` means the control is not part of the source revision's catalog (or\n * the revision pair is unsupported).\n */\nexport type NistCrosswalkRelation =\n  | 'identity'\n  | 'moved'\n  | 'incorporated'\n  | 'pointer'\n  | 'family'\n  | 'none'\n  | 'unknown';\n\nexport interface NistControlTranslation {\n  control: string;\n  targets: string[];\n  relation: NistCrosswalkRelation;\n  /**\n   * Set only for relation `family` (\"incorporated into <XX> family\"): a\n   * marker, deliberately never expanded into member controls.\n   */\n  family?: string;\n  /** NIST's raw comparison text for redirects. */\n  detail?: string;\n}\n\ninterface CrosswalkEdge {\n  from: number;\n  control: string;\n  targets: string[];\n  relation: string;\n  family?: string;\n  detail: string;\n}\n\ninterface CrosswalkFile {\n  rosters: Record<string, string[]>;\n  edges: CrosswalkEdge[];\n}\n\nconst crosswalk = rawCrosswalk as unknown as CrosswalkFile;\n\nconst rosters = new Map<number, Set<string>>(\n  Object.entries(crosswalk.rosters).map(([rev, ids]) => [Number(rev), new Set(ids)])\n);\n\nconst edges = new Map<number, Map<string, CrosswalkEdge>>();\nfor (const edge of crosswalk.edges) {\n  let byControl = edges.get(edge.from);\n  if (!byControl) {\n    byControl = new Map();\n    edges.set(edge.from, byControl);\n  }\n  byControl.set(edge.control, edge);\n}\n\nconst SUPPORTED = new Set([4, 5]);\n/** A trailing single-letter statement part, e.g. \"AC-2(j)\". */\nconst STATEMENT_LETTER = /^(.*)\\(([a-z])\\)$/;\n\nfunction fromEdge(control: string, edge: CrosswalkEdge): NistControlTranslation {\n  const tr: NistControlTranslation = {\n    control,\n    targets: [...edge.targets],\n    relation: edge.relation as NistCrosswalkRelation,\n    detail: edge.detail,\n  };\n  if (edge.family) tr.family = edge.family;\n  return tr;\n}\n\nfunction identity(control: string): NistControlTranslation {\n  return { control, targets: [control], relation: 'identity' };\n}\n\n/**\n * Translates one NIST control ID between 800-53 revisions 4 and 5. A control\n * present in both revisions translates to itself (identity); withdrawn, moved,\n * incorporated, and Appendix J controls follow NIST's published successors; a\n * control with no equivalent at the target revision gets relation `none` and\n * no targets. Statement-letter suffixes (\"AC-2(j)\") survive identity\n * translation and are dropped on redirects.\n */\nexport function translateNistControl(\n  control: string,\n  from: number,\n  to: number\n): NistControlTranslation {\n  if (!control || !SUPPORTED.has(from) || !SUPPORTED.has(to)) {\n    return { control, targets: [], relation: 'unknown' };\n  }\n  if (from === to) return identity(control);\n\n  const edge = edges.get(from)?.get(control);\n  if (edge) return fromEdge(control, edge);\n  if (rosters.get(from)?.has(control) && rosters.get(to)?.has(control)) {\n    return identity(control);\n  }\n\n  const base = STATEMENT_LETTER.exec(control)?.[1];\n  if (base) {\n    const baseEdge = edges.get(from)?.get(base);\n    if (baseEdge) return fromEdge(control, baseEdge);\n    if (rosters.get(from)?.has(base) && rosters.get(to)?.has(base)) {\n      return identity(control);\n    }\n  }\n  return { control, targets: [], relation: 'unknown' };\n}\n\n/**\n * Translates a list of control IDs between revisions, flattening redirect\n * targets and deduplicating while preserving first-seen order. Controls with\n * no target at the destination revision (withdrawn without successor,\n * family-level, or unknown) are returned in `unmapped`, in input order, so\n * callers can surface them instead of silently dropping.\n */\nexport function translateNistControls(\n  controls: string[],\n  from: number,\n  to: number\n): { translated: string[]; unmapped: NistControlTranslation[] } {\n  const translated: string[] = [];\n  const unmapped: NistControlTranslation[] = [];\n  const seen = new Set<string>();\n  for (const control of controls) {\n    const tr = translateNistControl(control, from, to);\n    if (tr.targets.length === 0) {\n      unmapped.push(tr);\n      continue;\n    }\n    for (const target of tr.targets) {\n      if (!seen.has(target)) {\n        seen.add(target);\n        translated.push(target);\n      }\n    }\n  }\n  return { translated, unmapped };\n}\n\n/**\n * Number of control IDs in the crosswalk's catalog for the given revision, or\n * 0 for unsupported revisions.\n */\nexport function nistRosterSize(rev: number): number {\n  return rosters.get(rev)?.size ?? 0;\n}\n\n/**\n * A NIST-shaped base at the start of a longer reference, e.g. \"AC-1 a\",\n * \"AC-1.2 (i)\", \"SA-12 b 1\" — DISA-CCI statement-reference styles.\n */\nconst BASE_CONTROL = /^([A-Z]{2}-\\d+(?:\\(\\d+\\))?)/;\n\n/**\n * Translates a control list authored against `nativeRev` into `rev`. Identity\n * when the revisions are equal (or either is unsupported). Per token: the\n * crosswalk redirect is followed when one exists; statement-style suffixes\n * (\"AC-1 a\", \"AC-1.2 (i)\") are kept on identity and dropped on redirects;\n * tokens with no equivalent at the target revision are dropped (the analog of\n * the awsconfig empty-NIST-ID marker); tokens outside both NIST catalogs\n * (tool placeholders like \"UM-1\") pass through unchanged — they are not ours\n * to drop. Output is deduplicated preserving first-seen order.\n */\nexport function nistControlsAtRevision(\n  controls: string[],\n  nativeRev: number,\n  rev: number\n): string[] {\n  if (nativeRev === rev || !SUPPORTED.has(nativeRev) || !SUPPORTED.has(rev)) {\n    return controls;\n  }\n  const seen = new Set<string>();\n  const out: string[] = [];\n  const add = (c: string): void => {\n    if (c && !seen.has(c)) {\n      seen.add(c);\n      out.push(c);\n    }\n  };\n  for (const c of controls) {\n    const tr = translateNistControl(c, nativeRev, rev);\n    if (tr.relation !== 'unknown') {\n      tr.targets.forEach(add);\n      continue;\n    }\n    const base = BASE_CONTROL.exec(c)?.[1];\n    if (base && base !== c) {\n      const btr = translateNistControl(base, nativeRev, rev);\n      if (btr.relation === 'identity') {\n        add(c);\n        continue;\n      }\n      if (btr.relation !== 'unknown') {\n        btr.targets.forEach(add);\n        continue;\n      }\n    }\n    add(c);\n  }\n  return out;\n}\n","/**\n * NIST SP 800-53 control description functions\n */\n\nimport type { NISTDescriptions } from './types.js';\nimport { normalizeNistId } from './normalize.js';\n// The JSON files the Go nist package embeds, imported so both languages read one copy.\nimport rawNistDataRev4 from '../../go/nist/nist-descriptions.json';\nimport rawNistDataRev5 from '../../go/nist/nist-descriptions-rev5.json';\n\nexport { normalizeNistId };\n\n// Descriptions are revision-specific: Rev 5 renamed titles (\"... POLICY AND\n// PROCEDURES\" -> \"Policy and Procedures\"), added the SR and PT families, and\n// withdrew Rev 4 controls (AU-15, IR-10, SA-12, ...). Each revision has its own\n// dataset; lookups select by the (optionally overridden) global revision.\nconst nistDataByRev: Record<number, NISTDescriptions> = {\n  4: rawNistDataRev4 as NISTDescriptions,\n  5: rawNistDataRev5 as NISTDescriptions,\n};\n\n/**\n * NIST SP 800-53 revision selection.\n *\n * The revision is a module-global default that every NIST-emitting mapping\n * consults through its default lookups. Set it once at startup (the CLI's\n * `--nist-rev` flag does this) to switch the catalog all converters target.\n * For explicit, side-effect-free per-call selection, pass an explicit `rev` to\n * the mapping lookups instead of mutating this.\n */\n\n/** The revision mappings emit when nothing overrides it. */\nexport const DEFAULT_NIST_REVISION = 5;\n\n/**\n * The description dataset for a revision, falling back to the default revision's\n * data (then an empty set) for an unsupported revision.\n */\nfunction descriptionsFor(rev: number): NISTDescriptions {\n  return nistDataByRev[rev] ?? nistDataByRev[DEFAULT_NIST_REVISION] ?? {};\n}\n\n/** Revisions every NIST-emitting mapping table has rows for. */\nexport const SUPPORTED_NIST_REVISIONS: readonly number[] = [4, 5];\n\nlet currentNistRevision = DEFAULT_NIST_REVISION;\n\n/** Get the module-global default NIST revision. */\nexport function getCurrentNistRevision(): number {\n  return currentNistRevision;\n}\n\n/**\n * Set the module-global default NIST revision. Throws (without mutating state)\n * if the revision has no mapping data.\n */\nexport function setCurrentNistRevision(rev: number): void {\n  if (!SUPPORTED_NIST_REVISIONS.includes(rev)) {\n    throw new Error(\n      `unsupported NIST revision ${rev} (supported: ${SUPPORTED_NIST_REVISIONS.join(', ')})`\n    );\n  }\n  currentNistRevision = rev;\n}\n\n/** Restore the default revision. Intended for cleanup and tests. */\nexport function resetNistRevision(): void {\n  currentNistRevision = DEFAULT_NIST_REVISION;\n}\n\nlet nistStrict = false;\n\n/** Report whether strict NIST revision alignment is enabled. */\nexport function isNistStrict(): boolean {\n  return nistStrict;\n}\n\n/**\n * Toggle strict NIST revision alignment. When enabled, revision-divergent\n * mappings treat a rule mapped only at another revision as a hard error rather\n * than a silent omission.\n */\nexport function setNistStrict(strict: boolean): void {\n  nistStrict = strict;\n}\n\n/**\n * Get the description for a NIST control ID at the selected revision.\n *\n * @param nistId - The NIST control ID, in any spelling normalizeNistId accepts\n *   ('AC-1', 'AC-01 a', 'AC-2 (1)', 'AC-02 01', ...)\n * @param rev - NIST revision to look up; defaults to the module-global revision\n * @returns The control's Rev-specific description, or undefined if not found at\n *   that revision (e.g. a Rev 5-only SR/PT control at Rev 4, or a Rev 4 control\n *   withdrawn in Rev 5)\n *\n * @example\n * ```typescript\n * getNISTDescription('AC-01');    // Rev 5 default -> \"Policy and Procedures\"\n * getNISTDescription('AC-1', 4);  // -> \"ACCESS CONTROL POLICY AND PROCEDURES\"\n * ```\n */\nexport function getNISTDescription(\n  nistId: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  const key = normalizeNistId(nistId);\n  return key === undefined ? undefined : descriptionsFor(rev)[key];\n}\n\n/**\n * Get all NIST control IDs present at the selected revision.\n *\n * @param rev - NIST revision to enumerate; defaults to the module-global revision\n * @returns Array of NIST control IDs for that revision (Rev 5 includes the\n *   SR/PT families; Rev 4 includes controls withdrawn in Rev 5)\n *\n * @example\n * ```typescript\n * const ids = getAllNISTIds();\n * // Returns: ['AC-01', 'AC-01 a', 'AC-02', ...]\n * ```\n */\nexport function getAllNISTIds(rev: number = getCurrentNistRevision()): string[] {\n  return Object.keys(descriptionsFor(rev));\n}\n\n/**\n * Check if a NIST control ID exists at the selected revision.\n *\n * @param nistId - The NIST control ID to check, in any spelling normalizeNistId\n *   accepts ('AC-2', 'AC-2(3)', 'AC-2 (3)', 'AC-02 03', 'AC-01 a 01', ...)\n * @param rev - NIST revision to check against; defaults to the module-global revision\n * @returns true if the control exists at that revision (e.g. an SR/PT control is\n *   present at Rev 5 but not Rev 4)\n *\n * @example\n * ```typescript\n * nistExists('AC-2 (3)');   // true\n * nistExists('SR-3', 4);    // false: the SR family is Rev 5-only\n * nistExists('SV-230221');  // false\n * ```\n */\nexport function nistExists(nistId: string, rev: number = getCurrentNistRevision()): boolean {\n  const key = normalizeNistId(nistId);\n  return key !== undefined && key in descriptionsFor(rev);\n}\n\n/**\n * Extract the NIST family from a NIST control ID, if that family exists at the\n * selected revision.\n *\n * @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a')\n * @param rev - NIST revision to validate against; defaults to the module-global revision\n * @returns The NIST family code (e.g., 'AC'), or undefined if invalid or the\n *   family is absent at that revision (the SR/PT families are Rev 5-only)\n *\n * @example\n * ```typescript\n * const family = getNISTFamily('AC-01');\n * // Returns: 'AC'\n *\n * const family2 = getNISTFamily('AC-01 a 01');\n * // Returns: 'AC'\n * ```\n */\nexport function getNISTFamily(\n  nistId: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  if (!nistId || typeof nistId !== 'string') {\n    return undefined;\n  }\n\n  // Extract family from format like \"AC-01\" or \"AC-01 a\"\n  const match = nistId.match(/^([A-Z]{2})-/);\n  if (!match) {\n    return undefined;\n  }\n\n  const family = match[1];\n\n  // Validate that this family exists at the selected revision by checking\n  // if any controls start with this family (the SR/PT families are Rev 5-only).\n  const familyPrefix = `${family}-`;\n  const hasFamily = Object.keys(descriptionsFor(rev)).some((key) => key.startsWith(familyPrefix));\n\n  return hasFamily ? family : undefined;\n}\n\n/**\n * Canonical NIST 800-53 fallback tags for converters when a finding has no\n * CWE or the CWE has no NIST mapping. Categories match heimdall2's global.ts.\n *\n * - SA-11: Developer Security Testing and Evaluation\n * - RA-5: Vulnerability Monitoring and Scanning\n * - SI-2: Flaw Remediation\n * - CM-8: System Component Inventory\n */\n\n/** Static analysis and vulnerability scanning tools (SA-11 + RA-5). */\nexport const DEFAULT_STATIC_ANALYSIS_NIST_TAGS: string[] = ['SA-11', 'RA-5'];\n\n/** Tools that identify outdated packages or flaws requiring patching (SI-2 + RA-5). */\nexport const DEFAULT_REMEDIATION_NIST_TAGS: string[] = ['SI-2', 'RA-5'];\n\n/** Dependency/inventory management tools (CM-8). */\nexport const DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS: string[] = ['CM-8'];\n\n/** Configuration-compliance checks with no specific mapping (CM-6: Configuration Settings). */\nexport const DEFAULT_CONFIG_MANAGEMENT_NIST_TAGS: string[] = ['CM-6'];\n\n// Rev 4 <-> Rev 5 crosswalk\nexport {\n  translateNistControl,\n  translateNistControls,\n  nistRosterSize,\n  nistControlsAtRevision,\n} from './crosswalk.js';\nexport type { NistControlTranslation, NistCrosswalkRelation } from './crosswalk.js';\n\n// Re-export types\nexport type { NISTDescriptions } from './types.js';\n","/**\n * CCI (Control Correlation Identifier) mapping functions\n */\n\nimport type { CCIMappings, NistCCIMappings } from './types.js';\nimport rawCCIData from '../data/cci-mappings.json';\nimport rawNistCCIData from '../data/nist-cci-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// The DISA CCI list's NIST references are Rev 4-era (they include Appendix J\n// privacy controls and SA-12/SA-19, all withdrawn or relocated in Rev 5).\n// getCCINistMappings translates to the current module-global revision.\nconst NATIVE_REVISION = 4;\n\nconst cciData = rawCCIData as CCIMappings;\nconst nistCCIData = rawNistCCIData as NistCCIMappings;\n\n/**\n * Get the definition/description for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns The CCI definition, or undefined if not found\n *\n * @example\n * ```typescript\n * const def = getCCIDescription('CCI-000001');\n * // Returns: \"The organization develops an access control policy...\"\n * ```\n */\nexport function getCCIDescription(cciId: string): string | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  return item?.def;\n}\n\n/**\n * Get the NIST control mappings for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns Array of NIST control references, or undefined if not found\n *\n * @example\n * ```typescript\n * const mappings = getCCINistMappings('CCI-000001');\n * // Returns: ['AC-1 a', 'AC-1.1 (i and ii)', 'AC-1 a 1']\n * ```\n */\nexport function getCCINistMappings(cciId: string): string[] | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  if (!item) return undefined;\n  return nistControlsAtRevision(item.nist, NATIVE_REVISION, getCurrentNistRevision());\n}\n\n/**\n * Get all CCI IDs available in the database.\n *\n * @returns Array of all CCI IDs\n *\n * @example\n * ```typescript\n * const ids = getAllCCIIds();\n * // Returns: ['CCI-000001', 'CCI-000002', ...]\n * ```\n */\nexport function getAllCCIIds(): string[] {\n  return Object.keys(cciData);\n}\n\n/**\n * Check if a CCI ID exists in the database.\n *\n * @param cciId - The CCI ID to check\n * @returns true if the CCI exists, false otherwise\n *\n * @example\n * ```typescript\n * if (cciExists('CCI-000001')) {\n *   console.log('CCI found');\n * }\n * ```\n */\nexport function cciExists(cciId: string): boolean {\n  if (!cciId || typeof cciId !== 'string') {\n    return false;\n  }\n\n  return cciId in cciData;\n}\n\n/**\n * Extract the base NIST control identifier from a potentially qualified string.\n * For example, \"SI-10 a 1\" → \"SI-10\", \"AC-3 (2)\" → \"AC-3\".\n */\nfunction baseNistControl(control: string): string {\n  const idx = control.search(/[ (.]/);\n  return idx === -1 ? control : control.slice(0, idx);\n}\n\n/**\n * Get CCI IDs for a NIST control using the curated mapping table.\n * The input is normalized to its base control before lookup.\n *\n * @param nistControl - NIST control string (e.g., 'SI-10', 'AC-3 (2)')\n * @returns Array of CCI IDs, or undefined if not found\n *\n * @example\n * ```typescript\n * const ccis = getNistCCIMappings('SI-10');\n * // Returns: ['CCI-001310']\n * ```\n */\nexport function getNistCCIMappings(nistControl: string): string[] | undefined {\n  if (!nistControl || typeof nistControl !== 'string') {\n    return undefined;\n  }\n  const base = baseNistControl(nistControl);\n  return nistCCIData[base];\n}\n\n/**\n * Map NIST 800-53 controls to their CCI IDs using the curated mapping table.\n * Results are deduplicated and sorted.\n *\n * @param nistControls - Array of NIST control strings\n * @returns Deduplicated, sorted array of CCI IDs (empty array if no mappings found)\n *\n * @example\n * ```typescript\n * const ccis = nistToCci(['AC-3', 'SI-10']);\n * // Returns: ['CCI-000213', 'CCI-001310']\n * ```\n */\nexport function nistToCci(nistControls: string[]): string[] {\n  const seen = new Set<string>();\n  for (const control of nistControls) {\n    const ccis = getNistCCIMappings(control);\n    if (ccis) {\n      for (const cciId of ccis) {\n        seen.add(cciId);\n      }\n    }\n  }\n  return Array.from(seen).sort();\n}\n\n// Re-export types\nexport type { CCIItem, CCIMappings, NistCCIMappings } from './types.js';\n","","/**\n * OWASP Top 10 to NIST mapping functions\n */\n\nimport type { OwaspNistMappings, OwaspNistMapping } from './types.js';\nimport rawOwaspData from '../data/owasp-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 4 (declared Rev: 4 in the data; every control it\n// carries is identical at both revisions today — a test guards that\n// invariant). Lookups translate to the current module-global revision.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst owaspData = rawOwaspData as OwaspNistMappings;\nconst owaspIndex = new Map<string, OwaspNistMapping>(\n  owaspData.map(item => [item['OWASP-ID'], item])\n);\n\n/**\n * Get the NIST mapping for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The mapping object, or undefined if not found\n *\n * @example\n * ```typescript\n * const mapping = getOwaspNistMapping('A1');\n * // Returns: { 'OWASP-ID': 'A1', 'OWASP Name': 'Injection', 'NIST-ID': 'SI-10', ... }\n * ```\n */\nexport function getOwaspNistMapping(owaspId: string): OwaspNistMapping | undefined {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return undefined;\n  }\n\n  return owaspIndex.get(owaspId);\n}\n\n/**\n * Get the NIST control ID for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The NIST control ID, or undefined if not found\n *\n * @example\n * ```typescript\n * const nistId = getOwaspNistControl('A1');\n * // Returns: 'SI-10'\n * ```\n */\nexport function getOwaspNistControl(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping ? atCurrentRevision(mapping['NIST-ID']) : undefined;\n}\n\n/**\n * Get the OWASP vulnerability name for an OWASP ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The OWASP vulnerability name, or undefined if not found\n *\n * @example\n * ```typescript\n * const name = getOwaspName('A1');\n * // Returns: 'Injection'\n * ```\n */\nexport function getOwaspName(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping?.['OWASP Name'];\n}\n\n/**\n * Get all OWASP IDs available in the database.\n *\n * @returns Array of all OWASP IDs\n *\n * @example\n * ```typescript\n * const ids = getAllOwaspIds();\n * // Returns: ['A1', 'A2', 'A3', ..., 'A10']\n * ```\n */\nexport function getAllOwaspIds(): string[] {\n  return Array.from(owaspIndex.keys());\n}\n\n/**\n * Check if an OWASP ID exists in the database.\n *\n * @param owaspId - The OWASP ID to check\n * @returns true if the OWASP ID exists, false otherwise\n *\n * @example\n * ```typescript\n * if (owaspExists('A1')) {\n *   console.log('OWASP ID found');\n * }\n * ```\n */\nexport function owaspExists(owaspId: string): boolean {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return false;\n  }\n\n  return owaspIndex.has(owaspId);\n}\n\n/**\n * Get all OWASP to NIST mappings.\n *\n * @returns Array of all mappings\n *\n * @example\n * ```typescript\n * const mappings = getAllOwaspMappings();\n * // Returns all 10 OWASP Top 10 mappings\n * ```\n */\nexport function getAllOwaspMappings(): OwaspNistMappings {\n  return owaspData;\n}\n\n// Re-export types\nexport type { OwaspNistMapping, OwaspNistMappings } from './types.js';\n","","/**\n * Query functions for CWE to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { CweNistMapping, CweNistMappings } from './types.js';\nimport { getCurrentNistRevision } from '../nist/index.js';\nimport rawMappings from '../data/cwe-nist-mappings.json';\n\nconst mappings = rawMappings as CweNistMappings;\n\n// revision → (CWE-ID → mapping)\nconst byRev = new Map<number, Map<number, CweNistMapping>>();\nfor (const m of mappings) {\n  let idx = byRev.get(m.Rev);\n  if (!idx) {\n    idx = new Map<number, CweNistMapping>();\n    byRev.set(m.Rev, idx);\n  }\n  idx.set(m['CWE-ID'], m);\n}\n\nfunction indexFor(rev: number): Map<number, CweNistMapping> {\n  return byRev.get(rev) ?? new Map<number, CweNistMapping>();\n}\n\n/** Get the full mapping for a CWE ID at the given NIST revision. */\nexport function getCweNistMapping(\n  cweId: number,\n  rev: number = getCurrentNistRevision()\n): CweNistMapping | undefined {\n  return indexFor(rev).get(cweId);\n}\n\n/** Get the NIST control ID for a CWE ID at the given NIST revision. */\nexport function getCweNistControl(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['NIST-ID'];\n}\n\n/** Get the CWE name for a CWE ID at the given NIST revision. */\nexport function getCweName(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['CWE Name'];\n}\n\n/** Get all CWE IDs present at the given NIST revision. */\nexport function getAllCweIds(rev: number = getCurrentNistRevision()): number[] {\n  return Array.from(indexFor(rev).keys());\n}\n\n/** Check whether a CWE ID exists at the given NIST revision. */\nexport function cweExists(cweId: number, rev: number = getCurrentNistRevision()): boolean {\n  return indexFor(rev).has(cweId);\n}\n\n/** Get all CWE to NIST mappings (all revisions). */\nexport function getAllCweMappings(): CweNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Checkov check ID to CCI/NIST mappings.\n *\n * The dataset is the JSON file the Go loader embeds (go/checkov/), imported\n * directly so both languages read one file; the bundler inlines it into dist.\n */\n\nimport type { CheckovCciNistMapping, CheckovMappingDataset, CheckovMappingProvenance } from './types.js';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\nimport rawDataset from '../../go/checkov/checkov-cci-nist-mappings.json';\n\nconst dataset = rawDataset as CheckovMappingDataset;\n\n// A Map, not the raw object, so ids like \"constructor\" never hit the prototype.\nconst byCheckId = new Map<string, CheckovCciNistMapping>(Object.entries(dataset.mappings));\n\n/**\n * Get the CCI and NIST controls for a Checkov check ID, with NIST controls\n * translated to the given revision. CCIs are revision-independent.\n * @returns copies of both lists, or undefined if the check is unmapped\n */\nexport function getCheckovCciNistMapping(\n  checkId: string,\n  rev: number = getCurrentNistRevision()\n): CheckovCciNistMapping | undefined {\n  const m = byCheckId.get(checkId);\n  if (!m) return undefined;\n  return {\n    cci: [...m.cci],\n    nist: nistControlsAtRevision([...m.nist], dataset.nistRevision, rev),\n  };\n}\n\n/** Check whether a Checkov check ID has a mapping. */\nexport function checkovCheckExists(checkId: string): boolean {\n  return byCheckId.has(checkId);\n}\n\n/** Get all mapped Checkov check IDs, sorted. */\nexport function getAllCheckovCheckIds(): string[] {\n  return Array.from(byCheckId.keys()).sort();\n}\n\n/** Get the dataset's source package, Checkov version and native NIST revision. */\nexport function getCheckovMappingProvenance(): CheckovMappingProvenance {\n  return {\n    source: { ...dataset.source },\n    checkovVersion: dataset.checkovVersion,\n    updated: dataset.updated,\n    nistRevision: dataset.nistRevision,\n  };\n}\n","","/**\n * Query functions for Nessus to NIST mappings\n */\n\nimport type { NessusNistMappings } from './types.js';\nimport rawMappings from '../data/nessus-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// The table was authored against NIST 800-53 Rev 4 (heimdall2's mapping; it\n// carries AU-8(1), withdrawn in Rev 5). Lookups translate to the current\n// module-global revision via the NIST crosswalk.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst mappings = rawMappings as NessusNistMappings;\n\n/**\n * Get the NIST control ID for a Nessus plugin family and plugin ID\n * @param pluginFamily - The Nessus plugin family\n * @param pluginId - The Nessus plugin ID (optional, defaults to \"*\")\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNessusNistControl(\n  pluginFamily: string,\n  pluginId = '*'\n): string | undefined {\n  // The mapping data carries numeric plugin IDs alongside the \"*\" wildcard, so\n  // compare on the string form — a strict === against the raw value never\n  // matches a scan's (string) plugin ID.\n  const exactMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === pluginId\n  );\n  if (exactMatch) {\n    return atCurrentRevision(exactMatch['NIST-ID']);\n  }\n\n  // Fall back to wildcard match\n  const wildcardMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === '*'\n  );\n  return wildcardMatch ? atCurrentRevision(wildcardMatch['NIST-ID']) : undefined;\n}\n\n/**\n * Get all mappings for a plugin family\n * @param pluginFamily - The Nessus plugin family\n * @returns Array of mappings for the plugin family\n */\nexport function getNessusPluginFamilyMappings(\n  pluginFamily: string\n): NessusNistMappings {\n  return mappings.filter((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all plugin families\n * @returns Array of all plugin families\n */\nexport function getAllNessusPluginFamilies(): string[] {\n  const families = new Set(mappings.map((m) => m.pluginFamily));\n  return Array.from(families);\n}\n\n/**\n * Check if a plugin family exists in the mappings\n * @param pluginFamily - The plugin family to check\n * @returns True if the plugin family exists\n */\nexport function nessusPluginFamilyExists(pluginFamily: string): boolean {\n  return mappings.some((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all Nessus to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllNessusMappings(): NessusNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Nikto to NIST mappings\n */\n\nimport type { NiktoNistMappings } from './types.js';\nimport rawMappings from '../data/nikto-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 4 (heimdall2's mapping; every control it carries is\n// identical at both revisions today — a test guards that invariant). Lookups\n// translate to the current module-global revision.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst mappings = rawMappings as NiktoNistMappings;\n\n/**\n * Get the NIST control ID for a Nikto test ID\n * @param niktoId - The Nikto test ID (string or number)\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNiktoNistControl(niktoId: string | number): string | undefined {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  const control = mappings[id];\n  return control === undefined ? undefined : atCurrentRevision(control);\n}\n\n/**\n * Get all Nikto test IDs\n * @returns Array of all Nikto test IDs\n */\nexport function getAllNiktoIds(): string[] {\n  return Object.keys(mappings);\n}\n\n/**\n * Check if a Nikto test ID exists in the mappings\n * @param niktoId - The Nikto test ID to check\n * @returns True if the Nikto test ID exists\n */\nexport function niktoExists(niktoId: string | number): boolean {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  return id in mappings;\n}\n\n/**\n * Get all Nikto to NIST mappings\n * @returns Object mapping Nikto test IDs to NIST control IDs\n */\nexport function getAllNiktoMappings(): NiktoNistMappings {\n  return { ...mappings };\n}\n","","/**\n * Query functions for ScoutSuite to NIST mappings\n */\n\nimport type { ScoutsuiteNistMapping, ScoutsuiteNistMappings } from './types.js';\nimport rawMappings from '../data/scoutsuite-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 4 (heimdall2's mapping; every control it carries is\n// identical at both revisions today — a test guards that invariant). Lookups\n// translate to the current module-global revision.\nconst NATIVE_REVISION = 4;\nconst atCurrentRevision = (nistId: string): string =>\n  nistControlsAtRevision(nistId.split('|'), NATIVE_REVISION, getCurrentNistRevision()).join('|');\n\nconst mappings = rawMappings as ScoutsuiteNistMappings;\nconst indexByRule = new Map<string, ScoutsuiteNistMapping>(\n  mappings.map(m => [m.RULE, m])\n);\n\n/**\n * Get the full mapping for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The mapping object or undefined if not found\n */\nexport function getScoutsuiteNistMapping(rule: string): ScoutsuiteNistMapping | undefined {\n  return indexByRule.get(rule);\n}\n\n/**\n * Get the NIST control ID for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The NIST control ID or undefined if not found\n */\nexport function getScoutsuiteNistControl(rule: string): string | undefined {\n  const mapping = getScoutsuiteNistMapping(rule);\n  return mapping ? atCurrentRevision(mapping['NIST-ID']) : undefined;\n}\n\n/**\n * Get all ScoutSuite rule names\n * @returns Array of all rule names\n */\nexport function getAllScoutsuiteRules(): string[] {\n  return Array.from(indexByRule.keys());\n}\n\n/**\n * Check if a ScoutSuite rule exists in the mappings\n * @param rule - The rule name to check\n * @returns True if the rule exists\n */\nexport function scoutsuiteRuleExists(rule: string): boolean {\n  return indexByRule.has(rule);\n}\n\n/**\n * Get all ScoutSuite to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllScoutsuiteMappings(): ScoutsuiteNistMappings {\n  return [...mappings];\n}\n","","","/**\n * Query functions for AWS Config to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { AwsConfigNistMapping, AwsConfigNistMappings, AwsConfigSuppressions } from './types.js';\nimport { getCurrentNistRevision, SUPPORTED_NIST_REVISIONS } from '../nist/index.js';\nimport rawMappings from '../data/awsconfig-mappings.json';\nimport rawSuppressions from '../data/awsconfig-suppressions.json';\n\nconst mappings = rawMappings as AwsConfigNistMappings;\n\n/**\n * The maintainer-reviewed (rule, control) removals the generator applied to\n * the mapping table — exposed so a consumer can distinguish \"removed by\n * review\" from \"never mapped by the sources\".\n */\nexport const awsConfigSuppressions = rawSuppressions as AwsConfigSuppressions;\n\n// revision → (key → mapping), for both source-identifier and rule-name lookup\nconst byIdentifier = new Map<number, Map<string, AwsConfigNistMapping>>();\nconst byRuleName = new Map<number, Map<string, AwsConfigNistMapping>>();\nfor (const m of mappings) {\n  if (!byIdentifier.has(m.Rev)) {\n    byIdentifier.set(m.Rev, new Map());\n    byRuleName.set(m.Rev, new Map());\n  }\n  byIdentifier.get(m.Rev)!.set(m.AwsConfigRuleSourceIdentifier, m);\n  byRuleName.get(m.Rev)!.set(m.AwsConfigRuleName, m);\n}\n\nfunction idIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byIdentifier.get(rev) ?? new Map();\n}\nfunction nameIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byRuleName.get(rev) ?? new Map();\n}\n\n/** Get the full mapping for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistMappingByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return idIndex(rev).get(identifier);\n}\n\n/** Get the full mapping for an AWS Config rule by rule name. */\nexport function getAwsConfigNistMappingByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return nameIndex(rev).get(ruleName);\n}\n\n/** Get the NIST control ID for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistControlByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByIdentifier(identifier, rev)?.['NIST-ID'];\n}\n\n/** Get the NIST control ID for an AWS Config rule by rule name. */\nexport function getAwsConfigNistControlByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByName(ruleName, rev)?.['NIST-ID'];\n}\n\n/**\n * Resolve NIST controls for a decorated rule name such as Security Hub's\n * \"securityhub-<canonical>-<hash>\", where an exact lookup fails. Returns the\n * split controls of the canonical rule whose name is contained in the given\n * name; the longest such match wins. Returns [] if none match.\n */\nexport function getAwsConfigNistControlsBySubstring(\n  name: string,\n  rev: number = getCurrentNistRevision()\n): string[] {\n  if (!name) return [];\n  const lower = name.toLowerCase();\n  let best: AwsConfigNistMapping | undefined;\n  let bestLen = 0;\n  for (const [key, m] of nameIndex(rev)) {\n    if (key && key.length > bestLen && lower.includes(key.toLowerCase())) {\n      best = m;\n      bestLen = key.length;\n    }\n  }\n  if (!best) return [];\n  return best['NIST-ID']\n    .split('|')\n    .map((s) => s.trim())\n    .filter(Boolean);\n}\n\n/** Get all AWS Config rule source identifiers present at the given revision. */\nexport function getAllAwsConfigIdentifiers(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(idIndex(rev).keys());\n}\n\n/** Get all AWS Config rule names present at the given revision. */\nexport function getAllAwsConfigRuleNames(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(nameIndex(rev).keys());\n}\n\n/** Check if an AWS Config rule exists by source identifier at the given revision. */\nexport function awsConfigIdentifierExists(identifier: string, rev: number = getCurrentNistRevision()): boolean {\n  return idIndex(rev).has(identifier);\n}\n\n/** Check if an AWS Config rule exists by rule name at the given revision. */\nexport function awsConfigRuleNameExists(ruleName: string, rev: number = getCurrentNistRevision()): boolean {\n  return nameIndex(rev).has(ruleName);\n}\n\n/**\n * Get the supported NIST revisions at which the rule resolves (by source\n * identifier or rule name), sorted ascending. Mirrors the resolution\n * buildNistTags performs, so a revision is included exactly when a conversion\n * at that revision would emit NIST tags. Empty means unmapped everywhere — a\n * coverage gap, not a revision mismatch.\n */\nexport function awsConfigMappedRevisions(identifier: string, ruleName: string): number[] {\n  const revs: number[] = [];\n  for (const rev of SUPPORTED_NIST_REVISIONS) {\n    const byId = identifier ? getAwsConfigNistControlByIdentifier(identifier, rev) : undefined;\n    const byName = ruleName ? getAwsConfigNistControlByName(ruleName, rev) : undefined;\n    if (byId || byName) {\n      revs.push(rev);\n    }\n  }\n  return revs;\n}\n\n/** Get all AWS Config to NIST mappings (all revisions). */\nexport function getAllAwsConfigMappings(): AwsConfigNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Hipcheck analysis to NIST 800-53 Rev 5 mappings.\n *\n * The mapping is a hand-curated, RMF-reviewed table (Hipcheck publishes no\n * analysis-to-controls crosswalk). The data file is byte-identical to its Go\n * peer at hdf-mappings/go/hipcheck/hipcheck-nist-mappings.json.\n */\n\nimport type { HipcheckNistMapping, HipcheckNistMappings } from './types.js';\nimport rawMappings from '../data/hipcheck-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 5 (declared Rev: 5 in the data; it carries SR-family\n// controls that do not exist at Rev 4). Lookups translate to the current\n// module-global revision.\nconst NATIVE_REVISION = 5;\n\nconst mappings = rawMappings as HipcheckNistMappings;\n\nconst byAnalysis = new Map<string, HipcheckNistMapping>();\nfor (const m of mappings) {\n  byAnalysis.set(m.Analysis, m);\n}\n\n/**\n * Strip a plugin publisher prefix (\"mitre/binary\" -> \"binary\") so lookups key\n * on the analysis name regardless of publisher.\n */\nfunction bareName(analysis: string): string {\n  const i = analysis.lastIndexOf('/');\n  return i >= 0 ? analysis.slice(i + 1) : analysis;\n}\n\n/**\n * Get the NIST 800-53 controls for a Hipcheck analysis name.\n * Accepts bare (\"binary\") or publisher-prefixed (\"mitre/binary\") names.\n * @returns array of control IDs, or [] if the analysis has no mapping\n */\nexport function getHipcheckNistControls(analysis: string): string[] {\n  const m = byAnalysis.get(bareName(analysis));\n  if (!m) return [];\n  const controls = m['NIST-ID']\n    .split('|')\n    .map((s) => s.trim())\n    .filter(Boolean);\n  return nistControlsAtRevision(controls, NATIVE_REVISION, getCurrentNistRevision());\n}\n\n/** Check whether a Hipcheck analysis name has a NIST mapping. */\nexport function hipcheckAnalysisExists(analysis: string): boolean {\n  return byAnalysis.has(bareName(analysis));\n}\n\n/** Get all mapped Hipcheck analysis names, sorted. */\nexport function getAllHipcheckAnalyses(): string[] {\n  return Array.from(byAnalysis.keys()).sort();\n}\n\n/** Get all Hipcheck to NIST mappings. */\nexport function getAllHipcheckMappings(): HipcheckNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for hadolint rule code to NIST mappings.\n *\n * One table covers both hadolint's own DL rules and the SC rules it surfaces\n * from its embedded shellcheck. The dataset is the JSON file the Go loader\n * embeds (go/hadolint/), imported directly so both languages read one file;\n * the bundler inlines it into dist.\n */\n\nimport type { HadolintMappingDataset, HadolintMappingProvenance, HadolintNistMapping } from './types.js';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\nimport rawDataset from '../../go/hadolint/hadolint-nist-mappings.json';\n\nconst dataset = rawDataset as HadolintMappingDataset;\n\n// A Map, not the raw object, so ids like \"constructor\" never hit the prototype.\nconst byRuleId = new Map<string, HadolintNistMapping>(Object.entries(dataset.mappings));\n\n/**\n * Get the NIST controls for a hadolint rule code, translated to the given\n * revision.\n *\n * A rule whose controls do not survive translation comes back mapped but with\n * an empty list — SR-4 has no Rev 4 equivalent — so a caller must treat an\n * empty list the same as an absent mapping and apply its own fallback.\n *\n * @returns a copy of the control list, or undefined if the rule is unmapped\n */\nexport function getHadolintNistMapping(\n  ruleId: string,\n  rev: number = getCurrentNistRevision()\n): HadolintNistMapping | undefined {\n  const m = byRuleId.get(ruleId);\n  if (!m) return undefined;\n  return {nist: nistControlsAtRevision([...m.nist], dataset.nistRevision, rev)};\n}\n\n/** Check whether a hadolint rule code has a mapping. */\nexport function hadolintRuleExists(ruleId: string): boolean {\n  return byRuleId.has(ruleId);\n}\n\n/** Get all mapped hadolint rule codes, sorted. */\nexport function getAllHadolintRuleIds(): string[] {\n  return [...byRuleId.keys()].sort();\n}\n\n/** Get the dataset's upstream source and native NIST revision. */\nexport function getHadolintMappingProvenance(): HadolintMappingProvenance {\n  return {\n    source: {...dataset.source},\n    updated: dataset.updated,\n    nistRevision: dataset.nistRevision,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AESA,MAAM,UAAU;AAChB,MAAM,gBAAgB;AAEtB,SAAS,UAAU,OAAuB;CACxC,OAAO,MAAM,KAAK,KAAK,IAAI,MAAM,SAAS,GAAG,GAAG,IAAI;AACtD;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,gBAAgB,QAAoC;CAClE,IAAI,OAAO,WAAW,UACpB;CAEF,MAAM,QAAQ,QAAQ,KAAK,MAAM;CACjC,IAAI,CAAC,OACH;CAEF,MAAM,GAAG,QAAQ,SAAS,SAAS;CACnC,MAAM,SAAS,MAAO,MAAM,aAAa,KAAK,CAAC;CAC/C,OAAO,CACL,GAAG,OAAQ,YAAY,EAAE,GAAG,UAAU,OAAQ,KAC9C,GAAG,OAAO,KAAK,UAAU,UAAU,MAAM,YAAY,CAAC,CAAC,CACzD,CAAC,CAAC,KAAK,GAAG;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AIMA,MAAM,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAA;AAGjB,MAAM,wBAAQ,IAAI,IAAyC;AAC3D,KAAK,MAAM,KAAKD,YAAU;CACxB,IAAI,MAAM,MAAM,IAAI,EAAE,GAAG;CACzB,IAAI,CAAC,KAAK;EACR,sBAAM,IAAI,IAA4B;EACtC,MAAM,IAAI,EAAE,KAAK,GAAG;CACtB;CACA,IAAI,IAAI,EAAE,WAAW,CAAC;AACxB;AAEA,SAAS,SAAS,KAA0C;CAC1D,OAAO,MAAM,IAAI,GAAG,qBAAK,IAAI,IAA4B;AAC3D;;AAGA,SAAgB,kBACd,OACA,MAAc,uBAAuB,GACT;CAC5B,OAAO,SAAS,GAAG,CAAC,CAAC,IAAI,KAAK;AAChC;;AAGA,SAAgB,kBAAkB,OAAe,MAAc,uBAAuB,GAAuB;CAC3G,OAAO,kBAAkB,OAAO,GAAG,CAAC,GAAG;AACzC;;AAGA,SAAgB,WAAW,OAAe,MAAc,uBAAuB,GAAuB;CACpG,OAAO,kBAAkB,OAAO,GAAG,CAAC,GAAG;AACzC;;AAGA,SAAgB,aAAa,MAAc,uBAAuB,GAAa;CAC7E,OAAO,MAAM,KAAK,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC;AACxC;;AAGA,SAAgB,UAAU,OAAe,MAAc,uBAAuB,GAAY;CACxF,OAAO,SAAS,GAAG,CAAC,CAAC,IAAI,KAAK;AAChC;;AAGA,SAAgB,oBAAqC;CACnD,OAAO,CAAC,GAAGA,UAAQ;AACrB;;;AEhDA,MAAME,YAAUC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mitre/hdf-mappings",
-  "version": "3.7.1",
+  "version": "3.7.2-rc.2",
   "description": "CCI/NIST/CIS/CMMC security framework mappings for HDF",
   "publishConfig": {
     "access": "public"
@@ -29,7 +29,7 @@
     "@stryker-mutator/vitest-runner": "^9.5.1"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
   "keywords": [
     "hdf",