@mitre/hdf-mappings 3.7.2 → 3.8.0-next.42532249979.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/index.d.ts +0 -48
  2. package/dist/index.d.ts.map +1 -1
  3. package/dist/index.js +61 -56
  4. package/dist/index.js.map +1 -1
  5. package/package.json +1 -1
package/dist/index.d.ts CHANGED
@@ -1,4 +1,3 @@
1
- //#region src/cci/types.d.ts
2
1
  /**
3
2
  * Represents a CCI (Control Correlation Identifier) item.
4
3
  */
@@ -17,8 +16,6 @@ type CCIMappings = Record<string, CCIItem>;
17
16
  * Keys are base NIST controls (e.g. "SA-11"), values are arrays of CCI IDs.
18
17
  */
19
18
  type NistCCIMappings = Record<string, string[]>;
20
- //#endregion
21
- //#region src/cci/index.d.ts
22
19
  /**
23
20
  * CCI (Control Correlation Identifier) mapping functions
24
21
  */
@@ -102,8 +99,6 @@ export declare function getNistCCIMappings(nistControl: string): string[] | unde
102
99
  * ```
103
100
  */
104
101
  export declare function nistToCci(nistControls: string[]): string[];
105
- //#endregion
106
- //#region src/nist/normalize.d.ts
107
102
  /**
108
103
  * NIST SP 800-53 identifier spelling normalization.
109
104
  *
@@ -128,8 +123,6 @@ export declare function nistToCci(nistControls: string[]): string[];
128
123
  * ```
129
124
  */
130
125
  export declare function normalizeNistId(nistId: string): string | undefined;
131
- //#endregion
132
- //#region src/nist/crosswalk.d.ts
133
126
  /**
134
127
  * NIST SP 800-53 Rev 4 <-> Rev 5 control crosswalk, generated from NIST's own
135
128
  * comparison workbooks (see scripts/generate-nist-crosswalk.mjs). Identity is
@@ -193,14 +186,10 @@ export declare function nistRosterSize(rev: number): number;
193
186
  * to drop. Output is deduplicated preserving first-seen order.
194
187
  */
195
188
  export declare function nistControlsAtRevision(controls: string[], nativeRev: number, rev: number): string[];
196
- //#endregion
197
- //#region src/nist/types.d.ts
198
189
  /**
199
190
  * NIST control descriptions database structure
200
191
  */
201
192
  type NISTDescriptions = Record<string, string>;
202
- //#endregion
203
- //#region src/nist/index.d.ts
204
193
  /**
205
194
  * NIST SP 800-53 revision selection.
206
195
  *
@@ -315,8 +304,6 @@ export declare const DEFAULT_REMEDIATION_NIST_TAGS: string[];
315
304
  export declare const DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS: string[];
316
305
  /** Configuration-compliance checks with no specific mapping (CM-6: Configuration Settings). */
317
306
  export declare const DEFAULT_CONFIG_MANAGEMENT_NIST_TAGS: string[];
318
- //#endregion
319
- //#region src/owasp/types.d.ts
320
307
  /**
321
308
  * TypeScript types for OWASP Top 10 to NIST mappings
322
309
  */
@@ -328,8 +315,6 @@ interface OwaspNistMapping {
328
315
  'NIST Name': string;
329
316
  }
330
317
  type OwaspNistMappings = OwaspNistMapping[];
331
- //#endregion
332
- //#region src/owasp/index.d.ts
333
318
  /**
334
319
  * Get the NIST mapping for an OWASP Top 10 ID.
335
320
  *
@@ -407,8 +392,6 @@ export declare function owaspExists(owaspId: string): boolean;
407
392
  * ```
408
393
  */
409
394
  export declare function getAllOwaspMappings(): OwaspNistMappings;
410
- //#endregion
411
- //#region src/cwe/types.d.ts
412
395
  /**
413
396
  * TypeScript types for CWE to NIST mappings
414
397
  */
