Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
feat(files): add FileReference v1 contract and byte-based file classifier
Alfredo Lopez34daa1efe70f
diff --git a/.github/workflows/build-publish.yml b/.github/workflows/build-publish.ymlindex 26431902a..c0e860060 100644--- a/.github/workflows/build-publish.yml+++ b/.github/workflows/build-publish.yml@@ -146,6 +146,7 @@ jobs:- 'packages/llm-provider-attempt-contract/**'- 'packages/codex-catalog-projection/**'- 'packages/grok-provider-attempt-contract/**'+ - 'packages/gfs-interaction-policy/**'mcp-proxy:- 'mcp-proxy/**'gfs-controller:diff --git a/deploy/images.json b/deploy/images.jsonindex d94202a8c..698d11973 100644--- a/deploy/images.json+++ b/deploy/images.json@@ -73,7 +73,8 @@"mcp-host/**","packages/llm-provider-attempt-contract/**","packages/codex-catalog-projection/**",- "packages/grok-provider-attempt-contract/**"+ "packages/grok-provider-attempt-contract/**",+ "packages/gfs-interaction-policy/**"],"published": true,"deployed_to_minikube": true@@ -87,7 +88,8 @@"mcp-host/**","packages/llm-provider-attempt-contract/**","packages/codex-catalog-projection/**",- "packages/grok-provider-attempt-contract/**"+ "packages/grok-provider-attempt-contract/**",+ "packages/gfs-interaction-policy/**"],"published": true,"deployed_to_minikube": true@@ -101,7 +103,8 @@"mcp-host/**","packages/llm-provider-attempt-contract/**","packages/codex-catalog-projection/**",- "packages/grok-provider-attempt-contract/**"+ "packages/grok-provider-attempt-contract/**",+ "packages/gfs-interaction-policy/**"],"published": true,"deployed_to_minikube": true@@ -115,7 +118,8 @@"mcp-host/**","packages/llm-provider-attempt-contract/**","packages/codex-catalog-projection/**",- "packages/grok-provider-attempt-contract/**"+ "packages/grok-provider-attempt-contract/**",+ "packages/gfs-interaction-policy/**"],"published": true,"deployed_to_minikube": falsediff --git a/mcp-host/Dockerfile b/mcp-host/Dockerfileindex df6f2275e..7b56ac0b4 100644--- a/mcp-host/Dockerfile+++ b/mcp-host/Dockerfile@@ -17,6 +17,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policy# Install dependencies (file: deps resolve to ../packages/llm-providers and# ../packages/llm-provider-attempt-contract)@@ -42,6 +43,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policyCOPY mcp-host/package*.json ./mcp-host/WORKDIR /app/mcp-hostCOPY --from=builder /app/mcp-host/node_modules ./node_modulesdiff --git a/mcp-host/Dockerfile.desktop b/mcp-host/Dockerfile.desktopindex 77abb297d..869fff46f 100644--- a/mcp-host/Dockerfile.desktop+++ b/mcp-host/Dockerfile.desktop@@ -8,6 +8,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policyCOPY mcp-host/package*.json ./mcp-host/WORKDIR /app/mcp-hostRUN npm ci@@ -52,6 +53,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policyCOPY --from=builder /app/mcp-host/package*.json ./mcp-host/WORKDIR /app/mcp-hostRUN npm ci --omit=devdiff --git a/mcp-host/Dockerfile.full b/mcp-host/Dockerfile.fullindex e7f10d824..3b2046094 100644--- a/mcp-host/Dockerfile.full+++ b/mcp-host/Dockerfile.full@@ -15,6 +15,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policy# Install dependencies (file: deps resolve to ../packages/llm-providers and# ../packages/llm-provider-attempt-contract)@@ -49,6 +50,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policyCOPY mcp-host/package*.json ./mcp-host/WORKDIR /app/mcp-hostRUN npm ci --only=productiondiff --git a/mcp-host/Dockerfile.slim b/mcp-host/Dockerfile.slimindex 2b5ee21a8..1863ace68 100644--- a/mcp-host/Dockerfile.slim+++ b/mcp-host/Dockerfile.slim@@ -15,6 +15,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policy# Install dependencies (file: deps resolve to ../packages/llm-providers and# ../packages/llm-provider-attempt-contract)@@ -52,6 +53,7 @@ COPY packages/llm-providers ./packages/llm-providersCOPY packages/llm-provider-attempt-contract ./packages/llm-provider-attempt-contractCOPY packages/grok-provider-attempt-contract ./packages/grok-provider-attempt-contractCOPY packages/codex-catalog-projection ./packages/codex-catalog-projection+COPY packages/gfs-interaction-policy ./packages/gfs-interaction-policyCOPY mcp-host/package*.json ./mcp-host/WORKDIR /app/mcp-hostRUN npm ci --only=productiondiff --git a/mcp-host/package-lock.json b/mcp-host/package-lock.jsonindex 2b1b9f464..6ebd1c014 100644--- a/mcp-host/package-lock.json+++ b/mcp-host/package-lock.json@@ -1,17 +1,18 @@{"name": "clerum-mcp-host",- "version": "0.1.440",+ "version": "0.1.441","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-mcp-host",- "version": "0.1.440",+ "version": "0.1.441","license": "SEE LICENSE IN LICENSE","dependencies": {"@anthropic-ai/sdk": "^0.32.0","@aws-sdk/client-bedrock-runtime": "^3.895.0","@clerum/codex-catalog-projection": "file:../packages/codex-catalog-projection",+ "@clerum/gfs-interaction-policy": "file:../packages/gfs-interaction-policy","@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract","@clerum/llm-provider-attempt-contract": "file:../packages/llm-provider-attempt-contract","@clerum/llm-providers": "file:../packages/llm-providers",@@ -67,6 +68,11 @@"version": "0.1.0","license": "MIT"},+ "../packages/gfs-interaction-policy": {+ "name": "@clerum/gfs-interaction-policy",+ "version": "0.2.0",+ "license": "MIT"+ },"../packages/grok-provider-attempt-contract": {"name": "@clerum/grok-provider-attempt-contract","version": "0.1.0",@@ -548,6 +554,10 @@"resolved": "../packages/codex-catalog-projection","link": true},+ "node_modules/@clerum/gfs-interaction-policy": {+ "resolved": "../packages/gfs-interaction-policy",+ "link": true+ },"node_modules/@clerum/grok-provider-attempt-contract": {"resolved": "../packages/grok-provider-attempt-contract","link": truediff --git a/mcp-host/package.json b/mcp-host/package.jsonindex 893808369..e86c1940e 100644--- a/mcp-host/package.json+++ b/mcp-host/package.json@@ -1,6 +1,6 @@{"name": "clerum-mcp-host",- "version": "0.1.440",+ "version": "0.1.441","description": "MCP Host - reads Host CRD and provides LLM access via OpenAI/Claude","main": "dist/main.js","engines": {@@ -28,6 +28,7 @@"@anthropic-ai/sdk": "^0.32.0","@aws-sdk/client-bedrock-runtime": "^3.895.0","@clerum/codex-catalog-projection": "file:../packages/codex-catalog-projection",+ "@clerum/gfs-interaction-policy": "file:../packages/gfs-interaction-policy","@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract","@clerum/llm-provider-attempt-contract": "file:../packages/llm-provider-attempt-contract","@clerum/llm-providers": "file:../packages/llm-providers",diff --git a/packages/gfs-interaction-policy/fileClassifier.cjs b/packages/gfs-interaction-policy/fileClassifier.cjsnew file mode 100644index 000000000..3fafc445e--- /dev/null+++ b/packages/gfs-interaction-policy/fileClassifier.cjs@@ -0,0 +1,479 @@+'use strict'++/**+ * Isomorphic byte classifier shared by Desktop (renderer and main), Control UI+ * and mcp-host. It uses only Uint8Array and TextDecoder so the same decision is+ * made in a browser and in Node. The bytes decide the class; the declared media+ * type and the filename extension only break ties inside the same family, or+ * stand in for missing bytes when a short prefix carries no contrary evidence.+ *+ * Classification never rejects: an unknown or misleading file is reported as+ * `binary_unsupported` and/or `mismatch: true`, and callers decide what to do.+ */++const FILE_CLASSES = Object.freeze([+ 'text',+ 'markdown',+ 'html',+ 'code',+ 'svg',+ 'jpeg',+ 'png',+ 'pdf',+ 'docx',+ 'xlsx',+ 'binary_unsupported',+])++const TEXT_CLASSES = new Set(['text', 'markdown', 'html', 'code', 'svg'])+const IMAGE_CLASSES = new Set(['jpeg', 'png'])+const DOCUMENT_BINARY_CLASSES = new Set(['pdf', 'docx', 'xlsx'])++/** A prefix shorter than this carries too little evidence to override the declared type. */+const DECLARED_EVIDENCE_PREFIX_BYTES = 65536+const PDF_SIGNATURE_WINDOW_BYTES = 1024+const TEXT_ROOT_SCAN_CHARS = 4096++const DOCX_MEDIA_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'+const XLSX_MEDIA_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'+const ZIP_MEDIA_TYPE = 'application/zip'++const MEDIA_TYPE_BY_CLASS = Object.freeze({+ text: 'text/plain',+ markdown: 'text/markdown',+ html: 'text/html',+ code: 'text/plain',+ svg: 'image/svg+xml',+ jpeg: 'image/jpeg',+ png: 'image/png',+ pdf: 'application/pdf',+ docx: DOCX_MEDIA_TYPE,+ xlsx: XLSX_MEDIA_TYPE,+ binary_unsupported: 'application/octet-stream',+})++const CODE_EXTENSIONS = Object.freeze([+ '.json',+ '.jsonl',+ '.yaml',+ '.yml',+ '.toml',+ '.ini',+ '.cfg',+ '.conf',+ '.csv',+ '.tsv',+ '.xml',+ '.ts',+ '.tsx',+ '.js',+ '.jsx',+ '.mjs',+ '.cjs',+ '.py',+ '.rb',+ '.go',+ '.rs',+ '.java',+ '.kt',+ '.scala',+ '.c',+ '.h',+ '.cc',+ '.cpp',+ '.hpp',+ '.cs',+ '.swift',+ '.php',+ '.lua',+ '.r',+ '.dart',+ '.sh',+ '.bash',+ '.zsh',+ '.ps1',+ '.sql',+ '.css',+ '.scss',+ '.less',+ '.vue',+ '.svelte',+ '.graphql',+ '.proto',+ '.tf',+])++const CODE_MEDIA_TYPES = new Set([+ 'application/json',+ 'application/ld+json',+ 'application/x-ndjson',+ 'application/xml',+ 'text/xml',+ 'application/yaml',+ 'application/x-yaml',+ 'text/yaml',+ 'text/x-yaml',+ 'application/toml',+ 'text/csv',+ 'text/tab-separated-values',+ 'application/javascript',+ 'text/javascript',+ 'application/typescript',+ 'text/x-python',+ 'application/x-sh',+ 'application/sql',+ 'text/css',+])++const CLASS_BY_EXTENSION = Object.freeze({+ '.txt': 'text',+ '.text': 'text',+ '.log': 'text',+ '.md': 'markdown',+ '.markdown': 'markdown',+ '.html': 'html',+ '.htm': 'html',+ '.svg': 'svg',+ '.jpg': 'jpeg',+ '.jpeg': 'jpeg',+ '.png': 'png',+ '.pdf': 'pdf',+ '.docx': 'docx',+ '.xlsx': 'xlsx',+ ...Object.fromEntries(CODE_EXTENSIONS.map(extension => [extension, 'code'])),+})++function familyOf(fileClass) {+ if (TEXT_CLASSES.has(fileClass)) return 'text'+ if (IMAGE_CLASSES.has(fileClass)) return 'image'+ if (DOCUMENT_BINARY_CLASSES.has(fileClass)) return 'document_binary'+ return 'binary_unsupported'+}++function normalizeMediaType(value) {+ if (typeof value !== 'string') return null+ const essence = value.split(';', 1)[0].trim().toLowerCase()+ return essence || null+}++function classFromMediaType(mediaType) {+ const essence = normalizeMediaType(mediaType)+ if (!essence) return null+ if (essence === 'image/jpeg' || essence === 'image/jpg') return 'jpeg'+ if (essence === 'image/png') return 'png'+ if (essence === 'application/pdf') return 'pdf'+ if (essence === DOCX_MEDIA_TYPE) return 'docx'+ if (essence === XLSX_MEDIA_TYPE) return 'xlsx'+ if (essence === 'image/svg+xml') return 'svg'+ if (essence === 'text/markdown' || essence === 'text/x-markdown') return 'markdown'+ if (essence === 'text/html') return 'html'+ if (CODE_MEDIA_TYPES.has(essence)) return 'code'+ if (essence.startsWith('text/')) return 'text'+ return null+}++function extensionOf(filename) {+ if (typeof filename !== 'string') return ''+ const base = filename.slice(Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\')) + 1)+ const lastDot = base.lastIndexOf('.')+ if (lastDot <= 0 || lastDot === base.length - 1) return ''+ return base.slice(lastDot).toLowerCase()+}++function classFromExtension(filename) {+ const extension = extensionOf(filename)+ return Object.prototype.hasOwnProperty.call(CLASS_BY_EXTENSION, extension)+ ? CLASS_BY_EXTENSION[extension]+ : null+}++function startsWith(bytes, signature) {+ if (bytes.length < signature.length) return false+ for (let index = 0; index < signature.length; index += 1) {+ if (bytes[index] !== signature[index]) return false+ }+ return true+}++const JPEG_SIGNATURE = [0xff, 0xd8, 0xff]+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]+const ZIP_LOCAL_HEADER_SIGNATURE = [0x50, 0x4b, 0x03, 0x04]+const PDF_SIGNATURE = [0x25, 0x50, 0x44, 0x46, 0x2d] // %PDF-++function hasPdfSignature(bytes) {+ const limit = Math.min(bytes.length, PDF_SIGNATURE_WINDOW_BYTES) - PDF_SIGNATURE.length+ for (let offset = 0; offset <= limit; offset += 1) {+ let matched = true+ for (let index = 0; index < PDF_SIGNATURE.length; index += 1) {+ if (bytes[offset + index] !== PDF_SIGNATURE[index]) {+ matched = false+ break+ }+ }+ if (matched) return true+ }+ return false+}++function readUint16(bytes, offset) {+ return bytes[offset] | (bytes[offset + 1] << 8)+}++function readUint32(bytes, offset) {+ return (+ (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16)) ++ bytes[offset + 3] * 0x1000000+ )+}++const ZIP_ENTRY_NAME_DECODER = new TextDecoder('utf-8')+const ZIP_EOCD_SIGNATURE = 0x06054b50+const ZIP_EOCD_MIN_LENGTH = 22+const ZIP_CENTRAL_HEADER_SIGNATURE = 0x02014b50+const ZIP_LOCAL_HEADER = 0x04034b50++/**+ * Entry names from the ZIP central directory, or null when the archive has no+ * readable end-of-central-directory record. Null is reported as "not an Office+ * document", never guessed.+ */+function zipCentralDirectoryNames(bytes) {+ const searchStart = Math.max(0, bytes.length - (ZIP_EOCD_MIN_LENGTH + 0xffff))+ let eocd = -1+ for (let offset = bytes.length - ZIP_EOCD_MIN_LENGTH; offset >= searchStart; offset -= 1) {+ if (readUint32(bytes, offset) === ZIP_EOCD_SIGNATURE) {+ eocd = offset+ break+ }+ }+ if (eocd < 0) return null+ const entryCount = readUint16(bytes, eocd + 10)+ let cursor = readUint32(bytes, eocd + 16)+ const names = []+ for (let entry = 0; entry < entryCount; entry += 1) {+ if (cursor + 46 > bytes.length || readUint32(bytes, cursor) !== ZIP_CENTRAL_HEADER_SIGNATURE) {+ return null+ }+ const nameLength = readUint16(bytes, cursor + 28)+ const extraLength = readUint16(bytes, cursor + 30)+ const commentLength = readUint16(bytes, cursor + 32)+ const nameStart = cursor + 46+ if (nameStart + nameLength > bytes.length) return null+ names.push(ZIP_ENTRY_NAME_DECODER.decode(bytes.subarray(nameStart, nameStart + nameLength)))+ cursor = nameStart + nameLength + extraLength + commentLength+ }+ return names+}++/**+ * Entry names from the local file headers that fit inside a prefix. Stops at the+ * first entry whose size is deferred to a data descriptor, because the next+ * header cannot be located without inflating that entry.+ */+function zipLocalHeaderNames(bytes) {+ const names = []+ let cursor = 0+ while (cursor + 30 <= bytes.length && readUint32(bytes, cursor) === ZIP_LOCAL_HEADER) {+ const flags = readUint16(bytes, cursor + 6)+ const compressedSize = readUint32(bytes, cursor + 18)+ const nameLength = readUint16(bytes, cursor + 26)+ const extraLength = readUint16(bytes, cursor + 28)+ const nameStart = cursor + 30+ if (nameStart + nameLength > bytes.length) break+ names.push(ZIP_ENTRY_NAME_DECODER.decode(bytes.subarray(nameStart, nameStart + nameLength)))+ if ((flags & 0x08) !== 0) break+ cursor = nameStart + nameLength + extraLength + compressedSize+ }+ return names+}++function officeClassFromZipNames(names) {+ if (!names) return null+ const hasWord = names.some(name => name.startsWith('word/'))+ const hasSheet = names.some(name => name.startsWith('xl/'))+ if (hasWord && !hasSheet) return 'docx'+ if (hasSheet && !hasWord) return 'xlsx'+ return null+}++/** Length of the prefix that ends on a complete UTF-8 sequence. */+function completeUtf8Length(bytes) {+ let continuation = 0+ for (let index = bytes.length - 1; index >= 0 && continuation < 4; index -= 1) {+ const byte = bytes[index]+ if ((byte & 0xc0) === 0x80) {+ continuation += 1+ continue+ }+ let expected = 1+ if ((byte & 0xe0) === 0xc0) expected = 2+ else if ((byte & 0xf0) === 0xe0) expected = 3+ else if ((byte & 0xf8) === 0xf0) expected = 4+ return continuation + 1 < expected ? index : bytes.length+ }+ return bytes.length+}++function hasDisallowedControl(text) {+ for (let index = 0; index < text.length; index += 1) {+ const code = text.charCodeAt(index)+ if (code === 0x09 || code === 0x0a || code === 0x0d) continue+ if (code <= 0x1f || (code >= 0x80 && code <= 0x9f)) return true+ }+ return false+}++/**+ * Decoded text when the bytes are strict UTF-8 without C0/C1 controls (TAB, LF+ * and CR excepted), else null. A UTF-8 byte order mark is accepted and dropped.+ */+function decodeStrictText(bytes, partial) {+ const usable = partial ? bytes.subarray(0, completeUtf8Length(bytes)) : bytes+ let text+ try {+ text = new TextDecoder('utf-8', { fatal: true }).decode(usable)+ } catch {+ return null+ }+ return hasDisallowedControl(text) ? null : text+}++function stripLeadingMarkup(text) {+ let rest = text.slice(0, TEXT_ROOT_SCAN_CHARS).replace(/^\s+/, '')+ for (;;) {+ const before = rest+ rest = rest+ .replace(/^<\?xml[\s\S]*?\?>\s*/i, '')+ .replace(/^<!--[\s\S]*?-->\s*/, '')+ .replace(/^<!DOCTYPE\s+svg[\s\S]*?>\s*/i, '')+ if (rest === before) return rest+ }+}++function textClassFromContent(text) {+ const head = stripLeadingMarkup(text)+ if (/^<svg[\s>/]/i.test(head)) return 'svg'+ if (/^<!DOCTYPE\s+html[\s>]/i.test(head) || /^<html[\s>]/i.test(head)) return 'html'+ return null+}++/**+ * Inside the text family the content decides svg and html; otherwise the+ * declared class breaks the tie. SVG is never granted by the name alone.+ */+function textClassFor(text, expectedClass) {+ const fromContent = textClassFromContent(text)+ if (fromContent) return fromContent+ if (expectedClass && expectedClass !== 'svg' && familyOf(expectedClass) === 'text') {+ return expectedClass+ }+ return 'text'+}++function result(fileClass, detection, mismatch, detectedMediaType) {+ const textReadable = TEXT_CLASSES.has(fileClass)+ return {+ class: fileClass,+ detectedMediaType: detectedMediaType ?? MEDIA_TYPE_BY_CLASS[fileClass],+ detection,+ textReadable,+ reader: textReadable ? 'text' : 'none',+ modelImageInput: IMAGE_CLASSES.has(fileClass) ? 'candidate' : 'unsupported',+ mismatch,+ }+}++/**+ * A generic text media type such as `text/plain` names only the family, so a+ * text-family extension (`.md`, `.py`, `.html`) supplies the subclass.+ */+function expectedClassFor(mediaTypeClass, extensionClass) {+ if (mediaTypeClass === 'text' && extensionClass && familyOf(extensionClass) === 'text') {+ return extensionClass+ }+ return mediaTypeClass ?? extensionClass+}++function mismatchFor(detectedClass, mediaTypeClass, extensionClass) {+ const family = familyOf(detectedClass)+ return [mediaTypeClass, extensionClass].some(+ expected => expected !== null && familyOf(expected) !== family+ )+}++/**+ * Evidence-based classification. `partial` means `bytes` is a prefix of a longer+ * file: ZIP entries then come from local headers and a trailing incomplete+ * UTF-8 sequence is ignored.+ */+function classifyFromEvidence(bytes, partial, expectedClass) {+ if (startsWith(bytes, JPEG_SIGNATURE)) return { fileClass: 'jpeg', detection: 'magic' }+ if (startsWith(bytes, PNG_SIGNATURE)) return { fileClass: 'png', detection: 'magic' }+ if (startsWith(bytes, ZIP_LOCAL_HEADER_SIGNATURE)) {+ const names = partial ? zipLocalHeaderNames(bytes) : zipCentralDirectoryNames(bytes)+ const officeClass = officeClassFromZipNames(names)+ if (officeClass) return { fileClass: officeClass, detection: 'magic' }+ return { fileClass: 'binary_unsupported', detection: 'magic', zip: true }+ }+ if (hasPdfSignature(bytes)) return { fileClass: 'pdf', detection: 'magic' }+ const text = decodeStrictText(bytes, partial)+ if (text !== null) {+ return { fileClass: textClassFor(text, expectedClass), detection: 'text_utf8', text: true }+ }+ return { fileClass: 'binary_unsupported', detection: 'magic' }+}++const SIGNATURE_CLASSES = new Set(['jpeg', 'png', 'pdf', 'docx', 'xlsx'])++/** Whether a short prefix without an identifying signature is compatible with the declared class. */+function prefixSupportsDeclared(evidence, bytesLength, expectedClass) {+ if (bytesLength === 0) return true+ if (familyOf(expectedClass) === 'text') return evidence.text === true+ if (expectedClass === 'docx' || expectedClass === 'xlsx') return evidence.zip === true+ return false+}++/**+ * @param {{ bytes: Uint8Array, totalByteLength: number, declaredMediaType?: string | null, filename?: string | null }} input+ */+function classifyBytes(input) {+ if (!input || !(input.bytes instanceof Uint8Array)) {+ throw new TypeError('classifyBytes requires input.bytes as a Uint8Array.')+ }+ const { bytes, totalByteLength } = input+ if (!Number.isSafeInteger(totalByteLength) || totalByteLength < bytes.length) {+ throw new TypeError(+ 'classifyBytes requires totalByteLength to be an integer no smaller than bytes.length.'+ )+ }+ const mediaTypeClass = classFromMediaType(input.declaredMediaType)+ const extensionClass = classFromExtension(input.filename)+ const expectedClass = expectedClassFor(mediaTypeClass, extensionClass)+ const partial = bytes.length < totalByteLength+ const evidence = classifyFromEvidence(bytes, partial, expectedClass)++ if (+ partial &&+ bytes.length < DECLARED_EVIDENCE_PREFIX_BYTES &&+ !SIGNATURE_CLASSES.has(evidence.fileClass)+ ) {+ if (expectedClass && prefixSupportsDeclared(evidence, bytes.length, expectedClass)) {+ return result(expectedClass, 'declared', false)+ }+ if (bytes.length === 0) return result('binary_unsupported', 'declared', false)+ }++ return result(+ evidence.fileClass,+ evidence.detection,+ mismatchFor(evidence.fileClass, mediaTypeClass, extensionClass),+ evidence.zip ? ZIP_MEDIA_TYPE : undefined+ )+}++module.exports = {+ FILE_CLASSES,+ MEDIA_TYPE_BY_CLASS,+ classifyBytes,+ fileClassFamily: familyOf,+}diff --git a/packages/gfs-interaction-policy/fileClassifier.d.ts b/packages/gfs-interaction-policy/fileClassifier.d.tsnew file mode 100644index 000000000..ff6b16e84--- /dev/null+++ b/packages/gfs-interaction-policy/fileClassifier.d.ts@@ -0,0 +1,48 @@+export type FileClass =+ | 'text'+ | 'markdown'+ | 'html'+ | 'code'+ | 'svg'+ | 'jpeg'+ | 'png'+ | 'pdf'+ | 'docx'+ | 'xlsx'+ | 'binary_unsupported'++export type FileClassFamily = 'text' | 'image' | 'document_binary' | 'binary_unsupported'++export type FileDetection = 'magic' | 'text_utf8' | 'declared'++export interface FileClassification {+ class: FileClass+ detectedMediaType: string+ detection: FileDetection+ textReadable: boolean+ reader: 'text' | 'none'+ modelImageInput: 'candidate' | 'unsupported'+ /** The detected family differs from the one the declared media type or the extension implies. */+ mismatch: boolean+}++export declare const FILE_CLASSES: readonly FileClass[]+export declare const MEDIA_TYPE_BY_CLASS: Readonly<Record<FileClass, string>>++/**+ * Classify a file by its bytes. `bytes` is the whole file or a prefix of it;+ * `totalByteLength` is the size of the whole file.+ *+ * `detection: 'declared'` is returned only for a prefix shorter than 64 KiB+ * (including an empty one) that carries no signature and no evidence against+ * the declared media type or extension. Every other result is decided by the+ * bytes, and the declared type only breaks ties inside the text family.+ */+export declare function classifyBytes(input: {+ bytes: Uint8Array+ totalByteLength: number+ declaredMediaType?: string | null+ filename?: string | null+}): FileClassification++export declare function fileClassFamily(fileClass: FileClass): FileClassFamilydiff --git a/packages/gfs-interaction-policy/fileClassifier.test.cjs b/packages/gfs-interaction-policy/fileClassifier.test.cjsnew file mode 100644index 000000000..6018e7ab4--- /dev/null+++ b/packages/gfs-interaction-policy/fileClassifier.test.cjs@@ -0,0 +1,91 @@+'use strict'++const assert = require('node:assert/strict')+const fs = require('node:fs')+const path = require('node:path')+const { describe, it } = require('node:test')+const { classifyBytes, FILE_CLASSES, MEDIA_TYPE_BY_CLASS } = require('./fileClassifier.cjs')++const EXPECTED_VECTOR_COUNT = 37+const { vectors } = JSON.parse(+ fs.readFileSync(path.join(__dirname, 'fixtures', 'classifier-vectors.v1.json'), 'utf8')+)++function bytesOf(vector) {+ return new Uint8Array(Buffer.from(vector.input.bytesBase64, 'base64'))+}++describe('classifier vectors', () => {+ it('loads every vector', () => {+ assert.equal(vectors.length, EXPECTED_VECTOR_COUNT)+ })++ for (const vector of vectors) {+ it(vector.name, () => {+ const actual = classifyBytes({+ bytes: bytesOf(vector),+ totalByteLength: vector.input.totalByteLength,+ declaredMediaType: vector.input.declaredMediaType,+ filename: vector.input.filename,+ })+ assert.deepEqual(actual, vector.expected)+ })+ }++ it('covers every file class and every detection', () => {+ const classes = new Set(vectors.map(vector => vector.expected.class))+ assert.deepEqual([...classes].sort(), [...FILE_CLASSES].sort())+ const detections = new Set(vectors.map(vector => vector.expected.detection))+ assert.deepEqual([...detections].sort(), ['declared', 'magic', 'text_utf8'])+ })+})++describe('classifyBytes', () => {+ it('maps every class to a detected media type', () => {+ for (const fileClass of FILE_CLASSES)+ assert.equal(typeof MEDIA_TYPE_BY_CLASS[fileClass], 'string')+ })++ it('rejects input that is not a Uint8Array', () => {+ assert.throws(() => classifyBytes({ bytes: 'abc', totalByteLength: 3 }), TypeError)+ })++ it('rejects a total length smaller than the bytes provided', () => {+ assert.throws(+ () => classifyBytes({ bytes: new Uint8Array([1, 2, 3]), totalByteLength: 2 }),+ TypeError+ )+ })++ it('does not decode a binary file as text', () => {+ const result = classifyBytes({+ bytes: new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d, 0x00, 0xff]),+ totalByteLength: 7,+ filename: 'x.txt',+ })+ assert.equal(result.class, 'pdf')+ assert.equal(result.textReadable, false)+ assert.equal(result.reader, 'none')+ })++ it('ignores media type parameters and case', () => {+ const result = classifyBytes({+ bytes: new TextEncoder().encode('# T\n'),+ totalByteLength: 4,+ declaredMediaType: 'Text/Markdown; charset=UTF-8',+ filename: null,+ })+ assert.equal(result.class, 'markdown')+ assert.equal(result.mismatch, false)+ })+})++describe('isomorphic module', () => {+ it('uses no Node-only API, so the renderer can load it', () => {+ const source = fs.readFileSync(path.join(__dirname, 'fileClassifier.cjs'), 'utf8')+ assert.match(source, /TextDecoder/, 'the module source was not read')+ assert.doesNotMatch(source, /\bBuffer\b/)+ assert.doesNotMatch(source, /require\(['"]node:/)+ assert.doesNotMatch(source, /require\(['"](?:crypto|fs|path|zlib)['"]\)/)+ })+})diff --git a/packages/gfs-interaction-policy/fileReference.cjs b/packages/gfs-interaction-policy/fileReference.cjsnew file mode 100644index 000000000..6df32c806--- /dev/null+++ b/packages/gfs-interaction-policy/fileReference.cjs@@ -0,0 +1,287 @@+'use strict'++/**+ * FileReferenceV1: the versioned, structured description of a file a turn+ * refers to — either an attachment delivered inline with the current message or+ * a Global Files resource. A reference describes a file; it never grants access+ * to it. Consumers re-authorize GFS references before reading them.+ */++const { FILE_CLASSES, MEDIA_TYPE_BY_CLASS, fileClassFamily } = require('./fileClassifier.cjs')++const FILE_REFERENCE_SCHEMA_VERSION = 1+const FILE_REFERENCE_NAME_MAX_CODE_POINTS = 255++const SCHEMA_VERSION_UNSUPPORTED = 'FILE_REFERENCE_SCHEMA_VERSION_UNSUPPORTED'+const INVALID = 'FILE_REFERENCE_INVALID'++const TOP_LEVEL_KEYS = new Set([+ 'schemaVersion',+ 'id',+ 'source',+ 'name',+ 'declaredMediaType',+ 'detectedMediaType',+ 'class',+ 'detection',+ 'mismatch',+ 'byteLength',+ 'digest',+ 'textReadable',+ 'reader',+ 'modelImageInput',+])+const ATTACHMENT_SOURCE_KEYS = new Set(['kind', 'attachmentId', 'messageId'])+const GFS_SOURCE_KEYS = new Set(['kind', 'drive', 'resourceId', 'gfsUri', 'version'])+const DIGEST_KEYS = new Set(['algorithm', 'hex'])+const DETECTIONS = new Set(['magic', 'text_utf8', 'declared'])+const SHA256_HEX = /^[0-9a-f]{64}$/++function fail(message) {+ return { ok: false, code: INVALID, message }+}++function isPlainObject(value) {+ return value !== null && typeof value === 'object' && !Array.isArray(value)+}++function unknownKey(value, allowed) {+ return Object.keys(value).find(key => !allowed.has(key))+}++function isNonEmptyString(value) {+ return typeof value === 'string' && value.length > 0+}++function nameProblem(name) {+ if (typeof name !== 'string' || name.length === 0) return 'name must be a non-empty string'+ if (name.normalize('NFC') !== name) return 'name must be NFC-normalized'+ if ([...name].length > FILE_REFERENCE_NAME_MAX_CODE_POINTS) {+ return `name must be at most ${FILE_REFERENCE_NAME_MAX_CODE_POINTS} code points`+ }+ if (name === '.' || name === '..') return 'name must not be a relative path segment'+ // eslint-disable-next-line no-control-regex+ if (/[/\\\u0000-\u001f\u007f]/.test(name)) {+ return 'name must not contain path separators or control characters'+ }+ return null+}++/**+ * The id is derived from the source, never chosen by a producer, so two+ * references to the same bytes compare equal and a forged id is detectable.+ */+function deriveFileReferenceId(source, digest) {+ if (!isPlainObject(source)) throw new TypeError('source must be an object.')+ if (source.kind === 'attachment') {+ if (!isPlainObject(digest) || !SHA256_HEX.test(digest.hex ?? '')) {+ throw new TypeError('An attachment reference id requires a sha256 digest.')+ }+ return `att:${source.messageId}:${source.attachmentId}@sha256:${digest.hex}`+ }+ if (source.kind === 'gfs') {+ return `gfs:${source.drive}:${source.resourceId}@v${source.version}`+ }+ throw new TypeError(`Unknown file reference source kind: ${String(source.kind)}`)+}++function parseSource(source) {+ if (!isPlainObject(source)) return { problem: 'source must be an object' }+ if (source.kind === 'attachment') {+ const extra = unknownKey(source, ATTACHMENT_SOURCE_KEYS)+ if (extra) return { problem: `source has unknown field ${extra}` }+ if (!isNonEmptyString(source.attachmentId) || !isNonEmptyString(source.messageId)) {+ return { problem: 'attachment source requires attachmentId and messageId' }+ }+ return {+ value: { kind: 'attachment', attachmentId: source.attachmentId, messageId: source.messageId },+ }+ }+ if (source.kind === 'gfs') {+ const extra = unknownKey(source, GFS_SOURCE_KEYS)+ if (extra) return { problem: `source has unknown field ${extra}` }+ if (+ !isNonEmptyString(source.drive) ||+ !isNonEmptyString(source.resourceId) ||+ !isNonEmptyString(source.gfsUri)+ ) {+ return { problem: 'gfs source requires drive, resourceId and gfsUri' }+ }+ if (!Number.isSafeInteger(source.version) || source.version < 0) {+ return { problem: 'gfs source version must be a non-negative integer' }+ }+ return {+ value: {+ kind: 'gfs',+ drive: source.drive,+ resourceId: source.resourceId,+ gfsUri: source.gfsUri,+ version: source.version,+ },+ }+ }+ return { problem: 'source.kind must be attachment or gfs' }+}++function parseDigest(digest) {+ if (!isPlainObject(digest)) return { problem: 'digest must be an object' }+ const extra = unknownKey(digest, DIGEST_KEYS)+ if (extra) return { problem: `digest has unknown field ${extra}` }+ if (+ digest.algorithm !== 'sha256' ||+ typeof digest.hex !== 'string' ||+ !SHA256_HEX.test(digest.hex)+ ) {+ return { problem: 'digest must be sha256 with 64 lowercase hex characters' }+ }+ return { value: { algorithm: 'sha256', hex: digest.hex } }+}++function classificationProblem(input) {+ if (!FILE_CLASSES.includes(input.class)) return 'class is not a known file class'+ if (!DETECTIONS.has(input.detection)) return 'detection must be magic, text_utf8 or declared'+ if (typeof input.mismatch !== 'boolean') return 'mismatch must be a boolean'+ if (typeof input.textReadable !== 'boolean') return 'textReadable must be a boolean'+ const family = fileClassFamily(input.class)+ if (input.textReadable !== (family === 'text')) return 'textReadable contradicts class'+ if (input.reader !== (input.textReadable ? 'text' : 'none')) return 'reader contradicts class'+ const expectedImageInput = family === 'image' ? 'candidate' : 'unsupported'+ if (input.modelImageInput !== expectedImageInput) return 'modelImageInput contradicts class'+ if (input.detection === 'text_utf8' && family !== 'text') return 'detection contradicts class'+ const allowedMediaTypes =+ input.class === 'binary_unsupported'+ ? [MEDIA_TYPE_BY_CLASS.binary_unsupported, 'application/zip']+ : [MEDIA_TYPE_BY_CLASS[input.class]]+ if (!allowedMediaTypes.includes(input.detectedMediaType)) {+ return 'detectedMediaType contradicts class'+ }+ return null+}++/**+ * Parse an untrusted value as FileReferenceV1. A missing or different+ * schemaVersion is reported separately so callers can fail with an explicit+ * incompatibility instead of a generic validation error.+ */+function parseFileReferenceV1(input) {+ if (!isPlainObject(input)) return fail('file reference must be an object')+ if (input.schemaVersion !== FILE_REFERENCE_SCHEMA_VERSION) {+ return {+ ok: false,+ code: SCHEMA_VERSION_UNSUPPORTED,+ message: `unsupported file reference schemaVersion ${JSON.stringify(input.schemaVersion)}; expected ${FILE_REFERENCE_SCHEMA_VERSION}`,+ }+ }+ const extra = unknownKey(input, TOP_LEVEL_KEYS)+ if (extra) return fail(`file reference has unknown field ${extra}`)++ const source = parseSource(input.source)+ if (source.problem) return fail(source.problem)++ const problem = nameProblem(input.name)+ if (problem) return fail(problem)++ if (input.declaredMediaType !== null && !isNonEmptyString(input.declaredMediaType)) {+ return fail('declaredMediaType must be a non-empty string or null')+ }+ if (!isNonEmptyString(input.detectedMediaType)) return fail('detectedMediaType is required')+ if (!Number.isSafeInteger(input.byteLength) || input.byteLength < 0) {+ return fail('byteLength must be a non-negative integer')+ }++ let digest+ if (input.digest !== undefined) {+ const parsedDigest = parseDigest(input.digest)+ if (parsedDigest.problem) return fail(parsedDigest.problem)+ digest = parsedDigest.value+ } else if (source.value.kind === 'attachment') {+ return fail('attachment references require a digest')+ }++ const classification = classificationProblem(input)+ if (classification) return fail(classification)++ const expectedId = deriveFileReferenceId(source.value, digest)+ if (input.id !== expectedId)+ return fail('id does not match the id derived from source and digest')++ const value = {+ schemaVersion: FILE_REFERENCE_SCHEMA_VERSION,+ id: expectedId,+ source: source.value,+ name: input.name,+ declaredMediaType: input.declaredMediaType,+ detectedMediaType: input.detectedMediaType,+ class: input.class,+ detection: input.detection,+ mismatch: input.mismatch,+ byteLength: input.byteLength,+ textReadable: input.textReadable,+ reader: input.reader,+ modelImageInput: input.modelImageInput,+ }+ if (digest) value.digest = digest+ return { ok: true, value }+}++function buildReference(source, fields, digest) {+ const name = typeof fields.name === 'string' ? fields.name.normalize('NFC') : fields.name+ const classification = fields.classification ?? {}+ const candidate = {+ schemaVersion: FILE_REFERENCE_SCHEMA_VERSION,+ source,+ name,+ declaredMediaType: fields.declaredMediaType ?? null,+ detectedMediaType: classification.detectedMediaType,+ class: classification.class,+ detection: classification.detection,+ mismatch: classification.mismatch,+ byteLength: fields.byteLength,+ textReadable: classification.textReadable,+ reader: classification.reader,+ modelImageInput: classification.modelImageInput,+ }+ if (digest) candidate.digest = digest+ const sourceCheck = parseSource(source)+ if (sourceCheck.problem) return fail(sourceCheck.problem)+ if (source.kind === 'attachment' && !(digest && SHA256_HEX.test(digest.hex ?? ''))) {+ return fail('attachment references require a sha256 digest')+ }+ candidate.id = deriveFileReferenceId(sourceCheck.value, digest)+ return parseFileReferenceV1(candidate)+}++/**+ * Build a reference for an attachment delivered inline with the current+ * message. `classification` is the output of classifyBytes over the whole file.+ */+function buildAttachmentFileReference(fields) {+ return buildReference(+ { kind: 'attachment', attachmentId: fields.attachmentId, messageId: fields.messageId },+ fields,+ { algorithm: 'sha256', hex: fields.digestHex }+ )+}++/** Build a reference for a Global Files resource at an exact version. */+function buildGfsFileReference(fields) {+ return buildReference(+ {+ kind: 'gfs',+ drive: fields.drive,+ resourceId: fields.resourceId,+ gfsUri: fields.gfsUri,+ version: fields.version,+ },+ fields,+ fields.digestHex === undefined ? undefined : { algorithm: 'sha256', hex: fields.digestHex }+ )+}++module.exports = {+ FILE_REFERENCE_SCHEMA_VERSION,+ buildAttachmentFileReference,+ buildGfsFileReference,+ deriveFileReferenceId,+ parseFileReferenceV1,+}diff --git a/packages/gfs-interaction-policy/fileReference.d.ts b/packages/gfs-interaction-policy/fileReference.d.tsnew file mode 100644index 000000000..ba9ece5e0--- /dev/null+++ b/packages/gfs-interaction-policy/fileReference.d.ts@@ -0,0 +1,73 @@+import type { FileClass, FileClassification, FileDetection } from './fileClassifier'++export type FileReferenceSource =+ | { kind: 'attachment'; attachmentId: string; messageId: string }+ | { kind: 'gfs'; drive: string; resourceId: string; gfsUri: string; version: number }++export interface FileReferenceDigest {+ algorithm: 'sha256'+ /** 64 lowercase hex characters. */+ hex: string+}++export interface FileReferenceV1 {+ schemaVersion: 1+ /**+ * Derived, never chosen: `att:<messageId>:<attachmentId>@sha256:<hex>` or+ * `gfs:<drive>:<resourceId>@v<version>`.+ */+ id: string+ source: FileReferenceSource+ /** Base name, NFC, 1-255 code points, no path separators or control characters. */+ name: string+ declaredMediaType: string | null+ detectedMediaType: string+ class: FileClass+ detection: FileDetection+ mismatch: boolean+ byteLength: number+ /** Required for attachments, optional for GFS resources. */+ digest?: FileReferenceDigest+ textReadable: boolean+ reader: 'text' | 'none'+ modelImageInput: 'candidate' | 'unsupported'+}++export type FileReferenceErrorCode =+ | 'FILE_REFERENCE_SCHEMA_VERSION_UNSUPPORTED'+ | 'FILE_REFERENCE_INVALID'++export type FileReferenceParseResult =+ | { ok: true; value: FileReferenceV1 }+ | { ok: false; code: FileReferenceErrorCode; message: string }++export declare const FILE_REFERENCE_SCHEMA_VERSION: 1++export declare function parseFileReferenceV1(input: unknown): FileReferenceParseResult++export declare function deriveFileReferenceId(+ source: FileReferenceSource,+ digest?: FileReferenceDigest+): string++export declare function buildAttachmentFileReference(fields: {+ attachmentId: string+ messageId: string+ name: string+ declaredMediaType?: string | null+ byteLength: number+ digestHex: string+ classification: FileClassification+}): FileReferenceParseResult++export declare function buildGfsFileReference(fields: {+ drive: string+ resourceId: string+ gfsUri: string+ version: number+ name: string+ declaredMediaType?: string | null+ byteLength: number+ digestHex?: string+ classification: FileClassification+}): FileReferenceParseResultdiff --git a/packages/gfs-interaction-policy/fileReference.test.cjs b/packages/gfs-interaction-policy/fileReference.test.cjsnew file mode 100644index 000000000..0060d3d64--- /dev/null+++ b/packages/gfs-interaction-policy/fileReference.test.cjs@@ -0,0 +1,147 @@+'use strict'++const assert = require('node:assert/strict')+const fs = require('node:fs')+const path = require('node:path')+const { describe, it } = require('node:test')+const { classifyBytes } = require('./fileClassifier.cjs')+const {+ FILE_REFERENCE_SCHEMA_VERSION,+ buildAttachmentFileReference,+ buildGfsFileReference,+ deriveFileReferenceId,+ parseFileReferenceV1,+} = require('./fileReference.cjs')++const EXPECTED_VECTOR_COUNT = 36+const { vectors } = JSON.parse(+ fs.readFileSync(path.join(__dirname, 'fixtures', 'file-reference-vectors.v1.json'), 'utf8')+)+const HEX = 'b'.repeat(64)++describe('file reference vectors', () => {+ it('loads every vector', () => {+ assert.equal(vectors.length, EXPECTED_VECTOR_COUNT)+ assert.ok(vectors.some(vector => vector.expected.ok === true))+ assert.ok(vectors.some(vector => vector.expected.ok === false))+ })++ for (const vector of vectors) {+ it(vector.name, () => {+ const actual = parseFileReferenceV1(vector.input)+ assert.equal(actual.ok, vector.expected.ok, actual.ok ? 'parsed' : actual.message)+ if (vector.expected.ok) {+ assert.deepEqual(actual.value, vector.input)+ } else {+ assert.equal(actual.code, vector.expected.code)+ assert.equal(typeof actual.message, 'string')+ }+ })+ }+})++describe('deriveFileReferenceId', () => {+ it('derives attachment and gfs ids', () => {+ assert.equal(+ deriveFileReferenceId(+ { kind: 'attachment', attachmentId: 'a', messageId: 'm' },+ { algorithm: 'sha256', hex: HEX }+ ),+ `att:m:a@sha256:${HEX}`+ )+ assert.equal(+ deriveFileReferenceId({+ kind: 'gfs',+ drive: 'shared',+ resourceId: 'r',+ gfsUri: 'gfs://shared/r',+ version: 3,+ }),+ 'gfs:shared:r@v3'+ )+ })++ it('requires a digest for attachments', () => {+ assert.throws(+ () => deriveFileReferenceId({ kind: 'attachment', attachmentId: 'a', messageId: 'm' }),+ TypeError+ )+ })+})++describe('builders', () => {+ const markdown = new TextEncoder().encode('# Café\n')+ const classification = classifyBytes({+ bytes: markdown,+ totalByteLength: markdown.length,+ declaredMediaType: 'text/markdown',+ filename: 'notes.md',+ })++ it('builds a valid attachment reference and normalizes the name to NFC', () => {+ const built = buildAttachmentFileReference({+ attachmentId: 'att-1',+ messageId: 'msg-1',+ name: 'café.md',+ declaredMediaType: 'text/markdown',+ byteLength: markdown.length,+ digestHex: HEX,+ classification,+ })+ assert.equal(built.ok, true, built.ok ? '' : built.message)+ assert.equal(built.value.schemaVersion, FILE_REFERENCE_SCHEMA_VERSION)+ assert.equal(built.value.name, 'café.md')+ assert.equal(built.value.id, `att:msg-1:att-1@sha256:${HEX}`)+ assert.equal(built.value.reader, 'text')+ assert.deepEqual(parseFileReferenceV1(built.value), built)+ })++ it('reports an invalid attachment name instead of throwing', () => {+ const built = buildAttachmentFileReference({+ attachmentId: 'att-1',+ messageId: 'msg-1',+ name: '../notes.md',+ byteLength: markdown.length,+ digestHex: HEX,+ classification,+ })+ assert.equal(built.ok, false)+ assert.equal(built.code, 'FILE_REFERENCE_INVALID')+ })++ it('reports an attachment digest that is not sha256 hex', () => {+ const built = buildAttachmentFileReference({+ attachmentId: 'att-1',+ messageId: 'msg-1',+ name: 'notes.md',+ byteLength: markdown.length,+ digestHex: 'not-hex',+ classification,+ })+ assert.equal(built.ok, false)+ assert.equal(built.code, 'FILE_REFERENCE_INVALID')+ })++ it('builds a gfs reference from declared metadata alone', () => {+ const declared = classifyBytes({+ bytes: new Uint8Array(0),+ totalByteLength: 2048,+ declaredMediaType: 'application/pdf',+ filename: 'q3.pdf',+ })+ const built = buildGfsFileReference({+ drive: 'personal',+ resourceId: 'res-42',+ gfsUri: 'gfs://personal/reports/q3.pdf',+ version: 7,+ name: 'q3.pdf',+ declaredMediaType: 'application/pdf',+ byteLength: 2048,+ classification: declared,+ })+ assert.equal(built.ok, true, built.ok ? '' : built.message)+ assert.equal(built.value.id, 'gfs:personal:res-42@v7')+ assert.equal(built.value.detection, 'declared')+ assert.equal(built.value.digest, undefined)+ })+})diff --git a/packages/gfs-interaction-policy/fixtures/classifier-vectors.v1.json b/packages/gfs-interaction-policy/fixtures/classifier-vectors.v1.jsonnew file mode 100644index 000000000..e75bc1013--- /dev/null+++ b/packages/gfs-interaction-policy/fixtures/classifier-vectors.v1.json@@ -0,0 +1,671 @@+{+ "schemaVersion": 1,+ "vectors": [+ {+ "name": "jpeg by signature",+ "input": {+ "bytesBase64": "/9j/4AAQSkZJRgABAQD/2Q==",+ "totalByteLength": 16,+ "declaredMediaType": "image/jpeg",+ "filename": "photo.jpg"+ },+ "expected": {+ "class": "jpeg",+ "detectedMediaType": "image/jpeg",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "candidate",+ "mismatch": false+ }+ },+ {+ "name": "png by signature",+ "input": {+ "bytesBase64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJ",+ "totalByteLength": 33,+ "declaredMediaType": "image/png",+ "filename": "image.png"+ },+ "expected": {+ "class": "png",+ "detectedMediaType": "image/png",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "candidate",+ "mismatch": false+ }+ },+ {+ "name": "png bytes named .txt",+ "input": {+ "bytesBase64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJ",+ "totalByteLength": 33,+ "declaredMediaType": "text/plain",+ "filename": "notes.txt"+ },+ "expected": {+ "class": "png",+ "detectedMediaType": "image/png",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "candidate",+ "mismatch": true+ }+ },+ {+ "name": "pdf by signature",+ "input": {+ "bytesBase64": "JVBERi0xLjcKMSAwIG9iaiA8PCAvVHlwZSAvQ2F0YWxvZyA+PiBlbmRvYmoKJSVFT0YK",+ "totalByteLength": 51,+ "declaredMediaType": "application/pdf",+ "filename": "report.pdf"+ },+ "expected": {+ "class": "pdf",+ "detectedMediaType": "application/pdf",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "pdf signature after leading bytes",+ "input": {+ "bytesBase64": "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICVQREYtMS43CjEgMCBvYmogPDwgL1R5cGUgL0NhdGFsb2cgPj4gZW5kb2JqCiUlRU9GCg==",+ "totalByteLength": 151,+ "declaredMediaType": null,+ "filename": "doc.pdf"+ },+ "expected": {+ "class": "pdf",+ "detectedMediaType": "application/pdf",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "pdf bytes named .txt",+ "input": {+ "bytesBase64": "JVBERi0xLjcKMSAwIG9iaiA8PCAvVHlwZSAvQ2F0YWxvZyA+PiBlbmRvYmoKJSVFT0YK",+ "totalByteLength": 51,+ "declaredMediaType": "text/plain",+ "filename": "notes.txt"+ },+ "expected": {+ "class": "pdf",+ "detectedMediaType": "application/pdf",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": true+ }+ },+ {+ "name": "docx by zip entries",+ "input": {+ "bytesBase64": "UEsDBBQAAAAAAAAAAADuR1hmHQAAAB0AAAATAAAAW0NvbnRlbnRfVHlwZXNdLnhtbDw/eG1sIHZlcnNpb249IjEuMCI/PjxUeXBlcy8+UEsDBBQAAAAAAAAAAACC2RzVEAAAABAAAAALAAAAX3JlbHMvLnJlbHM8UmVsYXRpb25zaGlwcy8+UEsDBBQAAAAAAAAAAADdWoYNDQAAAA0AAAARAAAAd29yZC9kb2N1bWVudC54bWw8dzpkb2N1bWVudC8+UEsBAhQAFAAAAAAAAAAAAO5HWGYdAAAAHQAAABMAAAAAAAAAAAAAAAAAAAAAAFtDb250ZW50X1R5cGVzXS54bWxQSwECFAAUAAAAAAAAAAAAgtkc1RAAAAAQAAAACwAAAAAAAAAAAAAAAABOAAAAX3JlbHMvLnJlbHNQSwECFAAUAAAAAAAAAAAA3VqGDQ0AAAANAAAAEQAAAAAAAAAAAAAAAACHAAAAd29yZC9kb2N1bWVudC54bWxQSwUGAAAAAAMAAwC5AAAAwwAAAAAA",+ "totalByteLength": 402,+ "declaredMediaType": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",+ "filename": "letter.docx"+ },+ "expected": {+ "class": "docx",+ "detectedMediaType": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "xlsx by zip entries",+ "input": {+ "bytesBase64": "UEsDBBQAAAAAAAAAAADuR1hmHQAAAB0AAAATAAAAW0NvbnRlbnRfVHlwZXNdLnhtbDw/eG1sIHZlcnNpb249IjEuMCI/PjxUeXBlcy8+UEsDBBQAAAAAAAAAAACC2RzVEAAAABAAAAALAAAAX3JlbHMvLnJlbHM8UmVsYXRpb25zaGlwcy8+UEsDBBQAAAAAAAAAAADOnpgTCwAAAAsAAAAPAAAAeGwvd29ya2Jvb2sueG1sPHdvcmtib29rLz5QSwECFAAUAAAAAAAAAAAA7kdYZh0AAAAdAAAAEwAAAAAAAAAAAAAAAAAAAAAAW0NvbnRlbnRfVHlwZXNdLnhtbFBLAQIUABQAAAAAAAAAAACC2RzVEAAAABAAAAALAAAAAAAAAAAAAAAAAE4AAABfcmVscy8ucmVsc1BLAQIUABQAAAAAAAAAAADOnpgTCwAAAAsAAAAPAAAAAAAAAAAAAAAAAIcAAAB4bC93b3JrYm9vay54bWxQSwUGAAAAAAMAAwC3AAAAvwAAAAAA",+ "totalByteLength": 396,+ "declaredMediaType": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",+ "filename": "sheet.xlsx"+ },+ "expected": {+ "class": "xlsx",+ "detectedMediaType": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "plain zip archive",+ "input": {+ "bytesBase64": "UEsDBBQAAAAAAAAAAACGphA2BQAAAAUAAAAFAAAAYS50eHRoZWxsb1BLAQIUABQAAAAAAAAAAACGphA2BQAAAAUAAAAFAAAAAAAAAAAAAAAAAAAAAABhLnR4dFBLBQYAAAAAAQABADMAAAAoAAAAAAA=",+ "totalByteLength": 113,+ "declaredMediaType": "application/zip",+ "filename": "archive.zip"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/zip",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "zip named .docx without word entries",+ "input": {+ "bytesBase64": "UEsDBBQAAAAAAAAAAACGphA2BQAAAAUAAAAFAAAAYS50eHRoZWxsb1BLAQIUABQAAAAAAAAAAACGphA2BQAAAAUAAAAFAAAAAAAAAAAAAAAAAAAAAABhLnR4dFBLBQYAAAAAAQABADMAAAAoAAAAAAA=",+ "totalByteLength": 113,+ "declaredMediaType": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",+ "filename": "letter.docx"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/zip",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": true+ }+ },+ {+ "name": "svg with xml declaration",+ "input": {+ "bytesBase64": "PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48L3N2Zz4K",+ "totalByteLength": 69,+ "declaredMediaType": "image/svg+xml",+ "filename": "icon.svg"+ },+ "expected": {+ "class": "svg",+ "detectedMediaType": "image/svg+xml",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "svg content named .txt",+ "input": {+ "bytesBase64": "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4=",+ "totalByteLength": 41,+ "declaredMediaType": "text/plain",+ "filename": "notes.txt"+ },+ "expected": {+ "class": "svg",+ "detectedMediaType": "image/svg+xml",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "name .svg without svg root",+ "input": {+ "bytesBase64": "bm90IGFuIHN2ZyBhdCBhbGwK",+ "totalByteLength": 18,+ "declaredMediaType": "image/svg+xml",+ "filename": "icon.svg"+ },+ "expected": {+ "class": "text",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "markdown with accents",+ "input": {+ "bytesBase64": "IyBUw610dWxvCgpDYWbDqSBjb24gw7FhbmTDui4K",+ "totalByteLength": 30,+ "declaredMediaType": "text/markdown",+ "filename": "notes.md"+ },+ "expected": {+ "class": "markdown",+ "detectedMediaType": "text/markdown",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "markdown extension with text/plain",+ "input": {+ "bytesBase64": "IyBUaXRsZQo=",+ "totalByteLength": 8,+ "declaredMediaType": "text/plain",+ "filename": "notes.md"+ },+ "expected": {+ "class": "markdown",+ "detectedMediaType": "text/markdown",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "html document",+ "input": {+ "bytesBase64": "PCFET0NUWVBFIGh0bWw+CjxodG1sPjxib2R5PjxwPmhpPC9wPjwvYm9keT48L2h0bWw+Cg==",+ "totalByteLength": 52,+ "declaredMediaType": "text/html",+ "filename": "page.html"+ },+ "expected": {+ "class": "html",+ "detectedMediaType": "text/html",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "html with inline svg stays html",+ "input": {+ "bytesBase64": "PGh0bWw+PGJvZHk+PHN2Zz48L3N2Zz48L2JvZHk+PC9odG1sPg==",+ "totalByteLength": 37,+ "declaredMediaType": "text/html",+ "filename": "page.html"+ },+ "expected": {+ "class": "html",+ "detectedMediaType": "text/html",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "html content named .txt",+ "input": {+ "bytesBase64": "PCFkb2N0eXBlIGh0bWw+PGh0bWw+PC9odG1sPg==",+ "totalByteLength": 28,+ "declaredMediaType": "text/plain",+ "filename": "notes.txt"+ },+ "expected": {+ "class": "html",+ "detectedMediaType": "text/html",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "json code",+ "input": {+ "bytesBase64": "eyJhIjogMX0K",+ "totalByteLength": 9,+ "declaredMediaType": "application/json",+ "filename": "data.json"+ },+ "expected": {+ "class": "code",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "python code without media type",+ "input": {+ "bytesBase64": "cHJpbnQoImhpIikK",+ "totalByteLength": 12,+ "declaredMediaType": null,+ "filename": "script.py"+ },+ "expected": {+ "class": "code",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "plain text",+ "input": {+ "bytesBase64": "aGVsbG8K",+ "totalByteLength": 6,+ "declaredMediaType": "text/plain",+ "filename": "notes.txt"+ },+ "expected": {+ "class": "text",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "text without extension or media type",+ "input": {+ "bytesBase64": "cGxhaW4gd29yZHMNCglpbmRlbnRlZAo=",+ "totalByteLength": 23,+ "declaredMediaType": null,+ "filename": "README"+ },+ "expected": {+ "class": "text",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "utf-8 byte order mark",+ "input": {+ "bytesBase64": "77u/aG9sYQo=",+ "totalByteLength": 8,+ "declaredMediaType": "text/plain",+ "filename": "notes.txt"+ },+ "expected": {+ "class": "text",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "utf-16le with byte order mark",+ "input": {+ "bytesBase64": "//5oAGkA",+ "totalByteLength": 6,+ "declaredMediaType": "text/plain",+ "filename": "notes.txt"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": true+ }+ },+ {+ "name": "embedded NUL",+ "input": {+ "bytesBase64": "YWJjAGRlZg==",+ "totalByteLength": 7,+ "declaredMediaType": "text/plain",+ "filename": "data.txt"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": true+ }+ },+ {+ "name": "C1 control character",+ "input": {+ "bytesBase64": "YcKFYg==",+ "totalByteLength": 4,+ "declaredMediaType": "text/plain",+ "filename": "data.txt"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": true+ }+ },+ {+ "name": "invalid utf-8",+ "input": {+ "bytesBase64": "YcMo",+ "totalByteLength": 3,+ "declaredMediaType": null,+ "filename": "x.txt"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": true+ }+ },+ {+ "name": "empty text file",+ "input": {+ "bytesBase64": "",+ "totalByteLength": 0,+ "declaredMediaType": "text/plain",+ "filename": "empty.txt"+ },+ "expected": {+ "class": "text",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "arbitrary binary",+ "input": {+ "bytesBase64": "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==",+ "totalByteLength": 256,+ "declaredMediaType": "application/octet-stream",+ "filename": "data.bin"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "gif is not a supported image",+ "input": {+ "bytesBase64": "R0lGODlhAQABAIAAAA==",+ "totalByteLength": 13,+ "declaredMediaType": "image/gif",+ "filename": "anim.gif"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "empty prefix falls back to the declared pdf",+ "input": {+ "bytesBase64": "",+ "totalByteLength": 1000,+ "declaredMediaType": "application/pdf",+ "filename": "report.pdf"+ },+ "expected": {+ "class": "pdf",+ "detectedMediaType": "application/pdf",+ "detection": "declared",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "empty prefix without declaration",+ "input": {+ "bytesBase64": "",+ "totalByteLength": 500,+ "declaredMediaType": null,+ "filename": "blob"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "declared",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "short text prefix keeps the declared markdown",+ "input": {+ "bytesBase64": "IyBUaXRsZQo=",+ "totalByteLength": 100000,+ "declaredMediaType": "text/markdown",+ "filename": "notes.md"+ },+ "expected": {+ "class": "markdown",+ "detectedMediaType": "text/markdown",+ "detection": "declared",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "short zip prefix keeps the declared docx",+ "input": {+ "bytesBase64": "UEsDBBQAAAAAAAAAAADuR1hmHQAAAB0AAAATAAAAW0NvbnRlbnRfVHlwZXNdLnhtbDw/eG1sIHZlcnNpb249IjEuMCI/PjxUeXBlcy8+UEs=",+ "totalByteLength": 402,+ "declaredMediaType": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",+ "filename": "letter.docx"+ },+ "expected": {+ "class": "docx",+ "detectedMediaType": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",+ "detection": "declared",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ },+ {+ "name": "short prefix with jpeg signature overrides a pdf declaration",+ "input": {+ "bytesBase64": "/9j/4AAQSkZJRgABAQD/2Q==",+ "totalByteLength": 5000,+ "declaredMediaType": "application/pdf",+ "filename": "report.pdf"+ },+ "expected": {+ "class": "jpeg",+ "detectedMediaType": "image/jpeg",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "candidate",+ "mismatch": true+ }+ },+ {+ "name": "short binary prefix contradicts a text declaration",+ "input": {+ "bytesBase64": "YWIAAQ==",+ "totalByteLength": 10000,+ "declaredMediaType": "text/plain",+ "filename": "a.txt"+ },+ "expected": {+ "class": "binary_unsupported",+ "detectedMediaType": "application/octet-stream",+ "detection": "magic",+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "mismatch": true+ }+ },+ {+ "name": "long text prefix ending mid-sequence",+ "input": {+ "bytesBase64": "YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYcM=",+ "totalByteLength": 70000,+ "declaredMediaType": "text/plain",+ "filename": "big.txt"+ },+ "expected": {+ "class": "text",+ "detectedMediaType": "text/plain",+ "detection": "text_utf8",+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "mismatch": false+ }+ }+ ]+}diff --git a/packages/gfs-interaction-policy/fixtures/file-reference-vectors.v1.json b/packages/gfs-interaction-policy/fixtures/file-reference-vectors.v1.jsonnew file mode 100644index 000000000..911951cd1--- /dev/null+++ b/packages/gfs-interaction-policy/fixtures/file-reference-vectors.v1.json@@ -0,0 +1,1035 @@+{+ "schemaVersion": 1,+ "vectors": [+ {+ "name": "valid attachment reference",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": true+ }+ },+ {+ "name": "valid gfs reference without digest",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": true+ }+ },+ {+ "name": "valid gfs reference with digest",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported",+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ }+ },+ "expected": {+ "ok": true+ }+ },+ {+ "name": "binary_unsupported may carry application/zip",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "application/zip",+ "class": "binary_unsupported",+ "detection": "magic",+ "mismatch": true,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": true+ }+ },+ {+ "name": "png attachment is an image input candidate",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "image/png",+ "class": "png",+ "detection": "magic",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "candidate"+ },+ "expected": {+ "ok": true+ }+ },+ {+ "name": "name of 255 code points",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "ññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññ.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": true+ }+ },+ {+ "name": "missing schemaVersion",+ "input": {+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_SCHEMA_VERSION_UNSUPPORTED"+ }+ },+ {+ "name": "schemaVersion 2",+ "input": {+ "schemaVersion": 2,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_SCHEMA_VERSION_UNSUPPORTED"+ }+ },+ {+ "name": "schemaVersion as a string",+ "input": {+ "schemaVersion": "1",+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_SCHEMA_VERSION_UNSUPPORTED"+ }+ },+ {+ "name": "not an object",+ "input": "att:msg-1:att-1",+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "forged id",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-2@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "gfs id with the wrong version",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v6",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "attachment without digest",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "uppercase digest",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "digest algorithm other than sha256",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "md5",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "name with a slash",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "dir/notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "name with a backslash",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "dir\\notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "name ..",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "..",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "name with a control character",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes\u0007.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "name not in NFC",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "café.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "name of 256 code points",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "ñññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññ.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "empty name",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "reader text on a pdf",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "textReadable on a pdf",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "image candidate on a pdf",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "candidate"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "text detection on a pdf",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "detected media type contradicts class",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "text/plain",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "unknown class",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v7",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 7+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "gif",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "unknown top-level field",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported",+ "preview": "data:..."+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "unknown source field",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1",+ "path": "/tmp/x"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "unknown source kind",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "tool",+ "toolCallId": "t-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "negative gfs version",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:res-42@v-1",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": -1+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "fractional gfs version",+ "input": {+ "schemaVersion": 1,+ "id": "gfs:personal:[email protected]",+ "source": {+ "kind": "gfs",+ "drive": "personal",+ "resourceId": "res-42",+ "gfsUri": "gfs://personal/reports/q3.pdf",+ "version": 1.5+ },+ "name": "q3.pdf",+ "declaredMediaType": "application/pdf",+ "detectedMediaType": "application/pdf",+ "class": "pdf",+ "detection": "declared",+ "mismatch": false,+ "byteLength": 2048,+ "textReadable": false,+ "reader": "none",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "negative byteLength",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": -1,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "empty declared media type",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": false,+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ },+ {+ "name": "mismatch not boolean",+ "input": {+ "schemaVersion": 1,+ "id": "att:msg-1:att-1@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ "source": {+ "kind": "attachment",+ "attachmentId": "att-1",+ "messageId": "msg-1"+ },+ "name": "notes.md",+ "declaredMediaType": "text/markdown",+ "detectedMediaType": "text/markdown",+ "class": "markdown",+ "detection": "text_utf8",+ "mismatch": "no",+ "byteLength": 12,+ "digest": {+ "algorithm": "sha256",+ "hex": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ },+ "textReadable": true,+ "reader": "text",+ "modelImageInput": "unsupported"+ },+ "expected": {+ "ok": false,+ "code": "FILE_REFERENCE_INVALID"+ }+ }+ ]+}diff --git a/packages/gfs-interaction-policy/index.cjs b/packages/gfs-interaction-policy/index.cjsindex b206858c0..8a12475a6 100644--- a/packages/gfs-interaction-policy/index.cjs+++ b/packages/gfs-interaction-policy/index.cjs@@ -179,6 +179,8 @@ function createGfsUploadNameReservationBook() {}module.exports = {+ ...require('./fileClassifier.cjs'),+ ...require('./fileReference.cjs'),GFS_RESOURCE_NAME_MAX_LENGTH,GFS_UPLOAD_NAME_EXHAUSTED_MESSAGE,GFS_UPLOAD_NAME_RETRY_LIMIT,diff --git a/packages/gfs-interaction-policy/index.d.ts b/packages/gfs-interaction-policy/index.d.tsindex 860d94cc6..1fe02cff2 100644--- a/packages/gfs-interaction-policy/index.d.ts+++ b/packages/gfs-interaction-policy/index.d.ts@@ -1,3 +1,6 @@+export * from './fileClassifier'+export * from './fileReference'+export declare const GFS_RESOURCE_NAME_MAX_LENGTH: numberexport declare const GFS_UPLOAD_NAME_RETRY_LIMIT: numberexport declare const GFS_UPLOAD_NAME_EXHAUSTED_MESSAGE: stringdiff --git a/packages/gfs-interaction-policy/index.test.cjs b/packages/gfs-interaction-policy/index.test.cjsindex 522d608ba..3a7c8d026 100644--- a/packages/gfs-interaction-policy/index.test.cjs+++ b/packages/gfs-interaction-policy/index.test.cjs@@ -117,11 +117,20 @@ function randomOccupiedNames(random, requestedName) {}it('keeps runtime exports aligned with the declaration file', () => {- const declarations = fs.readFileSync(path.join(__dirname, 'index.d.ts'), 'utf8')- const declared = Array.from(- declarations.matchAll(/export declare (?:const|function)\s+([A-Za-z0-9_]+)/g),- match => match[1]- ).sort()+ const declaredIn = file => {+ const declarations = fs.readFileSync(path.join(__dirname, file), 'utf8')+ const own = Array.from(+ declarations.matchAll(/export declare (?:const|function)\s+([A-Za-z0-9_]+)/g),+ match => match[1]+ )+ const reexported = Array.from(+ declarations.matchAll(/export \* from '\.\/([A-Za-z0-9_]+)'/g),+ match => declaredIn(`${match[1]}.d.ts`)+ )+ return [...own, ...reexported.flat()]+ }+ const declared = declaredIn('index.d.ts').sort()+ assert.ok(declared.includes('classifyBytes'), 'the re-exported declaration files were not read')assert.deepEqual(Object.keys(policy).sort(), declared)})diff --git a/packages/gfs-interaction-policy/package-lock.json b/packages/gfs-interaction-policy/package-lock.jsonindex 7466a3586..ebed08bad 100644--- a/packages/gfs-interaction-policy/package-lock.json+++ b/packages/gfs-interaction-policy/package-lock.json@@ -1,12 +1,12 @@{"name": "@clerum/gfs-interaction-policy",- "version": "0.1.0",+ "version": "0.2.0","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "@clerum/gfs-interaction-policy",- "version": "0.1.0",+ "version": "0.2.0","license": "MIT"}}diff --git a/packages/gfs-interaction-policy/package.json b/packages/gfs-interaction-policy/package.jsonindex 51d7feb8e..327cf32bd 100644--- a/packages/gfs-interaction-policy/package.json+++ b/packages/gfs-interaction-policy/package.json@@ -1,10 +1,18 @@{"name": "@clerum/gfs-interaction-policy",- "version": "0.1.0",+ "version": "0.2.0","private": true,- "description": "Shared browser-safe GFS upload collision, naming, retry, and reservation policy",+ "description": "Shared browser-safe GFS upload collision, naming, retry, and reservation policy, FileReference v1 contract, and byte-based file classifier","main": "index.cjs","types": "index.d.ts",+ "files": [+ "index.cjs",+ "index.d.ts",+ "fileClassifier.cjs",+ "fileClassifier.d.ts",+ "fileReference.cjs",+ "fileReference.d.ts"+ ],"exports": {".": {"types": "./index.d.ts",@@ -13,8 +21,8 @@}},"scripts": {- "build": "node --check index.cjs",- "test": "node --test index.test.cjs"+ "build": "node --check index.cjs && node --check fileClassifier.cjs && node --check fileReference.cjs",+ "test": "node --test index.test.cjs fileReference.test.cjs fileClassifier.test.cjs"},"license": "MIT"}diff --git a/packages/gfs-interaction-policy/scripts/generate-vectors.cjs b/packages/gfs-interaction-policy/scripts/generate-vectors.cjsnew file mode 100644index 000000000..b2d7727dc--- /dev/null+++ b/packages/gfs-interaction-policy/scripts/generate-vectors.cjs@@ -0,0 +1,472 @@+'use strict'+// Regenerates fixtures/classifier-vectors.v1.json and+// fixtures/file-reference-vectors.v1.json. Every expected output below is+// written by hand; none is computed by the classifier or the parser, so the+// vectors stay an independent statement of the contract.+//+// node scripts/generate-vectors.cjs+const fs = require('node:fs')+const path = require('node:path')+const zlib = require('node:zlib')++const OUT = path.join(__dirname, '..', 'fixtures')+const b = (...parts) =>+ Buffer.concat(parts.map(p => (typeof p === 'string' ? Buffer.from(p, 'utf8') : Buffer.from(p))))++function crc32(buf) {+ return zlib.crc32(buf) >>> 0+}++function zip(entries) {+ const locals = []+ const centrals = []+ let offset = 0+ for (const [name, content] of entries) {+ const nameBuf = Buffer.from(name, 'utf8')+ const data = Buffer.from(content, 'utf8')+ const crc = crc32(data)+ const local = Buffer.alloc(30)+ local.writeUInt32LE(0x04034b50, 0)+ local.writeUInt16LE(20, 4)+ local.writeUInt16LE(0, 6)+ local.writeUInt16LE(0, 8)+ local.writeUInt32LE(crc, 14)+ local.writeUInt32LE(data.length, 18)+ local.writeUInt32LE(data.length, 22)+ local.writeUInt16LE(nameBuf.length, 26)+ locals.push(local, nameBuf, data)+ const central = Buffer.alloc(46)+ central.writeUInt32LE(0x02014b50, 0)+ central.writeUInt16LE(20, 4)+ central.writeUInt16LE(20, 6)+ central.writeUInt32LE(crc, 16)+ central.writeUInt32LE(data.length, 20)+ central.writeUInt32LE(data.length, 24)+ central.writeUInt16LE(nameBuf.length, 28)+ central.writeUInt32LE(offset, 42)+ centrals.push(central, nameBuf)+ offset += 30 + nameBuf.length + data.length+ }+ const cd = Buffer.concat(centrals)+ const eocd = Buffer.alloc(22)+ eocd.writeUInt32LE(0x06054b50, 0)+ eocd.writeUInt16LE(entries.length, 8)+ eocd.writeUInt16LE(entries.length, 10)+ eocd.writeUInt32LE(cd.length, 12)+ eocd.writeUInt32LE(offset, 16)+ return Buffer.concat([...locals, cd, eocd])+}++const CT = ['[Content_Types].xml', '<?xml version="1.0"?><Types/>']+const DOCX = zip([CT, ['_rels/.rels', '<Relationships/>'], ['word/document.xml', '<w:document/>']])+const XLSX = zip([CT, ['_rels/.rels', '<Relationships/>'], ['xl/workbook.xml', '<workbook/>']])+const PLAIN_ZIP = zip([['a.txt', 'hello']])+const DOCX_MIME = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'+const XLSX_MIME = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'+const JPEG = b([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10], 'JFIF', [0x00, 0x01, 0x01, 0x00, 0xff, 0xd9])+const PNG = b(+ [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d],+ 'IHDR',+ [0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 0x1f, 0x15, 0xc4, 0x89]+)+const PDF = b('%PDF-1.7\n1 0 obj << /Type /Catalog >> endobj\n%%EOF\n')++const T = (cls, detection, mismatch, extra = {}) => {+ const text = ['text', 'markdown', 'html', 'code', 'svg'].includes(cls)+ const media = {+ text: 'text/plain',+ markdown: 'text/markdown',+ html: 'text/html',+ code: 'text/plain',+ svg: 'image/svg+xml',+ jpeg: 'image/jpeg',+ png: 'image/png',+ pdf: 'application/pdf',+ docx: DOCX_MIME,+ xlsx: XLSX_MIME,+ binary_unsupported: 'application/octet-stream',+ }[cls]+ return {+ class: cls,+ detectedMediaType: extra.detectedMediaType ?? media,+ detection,+ textReadable: text,+ reader: text ? 'text' : 'none',+ modelImageInput: cls === 'jpeg' || cls === 'png' ? 'candidate' : 'unsupported',+ mismatch,+ }+}++const v = (name, bytes, filename, declaredMediaType, expected, totalByteLength) => ({+ name,+ input: {+ bytesBase64: Buffer.from(bytes).toString('base64'),+ totalByteLength: totalByteLength ?? bytes.length,+ declaredMediaType,+ filename,+ },+ expected,+})++const bigPrefix = Buffer.concat([Buffer.alloc(65536, 0x61), Buffer.from([0xc3])])++const classifier = [+ v('jpeg by signature', JPEG, 'photo.jpg', 'image/jpeg', T('jpeg', 'magic', false)),+ v('png by signature', PNG, 'image.png', 'image/png', T('png', 'magic', false)),+ v('png bytes named .txt', PNG, 'notes.txt', 'text/plain', T('png', 'magic', true)),+ v('pdf by signature', PDF, 'report.pdf', 'application/pdf', T('pdf', 'magic', false)),+ v(+ 'pdf signature after leading bytes',+ b(' '.repeat(100), PDF),+ 'doc.pdf',+ null,+ T('pdf', 'magic', false)+ ),+ v('pdf bytes named .txt', PDF, 'notes.txt', 'text/plain', T('pdf', 'magic', true)),+ v('docx by zip entries', DOCX, 'letter.docx', DOCX_MIME, T('docx', 'magic', false)),+ v('xlsx by zip entries', XLSX, 'sheet.xlsx', XLSX_MIME, T('xlsx', 'magic', false)),+ v(+ 'plain zip archive',+ PLAIN_ZIP,+ 'archive.zip',+ 'application/zip',+ T('binary_unsupported', 'magic', false, { detectedMediaType: 'application/zip' })+ ),+ v(+ 'zip named .docx without word entries',+ PLAIN_ZIP,+ 'letter.docx',+ DOCX_MIME,+ T('binary_unsupported', 'magic', true, { detectedMediaType: 'application/zip' })+ ),+ v(+ 'svg with xml declaration',+ b('<?xml version="1.0"?>\n<svg xmlns="http://www.w3.org/2000/svg"></svg>\n'),+ 'icon.svg',+ 'image/svg+xml',+ T('svg', 'text_utf8', false)+ ),+ v(+ 'svg content named .txt',+ b('<svg xmlns="http://www.w3.org/2000/svg"/>'),+ 'notes.txt',+ 'text/plain',+ T('svg', 'text_utf8', false)+ ),+ v(+ 'name .svg without svg root',+ b('not an svg at all\n'),+ 'icon.svg',+ 'image/svg+xml',+ T('text', 'text_utf8', false)+ ),+ v(+ 'markdown with accents',+ b('# Título\n\nCafé con ñandú.\n'),+ 'notes.md',+ 'text/markdown',+ T('markdown', 'text_utf8', false)+ ),+ v(+ 'markdown extension with text/plain',+ b('# Title\n'),+ 'notes.md',+ 'text/plain',+ T('markdown', 'text_utf8', false)+ ),+ v(+ 'html document',+ b('<!DOCTYPE html>\n<html><body><p>hi</p></body></html>\n'),+ 'page.html',+ 'text/html',+ T('html', 'text_utf8', false)+ ),+ v(+ 'html with inline svg stays html',+ b('<html><body><svg></svg></body></html>'),+ 'page.html',+ 'text/html',+ T('html', 'text_utf8', false)+ ),+ v(+ 'html content named .txt',+ b('<!doctype html><html></html>'),+ 'notes.txt',+ 'text/plain',+ T('html', 'text_utf8', false)+ ),+ v('json code', b('{"a": 1}\n'), 'data.json', 'application/json', T('code', 'text_utf8', false)),+ v(+ 'python code without media type',+ b('print("hi")\n'),+ 'script.py',+ null,+ T('code', 'text_utf8', false)+ ),+ v('plain text', b('hello\n'), 'notes.txt', 'text/plain', T('text', 'text_utf8', false)),+ v(+ 'text without extension or media type',+ b('plain words\r\n\tindented\n'),+ 'README',+ null,+ T('text', 'text_utf8', false)+ ),+ v(+ 'utf-8 byte order mark',+ b([0xef, 0xbb, 0xbf], 'hola\n'),+ 'notes.txt',+ 'text/plain',+ T('text', 'text_utf8', false)+ ),+ v(+ 'utf-16le with byte order mark',+ b([0xff, 0xfe, 0x68, 0x00, 0x69, 0x00]),+ 'notes.txt',+ 'text/plain',+ T('binary_unsupported', 'magic', true)+ ),+ v(+ 'embedded NUL',+ b('abc', [0x00], 'def'),+ 'data.txt',+ 'text/plain',+ T('binary_unsupported', 'magic', true)+ ),+ v(+ 'C1 control character',+ b('a', [0xc2, 0x85], 'b'),+ 'data.txt',+ 'text/plain',+ T('binary_unsupported', 'magic', true)+ ),+ v('invalid utf-8', b([0x61, 0xc3, 0x28]), 'x.txt', null, T('binary_unsupported', 'magic', true)),+ v('empty text file', b(''), 'empty.txt', 'text/plain', T('text', 'text_utf8', false)),+ v(+ 'arbitrary binary',+ Buffer.from(Array.from({ length: 256 }, (_, i) => i)),+ 'data.bin',+ 'application/octet-stream',+ T('binary_unsupported', 'magic', false)+ ),+ v(+ 'gif is not a supported image',+ b('GIF89a', [0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00]),+ 'anim.gif',+ 'image/gif',+ T('binary_unsupported', 'magic', false)+ ),+ v(+ 'empty prefix falls back to the declared pdf',+ b(''),+ 'report.pdf',+ 'application/pdf',+ T('pdf', 'declared', false),+ 1000+ ),+ v(+ 'empty prefix without declaration',+ b(''),+ 'blob',+ null,+ T('binary_unsupported', 'declared', false),+ 500+ ),+ v(+ 'short text prefix keeps the declared markdown',+ b('# Title\n'),+ 'notes.md',+ 'text/markdown',+ T('markdown', 'declared', false),+ 100000+ ),+ v(+ 'short zip prefix keeps the declared docx',+ DOCX.subarray(0, 80),+ 'letter.docx',+ DOCX_MIME,+ T('docx', 'declared', false),+ DOCX.length+ ),+ v(+ 'short prefix with jpeg signature overrides a pdf declaration',+ JPEG,+ 'report.pdf',+ 'application/pdf',+ T('jpeg', 'magic', true),+ 5000+ ),+ v(+ 'short binary prefix contradicts a text declaration',+ b('ab', [0x00, 0x01]),+ 'a.txt',+ 'text/plain',+ T('binary_unsupported', 'magic', true),+ 10000+ ),+ v(+ 'long text prefix ending mid-sequence',+ bigPrefix,+ 'big.txt',+ 'text/plain',+ T('text', 'text_utf8', false),+ 70000+ ),+]++const HEX = 'a'.repeat(64)+const attachmentBase = {+ schemaVersion: 1,+ id: `att:msg-1:att-1@sha256:${HEX}`,+ source: { kind: 'attachment', attachmentId: 'att-1', messageId: 'msg-1' },+ name: 'notes.md',+ declaredMediaType: 'text/markdown',+ detectedMediaType: 'text/markdown',+ class: 'markdown',+ detection: 'text_utf8',+ mismatch: false,+ byteLength: 12,+ digest: { algorithm: 'sha256', hex: HEX },+ textReadable: true,+ reader: 'text',+ modelImageInput: 'unsupported',+}+const gfsBase = {+ schemaVersion: 1,+ id: 'gfs:personal:res-42@v7',+ source: {+ kind: 'gfs',+ drive: 'personal',+ resourceId: 'res-42',+ gfsUri: 'gfs://personal/reports/q3.pdf',+ version: 7,+ },+ name: 'q3.pdf',+ declaredMediaType: 'application/pdf',+ detectedMediaType: 'application/pdf',+ class: 'pdf',+ detection: 'declared',+ mismatch: false,+ byteLength: 2048,+ textReadable: false,+ reader: 'none',+ modelImageInput: 'unsupported',+}+const ok = { ok: true }+const invalid = { ok: false, code: 'FILE_REFERENCE_INVALID' }+const unsupported = { ok: false, code: 'FILE_REFERENCE_SCHEMA_VERSION_UNSUPPORTED' }+const r = (name, input, expected) => ({ name, input, expected })+const without = (object, key) => {+ const copy = { ...object }+ delete copy[key]+ return copy+}++const references = [+ r('valid attachment reference', attachmentBase, ok),+ r('valid gfs reference without digest', gfsBase, ok),+ r(+ 'valid gfs reference with digest',+ { ...gfsBase, digest: { algorithm: 'sha256', hex: HEX } },+ ok+ ),+ r(+ 'binary_unsupported may carry application/zip',+ {+ ...attachmentBase,+ class: 'binary_unsupported',+ detectedMediaType: 'application/zip',+ detection: 'magic',+ textReadable: false,+ reader: 'none',+ mismatch: true,+ },+ ok+ ),+ r(+ 'png attachment is an image input candidate',+ {+ ...attachmentBase,+ class: 'png',+ detectedMediaType: 'image/png',+ detection: 'magic',+ textReadable: false,+ reader: 'none',+ modelImageInput: 'candidate',+ },+ ok+ ),+ r('name of 255 code points', { ...attachmentBase, name: `${'ñ'.repeat(252)}.md` }, ok),+ r('missing schemaVersion', without(attachmentBase, 'schemaVersion'), unsupported),+ r('schemaVersion 2', { ...attachmentBase, schemaVersion: 2 }, unsupported),+ r('schemaVersion as a string', { ...attachmentBase, schemaVersion: '1' }, unsupported),+ r('not an object', 'att:msg-1:att-1', invalid),+ r('forged id', { ...attachmentBase, id: 'att:msg-1:att-2@sha256:' + HEX }, invalid),+ r('gfs id with the wrong version', { ...gfsBase, id: 'gfs:personal:res-42@v6' }, invalid),+ r('attachment without digest', without(attachmentBase, 'digest'), invalid),+ r(+ 'uppercase digest',+ {+ ...attachmentBase,+ digest: { algorithm: 'sha256', hex: 'A'.repeat(64) },+ id: `att:msg-1:att-1@sha256:${'A'.repeat(64)}`,+ },+ invalid+ ),+ r(+ 'digest algorithm other than sha256',+ { ...attachmentBase, digest: { algorithm: 'md5', hex: HEX } },+ invalid+ ),+ r('name with a slash', { ...attachmentBase, name: 'dir/notes.md' }, invalid),+ r('name with a backslash', { ...attachmentBase, name: 'dir\\notes.md' }, invalid),+ r('name ..', { ...attachmentBase, name: '..' }, invalid),+ r('name with a control character', { ...attachmentBase, name: 'notes\u0007.md' }, invalid),+ r('name not in NFC', { ...attachmentBase, name: 'café.md' }, invalid),+ r('name of 256 code points', { ...attachmentBase, name: `${'ñ'.repeat(253)}.md` }, invalid),+ r('empty name', { ...attachmentBase, name: '' }, invalid),+ r('reader text on a pdf', { ...gfsBase, reader: 'text' }, invalid),+ r('textReadable on a pdf', { ...gfsBase, textReadable: true, reader: 'text' }, invalid),+ r('image candidate on a pdf', { ...gfsBase, modelImageInput: 'candidate' }, invalid),+ r('text detection on a pdf', { ...gfsBase, detection: 'text_utf8' }, invalid),+ r(+ 'detected media type contradicts class',+ { ...gfsBase, detectedMediaType: 'text/plain' },+ invalid+ ),+ r('unknown class', { ...gfsBase, class: 'gif' }, invalid),+ r('unknown top-level field', { ...attachmentBase, preview: 'data:...' }, invalid),+ r(+ 'unknown source field',+ { ...attachmentBase, source: { ...attachmentBase.source, path: '/tmp/x' } },+ invalid+ ),+ r(+ 'unknown source kind',+ { ...attachmentBase, source: { kind: 'tool', toolCallId: 't-1' } },+ invalid+ ),+ r(+ 'negative gfs version',+ { ...gfsBase, source: { ...gfsBase.source, version: -1 }, id: 'gfs:personal:res-42@v-1' },+ invalid+ ),+ r(+ 'fractional gfs version',+ { ...gfsBase, source: { ...gfsBase.source, version: 1.5 }, id: 'gfs:personal:[email protected]' },+ invalid+ ),+ r('negative byteLength', { ...attachmentBase, byteLength: -1 }, invalid),+ r('empty declared media type', { ...attachmentBase, declaredMediaType: '' }, invalid),+ r('mismatch not boolean', { ...attachmentBase, mismatch: 'no' }, invalid),+]++fs.mkdirSync(OUT, { recursive: true })+fs.writeFileSync(+ path.join(OUT, 'classifier-vectors.v1.json'),+ JSON.stringify({ schemaVersion: 1, vectors: classifier }, null, 2) + '\n'+)+fs.writeFileSync(+ path.join(OUT, 'file-reference-vectors.v1.json'),+ JSON.stringify({ schemaVersion: 1, vectors: references }, null, 2) + '\n'+)+console.log(`classifier=${classifier.length} references=${references.length}`)diff --git a/scripts/minikube/pre-gate-incremental.sh b/scripts/minikube/pre-gate-incremental.shindex 5e88eb151..dcffa926b 100755--- a/scripts/minikube/pre-gate-incremental.sh+++ b/scripts/minikube/pre-gate-incremental.sh@@ -193,7 +193,13 @@ incremental_classify_path() {channel-reader/*) incremental_add_target channel-reader channels channel-reader-chatllm ;;mcp-proxy/*) incremental_add_target mcp-proxy mcp-server mcp-proxy ;;control-ui/*) incremental_add_target control-ui control-plane control-ui ;;- packages/gfs-interaction-policy/*) incremental_add_target control-ui control-plane control-ui ;;+ packages/gfs-interaction-policy/*)+ # Control UI imports the GFS naming policy and mcp-host imports the+ # FileReference v1 contract and byte classifier; both Dockerfiles COPY+ # the package, so a change here changes exactly those two image outputs.+ incremental_add_target control-ui control-plane control-ui+ incremental_add_target mcp-host mcp-host chatllm+ ;;packages/display-field/*)# display-field is consumed ONLY by the control-api and control-ui images# (their Dockerfiles COPY it and their field validation runs off it), so adiff --git a/scripts/tests/test-dockerfile-local-packages.sh b/scripts/tests/test-dockerfile-local-packages.shindex 393366895..e6ac18d75 100755--- a/scripts/tests/test-dockerfile-local-packages.sh+++ b/scripts/tests/test-dockerfile-local-packages.sh@@ -191,13 +191,13 @@ assert_copy_before_every_ci profile-ui/Dockerfile desktop-app-links frontend-comassert_copy_before_every_ci host-context-controller/Dockerfile \image-policy llm-providers network-policy-core workflow-recipe-capability-policyassert_copy_before_every_ci mcp-host/Dockerfile \- grok-provider-attempt-contract llm-provider-attempt-contract llm-providers+ gfs-interaction-policy grok-provider-attempt-contract llm-provider-attempt-contract llm-providersassert_copy_before_every_ci mcp-host/Dockerfile.desktop \- grok-provider-attempt-contract llm-provider-attempt-contract llm-providers+ gfs-interaction-policy grok-provider-attempt-contract llm-provider-attempt-contract llm-providersassert_copy_before_every_ci mcp-host/Dockerfile.full \- grok-provider-attempt-contract llm-provider-attempt-contract llm-providers+ gfs-interaction-policy grok-provider-attempt-contract llm-provider-attempt-contract llm-providersassert_copy_before_every_ci mcp-host/Dockerfile.slim \- grok-provider-attempt-contract llm-provider-attempt-contract llm-providers+ gfs-interaction-policy grok-provider-attempt-contract llm-provider-attempt-contract llm-providers# workflow-runtime-core is built in a separate stage before workflow-recipes;# these are the packages needed by that stage, while the application installdiff --git a/scripts/tests/test-images-manifest.sh b/scripts/tests/test-images-manifest.shindex e52d5857a..24830e5dc 100755--- a/scripts/tests/test-images-manifest.sh+++ b/scripts/tests/test-images-manifest.sh@@ -845,6 +845,95 @@ assert_codex_catalog_projection_change_rebuilds_consumers() {fi}+# Control UI imports the GFS naming policy and mcp-host imports the+# FileReference v1 contract and byte classifier from the same package, so a+# change to it must rebuild both consumers.+assert_gfs_interaction_policy_change_rebuilds_consumers() {+ local output rc+ output="$(node -e '+ import("'"$REPO_ROOT"'/scripts/release/images-manifest.mjs").then(async m => {+ const fs = await import("node:fs")+ const wfPath = "'"$REPO_ROOT"'/.github/workflows/build-publish.yml"+ const wf = fs.readFileSync(wfPath, "utf8")+ const sourcePath = "packages/gfs-interaction-policy/**"+ const expectedFilters = ["control-ui", "mcp-host"]+ const expectedImages = [+ "control-ui",+ "mcp-host",+ "mcp-host-desktop",+ "mcp-host-full",+ "mcp-host-slim",+ ]++ const filtersMatch = wf.match(/filters: \|\n([\s\S]*?)\n\n {2}build-push:/)+ if (!filtersMatch) {+ console.log(`PARSE_ERROR: could not find the paths-filter filters block in ${wfPath}`)+ process.exit(1)+ }+ const filters = {}+ let currentKey = null+ for (const line of filtersMatch[1].split("\n")) {+ if (!line.trim()) continue+ const keyMatch = line.match(/^\s*([\w.-]+):\s*$/)+ const pathMatch = line.match(/^\s*-\s*\x27([^\x27]+)\x27\s*$/)+ if (keyMatch) {+ currentKey = keyMatch[1]+ filters[currentKey] = []+ } else if (pathMatch && currentKey) {+ filters[currentKey].push(pathMatch[1])+ }+ }++ const sectionMatch = wf.match(/include:\n([\s\S]*?)\n {4}steps:/)+ if (!sectionMatch) {+ console.log(`PARSE_ERROR: could not find the build-push matrix section in ${wfPath}`)+ process.exit(1)+ }+ const imageFilterKeys = {}+ for (const block of sectionMatch[1].split(/\n(?=\s*- image:)/)) {+ const image = block.match(/- image:\s*(\S+)/)?.[1]+ if (!image) continue+ const changedKey = block.match(/\n\s*changed:\s*\$\{\{\s*needs\.detect\.outputs\.([\w.-]+)\s*\}\}/)?.[1]+ if (changedKey) imageFilterKeys[image] = changedKey+ }++ const problems = []+ const filterKeys = Object.entries(filters)+ .filter(([, paths]) => paths.includes(sourcePath))+ .map(([key]) => key)+ .sort()+ if (filterKeys.join(",") !== expectedFilters.join(",")) {+ problems.push(`filters are ${filterKeys.join(",") || "<none>"}, expected ${expectedFilters.join(",")}`)+ }+ const selectedImages = Object.entries(imageFilterKeys)+ .filter(([, filterKey]) => filterKeys.includes(filterKey))+ .map(([image]) => image)+ .sort()+ if (selectedImages.join(",") !== expectedImages.join(",")) {+ problems.push(`selected images are ${selectedImages.join(",") || "<none>"}, expected ${expectedImages.join(",")}`)+ }+ for (const name of expectedImages) {+ const image = m.IMAGES.find(item => item.name === name)+ if (!image) problems.push(`${name} has no manifest row`)+ else if (!image.source_paths?.includes(sourcePath)) {+ problems.push(`${name} does not mirror ${sourcePath} in source_paths`)+ }+ }+ console.log(problems.join("; "))+ }).catch(err => {+ console.log(`PARSE_ERROR: ${err.message}`)+ process.exit(1)+ })' 2>&1)"+ rc=$?+ if [ "$rc" -ne 0 ]; then+ fail "gfs-interaction-policy changed-path contract parse failed: $output"+ elif [ -z "$output" ]; then+ pass "a gfs-interaction-policy change rebuilds Control UI and the mcp-host variants"+ else+ fail "gfs-interaction-policy changed-path contract failed: $output"+ fi+}+# THREE copies of the 28-image list exist in build-publish.yml, not two:# build-push's `image:` matrix dimension (the array that, crossed with# `arch`, produces the 56 base combinations), build-push's `include:` list@@ -1337,6 +1426,7 @@ assert_network_policy_core_change_rebuilds_all_consumersassert_display_field_change_rebuilds_both_consumersassert_llm_provider_attempt_contract_change_rebuilds_consumersassert_codex_catalog_projection_change_rebuilds_consumers+assert_gfs_interaction_policy_change_rebuilds_consumersassert_all_three_image_lists_agreeassert_the_verify_set_splits_on_published_not_on_modeassert_the_default_ghcr_verify_set_omits_only_the_e2e_fixturesdiff --git a/scripts/tests/test-minikube-pre-gate-sync-state.sh b/scripts/tests/test-minikube-pre-gate-sync-state.shindex 8ffe48dd4..00b4066af 100755--- a/scripts/tests/test-minikube-pre-gate-sync-state.sh+++ b/scripts/tests/test-minikube-pre-gate-sync-state.sh@@ -105,7 +105,7 @@ if incremental_contains 'control-api/*) incremental_add_target control-api contrincremental_contains 'rpc-proxy/*) incremental_add_target rpc-proxy rpc-proxy rpc-proxy' &&incremental_contains 'host-context-controller/*) incremental_add_target host-context-controller control-plane host-context-controller' &&incremental_contains 'control-ui/*) incremental_add_target control-ui control-plane control-ui' &&- incremental_contains 'packages/gfs-interaction-policy/*) incremental_add_target control-ui control-plane control-ui' &&+ incremental_contains 'packages/gfs-interaction-policy/*)' &&incremental_contains 'tests/e2e/fixtures/workflow-plugin-sdk-e2e/*)' &&incremental_contains 'incremental_add_target workflow-plugin-sdk-e2e sandbox-recipes workflow-plugin-sdk-e2e'; thenpass "incremental sync maps known runtime paths to their own images and deployments"@@ -113,6 +113,29 @@ elsefail "incremental sync does not map known runtime paths precisely"fi+# A two-line case body cannot be proven by grep (the mcp-host target line also+# exists under mcp-host/*), so classify the path for real and compare targets.+gfs_policy_targets="$(+ PROJECT_DIR="$PWD"+ PROFILE=fake+ KC="kubectl --context=fake"+ FORCE_CLUSTER_SYNC=false+ FORCE_RESTART=false+ IMAGE_SOURCE=local+ IMAGE_TAG=test+ IMAGES_GENERATED_AT=test+ log() { :; }+ # shellcheck source=/dev/null+ source "$INCREMENTAL_SCRIPT"+ incremental_classify_path packages/gfs-interaction-policy/fileClassifier.cjs+ printf '%s\n' "${INCREMENTAL_TARGETS[@]}"+)"+if [[ "$gfs_policy_targets" == $'control-ui|control-plane|control-ui\nmcp-host|mcp-host|chatllm' ]]; then+ pass "a gfs-interaction-policy change reshadows Control UI and mcp-host"+else+ fail "gfs-interaction-policy maps to the wrong consumers: ${gfs_policy_targets:-<none>}"+fi+if contains 'incremental_plan' &&contains 'incremental_build_images' &&contains 'incremental_restart_targets' &&