npm - @mitre/hdf-mappings - Versions diffs - 3.4.4 → 3.5.1 - Mend

@mitre/hdf-mappings 3.4.4 → 3.5.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 (6) hide show

package/dist/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","names":["rawCCIData","rawNistCCIData","rawNistData","rawOwaspData","mappings","rawMappings","mappings","rawMappings","mappings","rawMappings","mappings","rawMappings","mappings","rawMappings","rawMappings"],"sources":["../src/data/cci-mappings.json","../src/data/nist-cci-mappings.json","../src/cci/index.ts","../src/data/nist-descriptions.json","../src/nist/index.ts","../src/data/owasp-nist-mappings.json","../src/owasp/index.ts","../src/data/cwe-nist-mappings.json","../src/cwe/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/awsconfig/index.ts","../src/data/hipcheck-nist-mappings.json","../src/hipcheck/index.ts"],"sourcesContent":["","","/*\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';\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 return item?.nist;\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 NIST SP 800-53 control description functions\n /\n\nimport type { NISTDescriptions } from './types.js';\nimport rawNistData from '../data/nist-descriptions.json';\n\nconst nistData = rawNistData as NISTDescriptions;\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/* 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.\n \n @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a', 'AC-01 a 01')\n * @returns The NIST control description, or undefined if not found\n \n @example\n * ```typescript\n * const desc = getNISTDescription('AC-01');\n * // Returns: \"ACCESS CONTROL POLICY AND PROCEDURES\"\n * ```\n /\nexport function getNISTDescription(nistId: string): string \| undefined {\n if (!nistId \|\| typeof nistId !== 'string') {\n return undefined;\n }\n\n return nistData[nistId];\n}\n\n/\n Get all NIST control IDs available in the database.\n \n @returns Array of all NIST control IDs\n \n @example\n * ```typescript\n * const ids = getAllNISTIds();\n * // Returns: ['AC-01', 'AC-01 a', 'AC-02', ...]\n * ```\n /\nexport function getAllNISTIds(): string[] {\n return Object.keys(nistData);\n}\n\n/\n Check if a NIST control ID exists in the database.\n \n @param nistId - The NIST control ID to check\n * @returns true if the NIST control exists, false otherwise\n \n @example\n * ```typescript\n * if (nistExists('AC-01')) {\n * console.log('NIST control found');\n * }\n * ```\n /\nexport function nistExists(nistId: string): boolean {\n if (!nistId \|\| typeof nistId !== 'string') {\n return false;\n }\n\n return nistId in nistData;\n}\n\n/\n Extract the NIST family from a NIST control ID.\n \n @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a')\n * @returns The NIST family code (e.g., 'AC'), or undefined if invalid\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(nistId: string): 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 in our database by checking\n // if any controls start with this family\n const familyPrefix = `${family}-`;\n const hasFamily = Object.keys(nistData).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// Re-export types\nexport type { NISTDescriptions } 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';\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?.['NIST-ID'];\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 Nessus to NIST mappings\n /\n\nimport type { NessusNistMappings } from './types.js';\nimport rawMappings from '../data/nessus-nist-mappings.json';\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 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?.['NIST-ID'];\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';\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 return mappings[id];\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';\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?.['NIST-ID'];\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 } from './types.js';\nimport { getCurrentNistRevision, SUPPORTED_NIST_REVISIONS } from '../nist/index.js';\nimport rawMappings from '../data/awsconfig-mappings.json';\n\nconst mappings = rawMappings as AwsConfigNistMappings;\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';\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 return m['NIST-ID']\n .split('\|')\n .map((s) => s.trim())\n .filter(Boolean);\n}\n\n/* Check whether a Hipcheck analysis name has a NIST mapping. /\nexport function hipcheckAnalysisExists(analysis: string): boolean {\n return byAnalysis.has(bareName(analysis));\n}\n\n/* Get all mapped Hipcheck analysis names, sorted. /\nexport function getAllHipcheckAnalyses(): string[] {\n return Array.from(byAnalysis.keys()).sort();\n}\n\n/* Get all Hipcheck to NIST mappings. */\nexport function getAllHipcheckMappings(): HipcheckNistMappings {\n return [...mappings];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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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","NATIVE_REVISION","atCurrentRevision","mappings","rawMappings","NATIVE_REVISION","atCurrentRevision","mappings","rawMappings","NATIVE_REVISION","mappings","rawMappings","mappings","rawMappings","rawMappings"],"sources":["../src/data/cci-mappings.json","../src/data/nist-cci-mappings.json","../src/data/nist-descriptions.json","../src/data/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","../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/awsconfig/index.ts","../src/data/hipcheck-nist-mappings.json","../src/hipcheck/index.ts"],"sourcesContent":["","","","","","/*\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 rawNistDataRev4 from '../data/nist-descriptions.json';\nimport rawNistDataRev5 from '../data/nist-descriptions-rev5.json';\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 (e.g., 'AC-01', 'AC-01 a', '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-01', 4); // -> \"ACCESS CONTROL POLICY AND PROCEDURES\"\n * ```\n /\nexport function getNISTDescription(\n nistId: string,\n rev: number = getCurrentNistRevision()\n): string \| undefined {\n if (!nistId \|\| typeof nistId !== 'string') {\n return undefined;\n }\n\n return descriptionsFor(rev)[nistId];\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\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 * if (nistExists('AC-01')) {\n * console.log('NIST control found');\n * }\n * ```\n /\nexport function nistExists(nistId: string, rev: number = getCurrentNistRevision()): boolean {\n if (!nistId \|\| typeof nistId !== 'string') {\n return false;\n }\n\n return nistId 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 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 } from './types.js';\nimport { getCurrentNistRevision, SUPPORTED_NIST_REVISIONS } from '../nist/index.js';\nimport rawMappings from '../data/awsconfig-mappings.json';\n\nconst mappings = rawMappings as AwsConfigNistMappings;\n\n// revision → (key → mapping), for both source-identifier and rule-name lookup\nconst byIdentifier = new Map<number, Map<string, AwsConfigNistMapping>>();\nconst byRuleName = new Map<number, Map<string, AwsConfigNistMapping>>();\nfor (const m of mappings) {\n if (!byIdentifier.has(m.Rev)) {\n byIdentifier.set(m.Rev, new Map());\n byRuleName.set(m.Rev, new Map());\n }\n byIdentifier.get(m.Rev)!.set(m.AwsConfigRuleSourceIdentifier, m);\n byRuleName.get(m.Rev)!.set(m.AwsConfigRuleName, m);\n}\n\nfunction idIndex(rev: number): Map<string, AwsConfigNistMapping> {\n return byIdentifier.get(rev) ?? new Map();\n}\nfunction nameIndex(rev: number): Map<string, AwsConfigNistMapping> {\n return byRuleName.get(rev) ?? new Map();\n}\n\n/* Get the full mapping for an AWS Config rule by source identifier. /\nexport function getAwsConfigNistMappingByIdentifier(\n identifier: string,\n rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping \| undefined {\n return idIndex(rev).get(identifier);\n}\n\n/* Get the full mapping for an AWS Config rule by rule name. /\nexport function getAwsConfigNistMappingByName(\n ruleName: string,\n rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping \| undefined {\n return nameIndex(rev).get(ruleName);\n}\n\n/* Get the NIST control ID for an AWS Config rule by source identifier. /\nexport function getAwsConfigNistControlByIdentifier(\n identifier: string,\n rev: number = getCurrentNistRevision()\n): string \| undefined {\n return getAwsConfigNistMappingByIdentifier(identifier, rev)?.['NIST-ID'];\n}\n\n/* Get the NIST control ID for an AWS Config rule by rule name. /\nexport function getAwsConfigNistControlByName(\n ruleName: string,\n rev: number = getCurrentNistRevision()\n): string \| undefined {\n return getAwsConfigNistMappingByName(ruleName, rev)?.['NIST-ID'];\n}\n\n/\n Resolve NIST controls for a decorated rule name such as Security Hub's\n * \"securityhub-<canonical>-<hash>\", where an exact lookup fails. Returns the\n * split controls of the canonical rule whose name is contained in the given\n * name; the longest such match wins. Returns [] if none match.\n /\nexport function getAwsConfigNistControlsBySubstring(\n name: string,\n rev: number = getCurrentNistRevision()\n): string[] {\n if (!name) return [];\n const lower = name.toLowerCase();\n let best: AwsConfigNistMapping \| undefined;\n let bestLen = 0;\n for (const [key, m] of nameIndex(rev)) {\n if (key && key.length > bestLen && lower.includes(key.toLowerCase())) {\n best = m;\n bestLen = key.length;\n }\n }\n if (!best) return [];\n return best['NIST-ID']\n .split('\|')\n .map((s) => s.trim())\n .filter(Boolean);\n}\n\n/* Get all AWS Config rule source identifiers present at the given revision. /\nexport function getAllAwsConfigIdentifiers(rev: number = getCurrentNistRevision()): string[] {\n return Array.from(idIndex(rev).keys());\n}\n\n/* Get all AWS Config rule names present at the given revision. /\nexport function getAllAwsConfigRuleNames(rev: number = getCurrentNistRevision()): string[] {\n return Array.from(nameIndex(rev).keys());\n}\n\n/* Check if an AWS Config rule exists by source identifier at the given revision. /\nexport function awsConfigIdentifierExists(identifier: string, rev: number = getCurrentNistRevision()): boolean {\n return idIndex(rev).has(identifier);\n}\n\n/* Check if an AWS Config rule exists by rule name at the given revision. /\nexport function awsConfigRuleNameExists(ruleName: string, rev: number = getCurrentNistRevision()): boolean {\n return nameIndex(rev).has(ruleName);\n}\n\n/\n Get the supported NIST revisions at which the rule resolves (by source\n * identifier or rule name), sorted ascending. Mirrors the resolution\n * buildNistTags performs, so a revision is included exactly when a conversion\n * at that revision would emit NIST tags. Empty means unmapped everywhere — a\n * coverage gap, not a revision mismatch.\n /\nexport function awsConfigMappedRevisions(identifier: string, ruleName: string): number[] {\n const revs: number[] = [];\n for (const rev of SUPPORTED_NIST_REVISIONS) {\n const byId = identifier ? getAwsConfigNistControlByIdentifier(identifier, rev) : undefined;\n const byName = ruleName ? getAwsConfigNistControlByName(ruleName, rev) : undefined;\n if (byId \|\| byName) {\n revs.push(rev);\n }\n }\n return revs;\n}\n\n/* Get all AWS Config to NIST mappings (all revisions). /\nexport function getAllAwsConfigMappings(): AwsConfigNistMappings {\n return [...mappings];\n}\n","","/\n Query functions for Hipcheck analysis to NIST 800-53 Rev 5 mappings.\n \n The mapping is a hand-curated, RMF-reviewed table (Hipcheck publishes no\n * analysis-to-controls crosswalk). The data file is byte-identical to its Go\n * peer at hdf-mappings/go/hipcheck/hipcheck-nist-mappings.json.\n /\n\nimport type { HipcheckNistMapping, HipcheckNistMappings } from './types.js';\nimport rawMappings from '../data/hipcheck-nist-mappings.json';\nimport { getCurrentNistRevision, nistControlsAtRevision } from '../nist/index.js';\n\n// Authored against Rev 5 (declared Rev: 5 in the data; it carries SR-family\n// controls that do not exist at Rev 4). Lookups translate to the current\n// module-global revision.\nconst NATIVE_REVISION = 5;\n\nconst mappings = rawMappings as HipcheckNistMappings;\n\nconst byAnalysis = new Map<string, HipcheckNistMapping>();\nfor (const m of mappings) {\n byAnalysis.set(m.Analysis, m);\n}\n\n/\n Strip a plugin publisher prefix (\"mitre/binary\" -> \"binary\") so lookups key\n * on the analysis name regardless of publisher.\n /\nfunction bareName(analysis: string): string {\n const i = analysis.lastIndexOf('/');\n return i >= 0 ? analysis.slice(i + 1) : analysis;\n}\n\n/\n Get the NIST 800-53 controls for a Hipcheck analysis name.\n * Accepts bare (\"binary\") or publisher-prefixed (\"mitre/binary\") names.\n * @returns array of control IDs, or [] if the analysis has no mapping\n /\nexport function getHipcheckNistControls(analysis: string): string[] {\n const m = byAnalysis.get(bareName(analysis));\n if (!m) return [];\n const controls = m['NIST-ID']\n .split('\|')\n .map((s) => s.trim())\n .filter(Boolean);\n return nistControlsAtRevision(controls, NATIVE_REVISION, getCurrentNistRevision());\n}\n\n/* Check whether a Hipcheck analysis name has a NIST mapping. /\nexport function hipcheckAnalysisExists(analysis: string): boolean {\n return byAnalysis.has(bareName(analysis));\n}\n\n/* Get all mapped Hipcheck analysis names, sorted. /\nexport function getAllHipcheckAnalyses(): string[] {\n return Array.from(byAnalysis.keys()).sort();\n}\n\n/* Get all Hipcheck to NIST mappings. */\nexport function getAllHipcheckMappings(): HipcheckNistMappings {\n return [...mappings];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AKqDA,MAAM,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@mitre/hdf-mappings",
-  "version": "3.4.4",
+  "version": "3.5.1",
   "description": "CCI/NIST/CIS/CMMC security framework mappings for HDF",
   "publishConfig": {
     "access": "public"
@@ -45,6 +45,10 @@
     "clean": "rimraf dist",
     "mappings:awsconfig": "node scripts/generate-awsconfig-mappings.mjs",
     "mappings:awsconfig:check": "node scripts/generate-awsconfig-mappings.mjs --check",
+    "mappings:crosswalk": "node scripts/generate-nist-crosswalk.mjs",
+    "mappings:crosswalk:check": "node scripts/generate-nist-crosswalk.mjs --check",
+    "mappings:descriptions": "node scripts/generate-nist-descriptions.mjs",
+    "mappings:descriptions:check": "node scripts/generate-nist-descriptions.mjs --check",
     "test": "pnpm run test:ts",
     "test:ts": "vitest run",
     "test:go": "cd go && go test ./...",