@@ -420,8 +403,6 @@ interface CweNistMapping {
420
403
  'NIST Name': string;
421
404
  }
422
405
  type CweNistMappings = CweNistMapping[];
423
- //#endregion
424
- //#region src/cwe/index.d.ts
425
406
  /** Get the full mapping for a CWE ID at the given NIST revision. */
426
407
  export declare function getCweNistMapping(cweId: number, rev?: number): CweNistMapping | undefined;
427
408
  /** Get the NIST control ID for a CWE ID at the given NIST revision. */
@@ -434,8 +415,6 @@ export declare function getAllCweIds(rev?: number): number[];
434
415
  export declare function cweExists(cweId: number, rev?: number): boolean;
435
416
  /** Get all CWE to NIST mappings (all revisions). */
436
417
  export declare function getAllCweMappings(): CweNistMappings;
437
- //#endregion
438
- //#region src/checkov/types.d.ts
439
418
  /**
440
419
  * TypeScript types for Checkov check ID to CCI/NIST mappings
441
420
  */
@@ -459,8 +438,6 @@ interface CheckovMappingDataset extends CheckovMappingProvenance {
459
438
  $comment: string[];
460
439
  mappings: CheckovCciNistMappings;
461
440
  }
462
- //#endregion
463
- //#region src/checkov/index.d.ts
464
441
  /**
465
442
  * Get the CCI and NIST controls for a Checkov check ID, with NIST controls
466
443
  * translated to the given revision. CCIs are revision-independent.
@@ -473,8 +450,6 @@ export declare function checkovCheckExists(checkId: string): boolean;
473
450
  export declare function getAllCheckovCheckIds(): string[];
474
451
  /** Get the dataset's source package, Checkov version and native NIST revision. */
475
452
  export declare function getCheckovMappingProvenance(): CheckovMappingProvenance;
476
- //#endregion
477
- //#region src/nessus/types.d.ts
478
453
  /**
479
454
  * TypeScript types for Nessus to NIST mappings
480
455
  */
@@ -484,8 +459,6 @@ interface NessusNistMapping {
484
459
  'NIST-ID': string;
485
460
  }
486
461
  type NessusNistMappings = NessusNistMapping[];
487
- //#endregion
488
- //#region src/nessus/index.d.ts
489
462
  /**
490
463
  * Get the NIST control ID for a Nessus plugin family and plugin ID
491
464
  * @param pluginFamily - The Nessus plugin family
@@ -515,14 +488,10 @@ export declare function nessusPluginFamilyExists(pluginFamily: string): boolean;
515
488
  * @returns Array of all mappings
516
489
  */
517
490
  export declare function getAllNessusMappings(): NessusNistMappings;
518
- //#endregion
519
- //#region src/nikto/types.d.ts
520
491
  /**
521
492
  * TypeScript types for Nikto to NIST mappings
522
493
  */
523
494
  type NiktoNistMappings = Record<string, string>;
524
- //#endregion
525
- //#region src/nikto/index.d.ts
526
495
  /**
527
496
  * Get the NIST control ID for a Nikto test ID
528
497
  * @param niktoId - The Nikto test ID (string or number)
@@ -545,8 +514,6 @@ export declare function niktoExists(niktoId: string | number): boolean;
545
514
  * @returns Object mapping Nikto test IDs to NIST control IDs
546
515
  */
547
516
  export declare function getAllNiktoMappings(): NiktoNistMappings;
548
- //#endregion
549
- //#region src/scoutsuite/types.d.ts
550
517
  /**
551
518
  * TypeScript types for ScoutSuite to NIST mappings
552
519
  */
@@ -555,8 +522,6 @@ interface ScoutsuiteNistMapping {
555
522
  'NIST-ID': string;
556
523
  }
557
524
  type ScoutsuiteNistMappings = ScoutsuiteNistMapping[];
