{"version":3,"file":"index.mjs","names":["PRIM","ENUM","STRUCT","MESSAGE","ROOT_TYPE_NAME","zstdDecompress","schemaJson"],"sources":["../src/clipboard.ts","../src/kiwi-reader.ts","../src/decoder.ts","../src/stack-fields.ts","../src/tree.ts","../src/diff.ts","../src/kiwi-writer.ts","../src/schema.json","../src/schema.ts","../src/encoder.ts"],"sourcesContent":["/**\n * HTML envelope Figma reads when you paste from the system clipboard.\n *\n * The wire format stores Figma's comment markers inside data attributes,\n * matching the HTML Figma writes when copying a node. Keeping the markers out\n * of top-level comment nodes is important for WebKit: Safari sanitizes\n * `text/html` clipboard writes and strips comment nodes before they reach the\n * system pasteboard.\n *\n *   <span data-metadata=\"<!--(figmeta)<base64-json>(/figmeta)-->\"></span>\n *   <span data-buffer=\"<!--(figma)<base64-bytes>(/figma)-->\"></span>\n */\n\nexport type FigmaClipboardMeta = {\n  dataType: \"scene\";\n  fileKey: string;\n  pasteID: number;\n};\n\nconst DEFAULT_META: FigmaClipboardMeta = {\n  dataType: \"scene\",\n  fileKey: \"TEST\",\n  pasteID: 123,\n};\n\n/** Build the HTML clipboard envelope. No DOM required. */\nexport function composeClipboardHtml(\n  base64: string,\n  meta: FigmaClipboardMeta = DEFAULT_META\n): string {\n  const metaB64 = btoa(JSON.stringify(meta));\n  return (\n    '<meta charset=\"utf-8\"><div>' +\n    `<span data-metadata=\"<!--(figmeta)${metaB64}(/figmeta)-->\"></span>` +\n    `<span data-buffer=\"<!--(figma)${base64}(/figma)-->\"></span>` +\n    \"</div>\"\n  );\n}\n\n/** Wrap envelope HTML in a `ClipboardItem` for `navigator.clipboard.write`. */\nexport function toClipboardItem(html: string): ClipboardItem {\n  const blob = new Blob([html], { type: \"text/html\" });\n  return new ClipboardItem({ \"text/html\": blob });\n}\n\nexport type ParsedClipboardHtml = {\n  /** Raw fig-kiwi envelope bytes, ready for `decodeFigmaData`. */\n  fig: Uint8Array;\n  /** Parsed `(figmeta)` JSON, when present. */\n  meta: FigmaClipboardMeta | null;\n};\n\n// Marker pairs appear either as real HTML comments (what Figma writes on\n// copy) or inside data attributes (what we write; see module docs). Most HTML\n// serializers — macOS NSPasteboard normalization, Chromium's clipboard write\n// path — entity-encode `<` and `>` inside attribute values, so both raw and\n// entity-encoded forms show up in the wild; normalize before searching.\nconst MARKERS = {\n  figma: { start: \"<!--(figma)\", end: \"(/figma)-->\" },\n  figmeta: { start: \"<!--(figmeta)\", end: \"(/figmeta)-->\" },\n} as const;\n\nfunction normalizeMarkers(html: string): string {\n  let out = html;\n  for (const { start, end } of Object.values(MARKERS)) {\n    out = out\n      .replaceAll(`&lt;${start.slice(1)}`, start)\n      .replaceAll(`${end.slice(0, -1)}&gt;`, end);\n  }\n  return out;\n}\n\nfunction extractMarkedBase64(\n  normalized: string,\n  marker: (typeof MARKERS)[keyof typeof MARKERS]\n): string | null {\n  const start = normalized.indexOf(marker.start);\n  const end = normalized.indexOf(marker.end);\n  if (start === -1 || end === -1 || start > end) {\n    return null;\n  }\n  return normalized.slice(start + marker.start.length, end);\n}\n\nfunction base64ToBytes(base64: string): Uint8Array {\n  const binary = atob(base64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i += 1) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return bytes;\n}\n\n/**\n * Extract the fig-kiwi payload (and figmeta, when present) from a clipboard\n * HTML envelope — ours or one copied straight out of Figma.\n */\nexport function parseClipboardHtml(html: string): ParsedClipboardHtml {\n  const normalized = normalizeMarkers(html);\n\n  const figBase64 = extractMarkedBase64(normalized, MARKERS.figma);\n  if (figBase64 === null) {\n    const SAMPLE_LIMIT = 240;\n    const sample =\n      html.length > SAMPLE_LIMIT\n        ? `${html.slice(0, SAMPLE_LIMIT)}… (truncated, ${html.length} bytes total)`\n        : html || \"(empty)\";\n    throw new Error(\n      \"Couldn't find Figma payload markers in clipboard HTML.\\n\" +\n        \"Make sure the HTML holds a copied Figma node (markers <!--(figma)…(/figma)--> expected).\\n\\n\" +\n        `Received:\\n${sample}`\n    );\n  }\n\n  const metaBase64 = extractMarkedBase64(normalized, MARKERS.figmeta);\n  let meta: FigmaClipboardMeta | null = null;\n  if (metaBase64 !== null) {\n    try {\n      meta = JSON.parse(atob(metaBase64)) as FigmaClipboardMeta;\n    } catch {\n      meta = null;\n    }\n  }\n\n  return { fig: base64ToBytes(figBase64), meta };\n}\n","/** Sequential reader for Kiwi-encoded bytes; mirrors `KiwiWriter`. */\nexport class KiwiReader {\n  private readonly bytes: Uint8Array;\n  private offset: number;\n\n  constructor(bytes: Uint8Array) {\n    this.bytes = bytes;\n    this.offset = 0;\n  }\n\n  get done(): boolean {\n    return this.offset >= this.bytes.length;\n  }\n\n  byte(): number {\n    const value = this.bytes[this.offset];\n    if (value === undefined) {\n      throw new Error(`Read past end of buffer at offset ${this.offset}`);\n    }\n    this.offset += 1;\n    return value;\n  }\n\n  bool(): boolean {\n    return this.byte() !== 0;\n  }\n\n  uint(): number {\n    // Little-endian 7-bit groups; multiplication instead of shifts so values\n    // above 2^31 survive (the writer uses float math the same way).\n    let value = 0;\n    let multiplier = 1;\n    for (;;) {\n      const b = this.byte();\n      value += (b & 127) * multiplier;\n      if ((b & 128) === 0) {\n        return value;\n      }\n      multiplier *= 128;\n    }\n  }\n\n  uint64(): number {\n    return this.uint();\n  }\n\n  int(): number {\n    // Zigzag decoding\n    const encoded = this.uint();\n    return encoded % 2 === 0 ? encoded / 2 : -((encoded - 1) / 2) - 1;\n  }\n\n  int64(): number {\n    return this.int();\n  }\n\n  float(): number {\n    // The writer emits a single 0 byte for 0.0, otherwise 4 bytes of the\n    // bit-rotated IEEE 754 representation.\n    const first = this.byte();\n    if (first === 0) {\n      return 0;\n    }\n    let bits =\n      first | (this.byte() << 8) | (this.byte() << 16) | (this.byte() << 24);\n    bits >>>= 0;\n\n    // Reverse the writer's rotation: bits = (orig >>> 23) | (orig << 9)\n    bits = ((bits << 23) | (bits >>> 9)) >>> 0;\n\n    const buffer = new ArrayBuffer(4);\n    const view = new DataView(buffer);\n    view.setUint32(0, bits, false);\n    return view.getFloat32(0, false);\n  }\n\n  string(): string {\n    const start = this.offset;\n    let end = start;\n    while (end < this.bytes.length && this.bytes[end] !== 0) {\n      end += 1;\n    }\n    if (end >= this.bytes.length) {\n      throw new Error(`Unterminated string starting at offset ${start}`);\n    }\n    const value = new TextDecoder().decode(this.bytes.subarray(start, end));\n    this.offset = end + 1;\n    return value;\n  }\n\n  rawBytes(length: number): Uint8Array {\n    if (this.offset + length > this.bytes.length) {\n      throw new Error(\n        `Read of ${length} bytes past end of buffer at offset ${this.offset}`\n      );\n    }\n    const value = this.bytes.slice(this.offset, this.offset + length);\n    this.offset += length;\n    return value;\n  }\n}\n","import { inflateSync } from \"fflate\";\nimport { decompress as zstdDecompress } from \"fzstd\";\nimport { KiwiReader } from \"./kiwi-reader\";\nimport type { Field, Schema, TypeDef } from \"./types\";\n\n// Kiwi datatype sentinels (negative = primitive, non-negative = type index).\nconst PRIM = {\n  BOOL: -1,\n  BYTE: -2,\n  INT: -3,\n  UINT: -4,\n  FLOAT: -5,\n  STRING: -6,\n  INT64: -7,\n  UINT64: -8,\n} as const;\n\n// `TypeDef.kind` values.\nconst ENUM = 0;\nconst STRUCT = 1;\nconst MESSAGE = 2;\n\nconst KIND_NAMES: Record<number, string> = {\n  [ENUM]: \"enum\",\n  [STRUCT]: \"struct\",\n  [MESSAGE]: \"message\",\n};\n\nconst PRIMITIVE_NAMES: Record<number, string> = {\n  [PRIM.BOOL]: \"bool\",\n  [PRIM.BYTE]: \"byte\",\n  [PRIM.INT]: \"int\",\n  [PRIM.UINT]: \"uint\",\n  [PRIM.FLOAT]: \"float\",\n  [PRIM.STRING]: \"string\",\n  [PRIM.INT64]: \"int64\",\n  [PRIM.UINT64]: \"uint64\",\n};\n\n// Copies made in Figma Design, FigJam, and Slides differ only in prelude.\nconst FIG_PRELUDES = [\"fig-kiwi\", \"fig-jam.\", \"fig-deck\"];\nconst ROOT_TYPE_NAME = \"Message\";\n\nfunction decodePrimitive(r: KiwiReader, datatype: number): unknown {\n  switch (datatype) {\n    case PRIM.BOOL:\n      return r.bool();\n    case PRIM.BYTE:\n      return r.byte();\n    case PRIM.INT:\n      return r.int();\n    case PRIM.UINT:\n      return r.uint();\n    case PRIM.FLOAT:\n      return r.float();\n    case PRIM.STRING:\n      return r.string();\n    case PRIM.INT64:\n      return r.int64();\n    case PRIM.UINT64:\n      return r.uint64();\n    default:\n      throw new Error(`Unknown primitive datatype: ${datatype}`);\n  }\n}\n\nfunction decodeArray(\n  r: KiwiReader,\n  types: ReadonlyArray<TypeDef>,\n  datatype: number\n): unknown {\n  const length = r.uint();\n  // Byte arrays are a length-prefixed raw block, matching the encoder.\n  if (datatype === PRIM.BYTE) {\n    return r.rawBytes(length);\n  }\n  const out: Array<unknown> = [];\n  for (let i = 0; i < length; i += 1) {\n    out.push(decodeType(r, types, datatype, false));\n  }\n  return out;\n}\n\nfunction decodeEnum(r: KiwiReader, type: TypeDef): unknown {\n  const id = r.uint();\n  const field = type.fields[String(id)];\n  // Unknown values can appear when Figma's schema is newer than the payload's\n  // consumers expect; surface the raw id rather than failing the whole decode.\n  return field ? field.name : id;\n}\n\nfunction decodeStruct(\n  r: KiwiReader,\n  types: ReadonlyArray<TypeDef>,\n  type: TypeDef\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  // Structs serialize every field in id order, no terminator.\n  const fieldCount = Object.keys(type.fields).length;\n  for (let id = 1; id <= fieldCount; id += 1) {\n    const field = type.fields[String(id)];\n    if (!field) {\n      throw new Error(`Field ${id} missing in struct '${type.name}'`);\n    }\n    out[field.name] = decodeType(r, types, field.datatype, field.array);\n  }\n  return out;\n}\n\nfunction decodeMessage(\n  r: KiwiReader,\n  types: ReadonlyArray<TypeDef>,\n  type: TypeDef\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  // Messages emit only present fields (each preceded by its id), terminated by 0.\n  for (;;) {\n    const fieldId = r.uint();\n    if (fieldId === 0) {\n      return out;\n    }\n    const field = type.fields[String(fieldId)];\n    if (!field) {\n      // Kiwi data is not self-delimiting, so an unknown field id is fatal.\n      // Decoding always uses the schema embedded in the same payload, which\n      // makes this unreachable for well-formed input.\n      throw new Error(\n        `Unknown field id ${fieldId} in message '${type.name}' — payload and schema disagree`\n      );\n    }\n    out[field.name] = decodeType(r, types, field.datatype, field.array);\n  }\n}\n\nfunction decodeType(\n  r: KiwiReader,\n  types: ReadonlyArray<TypeDef>,\n  datatype: number,\n  isArray: boolean\n): unknown {\n  if (isArray) {\n    return decodeArray(r, types, datatype);\n  }\n  if (datatype < 0) {\n    return decodePrimitive(r, datatype);\n  }\n\n  const type = types[datatype];\n  if (!type) {\n    throw new Error(`Type definition not found for datatype ${datatype}`);\n  }\n  switch (type.kind) {\n    case ENUM:\n      return decodeEnum(r, type);\n    case STRUCT:\n      return decodeStruct(r, types, type);\n    case MESSAGE:\n      return decodeMessage(r, types, type);\n    default:\n      throw new Error(`Unknown kind ${type.kind} for type '${type.name}'`);\n  }\n}\n\n/** Parse the binary Kiwi schema segment; mirrors the encoder's `writeSchema`. */\nfunction readSchema(bytes: Uint8Array, version: number): Schema {\n  const r = new KiwiReader(bytes);\n  const typeCount = r.uint();\n\n  type RawField = Field & { id: number };\n  const raw: Array<{\n    name: string;\n    kind: number;\n    fields: Array<RawField>;\n  }> = [];\n\n  for (let i = 0; i < typeCount; i += 1) {\n    const name = r.string();\n    const kind = r.byte();\n    const fieldCount = r.uint();\n    const fields: Array<RawField> = [];\n    for (let f = 0; f < fieldCount; f += 1) {\n      const fieldName = r.string();\n      const datatype = r.int();\n      const array = r.bool();\n      const id = r.uint();\n      fields.push({ name: fieldName, datatype, array, datatype_name: \"\", id });\n    }\n    raw.push({ name, kind, fields });\n  }\n\n  const datatypeName = (datatype: number): string =>\n    PRIMITIVE_NAMES[datatype] ?? raw[datatype]?.name ?? `unknown(${datatype})`;\n\n  const types: Array<TypeDef> = raw.map((t, index) => {\n    const fields: Record<string, Field> = {};\n    for (const f of t.fields) {\n      fields[String(f.id)] = {\n        name: f.name,\n        datatype: f.datatype,\n        array: f.array,\n        datatype_name: datatypeName(f.datatype),\n      };\n    }\n    return {\n      index,\n      name: t.name,\n      kind: t.kind,\n      kind_name: KIND_NAMES[t.kind] ?? `unknown(${t.kind})`,\n      fields,\n      field_count: t.fields.length,\n    };\n  });\n\n  return { version, types, type_count: types.length };\n}\n\n// Figma sniffs chunk compression on paste rather than fixing it per format\n// version, and (as of 2026) writes deflate for the schema chunk but zstd for\n// the data chunk. Mirror the sniffing: zstd by magic number, deflate otherwise.\nconst ZSTD_MAGIC = [0x28, 0xb5, 0x2f, 0xfd] as const;\n\nfunction decompressChunk(chunk: Uint8Array): Uint8Array {\n  const isZstd = ZSTD_MAGIC.every((byte, i) => chunk[i] === byte);\n  return isZstd ? zstdDecompress(chunk) : inflateSync(chunk);\n}\n\nexport type DecodedFigmaData = {\n  prelude: string;\n  version: number;\n  schema: Schema;\n  /** The decoded root `Message` (e.g. `{ type: \"NODE_CHANGES\", nodeChanges: [...] }`). */\n  message: Record<string, unknown>;\n};\n\n/**\n * Decode a fig-kiwi binary envelope (magic + version + compressed schema +\n * compressed data, deflate or zstd per chunk) into the root Kiwi `Message`,\n * using the schema embedded in the payload itself so newer Figma schema\n * versions decode without a regenerated `schema.json`.\n */\nexport function decodeFigmaData(figBytes: Uint8Array): DecodedFigmaData {\n  const prelude = new TextDecoder().decode(figBytes.subarray(0, 8));\n  if (!FIG_PRELUDES.includes(prelude)) {\n    throw new Error(\n      `Unexpected fig prelude \"${prelude}\" — expected one of ${FIG_PRELUDES.join(\", \")}.`\n    );\n  }\n\n  const view = new DataView(\n    figBytes.buffer,\n    figBytes.byteOffset,\n    figBytes.byteLength\n  );\n  const version = view.getUint32(8, true);\n  const schemaLength = view.getUint32(12, true);\n  const dataOffset = 16 + schemaLength;\n  const dataLength = view.getUint32(dataOffset, true);\n\n  const schemaBytes = decompressChunk(figBytes.subarray(16, 16 + schemaLength));\n  const dataBytes = decompressChunk(\n    figBytes.subarray(dataOffset + 4, dataOffset + 4 + dataLength)\n  );\n\n  const schema = readSchema(schemaBytes, version);\n  const rootIndex = schema.types.findIndex((t) => t.name === ROOT_TYPE_NAME);\n  if (rootIndex === -1) {\n    throw new Error(`No root '${ROOT_TYPE_NAME}' type found in schema`);\n  }\n\n  const message = decodeType(\n    new KiwiReader(dataBytes),\n    schema.types,\n    rootIndex,\n    false\n  ) as Record<string, unknown>;\n\n  return { prelude, version, schema, message };\n}\n","/**\n * Auto-layout (`stack*`) field knowledge shared by the oracle verification\n * tooling and regression tests.\n *\n * Figma omits fields that hold their default value when serializing a copied\n * node (established empirically via paste round-trips — see\n * .context/auto-layout/PLAN.md). Comparing payloads therefore requires\n * normalizing absent fields to these defaults first.\n */\nexport const STACK_FIELD_DEFAULTS: Record<string, unknown> = {\n  stackMode: \"NONE\",\n  stackSpacing: 0,\n  stackCounterSpacing: 0,\n  stackPrimaryAlignItems: \"MIN\",\n  stackCounterAlignItems: \"MIN\",\n  stackHorizontalPadding: 0,\n  stackVerticalPadding: 0,\n  stackPaddingRight: 0,\n  stackPaddingBottom: 0,\n  stackChildPrimaryGrow: 0,\n  stackWrap: \"NO_WRAP\",\n  stackPositioning: \"AUTO\",\n  stackPrimarySizing: \"FIXED\",\n  stackCounterSizing: \"FIXED\",\n};\n\n/** All auto-layout fields the oracle workflow tracks, defaults or not. */\nexport const TRACKED_STACK_FIELDS: ReadonlySet<string> = new Set([\n  ...Object.keys(STACK_FIELD_DEFAULTS),\n  \"stackChildAlignSelf\",\n  \"stackPrimaryAlignContent\",\n  \"stackCounterAlignContent\",\n]);\n","/** Shared node-tree utilities for decoded Figma clipboard payloads. */\n\nexport type OracleNode = Record<string, unknown> & {\n  guid: { sessionID: number; localID: number };\n  parentIndex?: {\n    guid: { sessionID: number; localID: number };\n    position: string;\n  };\n  type?: string;\n  name?: string;\n};\n\n/**\n * Depth-first node list per canvas-level frame, children ordered by their\n * position strings (Figma's fractional indexing sorts lexicographically).\n * Multi-scene payloads have several canvas-level frames; DOCUMENT/CANVAS\n * nodes (including Figma's \"Internal Only Canvas\") never enter the walk.\n */\nexport function treeOrder(\n  changes: Array<OracleNode>\n): Array<{ name: string; nodes: Array<OracleNode> }> {\n  const key = (guid: { sessionID: number; localID: number }) =>\n    `${guid.sessionID}:${guid.localID}`;\n  const canvases = new Set(\n    changes.filter((c) => c.type === \"CANVAS\").map((c) => key(c.guid))\n  );\n  const byParent = new Map<string, Array<OracleNode>>();\n  for (const change of changes) {\n    if (\n      !change.parentIndex ||\n      change.type === \"DOCUMENT\" ||\n      change.type === \"CANVAS\"\n    ) {\n      continue;\n    }\n    const parent = key(change.parentIndex.guid);\n    const bucket = byParent.get(parent) ?? [];\n    bucket.push(change);\n    byParent.set(parent, bucket);\n  }\n  for (const bucket of byParent.values()) {\n    bucket.sort((a, b) =>\n      (a.parentIndex?.position ?? \"\").localeCompare(\n        b.parentIndex?.position ?? \"\"\n      )\n    );\n  }\n\n  const roots = [...canvases].flatMap((c) => byParent.get(c) ?? []);\n  const out: Array<{ name: string; nodes: Array<OracleNode> }> = [];\n  for (const root of roots) {\n    const nodes: Array<OracleNode> = [];\n    const visit = (node: OracleNode) => {\n      nodes.push(node);\n      for (const child of byParent.get(key(node.guid)) ?? []) {\n        visit(child);\n      }\n    };\n    visit(root);\n    out.push({ name: String(root.name ?? \"?\"), nodes });\n  }\n  return out;\n}\n","/**\n * Structural diff between the payload we sent to Figma and the payload Figma\n * returns when the pasted, rendered frame is copied back. Both sides are\n * decoded kiwi node changes, so this reuses the same tree/stack knowledge as\n * the rest of the package.\n *\n * Figma omits fields at their default value when copying, so absent fields are\n * normalized to their defaults before comparing (see stack-fields).\n */\nimport { STACK_FIELD_DEFAULTS, TRACKED_STACK_FIELDS } from \"./stack-fields\";\nimport type { OracleNode } from \"./tree\";\nimport { treeOrder } from \"./tree\";\n\nconst NUMERIC_TOLERANCE = 0.11;\nconst GEOMETRY_TOLERANCE = 0.55;\n\nexport type Mismatch = {\n  /** A positional node label (Figma re-ids nodes on paste, so there is no guid). */\n  node: string;\n  field: string;\n  sent: unknown;\n  got: unknown;\n};\n\nfunction normalized(node: OracleNode, field: string): unknown {\n  return node[field] ?? STACK_FIELD_DEFAULTS[field];\n}\n\nfunction differs(a: unknown, b: unknown): boolean {\n  if (typeof a === \"number\" && typeof b === \"number\") {\n    return Math.abs(a - b) > NUMERIC_TOLERANCE;\n  }\n  return a !== b;\n}\n\n/**\n * A grown (fill) or stretched child inside a stack is resized by Figma's layout\n * engine on paste, so its size legitimately differs from what we sent\n * pre-layout. Accept the got size when it equals the parent's inner size on\n * that axis.\n */\nfunction growthExplainsSize(\n  gotNode: OracleNode,\n  gotByKey: ReadonlyMap<string, OracleNode>,\n  axis: \"x\" | \"y\",\n  gotValue: number\n): boolean {\n  const parentGuid = gotNode.parentIndex?.guid;\n  const parent = parentGuid\n    ? gotByKey.get(`${parentGuid.sessionID}:${parentGuid.localID}`)\n    : undefined;\n  const parentMode = parent?.stackMode;\n  if (!parent || (parentMode !== \"HORIZONTAL\" && parentMode !== \"VERTICAL\")) {\n    return false;\n  }\n\n  const axisIsParentPrimary = (axis === \"x\") === (parentMode === \"HORIZONTAL\");\n  const grows =\n    (gotNode.stackChildPrimaryGrow as number | undefined) === 1 &&\n    axisIsParentPrimary;\n  const stretches =\n    gotNode.stackChildAlignSelf === \"STRETCH\" && !axisIsParentPrimary;\n  if (!(grows || stretches)) {\n    return false;\n  }\n\n  const parentSize = (parent.size as { x: number; y: number } | undefined)?.[\n    axis\n  ];\n  if (parentSize === undefined) {\n    return false;\n  }\n  const padLeading = (parent[\n    axis === \"x\" ? \"stackHorizontalPadding\" : \"stackVerticalPadding\"\n  ] ?? 0) as number;\n  const padTrailing = (parent[\n    axis === \"x\" ? \"stackPaddingRight\" : \"stackPaddingBottom\"\n  ] ?? 0) as number;\n  return (\n    Math.abs(gotValue - (parentSize - padLeading - padTrailing)) <=\n    GEOMETRY_TOLERANCE\n  );\n}\n\nfunction diffNodeFields(\n  sentNode: OracleNode,\n  gotNode: OracleNode,\n  label: string,\n  out: Array<Mismatch>\n): void {\n  const fields = new Set([\n    ...Object.keys(sentNode).filter((f) => TRACKED_STACK_FIELDS.has(f)),\n    ...Object.keys(gotNode).filter((f) => TRACKED_STACK_FIELDS.has(f)),\n  ]);\n  for (const field of fields) {\n    const sentValue = normalized(sentNode, field);\n    const gotValue = normalized(gotNode, field);\n    if (differs(sentValue, gotValue)) {\n      out.push({ node: label, field, sent: sentValue, got: gotValue });\n    }\n  }\n}\n\nfunction diffNodeGeometry(\n  sentNode: OracleNode,\n  gotNode: OracleNode,\n  index: number,\n  gotByKey: ReadonlyMap<string, OracleNode>,\n  label: string,\n  out: Array<Mismatch>\n): void {\n  const sentSize = sentNode.size as { x: number; y: number } | undefined;\n  const gotSize = gotNode.size as { x: number; y: number } | undefined;\n  for (const axis of [\"x\", \"y\"] as const) {\n    const a = sentSize?.[axis];\n    const b = gotSize?.[axis];\n    if (\n      a !== undefined &&\n      b !== undefined &&\n      Math.abs(a - b) > GEOMETRY_TOLERANCE &&\n      !growthExplainsSize(gotNode, gotByKey, axis, b)\n    ) {\n      out.push({ node: label, field: `size.${axis}`, sent: a, got: b });\n    }\n  }\n  // Positions only below the pasted root (its transform is wherever the paste\n  // landed on the canvas).\n  if (index === 0) {\n    return;\n  }\n  const sentT = sentNode.transform as { m02: number; m12: number } | undefined;\n  const gotT = gotNode.transform as { m02: number; m12: number } | undefined;\n  for (const [name, fieldKey] of [\n    [\"x\", \"m02\"],\n    [\"y\", \"m12\"],\n  ] as const) {\n    const a = sentT?.[fieldKey];\n    const b = gotT?.[fieldKey];\n    if (\n      a !== undefined &&\n      b !== undefined &&\n      Math.abs(a - b) > GEOMETRY_TOLERANCE\n    ) {\n      out.push({ node: label, field: `pos.${name}`, sent: a, got: b });\n    }\n  }\n}\n\nfunction diffRoot(\n  sentRoot: { name: string; nodes: Array<OracleNode> },\n  gotRoot: { name: string; nodes: Array<OracleNode> }\n): Array<Mismatch> {\n  const mismatches: Array<Mismatch> = [];\n  const sentTree = sentRoot.nodes;\n  const gotTree = gotRoot.nodes;\n\n  if (sentTree.length !== gotTree.length) {\n    mismatches.push({\n      node: `[${sentRoot.name}]`,\n      field: \"node count\",\n      sent: sentTree.length,\n      got: gotTree.length,\n    });\n    return mismatches;\n  }\n\n  const gotByKey = new Map(\n    gotTree.map((n) => [`${n.guid.sessionID}:${n.guid.localID}`, n])\n  );\n\n  sentTree.forEach((sentNode, i) => {\n    const gotNode = gotTree[i] as OracleNode;\n    const label = `[${sentRoot.name}] #${i} ${String(sentNode.name ?? sentNode.type)}`;\n    diffNodeFields(sentNode, gotNode, label, mismatches);\n    diffNodeGeometry(sentNode, gotNode, i, gotByKey, label, mismatches);\n  });\n\n  return mismatches;\n}\n\n/**\n * Compare a sent payload against a Figma copy-back payload. Top-level frames\n * pair by name; nodes within a frame pair by tree order. Returns the list of\n * structural mismatches (empty when Figma reproduced the payload exactly).\n */\nexport function diffFigmaTrees(\n  sent: Array<OracleNode>,\n  got: Array<OracleNode>\n): Array<Mismatch> {\n  const sentRoots = treeOrder(sent);\n  const gotRoots = treeOrder(got);\n  const mismatches: Array<Mismatch> = [];\n\n  if (sentRoots.length !== gotRoots.length) {\n    mismatches.push({\n      node: \"(payload)\",\n      field: \"top-level frame count\",\n      sent: sentRoots.length,\n      got: gotRoots.length,\n    });\n    return mismatches;\n  }\n\n  const gotByName = new Map(gotRoots.map((r) => [r.name, r]));\n  for (const sentRoot of sentRoots) {\n    const gotRoot = gotByName.get(sentRoot.name);\n    if (gotRoot) {\n      mismatches.push(...diffRoot(sentRoot, gotRoot));\n    } else {\n      mismatches.push({\n        node: `[${sentRoot.name}]`,\n        field: \"frame\",\n        sent: \"present\",\n        got: \"missing (renamed?)\",\n      });\n    }\n  }\n  return mismatches;\n}\n","export class KiwiWriter {\n  chunks: Array<Uint8Array>;\n  currentSize: number;\n\n  constructor() {\n    this.chunks = [];\n    this.currentSize = 0;\n  }\n\n  getBytes() {\n    // Concatenate all chunks into a single Uint8Array\n    const result = new Uint8Array(this.currentSize);\n    let offset = 0;\n    for (const chunk of this.chunks) {\n      result.set(chunk, offset);\n      offset += chunk.length;\n    }\n    return result;\n  }\n\n  byte(value: number) {\n    if (value < 0 || value > 255) {\n      throw new Error(`Byte value must be 0-255, got ${value}`);\n    }\n    const arr = new Uint8Array([value]);\n    this.chunks.push(arr);\n    this.currentSize += 1;\n  }\n\n  bool(value: boolean) {\n    this.byte(value ? 1 : 0);\n  }\n\n  uint(value: number) {\n    if (value < 0) {\n      throw new Error(`Unsigned int cannot be negative: ${value}`);\n    }\n\n    let current = value;\n    while (current >= 128) {\n      this.byte((current & 127) | 128);\n      current = Math.floor(current / 128);\n    }\n    this.byte(current & 127);\n  }\n\n  uint64(value: number) {\n    // JavaScript doesn't have native 64-bit integers, but we can handle them\n    // as long as they're within JavaScript's safe integer range\n    if (value < 0) {\n      throw new Error(`Unsigned int64 cannot be negative: ${value}`);\n    }\n\n    let current = value;\n    while (current >= 128) {\n      this.byte((current & 127) | 128);\n      current = Math.floor(current / 128);\n    }\n    this.byte(current & 127);\n  }\n\n  bytes(data: Uint8Array | ArrayBuffer | Array<number>) {\n    if (data instanceof Uint8Array) {\n      this.chunks.push(data);\n      this.currentSize += data.length;\n    } else if (data instanceof ArrayBuffer) {\n      const arr = new Uint8Array(data);\n      this.chunks.push(arr);\n      this.currentSize += arr.length;\n    } else if (Array.isArray(data)) {\n      const arr = new Uint8Array(data);\n      this.chunks.push(arr);\n      this.currentSize += arr.length;\n    } else {\n      throw new Error(\"bytes() requires Uint8Array, ArrayBuffer, or Array\");\n    }\n  }\n\n  int(value: number) {\n    // Zigzag encoding for signed integers\n    let encoded: number;\n    if (value >= 0) {\n      encoded = value * 2;\n    } else {\n      encoded = (-value - 1) * 2 + 1;\n    }\n    this.uint(encoded);\n  }\n\n  int64(value: number) {\n    // Zigzag encoding for signed 64-bit integers\n    let encoded: number;\n    if (value >= 0) {\n      encoded = value * 2;\n    } else {\n      encoded = (~value * 2) | 1;\n    }\n    this.uint64(encoded);\n  }\n\n  float(value: number) {\n    if (value === 0.0) {\n      this.byte(0);\n      return;\n    }\n\n    // Convert float to 32-bit representation\n    const buffer = new ArrayBuffer(4);\n    const view = new DataView(buffer);\n    view.setFloat32(0, value, false); // big-endian\n    let bits = view.getUint32(0, false);\n\n    // Apply bit manipulation (reverse of decoder)\n    bits = (bits >>> 23) | (bits << 9);\n    bits >>>= 0; // Ensure unsigned 32-bit\n\n    // Write 4 bytes\n    this.byte(bits & 0xff);\n    this.byte((bits >>> 8) & 0xff);\n    this.byte((bits >>> 16) & 0xff);\n    this.byte((bits >>> 24) & 0xff);\n  }\n\n  string(value: string) {\n    const encoder = new TextEncoder();\n    const encoded = encoder.encode(value);\n    this.bytes(encoded);\n    this.byte(0); // Null terminator\n  }\n}\n","","import schemaJson from \"./schema.json\" with { type: \"json\" };\nimport type { Schema } from \"./types\";\n\n// Generated by `pnpm extract-schema` — do not edit by hand.\nexport const SCHEMA = schemaJson as unknown as Schema;\n","import { deflateSync } from \"fflate\";\nimport { KiwiWriter } from \"./kiwi-writer\";\nimport { SCHEMA } from \"./schema\";\nimport type { TypeDef } from \"./types\";\n\n// Kiwi datatype sentinels (negative = primitive, non-negative = type index).\nconst PRIM = {\n  BOOL: -1,\n  BYTE: -2,\n  INT: -3,\n  UINT: -4,\n  FLOAT: -5,\n  STRING: -6,\n  INT64: -7,\n  UINT64: -8,\n} as const;\n\n// `TypeDef.kind` values.\nconst ENUM = 0;\nconst STRUCT = 1;\nconst MESSAGE = 2;\n\nconst MAGIC = new TextEncoder().encode(\"fig-kiwi\");\nconst ROOT_TYPE_NAME = \"Message\";\n\nfunction encodePrimitive(w: KiwiWriter, datatype: number, value: unknown) {\n  switch (datatype) {\n    case PRIM.BOOL:\n      return w.bool(value as boolean);\n    case PRIM.BYTE:\n      return w.byte(value as number);\n    case PRIM.INT:\n      return w.int(value as number);\n    case PRIM.UINT:\n      return w.uint(value as number);\n    case PRIM.FLOAT:\n      return w.float(value as number);\n    case PRIM.STRING:\n      return w.string(value as string);\n    case PRIM.INT64:\n      return w.int64(value as number);\n    case PRIM.UINT64:\n      return w.uint64(value as number);\n    default:\n      throw new Error(`Unknown primitive datatype: ${datatype}`);\n  }\n}\n\nfunction asByteArray(value: unknown): Uint8Array {\n  if (value instanceof Uint8Array) {\n    return value;\n  }\n  if (value instanceof ArrayBuffer) {\n    return new Uint8Array(value);\n  }\n  if (Array.isArray(value)) {\n    return new Uint8Array(value as Array<number>);\n  }\n  throw new Error(\n    `Byte array expected Uint8Array, ArrayBuffer, or Array, got ${typeof value}`\n  );\n}\n\nfunction encodeArray(\n  w: KiwiWriter,\n  types: ReadonlyArray<TypeDef>,\n  datatype: number,\n  value: unknown\n) {\n  // Byte arrays use a length-prefixed raw write instead of per-element encoding.\n  if (datatype === PRIM.BYTE) {\n    const bytes = asByteArray(value);\n    w.uint(bytes.length);\n    w.bytes(bytes);\n    return;\n  }\n  if (!Array.isArray(value)) {\n    throw new Error(`Array expected, got ${typeof value}`);\n  }\n  w.uint(value.length);\n  for (const item of value) {\n    encodeType(w, types, datatype, item, false);\n  }\n}\n\nfunction encodeEnum(w: KiwiWriter, type: TypeDef, value: unknown) {\n  for (const [fieldId, field] of Object.entries(type.fields)) {\n    if (field.name === value) {\n      w.uint(Number.parseInt(fieldId, 10));\n      return;\n    }\n  }\n  throw new Error(\n    `Unknown enum value '${String(value)}' for type '${type.name}'`\n  );\n}\n\nfunction encodeStruct(\n  w: KiwiWriter,\n  types: ReadonlyArray<TypeDef>,\n  type: TypeDef,\n  value: unknown\n) {\n  if (typeof value !== \"object\" || value === null) {\n    throw new Error(`Struct expected object, got ${typeof value}`);\n  }\n  const obj = value as Record<string, unknown>;\n  // Structs serialize every field in id order, no terminator. Explicit\n  // `undefined` is treated as missing.\n  const fieldCount = Object.keys(type.fields).length;\n  for (let id = 1; id <= fieldCount; id += 1) {\n    const field = type.fields[id];\n    if (!field) {\n      throw new Error(`Field ${id} missing in struct '${type.name}'`);\n    }\n    const v = obj[field.name];\n    if (v === undefined) {\n      throw new Error(\n        `Missing required field '${field.name}' in struct '${type.name}'`\n      );\n    }\n    encodeType(w, types, field.datatype, v, field.array);\n  }\n}\n\nfunction encodeMessage(\n  w: KiwiWriter,\n  types: ReadonlyArray<TypeDef>,\n  type: TypeDef,\n  value: unknown\n) {\n  if (typeof value !== \"object\" || value === null) {\n    throw new Error(`Message expected object, got ${typeof value}`);\n  }\n  const obj = value as Record<string, unknown>;\n  // Messages emit only present fields (each preceded by its id), terminated by 0.\n  for (const [fieldId, field] of Object.entries(type.fields)) {\n    if (field.name in obj) {\n      w.uint(Number.parseInt(fieldId, 10));\n      encodeType(w, types, field.datatype, obj[field.name], field.array);\n    }\n  }\n  w.uint(0);\n}\n\nfunction encodeType(\n  w: KiwiWriter,\n  types: ReadonlyArray<TypeDef>,\n  datatype: number,\n  value: unknown,\n  isArray: boolean\n) {\n  if (isArray) {\n    return encodeArray(w, types, datatype, value);\n  }\n  if (datatype < 0) {\n    return encodePrimitive(w, datatype, value);\n  }\n\n  const type = types[datatype];\n  if (!type) {\n    throw new Error(`Type definition not found for datatype ${datatype}`);\n  }\n  switch (type.kind) {\n    case ENUM:\n      return encodeEnum(w, type, value);\n    case STRUCT:\n      return encodeStruct(w, types, type, value);\n    case MESSAGE:\n      return encodeMessage(w, types, type, value);\n    default:\n      throw new Error(`Unknown kind ${type.kind} for type '${type.name}'`);\n  }\n}\n\nfunction writeSchema(w: KiwiWriter, types: ReadonlyArray<TypeDef>) {\n  w.uint(types.length);\n  for (const type of types) {\n    w.string(type.name);\n    w.byte(type.kind);\n    w.uint(Object.keys(type.fields).length);\n    for (const [fieldId, field] of Object.entries(type.fields)) {\n      w.string(field.name);\n      w.int(field.datatype);\n      w.bool(field.array);\n      w.uint(Number.parseInt(fieldId, 10));\n    }\n  }\n}\n\nfunction uint32LE(value: number): Uint8Array {\n  const buf = new ArrayBuffer(4);\n  new DataView(buf).setUint32(0, value, true);\n  return new Uint8Array(buf);\n}\n\nfunction concatBytes(parts: ReadonlyArray<Uint8Array>): Uint8Array {\n  const total = parts.reduce((n, p) => n + p.length, 0);\n  const out = new Uint8Array(total);\n  let offset = 0;\n  for (const p of parts) {\n    out.set(p, offset);\n    offset += p.length;\n  }\n  return out;\n}\n\n// `String.fromCharCode(...arr)` blows the call stack on large inputs, so\n// chunk through it before handing the binary string to `btoa`.\nfunction bytesToBase64(bytes: Uint8Array): string {\n  const CHUNK = 0x80_00;\n  let binary = \"\";\n  for (let i = 0; i < bytes.length; i += CHUNK) {\n    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));\n  }\n  return btoa(binary);\n}\n\n/**\n * Encode a Kiwi `Message` into the fig-kiwi binary envelope (magic + version\n * + deflated schema + deflated data) plus its base64 form.\n */\nexport function encodeFigmaData(message: unknown) {\n  const { types, version } = SCHEMA;\n  const rootIndex = types.findIndex((t) => t.name === ROOT_TYPE_NAME);\n  if (rootIndex === -1) {\n    throw new Error(`No root '${ROOT_TYPE_NAME}' type found in schema`);\n  }\n\n  const schemaWriter = new KiwiWriter();\n  writeSchema(schemaWriter, types);\n  const compressedSchema = deflateSync(schemaWriter.getBytes(), { level: 6 });\n\n  const dataWriter = new KiwiWriter();\n  encodeType(dataWriter, types, rootIndex, message, false);\n  const compressedData = deflateSync(dataWriter.getBytes(), { level: 6 });\n\n  const figBytes = concatBytes([\n    MAGIC,\n    uint32LE(version),\n    uint32LE(compressedSchema.length),\n    compressedSchema,\n    uint32LE(compressedData.length),\n    compressedData,\n  ]);\n\n  return {\n    figBytes,\n    base64: bytesToBase64(figBytes),\n    size: figBytes.length,\n  };\n}\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}