558
- //#endregion
559
- //#region src/scoutsuite/index.d.ts
560
525
  /**
561
526
  * Get the full mapping for a ScoutSuite rule
562
527
  * @param rule - The ScoutSuite rule name
@@ -585,8 +550,6 @@ export declare function scoutsuiteRuleExists(rule: string): boolean;
585
550
  * @returns Array of all mappings
586
551
  */
587
552
  export declare function getAllScoutsuiteMappings(): ScoutsuiteNistMappings;
588
- //#endregion
589
- //#region src/awsconfig/types.d.ts
590
553
  /**
591
554
  * TypeScript types for AWS Config to NIST mappings
592
555
  */
@@ -616,8 +579,6 @@ interface AwsConfigSuppression {
616
579
  revisions: number[];
617
580
  }
618
581
  type AwsConfigSuppressions = AwsConfigSuppression[];
619
- //#endregion
620
- //#region src/awsconfig/index.d.ts
621
582
  /**
622
583
  * The maintainer-reviewed (rule, control) removals the generator applied to
623
584
  * the mapping table — exposed so a consumer can distinguish "removed by
@@ -657,8 +618,6 @@ export declare function awsConfigRuleNameExists(ruleName: string, rev?: number):
657
618
  export declare function awsConfigMappedRevisions(identifier: string, ruleName: string): number[];
658
619
  /** Get all AWS Config to NIST mappings (all revisions). */
659
620
  export declare function getAllAwsConfigMappings(): AwsConfigNistMappings;
660
- //#endregion
661
- //#region src/hipcheck/types.d.ts
662
621
  /**
663
622
  * TypeScript types for Hipcheck analysis to NIST 800-53 mappings.
664
623
  */
@@ -669,8 +628,6 @@ interface HipcheckNistMapping {
669
628
  Rationale: string;
670
629
  }
671
630
  type HipcheckNistMappings = HipcheckNistMapping[];
672
- //#endregion
673
- //#region src/hipcheck/index.d.ts
674
631
  /**
675
632
  * Get the NIST 800-53 controls for a Hipcheck analysis name.
676
633
  * Accepts bare ("binary") or publisher-prefixed ("mitre/binary") names.
@@ -683,8 +640,6 @@ export declare function hipcheckAnalysisExists(analysis: string): boolean;
683
640
  export declare function getAllHipcheckAnalyses(): string[];
684
641
  /** Get all Hipcheck to NIST mappings. */
685
642
  export declare function getAllHipcheckMappings(): HipcheckNistMappings;
686
- //#endregion
687
- //#region src/hadolint/types.d.ts
688
643
  /**
689
644
  * TypeScript types for hadolint rule code to NIST mappings
690
645
  */
@@ -706,8 +661,6 @@ interface HadolintMappingDataset extends HadolintMappingProvenance {
706
661
  $comment: string[];
707
662
  mappings: HadolintNistMappings;
708
663
  }
709
- //#endregion
710
- //#region src/hadolint/index.d.ts
711
664
  /**
712
665
  * Get the NIST controls for a hadolint rule code, translated to the given
713
666
  * revision.
@@ -725,6 +678,5 @@ export declare function hadolintRuleExists(ruleId: string): boolean;
725
678
  export declare function getAllHadolintRuleIds(): string[];
726
679
  /** Get the dataset's upstream source and native NIST revision. */
727
680
  export declare function getHadolintMappingProvenance(): HadolintMappingProvenance;
728
- //#endregion
729
681
  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 };
730
682
  //# sourceMappingURL=index.d.ts.map
package/dist/index.d.ts.map CHANGED
@@ -1 +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","../src/hadolint/types.ts","../src/hadolint/index.ts"],"mappings":"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"}
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","../src/hadolint/types.ts","../src/hadolint/index.ts"],"mappings":"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"}
package/dist/index.js CHANGED
@@ -1,4 +1,4 @@
1
- //#region src/data/cci-mappings.json
1
+ // src/data/cci-mappings.json
2
2
  var cci_mappings_default = {
3
3
  "CCI-001545": {
4
4
  "def": "The organization defines a frequency for reviewing and updating the access control policy.",
@@ -18740,8 +18740,7 @@ var cci_mappings_default = {
18740
18740
  "nist": ["PL-9"]
18741
18741
  }
18742
18742
  };
18743
- //#endregion
18744
- //#region src/data/nist-cci-mappings.json
18743
+ // src/data/nist-cci-mappings.json
18745
18744
  var nist_cci_mappings_default = {
18746
18745
  "AC-3": ["CCI-000213"],
18747
18746
  "AC-4": ["CCI-001368", "CCI-001414"],
@@ -18769,8 +18768,7 @@ var nist_cci_mappings_default = {
18769
18768
  "SI-11": ["CCI-001312"],
18770
18769
  "SI-16": ["CCI-002824"]
18771
18770
  };
18772
- //#endregion
18773
- //#region src/nist/normalize.ts
18771
+ // src/nist/normalize.ts
18774
18772
  /**
18775
18773
  * NIST SP 800-53 identifier spelling normalization.
18776
18774
  *
@@ -18807,8 +18805,7 @@ function normalizeNistId(nistId) {
18807
18805
  const tokens = parts.match(NIST_ID_TOKEN) ?? [];
18808
18806
  return [`${family.toUpperCase()}-${padNumber(control)}`, ...tokens.map((token) => padNumber(token.toLowerCase()))].join(" ");
18809
18807
  }
18810
- //#endregion
18811
- //#region go/nist/nist-descriptions.json
18808
+ // go/nist/nist-descriptions.json
18812
18809
  var nist_descriptions_default = {
18813
18810
  "AC-01": "ACCESS CONTROL POLICY AND PROCEDURES",
18814
18811
  "AC-01 a": "Develops, documents, and disseminates to [Assignment: organization-defined personnel or roles]:",
@@ -20493,8 +20490,7 @@ var nist_descriptions_default = {
20493
20490
  "PM-15 c": "To share current security-related information including threats, vulnerabilities, and incidents.",
20494
20491
  "PM-16": "The organization implements a threat awareness program that includes a cross-organization information-sharing capability."
20495
20492
  };
20496
- //#endregion
20497
- //#region go/nist/nist-descriptions-rev5.json
20493
+ // go/nist/nist-descriptions-rev5.json
20498
20494
  var nist_descriptions_rev5_default = {
20499
20495
  "AC-01": "Policy and Procedures",
20500
20496
  "AC-01 a": "Develop, document, and disseminate to [Assignment: organization-defined personnel or roles]:",
@@ -22633,16 +22629,8 @@ var nist_descriptions_rev5_default = {
22633
22629
  "SR-11 b": "Report counterfeit system components to [Selection (one or more): source of counterfeit component; {{ insert: param, sr-11_odp.02 }} ; {{ insert: param, sr-11_odp.03 }} ].",
22634
22630
  "SR-12": "Dispose of [Assignment: data, documentation, tools, or system components] using the following techniques and methods: [Assignment: techniques and methods]."
22635
22631
  };
22636
- //#endregion
22637
- //#region src/nist/crosswalk.ts
22638
- /**
22639
- * NIST SP 800-53 Rev 4 <-> Rev 5 control crosswalk, generated from NIST's own
22640
- * comparison workbooks (see scripts/generate-nist-crosswalk.mjs). Identity is
22641
- * implicit: a control present in both revisions translates to itself; edges
22642
- * cover only non-identity cases (withdrawn, moved, incorporated, Appendix J
22643
- * pointers, and controls new in Rev 5).
22644
- */
22645
- const crosswalk = {
22632
+ // src/data/nist-revision-crosswalk.json
22633
+ var nist_revision_crosswalk_default = {
22646
22634
  $comment: "Generated by hdf-mappings/scripts/generate-nist-crosswalk.mjs from NIST SP 800-53 comparison workbooks. Do not hand-edit; rerun the script. Identity is implicit: controls present in both rosters translate to themselves; edges cover only non-identity cases.",
22647
22635
  sources: ["https://csrc.nist.gov/files/pubs/sp/800/53/r5/upd1/final/docs/sp800-53r4-to-r5-comparison-workbook.xlsx", "https://csrc.nist.gov/files/pubs/sp/800/53/r5/upd1/final/docs/sp800-53r4-appj-to-r5-comparison.xlsx"],
22648
22636
  rosters: {
@@ -28553,6 +28541,42 @@ const crosswalk = {
28553
28541
  }
28554
28542
  ]
28555
28543
  };
28544
+ // src/nist/crosswalk.ts
28545
+ /**
28546
+ * NIST SP 800-53 Rev 4 <-> Rev 5 control crosswalk, generated from NIST's own
28547
+ * comparison workbooks (see scripts/generate-nist-crosswalk.mjs). Identity is
28548
+ * implicit: a control present in both revisions translates to itself; edges
28549
+ * cover only non-identity cases (withdrawn, moved, incorporated, Appendix J
28550
+ * pointers, and controls new in Rev 5).
28551
+ */
28552
+ function isRecord(value) {
28553
+ return typeof value === "object" && value !== null && !Array.isArray(value);
28554
+ }
28555
+ function isStringArray(value) {
28556
+ return Array.isArray(value) && value.every((item) => typeof item === "string");
28557
+ }
28558
+ function invalidCrosswalk(field) {
28559
+ throw new Error(`Invalid embedded nist-revision-crosswalk.json: ${field}`);
28560
+ }
28561
+ function assertCrosswalkFile(value) {
28562
+ if (!isRecord(value)) invalidCrosswalk("expected an object");
28563
+ if (!isRecord(value.rosters)) invalidCrosswalk("rosters must be an object");
28564
+ for (const [revision, ids] of Object.entries(value.rosters)) if (!isStringArray(ids)) invalidCrosswalk(`rosters.${revision} must be a string array`);
28565
+ if (!Array.isArray(value.edges)) invalidCrosswalk("edges must be an array");
28566
+ for (const [index, edge] of value.edges.entries()) {
28567
+ if (!isRecord(edge)) invalidCrosswalk(`edges[${index}] must be an object`);
28568
+ if (typeof edge.from !== "number" || !Number.isSafeInteger(edge.from)) invalidCrosswalk(`edges[${index}].from must be a safe integer`);
28569
+ for (const field of [
28570
+ "control",
28571
+ "relation",
28572
+ "detail"
28573
+ ]) if (typeof edge[field] !== "string") invalidCrosswalk(`edges[${index}].${field} must be a string`);
28574
+ if (!isStringArray(edge.targets)) invalidCrosswalk(`edges[${index}].targets must be a string array`);
28575
+ if (edge.family !== void 0 && typeof edge.family !== "string") invalidCrosswalk(`edges[${index}].family must be a string when present`);
28576
+ }
28577
+ }
28578
+ const crosswalk = nist_revision_crosswalk_default;
28579
+ assertCrosswalkFile(crosswalk);
28556
28580
  const rosters = new Map(Object.entries(crosswalk.rosters).map(([rev, ids]) => [Number(rev), new Set(ids)]));
28557
28581
  const edges = /* @__PURE__ */ new Map();
28558
28582
  for (const edge of crosswalk.edges) {
@@ -28694,8 +28718,7 @@ function nistControlsAtRevision(controls, nativeRev, rev) {
28694
28718
  }
28695
28719
  return out;
28696
28720
  }
28697
- //#endregion
28698
- //#region src/nist/index.ts
28721
+ // src/nist/index.ts
28699
28722
  const nistDataByRev = {
28700
28723
  4: nist_descriptions_default,
28701
28724
  5: nist_descriptions_rev5_default
@@ -28849,8 +28872,7 @@ const DEFAULT_REMEDIATION_NIST_TAGS = ["SI-2", "RA-5"];
28849
28872
  const DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS = ["CM-8"];
28850
28873
  /** Configuration-compliance checks with no specific mapping (CM-6: Configuration Settings). */
28851
28874
  const DEFAULT_CONFIG_MANAGEMENT_NIST_TAGS = ["CM-6"];
28852
- //#endregion
28853
- //#region src/cci/index.ts
28875
+ // src/cci/index.ts
28854
28876
  const NATIVE_REVISION$5 = 4;
28855
28877
  const cciData = cci_mappings_default;
28856
28878
  const nistCCIData = nist_cci_mappings_default;
@@ -28966,8 +28988,7 @@ function nistToCci(nistControls) {
28966
28988
  }
28967
28989
  return Array.from(seen).sort();
28968
28990
  }
28969
- //#endregion
28970
- //#region src/data/owasp-nist-mappings.json
28991
+ // src/data/owasp-nist-mappings.json
28971
28992
  var owasp_nist_mappings_default = [
28972
28993
  {
28973
28994
  "OWASP-ID": "A1",
@@ -29040,8 +29061,7 @@ var owasp_nist_mappings_default = [
29040
29061
  "NIST Name": "Audit Generation"
29041
29062
  }
29042
29063
  ];
29043
- //#endregion
29044
- //#region src/owasp/index.ts
29064
+ // src/owasp/index.ts
29045
29065
  const NATIVE_REVISION$4 = 4;
29046
29066
  const atCurrentRevision$3 = (nistId) => nistControlsAtRevision(nistId.split("|"), NATIVE_REVISION$4, getCurrentNistRevision()).join("|");
29047
29067
  const owaspData = owasp_nist_mappings_default;
@@ -29138,8 +29158,7 @@ function owaspExists(owaspId) {
29138
29158
  function getAllOwaspMappings() {
29139
29159
  return owaspData;
29140
29160
  }
29141
- //#endregion
29142
- //#region src/cwe/index.ts
29161
+ // src/cwe/index.ts
29143
29162
  const mappings$7 = [
29144
29163
  {
29145
29164
  "CWE-ID": 5,
@@ -32006,8 +32025,7 @@ function cweExists(cweId, rev = getCurrentNistRevision()) {
32006
32025
  function getAllCweMappings() {
32007
32026
  return [...mappings$7];
32008
32027
  }
32009
- //#endregion
32010
- //#region src/checkov/index.ts
32028
+ // src/checkov/index.ts
32011
32029
  const dataset$1 = {
32012
32030
  $comment: [
32013
32031
  "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.",
@@ -37423,8 +37441,7 @@ function getCheckovMappingProvenance() {
37423
37441
  nistRevision: dataset$1.nistRevision
37424
37442
  };
37425
37443
  }
37426
- //#endregion
37427
- //#region src/data/nessus-nist-mappings.json
37444
+ // src/data/nessus-nist-mappings.json
37428
37445
  var nessus_nist_mappings_default = [
37429
37446
  {
37430
37447
  "pluginFamily": "AIX Local Security Checks",
@@ -37857,8 +37874,7 @@ var nessus_nist_mappings_default = [
37857
37874
  "NIST-ID": "CM-8"
37858
37875
  }
37859
37876
  ];
37860
- //#endregion
37861
- //#region src/nessus/index.ts
37877
+ // src/nessus/index.ts
37862
37878
  const NATIVE_REVISION$3 = 4;
37863
37879
  const atCurrentRevision$2 = (nistId) => nistControlsAtRevision(nistId.split("|"), NATIVE_REVISION$3, getCurrentNistRevision()).join("|");
37864
37880
  const mappings$5 = nessus_nist_mappings_default;
@@ -37905,8 +37921,7 @@ function nessusPluginFamilyExists(pluginFamily) {
37905
37921
  function getAllNessusMappings() {
37906
37922
  return [...mappings$5];
37907
37923
  }
37908
- //#endregion
37909
- //#region src/data/nikto-nist-mappings.json
37924
+ // src/data/nikto-nist-mappings.json
37910
37925
  var nikto_nist_mappings_default = {
37911
37926
  "750500": "SI-11",
37912
37927
  "750501": "SI-11",
@@ -46850,8 +46865,7 @@ var nikto_nist_mappings_default = {
46850
46865
  "7283": "AC-3",
46851
46866
  "7284": "AC-3"
46852
46867
  };
46853
- //#endregion
46854
- //#region src/nikto/index.ts
46868
+ // src/nikto/index.ts
46855
46869
  const NATIVE_REVISION$2 = 4;
46856
46870
  const atCurrentRevision$1 = (nistId) => nistControlsAtRevision(nistId.split("|"), NATIVE_REVISION$2, getCurrentNistRevision()).join("|");
46857
46871
  const mappings$4 = nikto_nist_mappings_default;
@@ -46887,8 +46901,7 @@ function niktoExists(niktoId) {
46887
46901
  function getAllNiktoMappings() {
46888
46902
  return { ...mappings$4 };
46889
46903
  }
46890
- //#endregion
46891
- //#region src/data/scoutsuite-nist-mappings.json
46904
+ // src/data/scoutsuite-nist-mappings.json
46892
46905
  var scoutsuite_nist_mappings_default = [
46893
46906
  {
46894
46907
  "RULE": "acm-certificate-with-close-expiration-date",
@@ -47447,8 +47460,7 @@ var scoutsuite_nist_mappings_default = [
47447
47460
  "NIST-ID": "AU-12"
47448
47461
  }
47449
47462
  ];
47450
- //#endregion
47451
- //#region src/scoutsuite/index.ts
47463
+ // src/scoutsuite/index.ts
47452
47464
  const NATIVE_REVISION$1 = 4;
47453
47465
  const atCurrentRevision = (nistId) => nistControlsAtRevision(nistId.split("|"), NATIVE_REVISION$1, getCurrentNistRevision()).join("|");
47454
47466
  const mappings$3 = scoutsuite_nist_mappings_default;
@@ -47492,8 +47504,7 @@ function scoutsuiteRuleExists(rule) {
47492
47504
  function getAllScoutsuiteMappings() {
47493
47505
  return [...mappings$3];
47494
47506
  }
47495
- //#endregion
47496
- //#region src/data/awsconfig-mappings.json
47507
+ // src/data/awsconfig-mappings.json
47497
47508
  var awsconfig_mappings_default = [
47498
47509
  {
47499
47510
  "AwsConfigRuleSourceIdentifier": "ACCESS_KEYS_ROTATED",
@@ -53012,8 +53023,7 @@ var awsconfig_mappings_default = [
53012
53023
  "Source": "derived-theme"
53013
53024
  }
53014
53025
  ];
53015
- //#endregion
53016
- //#region src/data/awsconfig-suppressions.json
53026
+ // src/data/awsconfig-suppressions.json
53017
53027
  var awsconfig_suppressions_default = [
53018
53028
  {
53019
53029
  "rule": "apigateway-stage-access-logs-enabled",
@@ -53201,8 +53211,7 @@ var awsconfig_suppressions_default = [
53201
53211
  "revisions": [4, 5]
53202
53212
  }
53203
53213
  ];
53204
- //#endregion
53205
- //#region src/awsconfig/index.ts
53214
+ // src/awsconfig/index.ts
53206
53215
  const mappings$2 = awsconfig_mappings_default;
53207
53216
  /**
53208
53217
  * The maintainer-reviewed (rule, control) removals the generator applied to
@@ -53296,8 +53305,7 @@ function awsConfigMappedRevisions(identifier, ruleName) {
53296
53305
  function getAllAwsConfigMappings() {
53297
53306
  return [...mappings$2];
53298
53307
  }
53299
- //#endregion
53300
- //#region src/data/hipcheck-nist-mappings.json
53308
+ // src/data/hipcheck-nist-mappings.json
53301
53309
  var hipcheck_nist_mappings_default = [
53302
53310
  {
53303
53311
  "Analysis": "activity",
@@ -53354,8 +53362,7 @@ var hipcheck_nist_mappings_default = [
53354
53362
  "Rationale": "Typosquatted dependencies are a component-authenticity failure (SR-11) delivering a component of false provenance (SR-4)."
53355
53363
  }
53356
53364
  ];
53357
- //#endregion
53358
- //#region src/hipcheck/index.ts
53365
+ // src/hipcheck/index.ts
53359
53366
  const NATIVE_REVISION = 5;
53360
53367
  const mappings$1 = hipcheck_nist_mappings_default;
53361
53368
  const byAnalysis = /* @__PURE__ */ new Map();
@@ -53390,8 +53397,7 @@ function getAllHipcheckAnalyses() {
53390
53397
  function getAllHipcheckMappings() {
53391
53398
  return [...mappings$1];
53392
53399
  }
53393
- //#endregion
53394
- //#region src/hadolint/index.ts
53400
+ // src/hadolint/index.ts
53395
53401
  const dataset = {
53396
53402
  $comment: [
53397
53403
  "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.",
@@ -53548,7 +53554,6 @@ function getHadolintMappingProvenance() {
53548
53554
  nistRevision: dataset.nistRevision
53549
53555
  };
53550
53556
  }
53551
- //#endregion
53552
53557
  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 };
53553
53558
 
53554
53559
  //# sourceMappingURL=index.js.map
package/dist/index.js.map CHANGED
@@ -1 +1 @@
1
- {"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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"}
1
+ {"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\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isStringArray(value: unknown): value is string[] {\n return Array.isArray(value) && value.every((item: unknown) => typeof item === 'string');\n}\n\nfunction invalidCrosswalk(field: string): never {\n throw new Error(`Invalid embedded nist-revision-crosswalk.json: ${field}`);\n}\n\nfunction assertCrosswalkFile(value: unknown): asserts value is CrosswalkFile {\n if (!isRecord(value)) invalidCrosswalk('expected an object');\n if (!isRecord(value.rosters)) invalidCrosswalk('rosters must be an object');\n for (const [revision, ids] of Object.entries(value.rosters)) {\n if (!isStringArray(ids)) invalidCrosswalk(`rosters.${revision} must be a string array`);\n }\n if (!Array.isArray(value.edges)) invalidCrosswalk('edges must be an array');\n for (const [index, edge] of value.edges.entries()) {\n if (!isRecord(edge)) invalidCrosswalk(`edges[${index}] must be an object`);\n if (typeof edge.from !== 'number' || !Number.isSafeInteger(edge.from)) {\n invalidCrosswalk(`edges[${index}].from must be a safe integer`);\n }\n for (const field of ['control', 'relation', 'detail']) {\n if (typeof edge[field] !== 'string') {\n invalidCrosswalk(`edges[${index}].${field} must be a string`);\n }\n }\n if (!isStringArray(edge.targets)) {\n invalidCrosswalk(`edges[${index}].targets must be a string array`);\n }\n if (edge.family !== undefined && typeof edge.family !== 'string') {\n invalidCrosswalk(`edges[${index}].family must be a string when present`);\n }\n }\n}\n\n// A corrupt packaged asset is a build defect; refuse it before constructing either map.\nconst crosswalk: unknown = rawCrosswalk;\nassertCrosswalkFile(crosswalk);\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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AEpEA,MAAME,oBAAkB;AACxB,MAAMC,uBAAqB,WACzB,uBAAuB,O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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@mitre/hdf-mappings",
3
- "version": "3.7.2",
3
+ "version": "3.8.0-next.42532249979.1",
4
4
  "description": "CCI/NIST/CIS/CMMC security framework mappings for HDF",
5
5
  "publishConfig": {
6
6
  "access": "public"