@gerege-systems/eid-mongolia-sdk 0.14.2 → 0.15.0

package/dist/pades.cjs

@@ -0,0 +1,3520 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pades.ts
+var pades_exports = {};
+__export(pades_exports, {
+  PADES_ERROR_CODES: () => PADES_ERROR_CODES,
+  PROFILE_VERSION: () => PROFILE_VERSION,
+  PadesError: () => PadesError,
+  complete: () => complete,
+  prepare: () => prepare,
+  profileVersion: () => profileVersion
+});
+module.exports = __toCommonJS(pades_exports);
+
+// src/errors.ts
+var EidError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+
+// src/pades/assets/chain.ts
+var NATIONAL_ROOT = [
+  // 01-mongolian-national-root-ca.pem
+  "MIIFbzCCA1egAwIBAgIQGW2d2BtfmG+v6sgjAFTJxTANBgkqhkiG9w0BAQsFADBBMQswCQYDVQQGEwJNTjENMAsGA1UECgwEQ0lUQTEjMCEGA1UEAwwaTW9uZ29saWFuIE5hdGlvbmFsIFJvb3QgQ0EwHhcNMjEwMjAxMDM0MTE4WhcNMzEwMjAxMDM0MTE4WjBBMQswCQYDVQQGEwJNTjENMAsGA1UECgwEQ0lUQTEjMCEGA1UEAwwaTW9uZ29saWFuIE5hdGlvbmFsIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC1Z7StAGQ87aT6BjzAcP1pbGqLzNWfupbc3a+GXrTZlhfUiIV1lSEMbC1HtL6odbqTTxvR376WJ/kBp1VN6x04PaOeukM7a4Q1F9XvJYs2/FKs30/bGQXwNNruJlRDDhvP5gx6g0QUvfG+aQpTnYV8nNtaby+5THoJMCJdyztLJdpe9I52/sCtw33CeGFC80ZuYjK8Gm5b2oPZ/XDpsdMOm3pFMbJK0yfU5mvAQTHU89rJTLQWZDQPuDfLmc2ytwWLuI7HESLCKL0jBO+zM2mSMPvBZW5xu33GIb8UHqJaUs+fil+LdvUoZLp23LSiCKTy68rnrUoCIMKk0ZIdSUqEOOCLuBlXRz4rdiO0iwYlhXys6rQdKkj7fLdz9RWtdelzaqKd8vOUgOXTsDki+UrVYB/kEoP+XQKKi1RwTRQCAgkT3Sc53HNohmDoBICqK6IFeQNpzoKOR22t0s/AvYIO0iGK7UUH7+Ao3QZwmYhz6L5BJcr/Hv81Op5WYC3KqtGRAOHE7Mv+QLPnUqLAdvwoX5egQ8i9B50/0s2JG3RGh27DpTnbRnf3108f06czglA2BfC7svXBWjbDp7YxkilhM3tM6UCo8i0PPoZkxF5YcP67VCMnbpwWueuQFmshP7edsTlh0qt7/sLoD5fyyXVnK4lGMqgeckjCQCpUUQvbBQIDAQABo2MwYTAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUuC1LoUoTbEUTHY+2CzIx6oC6X7AwHwYDVR0jBBgwFoAUuC1LoUoTbEUTHY+2CzIx6oC6X7AwDQYJKoZIhvcNAQELBQADggIBAGSMhtI0/bowvun7+QotpEGSvCstem+LdyFCp6qFIbo77mkrNlRGAX6Z65oB3ix+afNm/d/VCx8Ydjx/9mhFeLyLiq8Jopr5cBQCtFKP6SQ2CtqA99y6shlu6PYmzDvxxhK+2jqbZmg10YNF55/wRt3tOBAMvgeUrgbZfJv4pi89+lRDDXgTNPWXPMA/7hK825pAleEztXMECu+SF6KINmw6SbI0tFaE1eOnTliVASj5Hb0XWvxMJATE7rof17NTepkesyOE0Rv4Dy0MYO1U356j7SfvBV2zQcec7utCCl3fR3glgtXd67xz722EkJFw3OLarlVqCr6olq/wCDMD1H6gjltvqDWLfYnuiBMilid+5Vb3O/EaGwLjJmyFC8B2mp0bzTlB8nq8O5AgKjaaj6l4aFPuVq7nzQ9f1tiw7p+fV47U2aOD5rLUbGcb4jLgCfHibmN8bIpsx9F+EJKqGKnMJ+r8VjQ3LPMlNxbhcQcl6EKZiLuVB6g5V3O5+FnZKv0ziA19kSJQOVOJbiyGVAzpGeaZ8Ftqd6MNXu4siCjJhuOH3GmUd5u0E4cFTORT3G8lyZMTmfg3uzvRCZBeq52jrGatPq2SYmjJm0a52ZoQrykhpR74rX7CCJTZfF5IIWm5QguOuMJZ9Ame3upE+mo2tMfZiMzmT8LTeFfgVlAT"
+];
+var INTERMEDIATES = [
+  // 02-mongolian-national-issuing-ca-mddc.pem
+  "MIIFfjCCA2agAwIBAgIRAMTWHlREVRvh75L6awpU3WkwDQYJKoZIhvcNAQELBQAwQTELMAkGA1UEBhMCTU4xDTALBgNVBAoMBENJVEExIzAhBgNVBAMMGk1vbmdvbGlhbiBOYXRpb25hbCBSb290IENBMB4XDTIyMDQxMzA1MjI1M1oXDTMxMDEzMTAzNDM1M1owgaUxFDASBgNVBAcTC1VsYWFuYmFhdGFyMSYwJAYDVQQJDB1DaGluZ2dpcyBTcXVhcmUtMSwgQ2hpbmdlbHRlaTEhMB8GA1UEMwwYUC5PLkItNzg1LCBNRERDIEJ1aWxkaW5nMQswCQYDVQQGEwJNTjENMAsGA1UECgwETUREQzEmMCQGA1UEAwwdTW9uZ29saWFuIE5hdGlvbmFsIElzc3VpbmcgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC5CrMTYfCsxVeuYqchVhalVqv2PVGQ3hXpkKI89A3Pbh3u2+Z/woPWL/0ilXNV0ac4AMLd/XdA4VXgD3TSuEq6TuiJ93Ss14iiygXU4UL0By/c//npW3/XuUtk+QkruGRv8pt7YFkwt6vxBH1jKCFChv57vscYKlJjSqcoW54Y6Ci6NdrwsFaf7JYJBE3+LS+nzffyuFOIy7qjVDZ+gej3QK7boBwOGnYCxz3gwW+evIH/5QHg2AAW2KmuTQlG+e27XfQZaAJQHFMzNrN5LxYc55HP6qd8TdnOvELP0zY0OEX3UBuLXyxPpnD4LtZpGpQX1HZo38Yn8lzZuax9ULNtAgMBAAGjggEKMIIBBjA0BggrBgEFBQcBAQQoMCYwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmVzaWduLmdvdi5tbjA4BgNVHSAEMTAvMC0GCGCDcAFlAQIIMCEwHwYIKwYBBQUHAgEWE2h0dHA6Ly9lc2lnbi5nb3YubW4wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2VzaWduLmdvdi5tbi9NTlJDQS0yMDIxLmNybDAOBgNVHQ8BAf8EBAMCAYYwHwYDVR0jBBgwFoAUuC1LoUoTbEUTHY+2CzIx6oC6X7AwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUz7gyZji9vGk/4qaMVa04wposACYwDQYJKoZIhvcNAQELBQADggIBADeX7yTFK4SpSIZnF59H8KdKU5B3DGV3gpsnspNQ9nMvlMzX0rn4ymdW/EzesyJ3nLqoavVmKBK0O09IU8vaDxhCDHpzyivGUlzKHwRbFJX32V57ifS4mawzBuHmjeES7DUgAGkg46llNuVUqsM+nouCq6pwdAEDgjvHrtrjsJ6uw+w+eK148SDr5fHiX27c+eUI1KhZo4Sx9VLToi8AR3wUDs4Im147tM/Ih5BQFk3/eC7lUpjPsqUsXZsTs1lEZcg1WpjjK9mJGpl3tPbe61nvu3y9WmLO+4RVzJNeWbAHPS6z4a/xh0AnjiCOT5ks5DAZO7YjKU+W/9ssgCEJ8M8ALrHob2xADZNhkPDS6aYyjr5Sd3FTPmjUTdFPI/UA3hp5vYoklhhKr2rAFRjMLSjMh/5ZeHwTctcjJJaq1fOxCfG08dQY/of0jd8fA89PIuaYu0eyfV5oD3XUZtiE5kSQ/vXjtiOmCLZdvhTNfJ+BU/mX6NhbpprE3V323fAoKBjY6WWXMXuOPMeHbXfWOpV3RT2+FepZMLzu5u++7bPy4PkV9PJX3Oqf6Bm025yaB7W8Ysen4FDuTQe2JTjHpj6kpB//ps6uBui9jQa8GKvb/WOnjypquQFwSkmSTIdP9D1wRffuPQEksEAyC0BqTzfJglVeva6zfELv6c3fcqxr",
+  // 03-gerege-issuing-ca.pem
+  "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",
+  // 04-eid-mongolia-issuing-ca.pem
+  "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",
+  // 05-eid-mongolia-org-issuing-ca.pem
+  "MIIGpjCCBI6gAwIBAgIQN27q7Ln+LfiCTE97T6magDANBgkqhkiG9w0BAQsFADBoMQswCQYDVQQGEwJNTjEbMBkGA1UECgwSR2VyZWdlIFN5c3RlbXMgTExDMSAwHgYDVQQLDBdDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEaMBgGA1UEAwwRR2VyZWdlIElzc3VpbmcgQ0EwHhcNMjYwOTI4MTI1MTI2WhcNMzEwMTMwMDM0NjI2WjBZMS0wKwYDVQQDEyRlSUQgTW9uZ29saWEgT3JnYW5pemF0aW9uIElzc3VpbmcgQ0ExGzAZBgNVBAoTEkdlcmVnZSBTeXN0ZW1zIExMQzELMAkGA1UEBhMCTU4wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCZ1t4EtDVD0qpIJ1CGF+TI3oq+NzKfNE4AHPYI9roeGL3E9tDMIcXMNbz2FVgbH3I4R5YSiu+9dRvYtL4NvbbGBHW31L1WCg89gjhOzeDpKRFQYkTBcUlf0mhZU4xgyBh2BOsfFnednun9BRWQP5gwCzOfV64hSmExaTeY8188lETu6sp9BoT2BbPAOEKysQgie++7TNwXwabqD+XVHKFlkNmKzTtra4YN4JzE1ciV2EWJBNZ+KIacgprmAj7y3nLjwHpm19M9RyXkDnxZJ9XznDQn4jfg5Ipr2wDQ72zwTQxEGwc2IyOK/2MH4fuEcxOEf1tZiYt5r4Ix/J7KK1HiUAHCIW7PR2pwVk9/gCHFp8VZ/wrEkDOMMdDQ5Dw6A6hXTVNn+b6D4L2uaHbgBNBWXLs1xQ17AS5GZ8ZTqmnxHnF2xM26oGxYsMRGeU7s8ImO2tf1PP9JDehy8aB4fzU34/K/x6kJo2rNZKoEWcDoxUkpBCnltIuK03Z0cXxaWWe26TemXER4VCqNNEj46ync+mTp66hsMe73opgf4iSLjTO0Gc5xUuO9BkY8lnCrC+SkXYjBceSmjPXysd4Ny89TPe5ch2DhrgWPNg9v5TSlzmHpmR0HTZklNDmofEK70Pl0L6lNHYB2m3TYLYP7vKI2n7K4WQLdrnZjwC/83Sh/wQIDAQABo4IBWTCCAVUwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFCKtNFyrdvbKRFm6Jb1yRdtD1o4LMB8GA1UdIwQYMBaAFF/hTgiJWOOOFpSbjmMNxrd2mWY7MHsGCCsGAQUFBwEBBG8wbTArBggrBgEFBQcwAYYfaHR0cDovL29jc3AuZWlkbW9uZ29saWEubW4vb2NzcDA+BggrBgEFBQcwAoYyaHR0cDovL2NybC5laWRtb25nb2xpYS5tbi9jYS9nZXJlZ2UtaXNzdWluZy1jYS5jZXIwMQYDVR0fBCowKDAmoCSgIoYgaHR0cDovL2NybC5laWRtb25nb2xpYS5tbi9jcmwvY2EwPwYDVR0gBDgwNjA0Bghgg3ABZQECCDAoMCYGCCsGAQUFBwIBFhpodHRwczovL2VpZG1vbmdvbGlhLm1uL2NwczANBgkqhkiG9w0BAQsFAAOCAgEARQny7bSZA3IFs70bWBZYPtEQlokI3UppWGSkLwL6V7S/JEmqtBHUdfd2pXWdZ+rc44HIPQW8zdrEwgSIOQNfPdGbq7f/kHvw0sSNt3nF7IZFDGjkCBOPLlqLPrkRZ3dhtB62Hrqpi6EN0urVxfBXgDCtI4NiPPj6v7qVlF6vIAoOP20XZUaA2n1kT+OkE6a7+bKdOIej55i9oauc/MYM8f5eLApBE5bL0KVqWicQg2JKRlbt/BlE8/JSMof8dNRr1KFoMaqXP76tbTnGeLed/QLFq2SSnL2dbJMrFaeyVX8WRGwbg3TBQS3EUcQ+nV8+g9IRWxoAIevbI6rNUBvXBwKR6yhkB/biPQad0cIYY4oZ2i4oG/gAWfMXdQA0qHdbd1g7UmtXfH5SeqEqC0gUx6UTRDfXEy8/t5UbSteKzgfkeWdar+5PJoByysk/l2/1JW+9+H3thccOcNA8dTLN9J9p5J2PPhORVpyT3GlBSOxWuT9uSbzvbWlwjt3bMUt8OfSBYRqZ4SYR8wztEt6WZNWaSLcjiAgFJUXBDDt00NWrfVv8EsfFg/7zbSlIG74XQz6bPFB8B2rB/b32gvCB3bxu0NCLCI5H+/f/8yBSeu2xxcCfaFgBb7s+yr+bhfQ7TD7KznCHUlJI9tRkt2JfsYablLfBP+ZKjrfOal4fe4U="
+];
+var EID_ISSUERS = [
+  // 04-eid-mongolia-issuing-ca.pem
+  "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",
+  // 05-eid-mongolia-org-issuing-ca.pem
+  "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"
+];
+
+// src/pades/bytes.ts
+var enc = new TextEncoder();
+function latin1(s) {
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) & 255;
+  return out;
+}
+function fromLatin1(b, start = 0, end = b.length) {
+  let s = "";
+  for (let i = start; i < end; i += 32768) s += String.fromCharCode(...b.subarray(i, Math.min(end, i + 32768)));
+  return s;
+}
+function concat(parts) {
+  let n = 0;
+  for (const p of parts) n += p.length;
+  const out = new Uint8Array(n);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+function equal(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function compare(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return a.length - b.length;
+}
+var HEX = "0123456789abcdef";
+function toHex(b) {
+  let s = "";
+  for (const x of b) s += HEX[x >> 4] + HEX[x & 15];
+  return s;
+}
+function fromHex(s) {
+  if (s.length % 2 !== 0 || /[^0-9a-fA-F]/.test(s)) throw new Error("hex \u0431\u0443\u0440\u0443\u0443");
+  const out = new Uint8Array(s.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(s.substr(i * 2, 2), 16);
+  return out;
+}
+function toB64(b) {
+  return btoa(fromLatin1(b));
+}
+function fromB64(s) {
+  return latin1(atob(s));
+}
+var ByteWriter = class {
+  buf = new Uint8Array(1 << 16);
+  len = 0;
+  grow(n) {
+    if (this.len + n <= this.buf.length) return;
+    let cap = this.buf.length * 2;
+    while (cap < this.len + n) cap *= 2;
+    const nb = new Uint8Array(cap);
+    nb.set(this.buf.subarray(0, this.len));
+    this.buf = nb;
+  }
+  bytes(b) {
+    this.grow(b.length);
+    this.buf.set(b, this.len);
+    this.len += b.length;
+    return this;
+  }
+  /** ASCII/latin1 мөр. */
+  str(s) {
+    this.grow(s.length);
+    for (let i = 0; i < s.length; i++) this.buf[this.len + i] = s.charCodeAt(i) & 255;
+    this.len += s.length;
+    return this;
+  }
+  byte(x) {
+    this.grow(1);
+    this.buf[this.len++] = x & 255;
+    return this;
+  }
+  /** Хуулбар. */
+  result() {
+    return this.buf.slice(0, this.len);
+  }
+};
+
+// src/pades/asn1.ts
+var Asn1Error = class extends Error {
+};
+var TAG = {
+  BOOLEAN: 1,
+  INTEGER: 2,
+  BIT_STRING: 3,
+  OCTET_STRING: 4,
+  NULL: 5,
+  OID: 6,
+  ENUMERATED: 10,
+  UTF8String: 12,
+  SEQUENCE: 48,
+  SET: 49,
+  PrintableString: 19,
+  IA5String: 22,
+  UTCTime: 23,
+  GeneralizedTime: 24
+};
+function readNode(b, off = 0) {
+  if (off + 2 > b.length) throw new Asn1Error("asn1: \u0434\u0443\u0442\u0443\u0443");
+  const tag = b[off];
+  if ((tag & 31) === 31) throw new Asn1Error("asn1: \u043E\u043B\u043E\u043D \u0431\u0430\u0439\u0442 tag \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439");
+  let len = b[off + 1];
+  let p = off + 2;
+  if (len & 128) {
+    const n = len & 127;
+    if (n === 0 || n > 4) throw new Asn1Error("asn1: \u0443\u0440\u0442 \u0431\u0443\u0440\u0443\u0443");
+    if (p + n > b.length) throw new Asn1Error("asn1: \u0434\u0443\u0442\u0443\u0443");
+    if (b[p] === 0) throw new Asn1Error("asn1: \u0443\u0440\u0442 minimal \u0431\u0438\u0448");
+    len = 0;
+    for (let i = 0; i < n; i++) len = len * 256 + b[p + i];
+    if (len < 128) throw new Asn1Error("asn1: \u0443\u0440\u0442 minimal \u0431\u0438\u0448");
+    p += n;
+  }
+  if (p + len > b.length) throw new Asn1Error("asn1: \u0434\u0443\u0442\u0443\u0443");
+  return { tag, raw: b.subarray(off, p + len), value: b.subarray(p, p + len) };
+}
+function parseOne(b) {
+  const n = readNode(b, 0);
+  if (n.raw.length !== b.length) throw new Asn1Error("asn1: \u0438\u043B\u04AF\u04AF \u04E9\u0433\u04E9\u0433\u0434\u04E9\u043B");
+  return n;
+}
+function children(n) {
+  const v = n instanceof Uint8Array ? n : n.value;
+  const out = [];
+  for (let p = 0; p < v.length; ) {
+    const c = readNode(v, p);
+    out.push(c);
+    p += c.raw.length;
+  }
+  return out;
+}
+function expect(n, tag, what) {
+  if (!n || n.tag !== tag) throw new Asn1Error(`asn1: ${what} \u0445\u04AF\u043B\u044D\u044D\u0441\u044D\u043D`);
+  return n;
+}
+function lenBytes(n) {
+  if (n < 128) return Uint8Array.of(n);
+  const out = [];
+  for (let x = n; x > 0; x = Math.floor(x / 256)) out.unshift(x & 255);
+  return Uint8Array.from([128 | out.length, ...out]);
+}
+function tlv(tag, ...content) {
+  const v = concat(content);
+  return concat([Uint8Array.of(tag), lenBytes(v.length), v]);
+}
+var seq = (...c) => tlv(TAG.SEQUENCE, ...c);
+var set = (...c) => tlv(TAG.SET, ...c);
+var octet = (b) => tlv(TAG.OCTET_STRING, b);
+var nullDer = () => Uint8Array.of(5, 0);
+var ctx = (n, constructed, ...c) => tlv(128 | (constructed ? 32 : 0) | n, ...c);
+function oid(s) {
+  const parts = s.split(".").map((x) => BigInt(x));
+  const body = [];
+  const enc2 = (v) => {
+    const tmp = [Number(v & 0x7fn)];
+    for (v >>= 7n; v > 0n; v >>= 7n) tmp.unshift(Number(v & 0x7fn) | 128);
+    body.push(...tmp);
+  };
+  enc2(parts[0] * 40n + parts[1]);
+  for (const p of parts.slice(2)) enc2(p);
+  return tlv(TAG.OID, Uint8Array.from(body));
+}
+function oidString(v) {
+  const out = [];
+  let cur = 0n;
+  for (const b of v) {
+    cur = cur << 7n | BigInt(b & 127);
+    if (!(b & 128)) {
+      out.push(cur);
+      cur = 0n;
+    }
+  }
+  if (out.length === 0) return "";
+  const first = out[0];
+  const a = first < 40n ? 0n : first < 80n ? 1n : 2n;
+  return [a, first - a * 40n, ...out.slice(1)].join(".");
+}
+function intFromBig(v) {
+  if (v === 0n) return tlv(TAG.INTEGER, Uint8Array.of(0));
+  const bytes = [];
+  if (v > 0n) {
+    for (let x = v; x > 0n; x >>= 8n) bytes.unshift(Number(x & 0xffn));
+    if (bytes[0] & 128) bytes.unshift(0);
+  } else {
+    let x = v;
+    for (; ; ) {
+      bytes.unshift(Number(x & 0xffn));
+      x >>= 8n;
+      if (x === -1n && bytes[0] & 128) break;
+    }
+  }
+  return tlv(TAG.INTEGER, Uint8Array.from(bytes));
+}
+function bigFromBytes(b) {
+  let v = 0n;
+  for (const x of b) v = v << 8n | BigInt(x);
+  return v;
+}
+function intValue(v) {
+  if (v.length === 0) throw new Asn1Error("asn1: \u0445\u043E\u043E\u0441\u043E\u043D INTEGER");
+  let x = bigFromBytes(v);
+  if (v[0] & 128) x -= 1n << BigInt(v.length * 8);
+  return x;
+}
+function parseTime(n) {
+  const s = String.fromCharCode(...n.value);
+  let m;
+  if (n.tag === TAG.UTCTime) {
+    m = /^(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})?(Z|[+-]\d{4})$/.exec(s);
+    if (!m) throw new Asn1Error("asn1: UTCTime \u0431\u0443\u0440\u0443\u0443");
+    let y = Number(m[1]);
+    y += y < 50 ? 2e3 : 1900;
+    return mkDate(y, m[2], m[3], m[4], m[5], m[6] ?? "00", "", m[7]);
+  }
+  if (n.tag === TAG.GeneralizedTime) {
+    m = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\.\d+)?(Z|[+-]\d{4})$/.exec(s);
+    if (!m) throw new Asn1Error("asn1: GeneralizedTime \u0431\u0443\u0440\u0443\u0443");
+    return mkDate(Number(m[1]), m[2], m[3], m[4], m[5], m[6], m[7] ?? "", m[8]);
+  }
+  throw new Asn1Error("asn1: \u0446\u0430\u0433 \u0445\u04AF\u043B\u044D\u044D\u0441\u044D\u043D");
+}
+function parsePreciseTime(n) {
+  const date = parseTime(n);
+  const m = /\.(\d+)/.exec(String.fromCharCode(...n.value));
+  const nanos = m ? Number((m[1] + "000000000").slice(0, 9)) : 0;
+  return { date, nanos };
+}
+function mkDate(y, mo, d, h, mi, s, frac, z) {
+  let t = Date.UTC(y, Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s));
+  if (frac) t += Math.floor(Number("0" + frac) * 1e3);
+  if (z !== "Z") {
+    const off = (Number(z.slice(1, 3)) * 60 + Number(z.slice(3, 5))) * 6e4;
+    t += z[0] === "+" ? -off : off;
+  }
+  return new Date(t);
+}
+
+// src/pades/crypto.ts
+var subtlePromise;
+var nodeImport = (m) => import(
+  /* @vite-ignore */
+  /* webpackIgnore: true */
+  m
+);
+async function webcrypto() {
+  const g = globalThis.crypto;
+  if (g?.subtle) return g;
+  const m = await nodeImport("node:crypto");
+  if (!m.webcrypto) throw new Error("Web Crypto \u0430\u043B\u0433\u0430");
+  return m.webcrypto;
+}
+function subtle() {
+  subtlePromise ??= webcrypto().then((c) => c.subtle);
+  return subtlePromise;
+}
+async function randomBytes(n) {
+  return (await webcrypto()).getRandomValues(new Uint8Array(n));
+}
+async function sha256(b) {
+  return new Uint8Array(await (await subtle()).digest("SHA-256", b));
+}
+async function sha1(b) {
+  return new Uint8Array(await (await subtle()).digest("SHA-1", b));
+}
+async function digest(alg, b) {
+  return new Uint8Array(await (await subtle()).digest(alg, b));
+}
+
+// src/pades/x509.ts
+var OID = {
+  rsaEncryption: "1.2.840.113549.1.1.1",
+  rsaPSS: "1.2.840.113549.1.1.10",
+  sha256WithRSA: "1.2.840.113549.1.1.11",
+  sha384WithRSA: "1.2.840.113549.1.1.12",
+  sha512WithRSA: "1.2.840.113549.1.1.13",
+  ecPublicKey: "1.2.840.10045.2.1",
+  ecdsaSHA256: "1.2.840.10045.4.3.2",
+  ecdsaSHA384: "1.2.840.10045.4.3.3",
+  ecdsaSHA512: "1.2.840.10045.4.3.4",
+  p256: "1.2.840.10045.3.1.7",
+  p384: "1.3.132.0.34",
+  p521: "1.3.132.0.35",
+  sha1: "1.3.14.3.2.26",
+  sha256: "2.16.840.1.101.3.4.2.1",
+  sha384: "2.16.840.1.101.3.4.2.2",
+  sha512: "2.16.840.1.101.3.4.2.3",
+  commonName: "2.5.4.3",
+  surname: "2.5.4.4",
+  givenName: "2.5.4.42",
+  extKeyUsage: "2.5.29.37",
+  keyUsage: "2.5.29.15",
+  basicConstraints: "2.5.29.19",
+  crlDP: "2.5.29.31",
+  aia: "1.3.6.1.5.5.7.1.1",
+  ocspMethod: "1.3.6.1.5.5.7.48.1",
+  kpTimeStamping: "1.3.6.1.5.5.7.3.8",
+  kpOCSPSigning: "1.3.6.1.5.5.7.3.9",
+  kpAny: "2.5.29.37.0"
+};
+var CertError = class extends Error {
+};
+function bitString(n) {
+  expect(n, TAG.BIT_STRING, "BIT STRING");
+  if (n.value.length === 0) throw new Asn1Error("BIT STRING \u0445\u043E\u043E\u0441\u043E\u043D");
+  return n.value.subarray(1);
+}
+function decodeDirString(n) {
+  if (n.tag === 30) {
+    let s = "";
+    for (let i = 0; i + 1 < n.value.length; i += 2) s += String.fromCharCode(n.value[i] << 8 | n.value[i + 1]);
+    return s;
+  }
+  if (n.tag === TAG.UTF8String) return new TextDecoder().decode(n.value);
+  return String.fromCharCode(...n.value);
+}
+function nameAttrs(name) {
+  const out = [];
+  for (const rdn of children(name)) {
+    for (const atv of children(rdn)) {
+      const [t, v] = children(atv);
+      if (!t || !v) continue;
+      out.push([oidString(t.value), decodeDirString(v)]);
+    }
+  }
+  return out;
+}
+function parseCertificate(der2) {
+  try {
+    const top = parseOne(der2);
+    expect(top, TAG.SEQUENCE, "Certificate");
+    const [tbsN, sigAlg, sigN] = children(top);
+    const tbs = expect(tbsN, TAG.SEQUENCE, "TBSCertificate");
+    const f = children(tbs);
+    let i = 0;
+    let version = 1;
+    if (f[0]?.tag === 160) {
+      const v = expect(children(f[0])[0], TAG.INTEGER, "version");
+      version = v.value[0] + 1;
+      i++;
+    }
+    const serial = expect(f[i++], TAG.INTEGER, "serial").value;
+    i++;
+    const issuer = expect(f[i++], TAG.SEQUENCE, "issuer");
+    const validity = children(expect(f[i++], TAG.SEQUENCE, "validity"));
+    const subject = expect(f[i++], TAG.SEQUENCE, "subject");
+    const spki = expect(f[i++], TAG.SEQUENCE, "SPKI");
+    const [algN, pkN] = children(spki);
+    const algParts = children(expect(algN, TAG.SEQUENCE, "AlgorithmIdentifier"));
+    const keyAlg = oidString(expect(algParts[0], TAG.OID, "alg").value);
+    const curve = keyAlg === OID.ecPublicKey && algParts[1]?.tag === TAG.OID ? oidString(algParts[1].value) : void 0;
+    const extensions = [];
+    for (; i < f.length; i++) {
+      if (f[i].tag !== 163) continue;
+      for (const e of children(expect(children(f[i])[0], TAG.SEQUENCE, "extensions"))) {
+        const p = children(e);
+        const o = oidString(expect(p[0], TAG.OID, "ext oid").value);
+        let critical = false;
+        let val = p[1];
+        if (val?.tag === TAG.BOOLEAN) {
+          critical = val.value[0] !== 0;
+          val = p[2];
+        }
+        extensions.push({ oid: o, critical, value: expect(val, TAG.OCTET_STRING, "ext value").value });
+      }
+    }
+    const subj = nameAttrs(subject);
+    const iss = nameAttrs(issuer);
+    const last = (a, o) => a.filter(([k]) => k === o).map(([, v]) => v).pop() ?? "";
+    const cert = {
+      raw: top.raw,
+      tbs: tbs.raw,
+      version,
+      serial,
+      sigAlg: expect(sigAlg, TAG.SEQUENCE, "sigAlg"),
+      signature: bitString(sigN),
+      rawIssuer: issuer.raw,
+      rawSubject: subject.raw,
+      spki: spki.raw,
+      keyAlg,
+      curve,
+      publicKey: bitString(pkN),
+      notBefore: parseTime(validity[0]),
+      notAfter: parseTime(validity[1]),
+      extensions,
+      subjectCN: last(subj, OID.commonName),
+      issuerCN: last(iss, OID.commonName),
+      // Go SignerDisplayName: Subject.Names-ийн давталтын сүүлийн утга.
+      givenName: last(subj, OID.givenName),
+      surname: last(subj, OID.surname),
+      ocspServers: [],
+      crlDPs: [],
+      isCA: false,
+      basicConstraintsValid: false,
+      keyUsage: 0,
+      extKeyUsage: []
+    };
+    for (const e of extensions) parseExtension(cert, e);
+    return cert;
+  } catch (e) {
+    throw new CertError(`\u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function parseExtension(c, e) {
+  const n = parseOne(e.value);
+  switch (e.oid) {
+    case OID.basicConstraints: {
+      c.basicConstraintsValid = true;
+      const p = children(n);
+      c.isCA = p[0]?.tag === TAG.BOOLEAN && p[0].value[0] !== 0;
+      break;
+    }
+    case OID.keyUsage: {
+      const bs = n.value;
+      let ku = 0;
+      for (let i = 1; i < bs.length; i++) {
+        for (let b = 0; b < 8; b++) if (bs[i] & 128 >> b) ku |= 1 << (i - 1) * 8 + b;
+      }
+      c.keyUsage = ku;
+      break;
+    }
+    case OID.extKeyUsage:
+      c.extKeyUsage = children(n).map((x) => oidString(x.value));
+      break;
+    case OID.aia:
+      for (const ad of children(n)) {
+        const [m, loc] = children(ad);
+        if (m && loc && oidString(m.value) === OID.ocspMethod && loc.tag === 134) c.ocspServers.push(String.fromCharCode(...loc.value));
+      }
+      break;
+    case OID.crlDP:
+      for (const dp of children(n)) {
+        for (const f of children(dp)) {
+          if (f.tag !== 160) continue;
+          for (const fn of children(f)) {
+            if (fn.tag !== 160) continue;
+            for (const gn of children(fn)) if (gn.tag === 134) c.crlDPs.push(String.fromCharCode(...gn.value));
+          }
+        }
+      }
+      break;
+  }
+}
+function isTSASigningCert(c) {
+  const ekus = c.extensions.filter((e2) => e2.oid === OID.extKeyUsage);
+  if (ekus.length !== 1) return false;
+  const e = ekus[0];
+  try {
+    const oids = children(parseOne(e.value));
+    return e.critical && oids.length === 1 && oids[0].tag === TAG.OID && oidString(oids[0].value) === OID.kpTimeStamping;
+  } catch {
+    return false;
+  }
+}
+var HASH_BY_OID = {
+  [OID.sha1]: "SHA-1",
+  [OID.sha256]: "SHA-256",
+  [OID.sha384]: "SHA-384",
+  [OID.sha512]: "SHA-512"
+};
+function schemeFor(alg) {
+  const p = children(alg);
+  const o = oidString(expect(p[0], TAG.OID, "sigAlg").value);
+  switch (o) {
+    case "1.2.840.113549.1.1.5":
+      return { kind: "rsa", hash: "SHA-1" };
+    case OID.sha256WithRSA:
+      return { kind: "rsa", hash: "SHA-256" };
+    case OID.sha384WithRSA:
+      return { kind: "rsa", hash: "SHA-384" };
+    case OID.sha512WithRSA:
+      return { kind: "rsa", hash: "SHA-512" };
+    case OID.ecdsaSHA256:
+      return { kind: "ecdsa", hash: "SHA-256" };
+    case OID.ecdsaSHA384:
+      return { kind: "ecdsa", hash: "SHA-384" };
+    case OID.ecdsaSHA512:
+      return { kind: "ecdsa", hash: "SHA-512" };
+    case OID.rsaPSS: {
+      let hash = "SHA-1";
+      let salt = 20;
+      for (const f of p[1] ? children(p[1]) : []) {
+        if (f.tag === 160) hash = HASH_BY_OID[oidString(children(children(f)[0])[0].value)] ?? hash;
+        if (f.tag === 162) salt = Number(children(f)[0].value[0]);
+      }
+      return { kind: "pss", hash, saltLength: salt };
+    }
+  }
+  throw new CertError(`\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u043D \u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439: ${o}`);
+}
+var CURVES = {
+  [OID.p256]: { name: "P-256", size: 32 },
+  [OID.p384]: { name: "P-384", size: 48 },
+  [OID.p521]: { name: "P-521", size: 66 }
+};
+function ecdsaDerToRaw(der2, size) {
+  const [r, s] = children(parseOne(der2));
+  const out = new Uint8Array(2 * size);
+  const put = (v, at) => {
+    let x = v;
+    while (x.length > 0 && x[0] === 0) x = x.subarray(1);
+    if (x.length > size) throw new CertError("ECDSA \u0443\u0442\u0433\u0430 \u0445\u044D\u0442 \u0443\u0440\u0442");
+    out.set(x, at + size - x.length);
+  };
+  put(expect(r, TAG.INTEGER, "r").value, 0);
+  put(expect(s, TAG.INTEGER, "s").value, size);
+  return out;
+}
+async function verifySignature(pub, alg, data, sig) {
+  const sch = schemeFor(alg);
+  return verifyWith(pub, sch, data, sig);
+}
+async function verifyWith(pub, sch, data, sig) {
+  const s = await subtle();
+  try {
+    if (sch.kind === "ecdsa") {
+      if (pub.keyAlg !== OID.ecPublicKey) return false;
+      const c = CURVES[pub.curve ?? ""];
+      if (!c) return false;
+      const key2 = await s.importKey("spki", pub.spki, { name: "ECDSA", namedCurve: c.name }, false, ["verify"]);
+      return await s.verify({ name: "ECDSA", hash: sch.hash }, key2, ecdsaDerToRaw(sig, c.size), data);
+    }
+    if (pub.keyAlg !== OID.rsaEncryption) return false;
+    if (sch.kind === "pss") {
+      const key2 = await s.importKey("spki", pub.spki, { name: "RSA-PSS", hash: sch.hash }, false, ["verify"]);
+      return await s.verify({ name: "RSA-PSS", saltLength: sch.saltLength ?? 32 }, key2, sig, data);
+    }
+    const key = await s.importKey("spki", pub.spki, { name: "RSASSA-PKCS1-v1_5", hash: sch.hash }, false, ["verify"]);
+    return await s.verify({ name: "RSASSA-PKCS1-v1_5" }, key, sig, data);
+  } catch {
+    return false;
+  }
+}
+async function verifyCitizen(cert, signedAttrs, sig) {
+  if (cert.keyAlg === OID.rsaEncryption) {
+    return await verifyWith(cert, { kind: "rsa", hash: "SHA-256" }, signedAttrs, sig) ? sig : void 0;
+  }
+  if (cert.keyAlg === OID.ecPublicKey) {
+    const c = CURVES[cert.curve ?? ""];
+    if (!c) return void 0;
+    if (sig.length === 2 * c.size) {
+      const der2 = rawToEcdsaDer(sig, c.size);
+      if (await verifyWith(cert, { kind: "ecdsa", hash: "SHA-256" }, signedAttrs, der2)) return der2;
+    }
+    try {
+      return await verifyWith(cert, { kind: "ecdsa", hash: "SHA-256" }, signedAttrs, sig) ? sig : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function rawToEcdsaDer(raw, size) {
+  const int = (v) => {
+    let x = Array.from(v);
+    while (x.length > 1 && x[0] === 0) x = x.slice(1);
+    if (x.length === 1 && x[0] === 0) return [2, 1, 0];
+    if (x[0] & 128) x = [0, ...x];
+    return [2, x.length, ...x];
+  };
+  const body = [...int(raw.subarray(0, size)), ...int(raw.subarray(size))];
+  return Uint8Array.from(body.length < 128 ? [48, body.length, ...body] : [48, 129, body.length, ...body]);
+}
+function checkSignature(parent, alg, signed, sig) {
+  return verifySignature(parent, alg, signed, sig);
+}
+async function checkSignatureFrom(c, parent) {
+  if (parent.version === 3 && !parent.basicConstraintsValid || parent.basicConstraintsValid && !parent.isCA) return false;
+  if (parent.keyUsage !== 0 && !(parent.keyUsage & 1 << 5)) return false;
+  return verifySignature(parent, c.sigAlg, c.tbs, c.signature);
+}
+async function verifyChain(leaf, pool, roots, at, eku) {
+  const valid = (c) => c.notBefore.getTime() <= at.getTime() && at.getTime() <= c.notAfter.getTime();
+  if (!valid(leaf)) return false;
+  if (leaf.extKeyUsage.length > 0 && !leaf.extKeyUsage.includes(eku) && !leaf.extKeyUsage.includes(OID.kpAny)) return false;
+  if (hasUnhandledCritical(leaf)) return false;
+  const walk = async (cur, depth) => {
+    if (depth > 8) return false;
+    for (const r of roots) {
+      if (equal(r.rawSubject, cur.rawIssuer) && await checkSignatureFrom(cur, r)) return true;
+    }
+    for (const p of pool) {
+      if (equal(p.raw, cur.raw) || !equal(p.rawSubject, cur.rawIssuer) || !valid(p) || hasUnhandledCritical(p)) continue;
+      if (p.extKeyUsage.length > 0 && !p.extKeyUsage.includes(eku) && !p.extKeyUsage.includes(OID.kpAny)) continue;
+      if (await checkSignatureFrom(cur, p) && await walk(p, depth + 1)) return true;
+    }
+    return false;
+  };
+  return walk(leaf, 0);
+}
+var HANDLED = /* @__PURE__ */ new Set([
+  OID.keyUsage,
+  OID.extKeyUsage,
+  OID.basicConstraints,
+  "2.5.29.17",
+  // SAN
+  "2.5.29.30",
+  // name constraints
+  "2.5.29.32",
+  // policies
+  OID.crlDP,
+  OID.aia,
+  "2.5.29.14",
+  "2.5.29.35"
+]);
+function hasUnhandledCritical(c) {
+  return c.extensions.some((e) => e.critical && !HANDLED.has(e.oid));
+}
+
+// src/pades/cms.ts
+var O = {
+  data: "1.2.840.113549.1.7.1",
+  signedData: "1.2.840.113549.1.7.2",
+  contentType: "1.2.840.113549.1.9.3",
+  messageDigest: "1.2.840.113549.1.9.4",
+  signingTime: "1.2.840.113549.1.9.5",
+  signingCertV2: "1.2.840.113549.1.9.16.2.47",
+  timeStampToken: "1.2.840.113549.1.9.16.2.14",
+  signerAttrV2: "0.4.0.19122.1.1",
+  role: "2.5.4.72"
+};
+var CLAIMED_ROLE_MAX_RUNES = 900;
+async function signedAttributes(messageDigest, signer, claimedRole) {
+  if (messageDigest.length !== 32) throw new Error("pades: messageDigest SHA-256 \u0431\u0438\u0448");
+  if (claimedRole !== "" && ([...claimedRole].length > CLAIMED_ROLE_MAX_RUNES || /[\ud800-\udfff]/.test(claimedRole.replace(/[\ud800-\udbff][\udc00-\udfff]/g, "")))) {
+    throw new Error("pades: claimed role \u0431\u0443\u0440\u0443\u0443 \u044D\u0441\u0432\u044D\u043B \u0445\u044D\u0442 \u0443\u0440\u0442");
+  }
+  const certHash = await sha256(signer.raw);
+  const attr = (o, ...vals) => seq(oid(o), set(...vals));
+  const attrs = [
+    attr(O.contentType, oid(O.data)),
+    attr(O.messageDigest, octet(messageDigest)),
+    attr(
+      O.signingCertV2,
+      seq(seq(seq(octet(certHash), seq(seq(ctx(4, true, signer.rawIssuer)), tlv(TAG.INTEGER, signer.serial)))))
+    )
+  ];
+  if (claimedRole !== "") {
+    attrs.push(attr(O.signerAttrV2, seq(ctx(0, true, seq(seq(oid(O.role), set(tlv(TAG.UTF8String, enc.encode(claimedRole)))))))));
+  }
+  attrs.sort(compare);
+  return set(...attrs);
+}
+function assembleCMS(signedAttrs, signer, chain, signature, tst) {
+  if (signedAttrs.length < 2 || signedAttrs[0] !== 49) throw new Error("pades: signedAttrs \u043D\u044C DER SET \u0431\u0438\u0448");
+  let sigAlg;
+  if (signer.keyAlg === OID.rsaEncryption) sigAlg = seq(oid(OID.sha256WithRSA), nullDer());
+  else if (signer.keyAlg === OID.ecPublicKey) sigAlg = seq(oid(OID.ecdsaSHA256));
+  else throw new Error("pades: \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u043D \u0442\u04AF\u043B\u0445\u04AF\u04AF\u0440\u0438\u0439\u043D \u0442\u04E9\u0440\u04E9\u043B \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439");
+  const implicitAttrs = signedAttrs.slice();
+  implicitAttrs[0] = 160;
+  const certs = [signer.raw];
+  for (const c of chain) if (!equal(c.raw, signer.raw)) certs.push(c.raw);
+  certs.sort(compare);
+  const sha256Alg = seq(oid(OID.sha256));
+  const unsigned = tst.length > 0 ? [ctx(1, true, seq(oid(O.timeStampToken), set(tst)))] : [];
+  const signerInfo = seq(
+    intFromBig(1n),
+    seq(signer.rawIssuer, tlv(TAG.INTEGER, signer.serial)),
+    sha256Alg,
+    implicitAttrs,
+    sigAlg,
+    octet(signature),
+    ...unsigned
+  );
+  const sd = seq(intFromBig(1n), set(sha256Alg), seq(oid(O.data)), ctx(0, true, ...certs), set(signerInfo));
+  return seq(oid(O.signedData), ctx(0, true, sd));
+}
+function parseSignedData(contentInfo) {
+  const ci = children(expect(parseOne(contentInfo), TAG.SEQUENCE, "ContentInfo"));
+  if (oidString(expect(ci[0], TAG.OID, "contentType").value) !== O.signedData) throw new Error("pkcs7: SignedData \u0431\u0438\u0448");
+  const sd = children(expect(children(expect(ci[1], 160, "[0]"))[0], TAG.SEQUENCE, "SignedData"));
+  let i = 1;
+  const digestAlgs = children(expect(sd[i++], TAG.SET, "digestAlgorithms"));
+  const eci = children(expect(sd[i++], TAG.SEQUENCE, "EncapsulatedContentInfo"));
+  let content = new Uint8Array();
+  if (eci[1]) {
+    const inner = children(expect(eci[1], 160, "eContent"))[0];
+    if (inner?.tag === TAG.OCTET_STRING) content = inner.value;
+    else if (inner?.tag === 36) content = concat(children(inner).map((x) => x.value));
+  }
+  const certificates = [];
+  if (sd[i]?.tag === 160) {
+    for (const c of children(sd[i])) if (c.tag === TAG.SEQUENCE) certificates.push(parseCertificate(c.raw));
+    i++;
+  }
+  if (sd[i]?.tag === 161) i++;
+  const signerInfos = children(expect(sd[i], TAG.SET, "signerInfos"));
+  return { content, certificates, signerInfos, digestAlgs };
+}
+var HASHES = {
+  [OID.sha1]: "SHA-1",
+  [OID.sha256]: "SHA-256",
+  [OID.sha384]: "SHA-384",
+  [OID.sha512]: "SHA-512"
+};
+function signerCert(sd, si) {
+  const f = children(si);
+  const sid = f[1];
+  if (sid.tag === TAG.SEQUENCE) {
+    const [iss, ser] = children(sid);
+    return sd.certificates.find((c) => equal(c.rawIssuer, iss.raw) && equal(c.serial, ser.value));
+  }
+  return void 0;
+}
+async function verifySignedData(sd) {
+  if (sd.signerInfos.length === 0) return false;
+  for (const si of sd.signerInfos) {
+    const cert = signerCert(sd, si);
+    if (!cert) return false;
+    const f = children(si);
+    let i = 2;
+    const digAlg = oidString(children(f[i++])[0].value);
+    const hash = HASHES[digAlg];
+    if (!hash) return false;
+    let attrs;
+    if (f[i]?.tag === 160) attrs = f[i++];
+    const sigAlg = f[i++];
+    const sig = expect(f[i++], TAG.OCTET_STRING, "signature").value;
+    let signed = sd.content;
+    if (attrs) {
+      let md;
+      let signingTime;
+      for (const a of children(attrs)) {
+        const [t, v] = children(a);
+        if (!t || !v) continue;
+        const o = oidString(t.value);
+        if (o === O.messageDigest) md = children(v)[0]?.value;
+        if (o === O.signingTime) {
+          const n = children(v)[0];
+          if (n) signingTime = parseTime(n);
+        }
+      }
+      if (!md || !equal(md, await digest(hash, sd.content))) return false;
+      if (signingTime && (signingTime > cert.notAfter || signingTime < cert.notBefore)) return false;
+      signed = concat([Uint8Array.of(49), attrs.raw.subarray(1)]);
+    }
+    let alg = sigAlg;
+    const so = oidString(children(sigAlg)[0].value);
+    if (so === OID.rsaEncryption) {
+      const m = { "SHA-1": "1.2.840.113549.1.1.5", "SHA-256": OID.sha256WithRSA, "SHA-384": OID.sha384WithRSA, "SHA-512": OID.sha512WithRSA };
+      alg = parseOne(seq(oid(m[hash]), nullDer()));
+    } else if (so === OID.ecPublicKey) {
+      const m = { "SHA-256": OID.ecdsaSHA256, "SHA-384": OID.ecdsaSHA384, "SHA-512": OID.ecdsaSHA512 };
+      if (!m[hash]) return false;
+      alg = parseOne(seq(oid(m[hash])));
+    }
+    if (!await verifySignature(cert, alg, signed, sig)) return false;
+  }
+  return true;
+}
+
+// src/pades/fetch.ts
+var DEFAULT_TSA_URL = "https://tsa.timeserver.mn/";
+var HTTP_TIMEOUT_MS = 1e4;
+var MAX_HTTP_RESPONSE = 4 << 20;
+var BROWSER_HTTPS = /* @__PURE__ */ new Set(["ocsp.eidmongolia.mn", "crl.eidmongolia.mn", "tsa.timeserver.mn"]);
+var CRL_MIRROR = {
+  "http://esign.gov.mn/MNICA-2022.crl": "https://crl.eidmongolia.mn/MNICA-2022.crl",
+  "http://esign.gov.mn/MNRCA-2021.crl": "https://crl.eidmongolia.mn/MNRCA-2021.crl"
+};
+var Fetcher = class {
+  constructor(fetchFn, upgrade) {
+    this.fetchFn = fetchFn;
+    this.upgrade = upgrade;
+  }
+  fetchFn;
+  upgrade;
+  cache = /* @__PURE__ */ new Map();
+  /** Татах URL: CRL толин хуулбар; хөтөчид http → https (allowlist); бусад үед хэвээр (Go url.String()-тэй ижил). */
+  target(raw) {
+    const mirror = CRL_MIRROR[raw];
+    if (mirror) return mirror;
+    const u = new URL(raw);
+    if (u.protocol === "https:") return raw;
+    if (u.protocol !== "http:") throw new Error(`URL scheme ${u.protocol} \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439`);
+    if (!this.upgrade) return raw;
+    if (!BROWSER_HTTPS.has(u.hostname)) throw new Error(`\u0445\u04E9\u0442\u04E9\u0447: http URL \u043D\u044C https allowlist-\u0434 \u0430\u043B\u0433\u0430: ${u.hostname}`);
+    u.protocol = "https:";
+    return u.toString();
+  }
+  async do(method, raw, contentType, body) {
+    const target = this.target(raw);
+    if (method === "GET") {
+      const hit = this.cache.get(target);
+      if (hit) return hit;
+    }
+    const ctl = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+    const timer = ctl ? setTimeout(() => ctl.abort(), HTTP_TIMEOUT_MS) : void 0;
+    try {
+      const res = await this.fetchFn(target, {
+        method,
+        headers: contentType ? { "Content-Type": contentType } : void 0,
+        body,
+        redirect: "manual",
+        signal: ctl?.signal
+      });
+      const out = new Uint8Array(await res.arrayBuffer());
+      if (res.status !== 200 || out.length > MAX_HTTP_RESPONSE) throw new Error(`${target}: HTTP ${res.status}`);
+      if (method === "GET") this.cache.set(target, out);
+      return out;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+};
+function isBrowser() {
+  const g = globalThis;
+  return typeof g.window !== "undefined" || typeof g.process?.versions?.node !== "string";
+}
+
+// src/pades/ltv.ts
+var MAX_TSA_SKEW_MS = 10 * 6e4;
+var tsMs = (t) => t.date.getTime();
+function after(a, b) {
+  const am = Math.floor(a.date.getTime() / 1e3);
+  const bm = Math.floor(b.date.getTime() / 1e3);
+  if (am !== bm) return am > bm;
+  return a.nanos > b.nanos;
+}
+function tsaRequest(hash, nonce) {
+  return seq(intFromBig(1n), seq(seq(oid(OID.sha256), nullDer()), octet(hash)), intFromBig(bigFromBytes(nonce)), Uint8Array.of(1, 1, 255));
+}
+async function timestampToken(f, tsaURL, signature, roots, inter, now, nonce) {
+  const sum = await sha256(signature);
+  const body = await f.do("POST", tsaURL, "application/timestamp-query", tsaRequest(sum, nonce));
+  const top = children(expect(parseOne(body), TAG.SEQUENCE, "TimeStampResp"));
+  const status = intValue(expect(children(expect(top[0], TAG.SEQUENCE, "PKIStatusInfo"))[0], TAG.INTEGER, "status").value);
+  if (status > 0n) throw new Error(`TSA status ${status}`);
+  const tok = top[1];
+  if (!tok || tok.value.length === 0) throw new Error("no pkcs7 data in Time-Stamp response");
+  const rawToken = tok.raw;
+  const sd = parseSignedData(rawToken);
+  if (sd.certificates.length > 0 && !await verifySignedData(sd)) throw new Error("TSA token-\u0438\u0439\u043D \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0431\u0443\u0440\u0443\u0443");
+  const info = children(expect(parseOne(sd.content), TAG.SEQUENCE, "TSTInfo"));
+  const mi = children(expect(info[2], TAG.SEQUENCE, "messageImprint"));
+  const hashAlg = oidString(children(mi[0])[0].value);
+  const hashed = expect(mi[1], TAG.OCTET_STRING, "hashedMessage").value;
+  if (hashed.length === 0) throw new Error("Time-Stamp response contains no hashed message");
+  const genTime = parsePreciseTime(expect(info[4], TAG.GeneralizedTime, "genTime"));
+  let tsNonce;
+  for (const n of info.slice(5)) if (n.tag === TAG.INTEGER) tsNonce = n.value;
+  if (!tsNonce || intValue(tsNonce) !== bigFromBytes(nonce)) throw new Error("nonce \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
+  if (!equal(hashed, sum) || hashAlg !== OID.sha256) throw new Error("timestamp hash does not match");
+  if (sd.signerInfos.length !== 1) throw new Error("TSA signer \u0433\u0430\u043D\u0446 \u0431\u0438\u0448");
+  const sid = children(sd.signerInfos[0])[1];
+  const [iss, ser] = children(sid);
+  const signer = sd.certificates.find((c) => equal(c.rawIssuer, iss.raw) && equal(c.serial, ser.value));
+  if (!signer) throw new Error("signer cert \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439");
+  if (!isTSASigningCert(signer)) throw new Error("signer cert-\u0438\u0439\u043D EKU \u043D\u044C critical {timeStamping} \u0431\u0438\u0448 (RFC 3161 \xA72.3)");
+  const pool = [...sd.certificates, ...inter].filter((c) => !equal(c.raw, signer.raw));
+  if (!await verifyChain(signer, pool, roots, genTime.date, OID.kpTimeStamping)) throw new Error("TSA cert \u0433\u0438\u043D\u0436");
+  const d = now.getTime() - tsMs(genTime);
+  if (d > MAX_TSA_SKEW_MS || d < -MAX_TSA_SKEW_MS) throw new Error("TSA genTime \u043B\u043E\u043A\u0430\u043B \u0446\u0430\u0433\u0430\u0430\u0441 10 \u043C\u0438\u043D\u0443\u0442\u0430\u0430\u0441 \u0438\u0445 \u0437\u04E9\u0440\u04E9\u0432");
+  if (sd.certificates.length === 0) throw new Error("TSA token-\u0434 \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0430\u043B\u0433\u0430");
+  return { rawToken, time: genTime, certificates: sd.certificates };
+}
+async function ocspRequest(c, issuer) {
+  const keyHash = await sha1(issuer.publicKey);
+  const nameHash = await sha1(issuer.rawSubject);
+  const certID = seq(seq(oid(OID.sha1), nullDer()), octet(nameHash), octet(keyHash), Uint8Array.of(TAG.INTEGER, ...lenOf(c.serial.length), ...c.serial));
+  return seq(seq(seq(seq(certID))));
+}
+function lenOf(n) {
+  if (n < 128) return [n];
+  const out = [];
+  for (let x = n; x > 0; x = Math.floor(x / 256)) out.unshift(x & 255);
+  return [128 | out.length, ...out];
+}
+var OID_OCSP_BASIC = "1.3.6.1.5.5.7.48.1.1";
+async function parseOCSPForCert(der2, c, issuer) {
+  const top = children(expect(parseOne(der2), TAG.SEQUENCE, "OCSPResponse"));
+  if (expect(top[0], TAG.ENUMERATED, "status").value[0] !== 0) throw new Error("OCSP response status");
+  const rb = children(expect(children(expect(top[1], 160, "responseBytes"))[0], TAG.SEQUENCE, "ResponseBytes"));
+  if (oidString(expect(rb[0], TAG.OID, "responseType").value) !== OID_OCSP_BASIC) throw new Error("bad OCSP response type");
+  const basic = children(expect(parseOne(expect(rb[1], TAG.OCTET_STRING, "response").value), TAG.SEQUENCE, "BasicOCSPResponse"));
+  const tbs = expect(basic[0], TAG.SEQUENCE, "tbsResponseData");
+  const sigAlg = expect(basic[1], TAG.SEQUENCE, "sigAlg");
+  const sigBits = expect(basic[2], TAG.BIT_STRING, "signature").value.subarray(1);
+  const tf = children(tbs);
+  let i = 0;
+  if (tf[0]?.tag === 160) i++;
+  const rid = tf[i++];
+  if (rid.tag !== 161 && rid.tag !== 162) throw new Error("invalid responder id tag");
+  i++;
+  const responses = children(expect(tf[i], TAG.SEQUENCE, "responses"));
+  if (responses.length === 0) throw new Error("OCSP response contains bad number of responses");
+  const serial = intValue(c.serial);
+  let single;
+  for (const r of responses) {
+    const f = children(r);
+    const cid2 = children(f[0]);
+    if (intValue(expect(cid2[3], TAG.INTEGER, "serial").value) === serial) {
+      single = f;
+      break;
+    }
+  }
+  if (!single) throw new Error("no response matching the supplied certificate");
+  let certificate;
+  if (basic[3]?.tag === 160) {
+    const certs = children(expect(children(basic[3])[0], TAG.SEQUENCE, "certs"));
+    if (certs[0]) certificate = parseCertificate(certs[0].raw);
+  }
+  if (certificate) {
+    if (!await verifySignature(certificate, sigAlg, tbs.raw, sigBits)) throw new Error("bad signature on embedded certificate");
+    if (!await checkSignature(issuer, certificate.sigAlg, certificate.tbs, certificate.signature)) throw new Error("bad OCSP signature");
+  } else if (!await verifySignature(issuer, sigAlg, tbs.raw, sigBits)) {
+    throw new Error("bad OCSP signature");
+  }
+  const cid = children(single[0]);
+  const hashAlg = oidString(children(cid[0])[0].value);
+  if (![OID.sha1, OID.sha256, OID.sha384, OID.sha512].includes(hashAlg)) throw new Error("unsupported issuer hash algorithm");
+  const st = single[1];
+  const status = st.tag === 128 ? "good" : st.tag === 161 ? "revoked" : st.tag === 130 ? "unknown" : void 0;
+  if (!status) throw new Error("OCSP certStatus");
+  const thisUpdate = parsePreciseTime(expect(single[2], TAG.GeneralizedTime, "thisUpdate"));
+  let nextUpdate;
+  for (const x of single.slice(3)) {
+    if (x.tag === 160) nextUpdate = parsePreciseTime(children(x)[0]).date;
+    if (x.tag === 161) {
+      for (const ext of children(children(x)[0])) {
+        const e = children(ext);
+        if (e[1]?.tag === TAG.BOOLEAN && e[1].value[0] !== 0) throw new Error("unsupported critical extension");
+      }
+    }
+  }
+  return { status, thisUpdate, nextUpdate, certificate };
+}
+function responderOK(resp, issuer) {
+  if (!resp.certificate || equal(resp.certificate.raw, issuer.raw)) return true;
+  return resp.certificate.extKeyUsage.includes(OID.kpOCSPSigning);
+}
+var NotFresh = class extends Error {
+};
+async function fetchOCSP(f, url, c, issuer, now, fresh) {
+  const der2 = await f.do("POST", url, "application/ocsp-request", await ocspRequest(c, issuer));
+  const resp = await parseOCSPForCert(der2, c, issuer);
+  if (!responderOK(resp, issuer)) throw new Error("OCSP responder-\u0438\u0439\u043D EKU OCSPSigning \u0431\u0438\u0448");
+  if (resp.status !== "good" || resp.nextUpdate && resp.nextUpdate.getTime() < now.getTime()) throw new Error(`OCSP ${c.subjectCN}: ${resp.status}`);
+  if (fresh && !after(resp.thisUpdate, fresh)) throw new NotFresh("OCSP thisUpdate \u043D\u044C timestamp-\u0430\u0430\u0441 \u0445\u043E\u0436\u0443\u0443 \u0431\u0438\u0448");
+  return [der2, resp];
+}
+async function crlCovers(der2, c, issuer, now) {
+  try {
+    const top = children(expect(parseOne(der2), TAG.SEQUENCE, "CertificateList"));
+    const tbs = expect(top[0], TAG.SEQUENCE, "TBSCertList");
+    const sigAlg = expect(top[1], TAG.SEQUENCE, "sigAlg");
+    const sig = expect(top[2], TAG.BIT_STRING, "sig").value.subarray(1);
+    const f = children(tbs);
+    let i = 0;
+    if (f[0]?.tag === TAG.INTEGER) i++;
+    i++;
+    const iss = expect(f[i++], TAG.SEQUENCE, "issuer");
+    if (!equal(iss.raw, c.rawIssuer)) return false;
+    if (issuer.version === 3 && !issuer.basicConstraintsValid) return false;
+    if (issuer.keyUsage !== 0 && !(issuer.keyUsage & 1 << 6)) return false;
+    if (!await verifySignature(issuer, sigAlg, tbs.raw, sig)) return false;
+    i++;
+    const nu = f[i];
+    if (!nu || nu.tag !== TAG.UTCTime && nu.tag !== TAG.GeneralizedTime) return false;
+    if (parsePreciseTime(nu).date.getTime() < now.getTime()) return false;
+    i++;
+    const serial = intValue(c.serial);
+    const revoked = f[i];
+    if (revoked?.tag === TAG.SEQUENCE) {
+      for (const e of children(revoked)) {
+        if (intValue(expect(children(e)[0], TAG.INTEGER, "serial").value) === serial) return false;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectLTV(f, now, fresh, roots, chains) {
+  const d = { certs: [], ocsps: [], crls: [] };
+  const addTo = (list, der2) => {
+    if (!list.some((b) => equal(b, der2))) list.push(der2);
+  };
+  const pool = chains.flat();
+  const issuerOf = async (c) => {
+    for (const cand of [...pool, ...roots]) if (equal(cand.rawSubject, c.rawIssuer) && await checkSignatureFrom(c, cand)) return cand;
+    return void 0;
+  };
+  const isRoot = (c) => roots.some((r) => equal(r.raw, c.raw));
+  const seen = /* @__PURE__ */ new Set();
+  for (const ch of chains) {
+    for (let i = 0; i < ch.length; i++) {
+      const c = ch[i];
+      const k = toHex(c.raw);
+      if (seen.has(k) || isRoot(c)) continue;
+      seen.add(k);
+      addTo(d.certs, c.raw);
+      const issuer = await issuerOf(c);
+      if (!issuer) throw new LTVError(`${c.subjectCN}-\u0438\u0439\u043D \u043E\u043B\u0433\u043E\u0433\u0447 \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439`);
+      let ok = false;
+      let freshErr;
+      const fr = i === 0 ? fresh : void 0;
+      for (const u of c.ocspServers) {
+        try {
+          const [der2, resp] = await fetchOCSP(f, u, c, issuer, now, fr);
+          addTo(d.ocsps, der2);
+          if (resp.certificate && !equal(resp.certificate.raw, issuer.raw)) addTo(d.certs, resp.certificate.raw);
+          ok = true;
+          break;
+        } catch (e) {
+          if (e instanceof NotFresh) freshErr = e;
+        }
+      }
+      for (const u of c.crlDPs) {
+        let der2;
+        try {
+          der2 = await f.do("GET", u, "");
+        } catch {
+          continue;
+        }
+        if (await crlCovers(der2, c, issuer, now)) {
+          addTo(d.crls, der2);
+          ok = true;
+        }
+      }
+      if (!ok) {
+        if (freshErr) throw freshErr;
+        throw new LTVError(`${c.subjectCN}-\u0434 \u0445\u04AF\u0447\u0438\u043D\u0442\u044D\u0439 OCSP/CRL \u0430\u043B\u0433\u0430`);
+      }
+      if (i === 0 && freshErr && c.ocspServers.length > 0 && !await hasFreshOCSP(d.ocsps, c, issuer, fresh)) throw freshErr;
+    }
+  }
+  return d;
+}
+async function hasFreshOCSP(list, c, issuer, fresh) {
+  for (const der2 of list) {
+    try {
+      if (after((await parseOCSPForCert(der2, c, issuer)).thisUpdate, fresh)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var LTVError = class extends Error {
+};
+var OCSP_AFTER_TS_MS = 2e3;
+var OCSP_WAIT_MAX_MS = 5e3;
+var OCSP_RETRY_MS = 1e3;
+async function collectLTVWithWait(f, now, sleep, genTime, roots, chains) {
+  let waited = 0;
+  const genSec = Math.floor(genTime.date.getTime() / 1e3) * 1e3;
+  let d = Math.min(genSec + OCSP_AFTER_TS_MS - now().getTime(), OCSP_WAIT_MAX_MS);
+  for (; ; ) {
+    if (d > 0) {
+      await sleep(d);
+      waited += d;
+    }
+    try {
+      return await collectLTV(f, now(), genTime, roots, chains);
+    } catch (e) {
+      if (!(e instanceof NotFresh) || waited + OCSP_RETRY_MS > OCSP_WAIT_MAX_MS) throw e;
+    }
+    d = OCSP_RETRY_MS;
+  }
+}
+
+// src/pades/assets/fonts.ts
+var REGULAR = {
+  psName: "NotoSans",
+  length1: 78036,
+  ascent: 1069,
+  descent: -293,
+  capHeight: 714,
+  bbox: [-621, -389, 2800, 1067],
+  widths: [600, 260, 269, 408, 646, 572, 831, 732, 225, 300, 300, 551, 572, 268, 322, 268, 372, 572, 572, 572, 572, 572, 572, 572, 572, 572, 572, 268, 268, 572, 572, 572, 434, 899, 639, 650, 632, 730, 556, 519, 728, 741, 339, 273, 619, 524, 907, 760, 781, 605, 781, 622, 549, 556, 731, 600, 930, 586, 566, 572, 329, 372, 329, 572, 444, 281, 561, 615, 480, 615, 564, 344, 615, 618, 258, 258, 534, 258, 935, 618, 605, 615, 615, 413, 479, 361, 618, 508, 786, 529, 510, 470, 380, 551, 380, 572, 260, 269, 572, 572, 572, 572, 551, 513, 580, 832, 357, 509, 572, 322, 832, 500, 428, 572, 350, 350, 281, 623, 655, 268, 225, 350, 376, 509, 745, 771, 781, 434, 639, 639, 639, 639, 639, 639, 881, 632, 556, 556, 556, 556, 339, 339, 339, 339, 730, 760, 781, 781, 781, 781, 781, 572, 781, 731, 731, 731, 731, 566, 605, 631, 561, 561, 561, 561, 561, 561, 864, 480, 564, 564, 564, 564, 258, 258, 258, 258, 605, 618, 605, 605, 605, 605, 605, 572, 605, 618, 618, 618, 618, 510, 615, 510, 418, 377, 300, 447, 439, 821, 749, 556, 716, 509, 639, 549, 284, 284, 273, 1010, 1027, 715, 625, 616, 731, 638, 614, 650, 509, 729, 556, 905, 577, 756, 756, 625, 698, 907, 743, 761, 733, 605, 640, 556, 616, 817, 588, 740, 673, 1035, 1026, 685, 849, 607, 647, 999, 638, 556, 597, 564, 438, 607, 551, 759, 488, 621, 621, 531, 587, 768, 614, 594, 606, 608, 493, 465, 509, 737, 511, 612, 589, 894, 897, 623, 759, 545, 494, 799, 577, 551, 619, 438, 493, 468, 258, 258, 258, 859, 890, 621, 531, 509, 606, 532, 436, 500, 1e3, 1e3, 411, 175, 175, 250, 175, 359, 359, 416, 512, 512, 376, 791, 1177, 232, 408, 310, 310, 1020, 0, 556, 756, 551, 621, 919, 789, 675, 634, 922, 742, 683, 572, 929, 780, 729, 640, 984, 849, 587, 490, 804, 761, 782, 605, 635, 516, 635, 516, 1220, 1095, 821, 659, 1026, 904, 919, 789, 643, 492, 609, 0, 0, 785, 659, 615, 594, 613, 615, 530, 434, 651, 533, 904, 796, 577, 488, 670, 557, 625, 529, 625, 534, 693, 623, 755, 657, 815, 738, 1056, 863, 779, 642, 632, 480, 556, 475, 566, 508, 566, 508, 631, 552, 862, 724, 703, 621, 698, 606, 698, 618, 849, 665, 849, 665, 339, 905, 759, 696, 560, 719, 587, 731, 621, 756, 662, 698, 613, 917, 755, 339, 639, 561, 639, 561, 881, 864, 556, 564, 739, 564, 739, 564, 905, 759, 577, 488, 584, 498, 756, 621, 756, 621, 781, 605, 782, 605, 782, 605, 647, 494, 616, 509, 616, 509, 616, 510, 673, 589, 530, 433, 849, 759, 530, 434, 632, 550, 586, 529, 564, 572, 551, 359, 584, 572, 258, 399, 268, 500, 536, 368, 322, 322, 440, 232, 602, 1544, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+  cmap: [[32, 1], [33, 2], [34, 3], [35, 4], [36, 5], [37, 6], [38, 7], [39, 8], [40, 9], [41, 10], [42, 11], [43, 12], [44, 13], [45, 14], [46, 15], [47, 16], [48, 17], [49, 18], [50, 19], [51, 20], [52, 21], [53, 22], [54, 23], [55, 24], [56, 25], [57, 26], [58, 27], [59, 28], [60, 29], [61, 30], [62, 31], [63, 32], [64, 33], [65, 34], [66, 35], [67, 36], [68, 37], [69, 38], [70, 39], [71, 40], [72, 41], [73, 42], [74, 43], [75, 44], [76, 45], [77, 46], [78, 47], [79, 48], [80, 49], [81, 50], [82, 51], [83, 52], [84, 53], [85, 54], [86, 55], [87, 56], [88, 57], [89, 58], [90, 59], [91, 60], [92, 61], [93, 62], [94, 63], [95, 64], [96, 65], [97, 66], [98, 67], [99, 68], [100, 69], [101, 70], [102, 71], [103, 72], [104, 73], [105, 74], [106, 75], [107, 76], [108, 77], [109, 78], [110, 79], [111, 80], [112, 81], [113, 82], [114, 83], [115, 84], [116, 85], [117, 86], [118, 87], [119, 88], [120, 89], [121, 90], [122, 91], [123, 92], [124, 93], [125, 94], [126, 95], [160, 96], [161, 97], [162, 98], [163, 99], [164, 100], [165, 101], [166, 102], [167, 103], [168, 104], [169, 105], [170, 106], [171, 107], [172, 108], [173, 109], [174, 110], [175, 111], [176, 112], [177, 113], [178, 114], [179, 115], [180, 116], [181, 117], [182, 118], [183, 119], [184, 120], [185, 121], [186, 122], [187, 123], [188, 124], [189, 125], [190, 126], [191, 127], [192, 128], [193, 129], [194, 130], [195, 131], [196, 132], [197, 133], [198, 134], [199, 135], [200, 136], [201, 137], [202, 138], [203, 139], [204, 140], [205, 141], [206, 142], [207, 143], [208, 144], [209, 145], [210, 146], [211, 147], [212, 148], [213, 149], [214, 150], [215, 151], [216, 152], [217, 153], [218, 154], [219, 155], [220, 156], [221, 157], [222, 158], [223, 159], [224, 160], [225, 161], [226, 162], [227, 163], [228, 164], [229, 165], [230, 166], [231, 167], [232, 168], [233, 169], [234, 170], [235, 171], [236, 172], [237, 173], [238, 174], [239, 175], [240, 176], [241, 177], [242, 178], [243, 179], [244, 180], [245, 181], [246, 182], [247, 183], [248, 184], [249, 185], [250, 186], [251, 187], [252, 188], [253, 189], [254, 190], [255, 191], [1024, 315], [1025, 199], [1026, 200], [1027, 201], [1028, 202], [1029, 203], [1030, 204], [1031, 205], [1032, 206], [1033, 207], [1034, 208], [1035, 209], [1036, 210], [1037, 316], [1038, 211], [1039, 212], [1040, 213], [1041, 214], [1042, 215], [1043, 216], [1044, 217], [1045, 218], [1046, 219], [1047, 220], [1048, 221], [1049, 222], [1050, 223], [1051, 224], [1052, 225], [1053, 226], [1054, 227], [1055, 228], [1056, 229], [1057, 230], [1058, 231], [1059, 232], [1060, 233], [1061, 234], [1062, 235], [1063, 236], [1064, 237], [1065, 238], [1066, 239], [1067, 240], [1068, 241], [1069, 242], [1070, 243], [1071, 244], [1072, 245], [1073, 246], [1074, 247], [1075, 248], [1076, 249], [1077, 250], [1078, 251], [1079, 252], [1080, 253], [1081, 254], [1082, 255], [1083, 256], [1084, 257], [1085, 258], [1086, 259], [1087, 260], [1088, 261], [1089, 262], [1090, 263], [1091, 264], [1092, 265], [1093, 266], [1094, 267], [1095, 268], [1096, 269], [1097, 270], [1098, 271], [1099, 272], [1100, 273], [1101, 274], [1102, 275], [1103, 276], [1104, 317], [1105, 277], [1106, 278], [1107, 279], [1108, 280], [1109, 281], [1110, 282], [1111, 283], [1112, 284], [1113, 285], [1114, 286], [1115, 287], [1116, 288], [1117, 318], [1118, 289], [1119, 290], [1120, 319], [1121, 320], [1122, 321], [1123, 322], [1124, 323], [1125, 324], [1126, 325], [1127, 326], [1128, 327], [1129, 328], [1130, 329], [1131, 330], [1132, 331], [1133, 332], [1134, 333], [1135, 334], [1136, 335], [1137, 336], [1138, 337], [1139, 338], [1140, 339], [1141, 340], [1142, 341], [1143, 342], [1144, 343], [1145, 344], [1146, 345], [1147, 346], [1148, 347], [1149, 348], [1150, 349], [1151, 350], [1152, 351], [1153, 352], [1154, 353], [1155, 491], [1156, 492], [1157, 493], [1158, 494], [1159, 495], [1160, 354], [1161, 355], [1162, 356], [1163, 357], [1164, 358], [1165, 359], [1166, 360], [1167, 361], [1168, 291], [1169, 292], [1170, 362], [1171, 363], [1172, 364], [1173, 365], [1174, 366], [1175, 367], [1176, 368], [1177, 369], [1178, 370], [1179, 371], [1180, 372], [1181, 373], [1182, 374], [1183, 375], [1184, 376], [1185, 377], [1186, 378], [1187, 379], [1188, 380], [1189, 381], [1190, 382], [1191, 383], [1192, 384], [1193, 385], [1194, 386], [1195, 387], [1196, 388], [1197, 389], [1198, 390], [1199, 391], [1200, 392], [1201, 393], [1202, 394], [1203, 395], [1204, 396], [1205, 397], [1206, 398], [1207, 399], [1208, 400], [1209, 401], [1210, 402], [1211, 403], [1212, 404], [1213, 405], [1214, 406], [1215, 407], [1216, 408], [1217, 409], [1218, 410], [1219, 411], [1220, 412], [1221, 413], [1222, 414], [1223, 415], [1224, 416], [1225, 417], [1226, 418], [1227, 419], [1228, 420], [1229, 421], [1230, 422], [1231, 423], [1232, 424], [1233, 425], [1234, 426], [1235, 427], [1236, 428], [1237, 429], [1238, 430], [1239, 431], [1240, 432], [1241, 433], [1242, 434], [1243, 435], [1244, 436], [1245, 437], [1246, 438], [1247, 439], [1248, 440], [1249, 441], [1250, 442], [1251, 443], [1252, 444], [1253, 445], [1254, 446], [1255, 447], [1256, 448], [1257, 449], [1258, 450], [1259, 451], [1260, 452], [1261, 453], [1262, 454], [1263, 455], [1264, 456], [1265, 457], [1266, 458], [1267, 459], [1268, 460], [1269, 461], [1270, 462], [1271, 463], [1272, 464], [1273, 465], [1274, 466], [1275, 467], [1276, 468], [1277, 469], [1278, 470], [1279, 471], [8208, 484], [8209, 485], [8210, 473], [8211, 293], [8212, 294], [8213, 295], [8214, 474], [8215, 296], [8216, 297], [8217, 298], [8218, 299], [8219, 300], [8220, 301], [8221, 302], [8222, 303], [8223, 475], [8224, 304], [8225, 305], [8226, 306], [8227, 483], [8228, 481], [8229, 482], [8230, 307], [8231, 480], [8240, 308], [8241, 489], [8242, 309], [8243, 310], [8244, 476], [8245, 487], [8246, 486], [8247, 488], [8248, 479], [8249, 311], [8250, 312], [8366, 477], [8470, 313]],
+  stream: "eNq0vQd8G8eVPz4zu8CiEL0DbACIwl4AEBRJkWDvXRSrSFGURIrqllzkKhfJTbZjucZJHNuxfS5x3J1yKYrjJI7ii/NzXBL/4rhckvNdLolTznF8Jvh/M7sLgBRdPr/P5y+bBLg7uzvz5pXve/PmLcIIIRP84pGxo7Wt3TRgfBehZCscvapjcGCE3PLPV+HvFxCq/FnHyGjzTbbL7AhXfBHOVw+MlFftnl0xIvRfi/D31vm9cwce/el9X4G/n0cI2+fPOZzfoPfEEfrw7/B3yc4DC3u3lWsvR+gPbyGkz1qYO3QAroPrk/XwqVrYc2RnyXNvRKFtNkJv+BZ3zG0PX/5/kwi900uftwgHsp7UTcL9af8KFvcePm/vjtEAnL8CIeHUnv3zc7WFZ92L0G+2IsT999658w7wPzKeDX8noH3+vrm9O4r2t3gR+igfnvHRgf2HDq98GVXB87Pp+QNn7TjQevGPvonQP/8bzisQQZ0rf0XPkdOIQwaUl6Ct8CzCeKkPEcLNIY47yPUX+E1GXucujvu5CBetjlTZbVal3xf8ygbX7sMFblcg4HIX/ITg5T2B3NxAQX4+3LcJP4/H2H0FVJDwEkxvrOB4Du6N+nke5kPgBaUCGnAmpc5RbOH8nBd+7rLGrdgOv8jpZBIT+oPgfi74tQfu50F5qCPRmqUhKoNRxwlIJSzqlQQpOAIN8YIWq9VLfTwmZDfpRygvNycbrvG4XU4H9NpiSv3T5RVjIWLzC/44+4lF2E9EYD82BfyJ38q7+tbCjsIbQu3Bi6/NP34y3Bn+XLgtfEnykhvybsBP3dXyf+Bfy13NL8O/5rvugilBDSs/Ijz5B/KhQlSBdiWsFUWFfpfTZlXxGkzyOegj6e15rHRwPJENveQw9PsoUiDFcQQkUmC0BDTfw/V7EvmII9wxaIPJsVQDPAGTg7bBFzQ8kVDnmUx2m1Gpyy6OB4OhmN3uiAWDsWh1PBaxwR8CHLTlEpgtweY3KZU2q91hqa6ORYOh5fhivm8pMj+9MJ6IjRV48vvCzeOli7OJ6khpfaKuuqKpEpsMo0YnPu0Z7ujepBgfwzZDt87C/cRS3FjVPqbZT07wRd5wsSH5jrLYFwwZoZOVK+9zevIy0gI3uVAAlaPP9zzmgrGW6LBSj1UKpWoJmmG1Au/KwsAFc1pOwyF0oA+p1WROEKfNk4ie2VyLOW6pT7xIg9kl0JheJ8whQTgo9E8kikNBj9tkzMrCqLQ4WB4q9+a5A56Aw2Z0mVxZhiyDXicokBZrDTp7sUVmY6CXAvuxwkfpE6mKRRUZZxypoz/o7u3q6+hpJ7bk4T58InlF0O8P9uHFrj52uJf9SV4+e2np3HOXls7WLFeT09GhwcHhe+5+Sz7YODg4NHTPXcAnsZX3yevkFeDmYhRD5ycMQbeSw3zMpBd4BWMRSja/wMarFMeLMZnjMBu1QiF9pdTyrm01i6RGsgRPJBzefIwilfnF3mKbxWjQalAezlMBGTAbrOCoro5HlPDpDymloceDaQI4GNdwSpEY1XFcMbhlqOH7bq92wlgRPHnuWPnhkYXzRzry4/PDRbFgQV2kYrh6Y3dDYjqPvDLU1The8K28ofLEvsLrNxVFd870bQkXDMe7hztLQgUbA76N4YKy5PP5zdXx5qIcytugPdBdTHu4EnamkwhmigMhpjA4SWHcldIT9Krwyjash6t0yJIwwt/4ODSHi+wWonMWW6JshHQw/mAw3NE70t7R0Tbc24HN5//71Mw75x5+c2b8TXqfXLgPn7oPHDhONSKW7oOBWn5RiCJ2O+Y7eofbOjraR+iNjrw5PvPm4XPfmZn6d7isEFfjj8gHSI8iCaMuS6tRq0Dj8SDxOtTV81jh4PgzIMxoD+r3PEW/nAMSDT3WIz2hEyPEHYJDCAmheCjuCOFm6yn9N87dPNo3cfYz+u/ayAenqqcNd5Y/+mj5nYbp6lPwvCq0n6jICEhfMOEHuSGKMR4j0LhUMVKWAb5QkAGm/pjSwKD/bP4Y6L1YBDf9+Med8D++ouNnP+t4kQ67cOUSdAodRirkTNiY9hmj2meWnhuwMGLElYwY8cgpXaWzSZ8jzOyKXVK94aoomw/0O+zGEZix3IQH0UvH5LlEeCBjKqm6Cv/1d/399CpmkdARGAWjPsJzcOVB3F/gYw/MsD+dBS53IOB2FVTLdgcjDVywJHMOY5o+uMfuVZyDQdrxUvL9zVhDTlMxBfsCmotoQR51oLeoHeQ49lymZdAcXHwQ9RcUBPzUDgIHSCJC+6JgEgHs4PcpibZicfORQ+WLo+edk7y4ZWiwrW1wqAXvPHTf+A8eOXzv2Pe/dtPJG28+efIk9HQCejoPz85CnoRTo1Zw8LhelO6w20jH6/WbgG+BysAGETy/mRCj29pb9v0u/LfiaLbRbmqou5VSrQLsowo0rwcVJUJ6HRgWMLkc6WVKA8YAA+E4OnX01qFAmBl0rzcWbyBi14VQtURZeJbNS1TJ8L9Wdwfba6IDheVFe1u3Hy4bjt+Cd3V9p3rTUEXdxoL8On/ljomabbPVN/G0B6VAQQ56UIQSiY0FmJp6whng8XqYbb43gHncA1NAwOLtQjyvmAOOZOpKJm+gwFsQKGJ8SQ2WnfUF6EztmkRh4FSZ1FJ/8R8HWzdvqj0yW7O1pHSxYuvortm29vGp9vra4XBJ8GDngb3E3zmq5zXjHQ1z1Sb7sN3V09xS19O9MbrB567PLdlO0YUNfoXJz4B7rKg4EdZjngNtypNeBSgC2n20iKj5gd7uxv0uk1kSoAAVH28MR0yREEyTH2jHeUl4cTT5EB6cWvwOj3mVU/sqRvfcc08Pfjvpfzva5bWUGJJMvhoZxU6jXNSaaMp2EA7ZNYC61EAzrpdqc0AL3C4gEz8LBGOQTBYGzCCN1azPAoOWi3OFlCZfTTBKJ4vX5hWqq7Fl32XXXRyf8xYslA/Mbd6S3Wkv8eCdyd+ZTLX4mX3b919itYwAdQbaezSKbDw0+CKnorSJQy91MK+5qAQ1JOpUMGFqYC4T5hVcL5xX8ESxS57GA31KsEWy2cnPCxbkleSXFIQCBQLwmyXaQGDOHLYg9ExPhEh1WpiDDrnHVEXb456OoztsEaO51NE2HXNySsdwYstZFyy27mv6a2N/W1t5e8jXiiv7bjnSySt6lMqywUXgx4OLB462njg+NNo6GKrPLx6NA5VLYBBaoLISBRI+AFhUylIol5OBIpxWmkw8SFwEe2NeG74KB5KX4DeTvyHnD7Yun0+1B9URGiZjYbDZ1YlIxG8TqDoHNqFaghcNsKQ6YJZysikQyQ7nhA065MEeZWqWlAKDZZIWES2tZGplWyurlRAYZJwzc16gIVDSWXzJ7kMXFraGol01W+vjHf76gmhH+4vdAEGGW43NbeTl8ZHiRKXFFmuvnNy1Y6qyM2rOHW2O94Q7YlWBKr/R3lBdFUuGo21t8WibW5ndRWe4CsalSs+wESt4yoMqoBXMMNgRrCC7UvO6SmblGQ6ECtgMY6ueiBwYqWogVCDSitIekrAUG1+QqDwdl+6wxkyhyvapaidR2keapg9u2NnWui/x14aBlvYKNsWfp1OsUPToygZ21foqDy707Kltu/b48Ka2ATrFm2pQyosJgs1wMO0tdfDQKi+moMDHMyZMM51pPWsif+J3grm5QTAryfPSfk0e2MRn2ZNsKDvhogqNI/OpB+J+q+3Mx1iolQRyRNrlex8Ec9mssZgUM+mnPBy9NBYcG/UzS36YqMlWypRPgl2oKg4EYgEbWHB1shC/lrwSHzn8YtUf+p+4E3pUg34FeuE/mKdVngBu5yWDTziOjFECzCpA53ID6zldwOkK+KnBp5PV+DS+q6Pjxx0daE0PAJhWFcehCwqbogofgce/lix89ktP9v+h6kVK/ayVv+LbgX8olq1KlBuAb/TQBUK1A6XPUdmKM+Hg50CZHeTBq/QEihQ6DzXp1euaIT2xgX+WQccThkB+qNjcUFfZ688Lz9XPLubECrz+rHaH30PnzeP/bTBe5fGWFOVWRF2mdlv2zFBpYyw3u6gwx3STPInQq9qVf+G6QCc0oj50QcJix2rSoQLNWw4+cQUGjAb4Oxfwd1CFAT6Bc4lADSOlQrkD+s78jSXRYwHy7lUDBC+Am6o5ot718RfwgML1PV2BUCAQDAcCBRrqgUriskpOHILSmiEnkkakqNvGmkE7pkYl5BGPi224LltJoqQsplSY22O9I9HZppJRpwYHXHnFjp7LR8760tAXb9q4v7h4d9M5D0zU7vvS/OI9W5JCpLimklfqwrbKejfeUTbeURzzBap2bmreUWtQ/9Rs4KK+yGhky6WtM/ct3Xynx9hqdozfd3jLl89u2nzXo4naTS0X8cqKHkpT+EcuJv8GXGhCJYnCLGo5exGFBtR6ErLUR310aj8RMhmhmQAwVKlzFXtDXsGPIxiXkRAFHxHi3Zz83egUdgxhe/IdTq/jBbNy6J033iD/thwhClVRaVZenemXwFsgc2QTzKMRUJuPWlElqCrcK1DlRe3SAgM91JTCfPE8U/rQAbfbbMLI7XN7czxOu8lldoF+NmKjOu0PiW6z32+ySMjDZjNJNhWXHr+6vbm0q+jYof/9zXTryNQ5n5vt7gMoN7CtcSRLIQBmmgMImvx5XW1d5N97ksvd9TVtVKY2gp6dADlxo3gi6gB45lQDuNCAMeV6qe1Iq1fGWAcJmHm7lZl4N3YraOd8Z7ACZRnq6OObDl1xwQXlm8Lh0bq9J7sG7th3cFOBd4gcu+P4sS8Ys/oN+sn7D+y5b0tRr8GJGKQlXwLKqWG2qMYEFSLFfdIw0Rvw+iS8C4SgHCdQSpgi+eRLP3zsx7/ec+fm2esuPXsO+/Cep79OTg9+4Zwbji3/HDFdiN+Du2tRYSII8wRQgV/IeIZCIT8j7Yx4vSYAKuJ/+L3kQXxD8qfYn3wDx4Cyb/avoIz7qpGfxkeAu1bfN3VLI1UsEb98x3+dZHfzgTU/PbA8IM3F9TAX+aguUWME/QgMweUCpgEW5XmKEBQ8Yvwjw2dgH8msW0CC/ZIDZcqcBxZx8YtWnE5SzI9v+0ftOT37bx8Yv+/s+t1lvuBs5OgN8XO2ljd7vgSa9B6LeeK+gwfunbJb+03OO46PXt6lEV6WRkouZxT0JnJhnIBG8YKCxUBoLG015WCcJpgW+B0hl08mT05O4n2TuC/5JHDhS7hM9MUQLmL3y0/kUE+U+qGqNS6HTXQ5wCswhcAqCCYHLkomN23CZNOmqIXUWaNR6/IPLXCrlSdWmtEzTPLCiQC1OBymkS1ADPCJdlB5p+yry1IpqWTxwLxCCplWx6CzViXvLNAbC6yu0uzJnd8VlL280lpVSn603LSwTaLAbniCnvZYr+IID0CklwK2pT4sksBmsoh+jJ8TGAHAkICXRHYvLXdNTuY25H1/V/J3eDSR/AMQ4i5fq++XyZ9IXPQ3uLNCingyXE+2prGgAikkLEiJapubxDXgKB4fFK/lKB1tKJQosGgw89pEPxMoysmupg1B30x2Je0c5wdXhnbPAv+ZmD/n5/AX/8Bz/MixX/NvXTGhIPyfyFl5uzYkB+A5Xyddy9X469Gd+cs3SHS4DZ5oRjkJN8z9WiI4THaJCFh+EI6UESAxuW1X8jKeKEcW8UU8sM4mMuRfjCcPwjMeNyZ68/FNVG9TSfg5eL4GGlv9OM8XGD7D800hulW+7897Tu7Zf1Nn500Hdp/sWX7hrCPnHzhw5MghvHP/fdPT9+/fd+/01H37r/zCF6688vOflzSQyJFWihoojxPgcSWmCkghqmw2IbosjIz6LKvOCmyrpOG7tLdDFZPf5PBLuhnnnjgau2j38OTTU507t4+T0/u21y0kkv9FTvclf9880NbKxruZjdcKsg++HphrjnoENMrD82lfORV2CASbrFSbUKfU4QcM+/EE2LXw8KXXKHXKdalw+Tf8T9yNzyCERIlZxukOqo3AeimwjLsXWGxPMmHQV2q+jICwLCaDw+gQg0pIj/WqDNfC4udWUyV47JKipoLndj1y/eSpnbvHBsFk7ti5obdUlzyFQ8lfkdP9yX+0tbTXAREiK+/j90EvFqKyRLEH9GK2AOZJKboCaWWY4bWXBJiRCKxxPYOh9bSiI5fg9685u36nr2D3hsGh3K6mqS21Cy1128LZgbHyltbc1trGsdLvzS6ZjZuN7oaYv6LQ4d06smGoxG7uM9o3lBdUBO2OWLcY6SFeoJpA4yeUMizsmWEEJKkwgYdu8+OWyTeJ4zfkggGq/SeB548ymZKuXcrkdovf4peGxGAZVVZsVCBSR+svmD127eSWmbmxiY+6z2278Vz8QrJybOvCEP4ZZSKKgsZZVAf0top5mxzYp8wwVBbKErUL5vxcxMIcvriFjK9MrszcbbQLgt14lxiXSlaX9Pn9/aX4ebhzFmieW+DOeVTzeMwCDaX0Up2ToQvg7nkoz2lymajmofcXMVXmg1JfuFu+O3Wtyqgh2KK/cuo7M/uzTAqFVXfxlsv1VoXCnLWPdgK/nFNbqtaNliXLoT+9ZZuDoekS/Giyv2zKDzOGn6SWCcbcnrItKsU6mtpsNsuamvNboDOWCEfad37n1Owff7P90cdm38DVydP4MN6cfBc7k1+VKUljcyrqZyk5GobpJVjS1iAFZrOJA/SI4U7A7FwEe74196fJP22Dc7PJnuQfsAl/k94nCPexMcwAWEQANkkHxiSGSSMes8ksB8bEKICX2JImfF7yZvyr5FX4slZSPdi6fBruOriyDVcw7hO9QPh/PgVESIr9FCCDNqqRK95665pr7uQWO5fDUpRy96dEKS3Yj7di7VjyfSlICde5Vrahf6aeytrOpwaCU091gJmJwY/rmmveemsz+WXnR7czSmAtsZMXwacLPa7c3prIVtBALNN9xxiTnpMZB3lciVphmkCZcMGXq/6r/6m7sBY/l6zHC8nPUwSQXNmJv7tyP/Qhn93tjAixiaEJehsF0BJ/N5nAp+5IUCxCZtBfSJLGqdmVHg1PJDOK8DHoA+2HFmltlAysG7nEYfMDK8du1HoDhjpHbWUWSdrjUUuWecMGswZ0aBnorbeIF2xYEDw6vQucDifmeCU4c5y0mAKAEbwCJQeoji6XCJgFCJRKPEdEvUrduPWawEnaTgblEwkXDez4vdnBnKDdajJo1YAVPdgjuw8mf9qhi8fTfq1FduRiMZy/bSZh4v19rV1bL758qjZW1Ov1+Lf2b++LF7dOggM0k7ypt6Sob3hwjOfyW6IuY7PFk3yHr4mUFvX002AvGgUdVkE+AKjhRdc8Y+SIgsfSSKkR38MicXIYRKEQRwkGzcNWHig11rSR1oxkw+dJ5GeeBT0zu7bJxETC4LDnZtu9Dq/JWhBkMT4wk5lxvZBfoNAH1L809ugj0FXHYOP2I+fPNw46BHPj+G2jzU3jnR2k0Vdn8pVde801J8ryW8kHybe2LfDzu5a2/5TyUxxm+HvEJ3pPWnCaHFmEI04QZhqGFCOjrJ9iIA70OEY2i1GvFmTvSbEWqKd9KVzSsb+x+WBnYa/T40xk39nXW9KS7WnS1J4/O39hrSmrS2386dyCWdevN8gxUTOjvQ/d8oxZTXiFTPsc6MueFJEO9Ylrc5ySsC5JxPeuaQS93t2XXsWjDaFN+jQN4pzZBsjvcNgxggnwOXwmo0EPnqIN21TiWGMscuKIwKCpMqA8GaK8F5WMMbZsP+/I9oYBFzjN4x063jlYOdrWPNHR0aGBKbiuzKuLGF5dVnX6Krq2zBi37z44u3VJGjuGeXCgXNSSSGTBTOgAJxCKWChyWUj3cVX8zQVTle1x5rpyTQaNSqlADuyQUIvdZvPa17q1DhAaL/i1BW3zseSNZGIwMlBUOBjvPbupbnd7Y5cA+r2B+Or3dsWmZi3mPrOp4YKJ8YtbO4c6W0cpv8BE4cvJMvRzOmGgEX2DACKipMEZmKocmAUPkkKae5hPpZgFiu+VrIuHaXXqt+4649xEQg0uoLyGRqGWPxaXqC1BHVsE9145PjMzPZwfsziMRfaS4ivxy8kS/HJhbt7ilFZoU2jqGv0iLxmBl3xAzWJ0NGGwc0SpAILyQFhOVl0+0EoKNIcFIuksMYjWJyOy/XQZOAi929sntkwptzMbgvrKzwNjUJBXnF/sdhr1WrWSrSFI6ssRiVPnzO9jQVzKL3RhY/VqOOMibImN5iqy2s++4JyegXPbBgjmqw8snn32oZburvah7l7iCxd2LL956LBvqGio3ZZVqh46efnR27p3z8/vGpuz7WNWAqaKuJgkdT4NCopQMaISYodu70mBskMy9PXAidQxFtGRTkx83WTxWQIUqFussgKizhadDeoTPaJQuiei27aNnTfZMj5OXGF/YdGWheRX8NilO2bAQfyAzgW1v0+Tt1n+wnU9j2mgIw6GdalG2dNH/e+9klcCkpy16vSBtadLP+nqhI0epO7jrszjEyDTFpq/kJmtoFyTreCA8Vxmzcuz2nNzm8bJ256cbPiX4/nJ8rvEicjKT1aM0ig86L6ExgjMZABmokkFGsb2EnrfQym4V+QNuoKxPzUqT3o9Z70mpZ92FwZOwATjXWecoyM06LKcDqs5y6PzFPiU4tp8ymBwaS+CRQn6c+3iWGtcQb0h35JfNN5JHszxsFF/dLmg6OCV/kqye/n2nlGZo3QwnRbUkVAb9FqOpyBH5CoTE3bo296+lM13UGeP5RfsXnVm4hmTxeziZZPWQOLxCLhWIZpKE/kqh3ml06V+eOFX7y59a+PYGN5tjFpUuXmap3+X/LcPYz+k/MT6gh6BrxwKix3QAtX2SFjPw/6SoefEUyJeilBeBQaVr+c2g27woi3P5DqJKB5UIdh5tuIkKFUclQQ5supJuEHm9/ZJZ1Uk8yRYC4xyPDQPygQzoBYAtXixN41aUsKSEhoHEyT6m9w9NTm2t79lbN9QAxgLhWu04uKgwrOF+LYsghBNXDK5OflL+Ng+A962s6uocLKsJC3fPpiNwaeNOD0ACxNjXkFWCbdDZBd6SoEzzkwkTKDQ9VKnLdiiPLPTrLN4bCtI+EQr7aJ7Wurc2KWpXkn2KwQ9WrPSf2h1vCOQinyK5ugMZz905aGO/Ynjh7r2NyZ39wwP9fYOD3dj3bGTTRdNHPtc0wUTs/v3z87u2cOQmhGQmg90nB/tpmghjdRyMuDBoTS06pN1uhdR3bDKoq5pk8YAfnD4V2GA9IIwDQzZJBJRu5peXsCb5o8ACBhyKAk/3pnFO/srh1tI03hlY14H8V1z7dXXl+eZopZfc6ouf0X39Ixpfnf1lvrpfZmWi6KgOYpA0ygoO4U4D6UxJjND+8XcNkL2ZuCfM5rIwJLiGglYKsQFdn8a2ICd8nM0zJpCNN8inNIxlJg7csG2xkEnr2sfv32kDbeOdbZ3aM0VJl8FBTYV/q6PPsDlUzPmnbsOzs7uFrkUX8+4dKfYfy1dxTHyACtJr4f+xcl/TYgNzEz9cTyRoTNhtolpclnlyydgMCL3qpSUdxWSnRWktZ0U7w4Y/DqtLk9f2Fk83qnh3cPEx3FDHF86VJ18hzi3lSSQFKF5gvg+MUJz6LNFaMrIatQiBWieOLytZigvf6q8pd6+IRbtDu+frBwN5Pq6Q9Ub3Bsjkc7gzf2DZuOg0VNcYM3Pt1rDNSWt3RZTu97qz7Xn5Vgt4Q20p0bo6Qi5CTlpRogeE57DiPDQMdpRnjtGLQJLbdjbR3k7ndtgs1rMJiOjlxM7abQvkIENKdqKR2zUr4YpV1mLdPqos6ijpLfPH/3CF8obBL5FUOd0NuGaIv9ZF7QmT1eWM38U5N4G9tGCep9maZeyJlLAxJK9oucghStAE8lH4e/McOBEQgeHLAjARoEYZEl7e9RcMbNFbJ063j0dnds2ce5EG3Euv9tRFNqyE88m/+Xo9hnsEKMb+CPojYHGiQS6YNtLn703IyPBgAweMQrNRagHTE2QJcL99KczZ6nMeo7nDRbhrJkXiDP5nL260mSqqrbh+uV36VjBsHACoWticHe3geNScShqG8QAmcttcrK4ZpCtP6ZiROJj2DcWLuL8+FEdEIk367duv2mqW2vleV6rF2a3TmttAKBtWT2Ttyzg8sIBu32gKPkL6M87xeM5pqq4HZclX/IN5rjGy3AudAwjMw0cwKi1VPOqlRx3xrjNZrOJ2Vwu4ohHOGpv/S9/c/s1V89/8wfbT948j81Yefp08sPkn159lY4UrxhxEu7oplExt0UBQzUzrCPeNQP3BvwuFhxZNbbMBKN4HM8cNjiVvNKt3zv7H9kT/c4CnTbPVLbBmA2DejHc5XUNFeKK5Tt7JxVcO+GjxR3QgxB041HowcfEl/Z+cnwJP5o8D+cn/4IPJH+L/bX4jtbm5D64a/bKNjxNTqMcupZqZ4YTNC5d3aQLy/D/Dtl5WeL7PSabSUwDVlBnD9RhrJoB9wjIDPjdgs1OvW8Hnp5eaqyra9w3Hq3bu7c2difuH7wpUtyFi6puHuzvxCWVn1uwKC0LN1UW01WcP68YcM1q9MLgHsb7MUMvNHAk/iWjF7rA8eeuLvLBRw56Nh9GsVUeBSh5GmkXV+12icssO+TFziXcD2MwedgoHKz38RgbC50dFjsQx6L054udl4eymRRX3si6fRK63QlDOikO6ZaBAZbJgPOIGt8DfmA9izZVgrRhCyh00mvGuFuJuS6ap0AmqFSChtol+ayEG5JTRmgMCjMVKcSYvpSdVWAerCsot2c3OCs6czaUFZTbchqclR3ZdbjRqPW5+mNZVvrZV61jWSrd6DnQ3NS7oPE7+lRuXk6OOAQyaZZyR6xpMydELP7n5CT76VrXHvwbKZHhG0l6KZoCLfs78jJgxIWEKY/GSZmlcphACqj/WMnAOrQE9qH+O9gsllTGVsR3A/MkfHQmjiGe44+n23GUIilKgMvrNtkKAqLLa8+wGJLXDqg4xswJzT3Hc8E2l9vd7BnuG+gtacrz1IZa6sYqKsZrW8kV2KTt0hh3LC7OmnR9OgOZ266uP2ti6nCDehPlGAAWDvIL+OxMtFEjTBPg7VjBc3RVHyYLer/AjJsKS+4J8813K8Bu5GR73NR2gKnVgu3Ix/nqVbbWRo0GXd332rxMQmjma7Qa98fHfXm5XYUb6l94ociNjybVxTVbt+4nv3CCTXPWNV/bvLixzjjYrU0072q+eWI7ULEOHQVN1gxUr0QbE7X6LCWII8qzGmgHc7MdNprc36sDfNudYyeYshgMZAczMtR55fqDReVhKVGIJviKYam4Q6B5jzTvl6ommvwbDMat9lXZIJMWY3Nls6M2Ly/ubKlIGKz+xvIWR01eoqK5osloafHVFQRq/f7aQEGdD8/lbnC0lidMoFcT0GpDXmNlc3nCaPYnypvhrwLasCBQ5/fT1R89UL8E5NWOIokKNcYquq5LFgWKL9gavkYMwDN6r9pPoaXZLKBQKYHTWcXww0VwzpPTP7nwtttu2ww/5/94C96LtySvTgwnLr0UfuFzgTRpTSOgelHX2GTfaE8q/MWgo0Vi0YWMo+CqSZFvqn9sog6iWih5+Z+Tl9PZWvlf/D2yjCKoCW0CBxtu3VgTzNZxSg4HpDhLjvxQyamVLAcDduyh1FfPOAoiURT2ewNhXkoul/2EtGw4WA4rm9EzoRfMqkNM9QvCXLdU5BWEd87W9Ac8vtaK+sqa3r7NZTn+0KGF+HB+/kx5d40lHo/2hHoaB+2OQk9rQ3YJvrZqo8EaD9e3WQwtektednYoO7uzPtJkssSCbb0mY4/BXZxtyc6zWotqqwORXJW+2OcKByxCGUXvt5Bz8dfI6yxnLsA0I11dhvFPsM06c1T48CoVmOmlZ+Zh35JtsWTTn297xC8e8qDb4XC74J/0KWZPcgbQUxYURI1oB3viJE22qq8kgnIj5gWAhWA6FZhjuVOCQrkLCRrME4HfpWa7gCbUzK8FySdoKByyWTGqrYlWlZeGGsONgDuDtqBWTSG2FsSeLTz4qE6i2VI0nUdPQlU0z6yMiDlVuSTuS2fQrFJn+K7B4/PV1fPHB3uP7dhAPxMHNleUjRxsnbxusGzkrJH5bWWTTU21OVXFdU0bQJBczioNbSZfRj9jZaNntTWdtbly6Lpp+jF5wY6mHRtyN7o3dfeO6DQJDRU30FKX4Ch5CbzRApRM6B2YR3a2coGVlC1tNPyXWo24hsX3mN2/Lr12cSOL6q9a49iVccmadgEWpU61U8IZJd6Rbs/TRkFx9wkCq4DAWKdbQ+MJ+YZKPORJFCGsBMVMjq7bmrDWVGaUZGiCBn9cHjdG3jx3gafAajboNCrw6F3YpTaIQS5bagNK5tKJI7108nhTc3mWtSZYXnNnTVFOdpXD7m6K1xfluCKl5KXqul8X2TyVVfNKYve6DdpKnfEpkudxOcrDDqB1GNXgV/FrSAnev+rpLBV4IFXFFnGfRVz8CD/QeOJE4wM/eqjhxImGh7D+JwUPPxz4iU78EDMjjxIVvgJYNAATQ/MGaK49JmMUwdL1P8L2NqRySDBdgI4RVUfyIL4i+dF3OlZW5J0RREk1LuChTNmIoo1oH5OO+XKsVOHeLIEogMIKcpSKB0/Fg0dqFa/epcMqpFSolAtaUTy0TDw0TDyqYyEmIPW1sY3VG0PRUDRSVVlRFM4UE/1nFJOQKSLtEgJfxxaXM+I+TUjajg73VuQe3ry9oSpUEi6p/FQBmcVPJ5rK41nPPvLIH8J5/vxrqLuwTD7A/+BqP8s6I8XU+B9JJf6QfNDMIhT4bnw224/mQBvY1WWUhuAv71KIJEtlbgPJaKKJxZTl0DnScVem92QsBiQIyQEgYMdXO8c2d3WMj7dXlJaXVZaV4btHW1s3b25tHa2LFpVEoyVFUZpdDY9Rk80M9VUmyjJ35CA6qwsgH8KsCgvCbqE/K4sGfs1ibpdal7N6iw71GKRtOuAxvIavZFt1lh/qoH6IE9+FI9wo6JGKRKkeHqHD4iYQlqVPHd5dbJ16TPJHODRgp/tAssCHXXcfiCBEcFXy94cKCw2AOCvd/py24kRXXc3QD/Bd1QdClSF7fr7DWubKbYxX9sf66FyY8O24CfoQRn2J7iAGEQHYQEGbCYwsDf8p2L4GmlpHmZgjPDAzFZ4JaQWP4CG6sprjcbPNDSiMw0KWHP2W9oTI+eXr7Qi5r6OzODdUvmkikMhtb4hW1EY3bKgqL8zJi3kK8tq40YaKcFTDCZHC2i6dodFX6C/wxkN5+Tk2U5nDjVatTUvcpkREzJKTlqZtVpnbLHoi+GM0rfsvWVUbnLUGv0+7RP5OV6SzLNG4ncaVVozEDb6hC00nNBz4Pxq2q0TU1U6YfBYvopqXBR5SYb9s+RQ7KGcepiJ+VGm4kMtnchSYBOrCp2IQqUifHIlwd+gVrsGaUI0VcOn4+HkTrTQc0RkuclnN9YVf5FTJ+y9hIQm2wnopCQAKM6Ohp5U0j1mKmjupWwTw5ygFBldAT1jQZg/1AXNWn+Lh3JiUaMvjgYmvB/1SLqaCLZNlZkt6SaB2Z60hZGqYjsS3N2HzJVzjR9/Hn+MVZXumtu4tQ6AnO3EOeg7fywlsNa8YqR9H+Bu4+LFYMe2vfsWIXgZSWFEVm6uQ2QB4jijETES2b3bNlll7gY/mjNDZc0hLXPIui3gEcNrL3d35ZnWuviAYCxbXugsi11bEFHHCWVxup2JzTEVzNwL4LvQeyFQWjThoNUo5A5AqJWpkJa0kJfpwWY5iiyljE9d7HRzWOHXV/su43uQmbHUX2dQ2dahyWsYCE4AFqL5qEC21GbH9zzvkGNQ1FAQ7ZS3GTk5IkWtQYRPPMMBmkEPXkg+ZEbjGE5s7W8Y3dXWMflhSWVlCf0jh0MTYyPDY5pHaurraug0b4E4hsJSvrLWUWNyLKIgf+BXRRv74QfrxIMY/CTz8cAGYSvYB4g3WkbzFslyMyAPoZpbN0qYsrcApkBdzCivmlXSHCYcVY5SBOCXiFtRYKQDzKPlFGh+e1apAcBR4wGRC4N+ZPCZpL7fFbDTodSxbJktKE4ngCObSu+VMfgx6EzwCqkJD1NGjZy7GT/Uke/3yJHR14Cd+8MOujRufv4hgRb6W5dpUpSYluSn5ztYo9iT/WL/1i1tsNU5tpQmeaYeR/VIaWRHawsY1LI6L5hDngMYzAzzi6Zo4zyn4pdToGIAaowBqVi2oOIBQbGSmIlNRYdiX73GlRqX5+FGtr6xtW9nQTBlD86+jvNcZ4TravAHmD2QOvNlfgDYvQXGUQP+g4+x5zEMDCi4YJk2w8YFi38gTrKZ6oAKrNMpeDzur/JizE+IN4koskoYaJaKmewLVWFCP0a0jCLQkYBuNFqsEjWqRbvGeNWYZOEEtDHgSDQB5wKjwR9H/0w0mEsWlpYWFGG2oKY2XxkEqABeVlxWWFJYUF+V47FajXqcF+w+Wx5S2/x9rcCKZlonDdPPYmTx3cl1rVCbZqiY2bfjKTDbE9jPNU4btohmty9VnMCbIrXMlge9lMaZiuhvIjQnvEbMzeDjLA4ZkUaedGVEnT6CkwCdluGaoDHEDjugROVL7UyjrARKpkzfcOAwF3mCJubG2qteX2pLj82W1p8JULwVqKrPzS+mWHLcxtSUnp7Ao2wQanu0a4R4jQaotsAD++c3oCaR6nODHngA1v06Lw+jtT2lxCu1dt8WNqRY/ACW9XosTqRaLKEdsQVa32Jdq8Sx6AJA6a7GRGiRC23Ax0AoGwPE1iRh1YlUK5QJSQXMVBsXG8yxisdSHBAHNSnn8FrMcQzHSLUFeYCDBj1NbIQJ0kSuWPPHh7i14BP978vdYSP4Tu5effq32jTfEnRG/wX3w7I2ANSbIy9C/AuiqgM4DAaM2lO2ZYNQJShS+ko0Mp8a+tsVhsKqf3OIU2rpuixOpFougGVmLFP3YDgR2jyKpH2jNPWiLhowWh1HfmhbUyI5ktDi18qs1LXLheJz1Q2yxuHJ1Zj+A+3OlnS90/bcxUa+gsS0icITND5pViREuQZA3Cxn0dBcOXZDSuwwulnANRhHrNHLuEtsdQ/MtHWLoK5Jvigbxxt13jv3w8e91dz+/74knJrHvero/5tDTX8e1/bi573/6/4izbzgmzQ+5jfFmucSbX1ozJpahz0ZdIVHujTXcu7bFYVz0KS1OoWfWbXFjqsUPgL/Xa3Ei1WIR7cyUEZidBLoCfK8G0D7KJ3m6bxFnlDDAz1c99GDVw/8SffCh6IOkIfLQQ5EHH4w89GD0YdDgG1feJj8n/wW4Jx8VovrEBpsFPIICf7bHrlZyRKUk1JGxYtwtYNQl5/uJu9qldc5QSVHGJgUxdCqn+9G4qoKugFC9rYiGMMN9bMvCga6KjdGSks6bDkQnAmUbIzPLLzicuDHaf+QQfiWSPOVuKzr/ANvEUN4a7q48Mbbv3mmnrbmwY/7xjdsD+Af+z195aVey1mz9Ap1NllnO6FwtzdVza2ZzbYvD2PQpLU6dwRFiixOpFouypKzSVtXsHrWSLH038x4Z+y90gGbKEsUwBwowpwtKLG7ZWxBzoyURsFn0doPdazL5BZnCfupm2GgBBMkwmkhR9KK9Q5OTW2+8OPmrXXNj2ybwxfULiS+Q0xfu+2fLQFtL8vfMJ3qfdJNl6PnVoh+kgVklFgbaPfIfXHqlnSZ8sSy2PeKiNoflTEoasXVnnKUJkhnr3hQm00x0nuxae2piIqGNRcrLisKBcgWr6aHn2Or3maFato2hgZO3pjMoT1mKaLKLirJ1wUB1w8JIeafb3RuOVxTGGss8hYWejhr/xsB47fbGuXPJLl8klJ9n1tlzXAU9daP9ZuOA0V0WLqjyFdaF80q8+UFPUdBSVrz8DdLZMuDvplwkZjMnYfaaWUp20/4zj9I5/TZar/WpzvTRN1NHf1CbPvp66ujiB6mjXGXqzs+iy1l2ORznSgFNlKAIakBfTFgLsBIV+YlCac4iYt4n3Sobpltl1Vih1xCWAapTEaUSzQlZLDuCRqW4OboB6SD1XYr1WIMVmjFojz6t9UQiFIuWlWJUtyHaEGuorCiNlEXCQW9etpsmXrM00hJcYlg3jTS0Xg42VQZiDkwkGlSko4pkqmkmknyQDHRX9QbDfVXXNfim+7rmzrtwcmMk3Of1+LdXNgzZ3JtitS2KDzYkb5/pjBQ1jhJf/Z7O6q1TLP/0YHSjmK/ta4o6Tc1Wd2FpYVnnQHfbptdSedtA6/iKkeYxA61bRTuNHkLicZpXS2exXZzzQ2cepXN+at3Wp3rTR19PHV38CI4ybfA8bYt/I975NdqW5v3bMo4eLqBtf8n2CaaPnnqMHv0fOKqn92VHqVXdilAql2oZdHYJrYdgp4HQ3ny6DEfr3KhxNw0D0CWkXRl62ueFGSzxlQSKqejRxXhp1Ssj18pB61kxDR6ypHJOo8Ff5jflHArOt44dP9y5v/GSPbEBJ29sLroseMBW5rhgU0/vyEhvP1k2FNhaqjckvn3+9TfU7e05cDQ7l2zYGuyJJ/SerOT/mRjpmp2bbpgAGojZaVRGBkQZ2SxTMcRoO8hG24SOofWOH0YvrXMcaDaTPvpm6ugPBtNHX08dXdRTOatCR4iadLAYoQc1gY8DjiGoLroYLYCjTNc8FTyvmKDFQOZU4HvxQ2KdK4fNCC5xZrYoW/LMiFjS/f1Cxt84x+H1Ohz5+ckkfu2/pe/4Zzn5Prfbl59zY0fHc/J36Fl85U3obzWyAW4KUrtsNoLg+7xul0UFdllQMLtsYgvpabt8KNMuB0sK08l0KbMcqRKnnVpli2SVOWaUQ1ce6qoJ15bmeY8f6qoN1ZXm+JK7tbpfF0SHu3Gt49e+6FAvTbTz1oQaCnYkjn2uoCbY6J9vCDa5cJVrz2x3ZfJnjv1AazHjh87LZmker2Xztfb4YfTLdY7DPG5PH309dXTRSo+KeSe07aR0j3sQSuX6fQDYMoi2PGNRSrl+NIyWJyb9S2kbLJNPznmTMiryaDGJYx/fYiKhDhSETE6fVCSHBfxyCQv42VL7LgRR2YlCQyqOzDcOOpWgqcfHwRY6+xPzR6bau4dbSdN4dxvWXX19Wb6Q79O+xb37lr5U56s4cdWOHdPTlvndu9PjfF0aJ4z+N1KUFJ9PksiMClnsI1ev5jlp0xcix1gxK2huRma7LbWXiG3iYYudYth0Oau00tLgrvF4qt31lvISHd3SE7NojeUeT5lJa6UhVOlZQ+Q+4EVp19K6sTZ51xRbBrB5Y3go+Rq5j9ayIOwOPFf5/9MqwC2V9fWV5YnGCldevtOZn0Nmaqqq4vHKSE1VrtudS3+kUdxG3gQ5irIeFCKaDcOWWsU1M4y5ORr1xdyQuH/Y5zP7fDS6yx4ubjelti0ixlDpFIeVG8pzYxU2h0uoUtaUZ8cq7U6nQGbq2nKyc3Jq2+FXjjT+G1hMG5Aee7rfnKWkG27phDFicoyYdP0XDVhtNmsq6yUV4xbYN1rqC9+gKat2VOnz8zRbH2NfbVXGreTvplop8K1h33JGfXSnJZD3dUCZLtQvpqI4eZrGgQSCdrHE5M4+uvTRJVC4lj5Fj9F6kbQBrexnFCPeFqvJZLWY1JqcYm+M7WthW+1NERNNj4gxIbDhfVedmC4biY/HR8qmr736X4Wbbn77nc3bwvjZZEN42+Z33r75JuFfxYxAI3kAZDWXrpgYssQ4PyHdLOu4hyXKdfUpsULRp6D5eLkoFwCi1SRoPMWKGNthbaKYke07l8rBsf23Ntzde7BhrLinbPPoFqNxzGhoO7f3vf/gIofnsTX5nz3D+Tz5xnKXasdS29ntLec1L1xUp/iPlA99HGTtdYrZ8d9wJbpPRPX3if6VZuXv5A6gpg+d7HnMAtQ0OMF3NdDal4QlgHpWHQFmoijawhaGBZBPQazjwzJmghKcpkniJYhtflunCceF+lLpNtCMJZFnu1kxTZqjSUNlPuxTC3TLkYyaYzQnWzD5Obb1VkxtoalbSvxslc8VNG9s+nJ+d2ACP4w/+gD7egsPH62ey9L1Kvm+Jnxzli75JN2m+06W/sBermVHXKLM75k380tGmb/jglXeDEb1oKXHyMsoB7UnWmhJDS1oPDdW8B4MlrM3swYFNVDFom5VioPCyMk8fIMOXPscnCMI8gaqjHwOmjSUQpf42ofuG7p9KbqtqqBwKLT74iw8nfyK8ujhorGywhnNcw+edf+ExdFrtVx01sBFx0yWEaNx1d7qeCLqhP65eJgjblXmbnE6fZh1jEYkoVOFuFABnXJ8ph3WQOl/1O/wf9IO62s0n7LBumZ2Saw9gP41ow5jkG2OCOHUPlXBwWokzE3SeCQ9lgNnVrjjSGBRMMCEIEsCUQL5KZjh+SBLYAgp+o1GNbCU0WIEuuu0KoPaoOCQgAXKSRYfjcrarBHpk4NH9FVUVAyXV5TfOcnZNtTUbKA/H/2BPhbwqVSNgihRMbPC/Mr/cN9je6XD6AYxh0LDOiJ5mTS9W6CrNjzumRDP03IiALUEuVAiCYLos6lICUjR+k3YalhIap0pJuGgL9/ldNjMYlZ+Hs5TszmU800buLjXFMmXAkigX5XKgBxlbvFn6+y6skKBVypVPL57Huuuufw77ytUgjKrC39vfnLz6NS8VjvM8Q2jZRO7Ty4m/+uXS2eRC7been78yM7x9s6uFtHH534OdDAhN83o4mhGl0LAigVqd4I0ysVvVSsJdJ+HKaVrrtAUnHxw9E0aIVusfwE/cie9plQH5yZx9+R22qvvJp/B926nHdpOTiffwvnJt36xcAAE4t6+tta2ZiTt1b+Z5ZUB58PzORuttNIrxRx2idWBgfGDfUKqN9DY7rf4oScq1hOmS2ySLvEz8yuYnvkq/ugf4aHCw/snuofbepje0GftPfzSS30d7uRTcnxtgemONyXd0bImmqJY+R+yyPTuuxTL4ffQAyyzcm5lGzkiV7Gh6xWK49QyBNlOka1URENsx5gWaVn8VhCoYZAKsZj8Ntz89iTeMfH2nXcCm15BLlyuvlOOI5N/AyzlQ3L1h6hUB6MSkIlYUW9BTn8LMsQ4S8tihDh4GlsW1yKNlz7PVRzhaJRYnJ+QPDfbMH44+egeOjm7d9OJ2U1OD/z01V0H+9rbO1rOqJu0IVGtYnWTUs+WMpaD4hY7pSzzvvxst8thMcF1Bq8gyv6qckmc3ANTik1eSBVLuvsKVizpRlos6ZrV1ZLwHbRW0vKLcqUkpu9TFVpSlKAZNqGMCi0CrdAC4zfN4WPJV2hpn2OUohqYtxdZdQfG9SpAVYgbkUO6ILQwfUiUWspo1JRRqAoz6DSpYQ4dMZodLkonre9ogy9eJUinpq0wqiIceF/4q1s2L//HKN6eXFaqhJI7/1h91YKrqn3/5uVjf7zzzj+SkhsPL1yHVlVCorXZxOzb1XOrmFWKGnENJ0XS5ZBsc2uLIbHMZhgFd4zVogE9m0WxE8NzKqxUYOUCT0cZ7NOoBU6+Pa1KYzKx9QazVsgrjtBKDFTG4TcnVQ3xc+Svb84+Pz02/fzsm3/d+crU2PTL+AI8kPwFLmU/jyWP4/7kE/SHZr+z2oGvogDqTnQ4QKpp7lo++PxyTSBFr1T0c0Eu+imZuJTt9bhsFoMuSwNmLoADQtrMxe2xaCgUc9jFONyq5Tb4/Z/RneHyrVWnvr9z58jEYO/gdHbxQvycy/rbv3qrxmQcMVsxueoyAHIYt9TG6zAO91lsM5uaZrQK963ze6TKOjcB/Sy0mpQptQcj2MdzRGY0C/gCDpOCShrbjQhOFhaL+FTH/RjsHkd4fP7cJIyXT14B+u8873CrkQwsV+MrApvaDctfk3XQTUzDvCFpmDeRXOVpgVULKU0U0VVvlmgCjgEvaWiWB8LknmUTmFO8kTFnc5O7fjb3+w8Xf70Ij6cz9HjymDQ7YAfJBEPfB9NWkM+0gjy1glzKCtINeJJpE9GhQjZ+nowzKVCokK2dCXwms7T7zIVdyjPtHBgPZuHWGLaHJ0H/MqOWacyWq2VLhtbWXDJmpXeNBPvE+ifiVAF3200Wk1JwF0dWF1vyiyWY5tLVlrpp9aU1tZakCkzyvBxnUgtP/NgZWS2tktaH32AaD05OJm8Qq2/B/fuST1K9RDHqd8grSA96qZSiCU7CounyoUBMWt3HbjW4jW61QCv7KIVVlQsojM50P/FF2z/X1/e5Hbc90HfD9n2HDu3dd/bZmon7Dh36yvizjxy6b7z/luuuu/nm607cKo/rQlY/hFYVg4eKWojWMJVQnViWT+R3rzga4plI3s6yBi4Q9Wtm5abiRBjkm4o6K5kh3k8h62nJWGkDoD6dKWtBkUTaQHxHLNlE6zXNTqUqNuF5Vq5JQvbjctU8iuwd2jPqPhSn6z6UiHUfGJSndR/Wg/IZeb4nHrp/6PMyjj/nssvOX4vgb7/m2ptEAA9yLNUcApwZY/LLkAOTL+pBqjlO9MMIK34TXAPlbVatRhQPxSrxwJkbkvTkjrDXmGMtqctOvrf9OYVewfNa/qtbf5ufGGQSUlpHHMlzNXl6bZ4Gn0jiztlyirujK38jy0AlE3IC6v28mMDrBQFn6TTKXSotEaAnCoHtbwGzINocj+iUr9+QthFFXsHKC9B6VGMfd0vFLDQnioGJiYTbbKZvXnC7zE6zE2wrQErqt5uyGD7KeEEBU+Uh6cUEog+N99zylbtvm/j8l+HXwT37f7x/3+6zdNu4Gy679HoyOUmuu+zy67ltX8U3ctu2zc/z/Pz2bXMcmwmYmQ7Gk8GEXwP94tdV58CLZrOZsbdUhYjWt1FIRYj+tPM7p9JFiJLX0KJEEg58fT0cyLZZ00j4ejjQK2NnG7li+Q0KBOcYEDxGxeiPtM+0bGaC4RTABgbMAlqEVU1F0Psl8RkKLONhgCgWv9lP9ZuXJdKJ4Q/KQvAY/PvoWPHvJrqGCzeHJ3GZ2fDin97ubzIbMJgiSYc+xMYQSPgkaEAfoNj6cehD7L2XeXc4B/6fojXwyPnsp1rCx9wHLN8BtJkKg+o4ziI2oCTp5skMyhiQQcpxUAs5GbQR6cPd89H3JrGV/p9BIpFMhMnc+evg45TL8Mn4mK3Mr8HHj92/wjyXedGNAq+BeU99zGsS0bFYZZKujQK2grEySMWJXhNIxVYVL4iGRwP9o0lDGp1Gl6WFa1ReGCRTdpz4WDrITLeJPRqfN7n8U+nxp0XfDTRsn+S3bZP24ahh0qmGlSyQCBnB4m1NaVizMUsjPlTSsGvHum1yPnOopzNGiun6HukBi5RNoyZmQG8mQG8ycuM/FbmBmdKxtxooUDbOTiO3SJXFG/OCqg3Ka25M7b8XnyiZGf5Qn7wHb8m6Yr5opCIHENuhW3t679AYjSMFmAycewRbbf0W+5a7Fg4/tIXampX3uYehh2aUi+4WMYqXRi6VPBgcQeDmaPWMYB+oJCWaI7KrLq4cB1INaRNoLQ1iTeNE4ce0A2EMSY1lt34i4bFaMHjKllxrrj5LfqMDMmOzRrQ0IT+rRJkqgZRpq8mh6+9XXjw5eVR7/1W33HPfrbsP7t+9d/9+zVNfEUt13nLv97/2tWf7b77++pMnr7/+ZiRlq+QwhGilOUWY1kjsBaTI1rUX5EKqIHGSCdfrEDIZdFa9VawzF1AxXcdC1xEG7yksor3J/eGXrr7shclj33xpz4HJzbiq/Is7AHfhguSv8QGsa2w+AU8vXXkf/19W68dLq2rpgDGyoAtWur0jVVVLEg651E+pVIKGF9KBxTOasIhJulQNw5AuWiEoN9vpdXktZlaWhqc1gsSYSXo/CHBUpMqWUc9IoPbjteHx5akNDR1jOVunX0iY+IIRX2JsYHJEM9T9gJrL21gTbCt6Knmyr6ywo2eglOOj0XEYH30LSwDgZDYKoomEhu4cxr1qjLvl6i0SRAuvhmgetglBXkBIH59IWHJzWP56MDfosFGhkNAbSEEc/ncABM6sey9yBytEhUvOvQTjy29w76hS5bfXmxsGijUK55aNCxc27O/uGrrjjiHNgw/+8EcOQAQDnFrFayNTHYHSy49uurC1a9fcd761bTdIK13PFNiucgegAPDrhXX9+vAavz4vx83CVHCdPtOvT72EQfTrZbfe7x99bX5hT0Njydb+o0ttibPPP6e9+ZrDxNnWPGvjVc2x4vZCXFcQ6k6eV1gyJlUBwXdDv1b58+GP8+f9plHc+3fi7E5WMW/+MBmFa83Is443H/5/8ubpfndw52v8+QKgeXCIloZGk7PNOOtHRMkpc068WrS93RyIDW1MVr164sSr+Iqy8UD3IpXHCpCID6XqVw2JOiuoR5u43xtEkhNFkrFMqQhJlelArssJXK0DUA9MLawG9asyFzgvA6m4ipW66qDlr05y4wOs/NX/xQbc0NzQpRGLXdXv7YpPzrDsA9zTOjpEaU1f2vBnoNcnRAXCnxoVcEQAW0TEDfhs/4mg+tYj07d2j3bfOv3It7Z/Ab58AYO4vgP/VlDy3T/CP3i2D6jzTaBO8LNHA0rPiAbQXWFZFCkHcTDTpsjZtx+TfPuLyi3+8fFrO/vGx49v2OhvK3OHpqtm98TjjYlzNEZ9r2+6rKRjOBjUWztMlp7msoYsXtdW1bNJrlLjZLUhchJuChrDnz0GMDpGKJDi945RBJdMEmfym1llpXr87eV3cb2xslyX7EBSroGT/JYE0TKLAdSiLyH52Vp49sfEAMKfEANIz9Do+MQXp5/43va7J4jz7bfFGaHZkiv/xO/DvZ3oQM9jvrX+v/SHlGvly3T/wx/r/oc/zf13Yue67r8oc9XZbp1JXVAA7McrObx7/McKlUKTENS9HKns9Df3bmsBsv1s6pK6xXGZOg+zmQFP3KBN+/7hVb4/TJEdKCP7/qtdf5tp9LwnnjlnmCPctzqfgIucyWH8NXjMZluZPTmEHy0tTz4iPcvEqlOs8frDn+D127wxMTY9Oo6zxseToLfefHP53T//WdIWxCfVGsrw+EtXmxOaYWqz0OxSMbM0w+OXoNMqhz/UcSBx5aGu/YmrDg729g4NdfdoxJpDF04cu7Fr/8zWvXu2zu6XxqOG8azy9sOf7O2P4qfGkx/RPUL4Z8kqtKZ60eLqKj85bBFNnA1ao4itYJX0USxexLHqRczWpDTimW0mElaHHUnVi6gmKigwUcTikGtPrapgZBE3wfvFYpKjrFxRU7p+0ecrGvPau4fbmt5j1YrSxYtwOatZxKoX0XclgZZ6junweCJK32Vj0xCO2FdFFErXRBQsJlaHH1R3OqKQGVAQdTcuP+/Kq4+E+nM8edW+oc2P5DbnVWtOHDt2q9HYptft3vF8Vla3U6pN+Kw8M6nVD5ga2YtZNTNs5cP07Ufwk4/in3VTq0gl24iXWd2TikSpSctetpSKPITTkYci2nmHndXSkcIhjoyKJ9zqYigjDn+WzmOkFU9+KdVCcRlYLZT3FNwAx5eHO4h7dSUU0OcVwCGPs4prbsCJVYnyvFyngxdX0zE5RrVjmK2ml7DV9CKFJLFgdmySs8xKR6SCAnQJ3Wp3gJOriAZDpupq3Lb5wpabL9186S0tF21O/nXr5NQs/vHs1NTse+/w7eePXHCr8Nprwi0Xjpzfwb+N/zmzJOAvC7tnZnYLyTmBrmOqgcLvM8leGx0If3x0QK4/o342XX9mVfkZjDYDNplk9xUjA0SxSR7tZ4sMKJOD45gbHzpxApRSFYhc5Sss5gW/PoD7GmlkQLduZCCcERkwIqPZb/axyEAsIzAABDXhu/p7T49vbOlsHX8l7+lH7tsYz/mI1eIZRogrYX2XIwLhT40IyP8Nj/8n/Cd1GX7EqkOjK4e5cxn6FOMBRNjE4gHhzxQPSP1n4/zLVeO/Hf/t2EiKLBJpCJUc0sx6bVkvGhBeEw2gYrs2GmCjS8rMQ2aI4is3//fSGwf3LC1d1tC6BPL1o/uGp7q2l5cihqcxuYe4WCTAtjYSEF4nEkALzq6NBMRN8iOlSAB77Oj4AjwVV48ntQvw5AVMnM/dt2mKat6uHRWlTPPCoP7OKguZ1kQBwmuiACbDmijAmjGOjqeHSJw/un94smuuskx8x9/7+Lusqu5nigCUnhEBMOqlLRGgXYRM7RIXQwC+NFD7TvGA29ftu0eb/F/MqUfb6xvcvqHA4auu0hh1XXr9Y50DQ54OvfGGqy4/KdU3/jOryZaHDon25kzPP/yJznw45cyXrufMJzx0gzwAzjxbXoYvb8GWlC8v5rhXr2eHCV68SLUwPr6ovXChfan+6N6+1rbe/vZ2zdEjAL/fPHhe0wUTx0527dqxY2Fhxw66U9MPBP8jzKfuE335cMqXN+hpfEdvNVjhEp3JFGS+PC0IIzrzgMotkZjf51D6b69vxtsn/zJ+9LrPXXT9AUJeNwxt7B1dfvfFF7HjGxOzFH+KnsurgD8/ZPjzrzhfimHTPcofoDC6NqHPo2+KwpgTs4nE4DCAUoUK82oFS59RzyG1OkxrSrC9TBIS1IimxpMIZzRWg0ekJrvWbwrUx6jAl3ozr5xMFMZh7apkolSBR7YHXq7gI1d4teKDFXn6kLm05JzxlomRkfFvfpMQhXuofnb+PW0PL1RE8bGj22cAlm9pHx1tH7cETYVF27cmjzwpYXLwS2kW5weMJn9H/8toIiIEvygVFCFoMF1yUPCudbOJStdkE0nbhaQX9wjrAAaWTLQOZugYVWMu+b+ar0jI4biIHEb6Ox9j0IG95fR9/ADIRVh8ixD0iwYiyKosotI1Sw/ZbptFpO2qpYdPKAIINH5lsa1wOvSxNQAPagoGrI5if2YFwA691Z9jz6cVAGuK+wczKupSDdon5sE6eLnYHwuxhVlh3BAnRlV4Oe05fXwiYdEA04hqVckjNVYrpSShaqbmaHrQZdFsZyS7dZwcrMnx1GRnL99ANSnV4Q7owR+gByrQojY0JfbBzXKSxCo3tBs8H5YTk8Q3QmTmLKVOAc+azRo1RmabGVhWn6U2aUwKDqmwKjNtSSnnLbGetZaWlTrn6a9LaO9qaty57JfUw5UVuV4vUdIVAWrjV/7JlRG6jhNC10t+G6hkgZP9NvEPPu23nZG8FP705KXwJycvhQK+fJBNuwXcOtDuqeSlYKZbJ5kZ2bmTbVu1zqOnXl5AKXp5s9TUfffb1NNrxgeZuRN4Rdrje+7+kSnJ5xucryyTbB/XBzQwged0RuZSeG3mksuxTuYS9czkDgKCThneCQBcS68fWHo2uYynli7Z2Awm8aWXXvry4NhHH3VNlxZLq0nZLDN059N6utrVm14no0teGC3IliVMeVg5q6abWEJKmsSd0UaBwKQIu1a1AG9ZTCb1WUIMAmmEXBGYnKnd5Oq246DYXniBI0r3ZHSOlbCW1VnIWFg0s5D8Om6hRW6TUpxBy3TaiqjTcJhlt4sew29IEKsQ3V5Qu/QhUj+O8TdWPpTqKQB+Y/7imnWu8GfOd1I8No758cdk1Lb87gkpA2aZ2wIeDcWZ1L7QOhrpJIO1nii2MU80hpeT353EndyWf18+Tk7fJEUR7yRPQdv2nsccYhVkFrGXbheWbudhJzKeI5+YSGSteRQL1sfwnX8Z/xt56q0k4OEvym8ufuGzvbnYawvje+mri9lV3KnPfBV3O1wl1gKiVxElDtL+riRXfPhLK79ntdCKWLZ2nlSZECANIax+Cx0Vx97kbJQztek7Nmy0/s2XknP4y/RnMvEcfdtGFn4FfYWtJbG3Youx1yXcbxXfik0zumlqd5a+wtmkthoVs/it2FHxRZRnXC2/NxXJV8svtvwKff2zxmJUzJDvya+xhLHRt2U+gw5jARchy/JDYv2O5YckfqP3vpfd+8y3fKuR2sregpJL6Ou6Q/GzFEaruslVoRfIaf/oWDB2aVRL3z2JX8FT7C0xJlSQ8Iq+tIK+fJjeSA2On9qkNumyoIHKQl95iWmXaTjeL3/BU/ps1aygr3CdB19mlPpyFzlde2VUG7ukWvpAGU8CSiBHwio+iRM7bLVaLWyLi0wPQf6Cp1Jv+nwCviU0ZkYjicJamdIirfA+RqsymVYkTasm+HUKNJIWrL5Oq6FIlYZ6UzVaPqmwuM3M3lsesvgtQswRighxfOph13bn3Xc7t7sexr81JHX4b4YxwwsvGCTf8zlWkT+REIGZXn53OaAM02d7pJtVyQnEbSGHP04fGpeeDAew6+GHnTucDzxgsz3wAHx5+GHbXwyj+m9+Uz9quOFKw6jhW9+CX1fSUfehv+Bi/J8wavoGclacTipcQEvT+cia0vF9ifLyBP3Be1tralqba2tpDZmVv5IX0REUpL4jaDADVjIlYCBa9lm58j6/yGpEGcDWBFAlqkNt6GnR46gyq0yc0ppl4TQKpWaJvuJCq8C7jKxetYHTc7QGpQ5rtWROLRCpWmDt+hcZ2Nv7xEv1YvFK+j4VerUwp8aCcJDudKjbWB+pCgU9bnF/V0tTfdvGtg3xqrpIXWlxsDJU6c1zBzwBh83oMrky933Z1rwlQIH9WCHlusSiiowz3sxWqRbe1LcfdPd29XX0tBNb8nAfPpG8AqxmsA8vdvWxw/h+6Uvyr+IJHfsgL5+9tHTuuUtLZ2vo64qiQ4ODw/fc/ZZ8UP5sHBwcGrrnLvE3neMQfh7cWJpjzvQTwrQIKciUXFCW8z8weXctOZ1MUimhrZ+A1iEcQ4/RHUlYzMShld0MrF6N8kkFxqmqblI5N7mOG6vXW4P1Ukv2bl2Lw0Y3qO94kNaxwa+JBWxoVTZaJOsFlh9I32xbjkYSg/TdruiYbNezsFKLeZWS34VUhKjGkEpFZnVqDceDPzpQUuLNt1kBUZWXlJeVhgL5xd5i0dmUVhT0SraiIL2tz+THdC+XKfAx+4wE0O+zO3AbDV4NbEt+naclWo8nNg21J0aHW0uCwZLicGgzOJWnl59yt7a58OdgGvrdHe2e5OHj48O0vM/weO2GeE0sVhPfcKqtjVoVMoOj5LeixadlyfCxjIpC4n4ojOgCP/jFwGMKhnLpThfw7yNK5R0tA6p+bVOTtl8YIDPtid7eRPvqmhPiTpa/4Moz60WQm7jHYB7/gi9FT3BKlhmpAvsgtxD91WTKX/0L9VdT6yjJ1DrKX3Acie/G+l/uYpitII3eB5waWvS6l2AipgmmwvdBFLS4cqw0VuYIBkkoksuJ8U8wMuJ3M4wMDGIZCXF/im+pU25R5JdFnArBYZhTZ5EtXH7Fhmy+vovM8HPTg/kNUdOVitn/xtylU4/ffXUkpy+Mheieik2P3Htjzbl4w3f/Lfm5k9FjV9clLxfrX5Nl4kJ++tbMPIdZ4NMvcQuzd6WJCMuP/NlgUmgnMe0L3QxLOxShZcCr2St/U9/JsjD5/3X3HoBxFdfC8My9W6XVanvRrqQtWu1KWnWtellrVWx1yW0lFxWruBsXwDYEDAbbGBJqCDWUAA9eQlhDQoCQF0ic8iA4lWAgPMD04NBCeLzEWv3nzL27WsmSbUpe3vfvanRn751yzpkzZ87MnTlnWV9Grf6cntyuUslyma/SxivtKW2qFC7MO8vSJeVtcs56TfTTC8v21nwU+vZP1w5+56ulaQHb10vWFffeeUPjsr8cRPfFANsWxu12fLM5Q4sFBlBMiPvG5HLZEK6jgCqL3A0cbTfaIZfOKRiCFTfrx7RZceXE7Y3tDL/zxhtXPPXU6vU7S3ZfnrR6ycqxJZylY3y84/zylVWD2zoaQ02V0SkRnmbuEnZ2IRisgyqJDLgTAFBw8gkJO7AmFSYDCgU/RFgD63W4G0eXpk9j0wE2H0CI9CIscWMdAT3+RJCeve++bzw/seP42We/eeXVNZ2t3CUbF133jfZ++utFG6Obv+0rKnKzvU6f8F+BUcJD7hIdAOiojNdTicxFlSBpiVICM7NZNzm4KVoxcMlBUFCqxIUpmSy2bYWAgjLMJcXnaAmJ2GOZLHErCkudFF+8osSRYbelWWEoUCeLq1e4gzpZfH0U24nCnEXPdYiJu2/TVYskdw0M/FvS4mvXVo56s1zdxRsuUNO+6Hek559buCTHtyxp6c0TwuaU1Zd3pxk6tGk7t3ZdcDlzKExEaw4/5Vwk6yS6OIEErtl0EW6ehi6+U9PFF6dL/jx0yUw/iS5ZNGuaLsKq3kl0iZGlpGVLo/SycPigsmljKKfDlpbWkN7RBZPj6JTyRv+CdHtDUtmWZbjI1zdRpFUtTFZ39rR9V6fqUKeKfrC/zfarGUlu0EtkeMRSRtfC5FWa3ckW2lkn12njEykFTKQoje2/d1PcJiIv9WZn04to7uCBlr6Wy1bR3DxJqk7hvsObbGKOGduiD2PgngqnFhYbwsPpNezkE/yrENfHi4L5enzr3zEDBl8CDJrUmTDE3/a79WYZA8FLF78+sCbQXTE88FqZ2ph+SbolGdct3oUPZ6kpKGlbVJclnjS6Q5QeJcHCJKrApX+ioBPJSkCGbQnkxVqtFjYAxj4qeWYi9nqRbQECAYRsbifNGdnf1Nt8YOjynw8MvHVBntykdt+cpTIyQnRGH4oFYcd1OKPWPTCUWR1bR5AJb/ZxzTWdKmAyPxs63+mgm6ZLhcg8FXHovJz7tf7RQHfZ6MDYV5ctu3+wTGZItl1sT9ZJkVDvsw9neeWVGn2VraE1vUSDcIHuyT3DLOM70H64nXIKuQMg4tBAJto8JxwoFQr5ICqG2YIPH2GvTgbkSTfghlqDLkmeDpNYOYwEZre3gEPKuRAudwXMPbwBqdPMXfGrxg6/tnFlozqzomSgJJChXjDUqM1rX/BL+rvoTUCxxg8kBb2VL71YWGaM3k8XG8sKX3ypsqdQ8kFj73MIKWjL3E6gIEJaG6wCSGVSh43jYWDCfSUglSnZgz1ycDZ3iaACpGbGXQmAAjFnA1p5Z3mtK7Uh3JBiy8vu9eVZ1cHlDRpnbfmddG/0+EHOUnq/1NuQc9edrmztP/6h8bruvMvX4JPeX7rwGyL//Z6djPWQR4VFsWQn5ZIVHkqS2WEH8ZcyeXrVTAmdAm3lI62TkxWDqiROocjulEt5XlhIELaBeXAlWwlz+VMnDsL8HU8wYwIlUEUpm5gzYX8/znaz3ACry5Gp1eqFtkxBRpuzLWGuKrj3ZoTir366sSNPG+oPpbrKi1cUV2SqF6xusWb8bmCArjgMjXozNuqHkoIeaNSSUl30u7TPVFrw4qu9NqGDHG/sPSr2jHZoVzeoRDuDqSCVk+TZVJEEjKaIbe7LJLGOso4kJckHZ/cWG9MaFVIFle6B2SgoCtKJORP2B0FV8GShYqNFbJEnVLMQnuYJnJ2zbiZinDyDNbL9thRgDaUh+evLltHUO2Ls8V2ptx7Yw+nV/P3vmmxgD4tP9QEI6e+ULrwORqqMqVzOwC8FvDcF13ciVn1tSRIYV1pAo9BQmdxDJby0o5UqaHs2lSwCpOUgLfYocRiiCjT+Lieg9cvW4vI/L1mDC6lsMwM6Ou/uamqsr62pCpQW+NzpFpNCRpbSpTjkoPsBozDImBK2K8WN67G1dyFBzABKRflcpgZR6QuUmkzmeo7epbUqZHqlOWAOrxzuGhi9+OsVlQZ3sb++yukvUScFShxltfnNnY6xnSP9O0fHR9at6wnWrc71e5YFrA3GoKXWqs8t5ZdKuSpOkutUrQ4tWqaSqJa1rt4i5VKtWpOd55MVSxVajnfXuGubJXxjqLmmvbW2vNplq7N65BkLTCmaQJq5AG0bqKbq6Y+4G8gSsi443oGU7V3UopQAVzQDaWG+Lc9ipPWciqrr5qJqV2doQV0N2nj3e11AVZjpLqFLpqmaQFT2yiJO1GmaxuzNnp6muzRp8hSDqcRU01xZ6KhwbdldVqp1FQRWeZzZymS/2bW2sqYxzdXXsjDc2dVS3by4oca70JeZWe00BgxBS5kdSMrdACSVZqenNJUVV6VIlJllvlCYo2pzqsksTVa2JSdJ3eV2Z4Wb0pziwtyFnvzsbK22JUUrSavRp2iLbGZ/Otr3Eq0myMjPRMskgqUCGfk5W0ac9tluAhFbESybtt4VPxEjj/nUAq3IYtZqbGnmdEu6Qa8xaU3ZboXccpI3d4/gcRNdaoGSONOfe/SRs7Yp6e+UW87atlUWzZdtneHW/dBF27ZdNPkfB3btOsBsxsQ8rBmIbU7o8mdAZzKmqq0Wo81k02nxbafHJUKX4HvNOxO2BO9r/9PWJqeV8s6FnW3S6C+kHQk+2Lb1dnf3RicGli0biHmUvpH7DbGSvmCyCQS5ORnFuWjASocL3Nxw/OSON+ZtMpvtXWEbl/PiC8mplBh0TLMUz/NQF7pQojHv2hWCdgk8yE24PKY7J6JTq7+ltSgV1tQes7eqSOdUqSwwfW+JEpDJFcVd2d5w8eTC5T453yaVxqC1cukA7bgwDDGfZNoEn2SU18Z9kuXP9EnG1uy9MZ9kCfuBYg8YBriuN30iabpLxV1BCYjQD1QGZYrRZFefd/YvVl6YauAkEk1yi9ZZyKVLuCapLze6m7NEb81tUBsXul4oq7YQ8ZzzjbgGQBezNYA/c6vnsFFnZbamlrCZ/J+5HJG7NZIfM+62kXLSHGyEoVtSDi1VSOWkAMQJvoGdPjuHL+hivvv8+GZINgzqSK4MPT7psjzI6xkn8XqiLz/P/B6huFub949O7G9s3L92dF/zZHRs0+Y1I5s3jXM5q85NNcslUpt6w6o37AOdVtFVlNY+o2Ns2X/zzfv333hjXvQZ70KXtddHS2a4jxLsgUla2Z5ZwarUALeIvQWsm/oZ9ykvgdlvCe48yfeCyuUUtgGdbPw5tlSTl5OZrlYlHHwTXu9WCKMMk5H4oi5uCA2PXAkYs0NY9Ga7R7riK8GrDkg9dluWPHx+qPH8sNwzrMhKs2QpV65atVKRZU3LUqwYHKyxpqtHbhq55kljusWSrh66cWTkxuHUdOs+s15vNly3ffu1cDGY9Nds336dYCvsaW4lAG8i+Whv0JEGrJuXzQm+sohoJAyav180HcWT3tzc3CyJnFmOkjMgY6Oj4INJPhN4ZmcE/nErz1qjqLBnSFefs3VUkmFPc0oGd6yoqZenp6VlyILVNUFZhrVE1VBNU3Z8VVtksmkvP3v7Fdo0o9GmvWJb76gGtBNj6ujixeOpBm1W6rggb/mfSXAfjpOEybnBHU4dJ+fa8kFpX1TAJSnqqjll0nIqU0rRmjXHo6+GJIVSkaTcgxwtJdBY+L5WDkiqKKj1wymg1ud1JlOlUjasTuVkMr+sy+1atqSro7V5QUNtTWV5SVFejivsDudo0RKQRm7Po4IoLC01CgaA0LQKvsKPLxfKeVf23Ecd2c662YaLhb39Lq+M9tQFshf1lcoUleEme1lwXY3FmmayO2trxledX1e/oye7PcNlKkvvGxgfy6ywDqRVOsbGV/Sll5pdGe3ZPTvq685btba1lf9moDw9vd5uqzpPb0tRpuj0ele6t0o9KRu8b8umO/otxpDWcOMl+2+z6J97zmC+bf8lNxq0IaOl/45NW+4brK/HNq8GSnfxW4HSDtDUDgQvtVqA0q25QOmWPKB0dQVQWtKxmCppu4bOonUqnZ/Y+TFiawViu5x6HSgq3e2LUHGrqgyUFub7sp1LXUt1Dr1Dzc6jS3iipVqdIBsT6Y5OeAWKB8QW4E/aETo/3cUtrTIZ3QdUL5ErqsIhoHrthN1ZV11tsUxsOG/bqKvSmmHJMdTVd4VcZfawvdzV1N5Qp881Z1qrXKPbzttQ2Wuz9/Bb0+0NdntVaiCwwZXuq1S7DfYUpUqXfeKDKy85cI1WHUpOWT+2eqPVfust6daNq8fWpySH1NprDlxypc/l8mG/ZOum/HYYrcvIBcEU9OctLc228EpZzFEB2x2IBum2JQPFcQmcTijkQMbsTpjbKJVeJYwz7lgi2Z55U/UH7Wo1IeoydVlhQV6u06HXCTubtFqY/rAZohv9xbMQ4E+7PMvd7NNYVlg0lgGLxms9s7VafrtmSQl8lmhOHDizZVugkbBu+xMAtpjsDaoZjfI9DqNEpogRKYvhrwAisU2Ug8lsuUeVpOQVCtwdLe4O8MSSKfacIl2MUMXq4hyf3WY26bSnIJT0tEvEnQl04prOZL34JzEq3XeahWN2QlvDjbMT2tXBigTHqfEzAmz9kllp9ePGxVweVHv2YlHclSyTz/DSJp5phemgIM3oLZXrcjyuxSXnHDjnUmu+fuD8G1oWf5P7g8nQqTHftG/vTVJ59EdvDt6zfuM9qwQ/Fhr6FIyo1vngyT8VPKL5grnhYeBU+Xqsadam9MW9fT0OvyF84b7Q2ZxLq1qk1MBEa0iljD725qVfGz2/itl8inL53A6iJ7KHkhIsIsetIjPLyD+uGfiq6/LRK5xX9Nf2X+H86pqvuq7gdrhu7q3q/U5fVe9Nzlt6q/ru763uI4rJX0ylclU8cANoRzmkgjSTxTBcbiHPs70CRxxo+kvCUckeV7LSKZdKZSqZVLUnS691p0pT1AZ1imFPts3qMUtBoTMZ7Xu8mVx6Rjq+dGNrGwoqSaKg18rWaahKR0EQqtdZqCGNgtgyrSP2jAx7P7HbM4ZJhj2jd2RkyZKWlsrK3Fw749iRLSNbNm1Yt3Z8dMnwkuHBVSsGwstaFrcs7u3u7GhbWNlc2Rxa0FBfW51bkQuysbiowG/Psed4PW6XI0NtU9usZqNBp0FehzHPJxdcdfDCgOYWJtHSGb+cM37xp3hGT/FsZpkX8TW11Q2SQj4/IytbQn1cLfsp8ePPyaIZT6+b8ZDv5mvqqoJ8gSQ/PcvLn3hiRlpu54zE0T0zn94cqAuWuHRa978F6hpKMRK7Rl8rqw+WOHUad+wafRETO/WYRrh+K/aIAI+8EH2by+bL2K6INOKGSVaA1JNW0st4pCVNCzKoogxfGLozM2wmIzQyT2priovwPVkHuuidc78JIa0toUa2lQJErGCYMLaLQopOIXE5VAp3vLiEg24ijdCFvB4TmwiBRBccR3orpGbcIAHZMLEbt6AsUJllfTKVzxC93daQVq00F+n4krwhdxXNGS880VOyNU+Zv66Q35+/vqB4q78EHvsgXdXkK1XUN1HoyxuiayFzFZbCl0EKJSS8SMxfUIxJkyBP9JlYNVWx1NG/QP4c/5Cr2sJqhWKXQ01QITt93MQT/mbgRw/pCC7KpAoZO0zH3pMmwVjHkXVEAYqFQrkGRXf8uL5aTYnao/ZkudFUqsWsSU0W9IkUmqJis0VmLlC056iviB0mcyccMCvl6YUjPdJeaWFZfrl0sSy8vXMxTO4k0bNHl/C4/e+yNSMLeb69s9zjLWvvPLHgcXpJeke7dfIBmFGe6+xsMnI9k5dG/8b2Urdyl3GfAB4u9MyUbuROg4hvBiIutcvpyMzAnbpnhoiIh1zAYtEMLBbW9UG10WMbF4OUyty4soFb3dEhovDOo7TOUFKYGm2A+eQvHe0Z9MloSXQSMDCLVrL0IPXqgzVSXCQX3UCKbwSVjP4J7wLx7aTFZLAZbcKCvmfWu8AE0/0BPR5tBSXth3fdNbDxgsDFV/ysre3xkfHvD3FPDXTtC6ysHtnCuboGonujU5c2VYpvJ9OZryQGj/B2cg6oEuAx6AkxG/U2g004n5qVCI9oGmX2y8n7r7vu+i0b1u443tHx5teuqu1o4T49NxSNdra393P1oXMn/y68nxRsshQzWwzp+D4BN+5IeImMh/mVFA/88R1SyjMnlhMzTPx4aZdOY0/TpOvSnVqvDDfFoZ83uZeBohXMuwv+SdkBYK64pKqqtLUotHzg8OUXRZ83ZmlLKhbYMx4bpJ9WjWa2561KQeckm/+H4xpzF2sr8y6Lvpl4iiwNZNHuoNGb7clS8TDMWE0ckVrMDELxUJlwSkw8xxTfV43A5lJ2qAwfYKLYWfLZafqDZrsNj2Hb/Ha/NhXfAaKWoYht6hddZE0fMGP48jGbuTFss+li4VxZeGGKYDe3IKeirMFZ2RfiFoRNuuqKOrOpNakw01Cu/pN44mzJ2a72nCUqeoydNZO153Sn9VWOjaFWgi62/sHs7ecHc6VUNIyNpzlkg4LsILE9CqKqJ1i+o2jfjW1UREsW9B/RJ44cGWhr457q+agr+nPmTkI49UtvZWcL5i7dN2/pif5a6a0f3ntvuKODs7Td0fTOO03vsjffMmajygHtpktiZ1DQ2ZyMmqlUJhE3xrqJRI4HRsg6cbQQuSv+qjYXN1Y7plPJiFQmHZuZGFvOKGxWV6vE97YO6lCIq2u4KxRoET87P8NMPzUaKlIH6G3RH+prbHfc2bSzq6AhPbPeNbBqD62WctFngF5/52XfuW7TVS0qVY9Kdd7Oc3ez99fJ7KSVg7QGm1CoplOpREt5qQZPLbOTuCAJ1yXSUSr1xr3D5rJzYw7i0Gd5PO44ReeGkVlldmvpnX/TunQX7q8eqc2uspqrXQ2hJf0alzYMVL+Vk+y/dnhXZaq6K0U7NL5uDS95jbMwP+dN/NnMBlZlMGDQqpMVIHHw1S7I0n24NY9Za4WeNpRwns1IjDp0qK7V4TErSvXs0AgFQlI3paUUzcbw7dF3XxlcVhJ9Z1n07QmaGX13lGqXUS2MIfdEX4l+/DhdH72ehS10RfQeOoBB8LzeyqvYOfN5IfKdDiKYzyFEPEDEu9EgD0Ck546+9MDI0qK3+94e/eCloef7XoCx4MTT0eijVBP9gAUDlURPCIHtIJvKYjboysn+YGYalUitlJe4of3QG3sODG20hMpJMZXJ5aKM8c5j2WT2CiLaroillBOZXDY2RwZ8u5USKC0qyMpyujx65AEp8xtxBjbsYnbvBf9S1JxhLxn0zG3U7vyt1rzS4kybNk1n3WEtS6fa1FPbuOtfn2So8vrLFJVSMzubn8XO5lcAlTJmUwnEJ/CDggChFDEi+U51+AsHWvkwkCoXLTd74kkVBAoYm/u4WH9Q5fbYPG6nO0uvlGfmmWNUOu3Z/plkej8jPacjfZ6z/mODltwEMmVwqap5jv43L5bpq7Pj9AFdj7sSepgazxWmKCge/xCYWSbl0HAt4+VpkxVqosaz+Do527wx3bWgT3Ero09NblxWE/3RwACtgZ50d/RVsSdhtxL6z9KpFi4D+g+rL1nBzFB0xHbds7FPIiFD03vCoD7oOLrYrnueVaUvxS5En8r7KBx+Y+iNHww89hj2EOwx0D+iv4qeEK2+rWe6U0EwT69JBdnKcwrQ8PEgE1MJJOylh1SwB6LX6bV6jQzY2OMOeFk1uI5VUUqN1O2lgbq6gYG6uifHo8/TwMb/vOKmJgGr0N0jf4g+7Ire+Wrs3L6U7bsoCxbDzDo5SS7hFac0bgBKmg7rjh02FSqVG81urxEBWRquDG4aeuaV8d3BSkQwePPi898q/8dlK+9qiH6AdaaI1hQNpCZYmUoVUqbiztrFJmOoJuH7aa+8i3mPNGhjLriY+YvEzWtxG4tLlgysXh23s5jdvXRp92UJphaFM8aAMWqEoH8lK6QwQmB7QuVMI0SL5vwgO+AtnHqaPuvNtEEmFVEoCuqgULF46u3+hx+Gxv10/CMcmj8dWBD9ATZu9M+sqVctGIDa5VD795idoLygLxnKJszuC8cPsr2P2QmbC5ldIJ0ONxcqOcayTLHg7ok+RZs2As/eFRWZ9mrGsbt7GMsKuxc3MEsVc9bhm7sOGkfECbI9/ManY39d9m1K34QmnIy+y+T5bxYyUS70weeZFlsUzI8f5JQB7WTyNcKWOY7Od4jYzUwYiEertdze/ujV0P229C97/PHpvUGT+6IfC72vlRPOKs9Tk+9UNbED+YLpB6jJ0RN9KRym7nD3o4/iVp+XX2aTFtHqmjem8+G5IgkVrfAIxiQTrB3P0MpE62tM62P2JDdH7xqIXiOg0DO5T7AoKfSy38e0vpPK952qfDwrYnTHLFe4Kf/tcPQlhH1htOj99wW9jz/BdtSchW8WeVChJbyacpIUPLga1/vQRySuuEul8kHCNnrhxLEzdjSSqeyOeCoOBerYrMQSGBlwE5quzOMpZi/r5teftEIrO7khfYX1hjtC53YV1meAnte/6uyNxqrU/uj3BugUvZjnv/P1DVe2piT3JKecf87OXbwkeoTbNbmfe0rQ+fhGtvMlFAwiZjbALBWQUjPMZqPkOxklABYUvmzXNLDzansCtHKNS9OytTGwojKr3Gwqc1TV9iyGaXU4Gg3TB2kxJ6k8fzxR7ZNIX8VT7wAkexP4HPcK9ywpJQ2kK9ieDtBmAL/W5XBSuVIC8yfQVUkSjuIdoFfLpTL5OrYjmjl1j723nt5W4fGCrpqVlR17LSpnp7WNsTdpCU54EtY/p32pif5FhBdu3K/cFY7ULHN2htprKOhyWxsca69uu/EOR7XOoiox75jYs95s8uUXLS4rXVyyojC/oKAgq6icti/Y2GORK5K7ZbI0s1I5cOeGyC+T5B1S5S2XXX2FtPhg+7JNpcWbBvuGR7pbz812nCe8P3yNWwX6SwmpJ18P2nAWAiKIVlFO7krnJFwOkMQNUxJZh+BhNIfwSioH9WZd3H8BW/dlup2/M6ai+AXblvG0EuhEMDGZIwsuy9vKSikprS+rz8/zepyZFhOzM1pCS5JmLxmzJZHEd3NzUlnqmrZ9SZ3pOWp9UpahpyGzpUpr4e2egdCCpVXepIzUDJvKrfU0pRtLPN2bKs+hSS53ltXhy+RccmkrL9s8VjVQKqWO5dUrly0ebBq2SRTyFonEqFOo2s5v33Pzj2sCxe1GQ3tZaQ3wRR3oy/3cH0Al2xA0qwBTawqwdhrobz4q5b2gGkrj+79EJZet4DNW8ncyH0RAvlwJeqpGL6xSydgcCfHkrhLG7qysHFlcJxaY6CQ7rG6Xe6YmvMuVccEF3Tdt3roky9lbtP2S884rXOLzLa3hOUtOXL2zVWaYfnzdxrtX5XakWm7ad+nNbFuyoTKm1LF3AVnobYvkIq4piKtaxDUbcPXMhWv+meKaPxtXj9HtOQlXkScScJ2Jaa4rs2ekcevCnA6LzRK0f7Ozwx+y24K5M/HU7T13zfnV7B3D08MTupQudeoMPJUwcjrZrmPccywBPVIiXYNvmGLz6/kOb4pjmZY2DrwM4h8GS25Xb+/kczBMUmKYaqU/Z7uJsVQ8ms2twV0kgs3yhDWFxFIpK8/NyqY//273sp77Ocui6G6cwf16Ucw3IbOiW83kFJ5MPcHG4vRgWqqCi3nUpmz+mEu6rDoNL7fmSd2BGfZqaG74dyvPSrVLpbI0zZaVv/vgPS4t+oKv32oN59DsyTdju2jKmaV7pmVLQbWmuMAtxf3QZK2w20d86yZYUhE0MTZKsjURwUwsUwffu+6690YefWz4vWuv/fduC300egcdjLbbu/89EQsj2mzRoN4H9RCeaX9rYSAWjwrnctM212JrMHx8BSYBP3rit/v2hy878NuVm7VpconCptuA+4lD998fAtXppYIup7O3kGYyK99NzApxKtasUsp4CU4lppkAUaSJygybgsfmEcLEG/VNUGV0JT96YlC0hvsYKk7loBROW8R9gXGFDmYuVtZe89Xnm78+r9wt2tbBictPfddct0a0r3Nl12OP/fGPMQs7v4Spi8DXfCvDDdpPsDErcLWUCv43cJJ0CrsyAnuLKuFHk68/wyW/TkcH+mNsjvZsBY0QeJ37CcNKqEkiXzJdk+8z1rQx2ngT/eb91BDufRS5flH0PLRgE41iTT3QXg8ATmZcOTEB0ZiLN/QVzhMpL47da5juli1u14J7ZmKedodBxR4muDhkjojYO0quf9mygeqx+tHNA3VNNatr0GQvzjw9BuuqME2PflBdZdIL8882aMVBwNeEUBhPCYVvGgoTMblmQxEQoECjQ2zPA6fpXt6Tv7yub0V4oqQvDw+DR0889n66c9nC//zpysw09ALag1uXmOVsmKtZjJxEKuM5GMU74i47pYRtIQAAxDPeAuGtxKrV67VGEQAkgdzIXs0KVAAoyhkhVrhasuu27BgILqrzLsxkJwXcKUbp9dcMrEBCVFXfd7dEr6IrGS0AGgWzplUbrLKaABrgan5ecHzT4KSRNK1Or4+DExDAiRPELMAT4BRhe6WjRqLsC4cHazIqM9jZAL1dsWsbXd761OF+/urLZTb9m2TGfD0nmI32+WByxids+2I2rYV1CD2whEYKPUuPTqhiNgNETXl4oHpjRYwTBmDy8CJyQfQ1qqmuMhqi95C4B8RPQRYLu85sU5/wRtA13SB3DwSTcKdDCvMf3h5RsTUhqVwmk25T4HwJl43W44EwMqyks4Z+NMQDSUEZ3XPatP3BdE8WJT5vVq4n15lpSzPqRd+ebuoWN/vO8u2Z7RVde5bi1q/SUsGlpxOUqPfWX1wz+XfFrl1NmwryNvfcdk+SpaJFIWvn5eVawx37h89W0HtWcc8O3DpRet4lFk2fxvjQzQ0Bg0slz9QW33ZXz/nnbr0Y6GCa+oQb55yfhw75n4EO+fPSwZGRZjWcAR2yE8lQz8XIcKBlTSB6Fbe8u7ojN6enYvsVkmCzQrpQIitNSlowWlXfJqO6IOes3bgoMNyv13botPsupOUVOkeS3K4t7l5TuLCrvXmJwBFNjCOySQHo3clICX0KN02KfJg1y+Wybbh7ex9o0bjeIafrk6lCIZzKmsUXBZheIZPvObMM/cFMn5eSvFxvga8gy5WRbjGhpUlGlmyarZqDLNgBs+flkJks4h0OLd97UDnNI5q7BR7JDnPP9t86Vs6YRK3nvvcD9QNXzGSUjo01jFNaGad4QJ/eH0zOpFLiIJxMGqOPn1AFqJzbCHABoMvhehRHgAcUiukXWLEZhg3ICckVlNtzRun7g3pvdm5Ott/r1xpdBleWUZ8M0zpp9izGONnKLBBJL/LKyMB6Ps4dmov6E1jH3epfliUwi0R98ZZpDtm+Oc46mlTuEHcNskvMyzvT7XLZznXmo4Z5FX+R7QL+gHpBWWQngZOFXcCCvVq0i/oP0S7qMdH7koy7BKSgm4wFdRkwS7fCvBe4T5KcsP6QEZusy9g2KnLS0oNt1tLDdDpcdUgyavUej8chx5cRcy05xNYcULpWVJTSXOO37lx4XldBfUZmg2/J2IJtba4q48CAudz62w30/Luv3HxlM3u7tHtnz0SJQh79L5C6t6U32N8R1pySOTWz61MXrLaCJEDrwQpKeblga01GOF7GrRN3NMcNZgk6sFaHSw5uhNQzz1IDWy7N4Dh13WhNVoXZHHDWdq0K64oMy5f/efiVti316cM7q1LVHSrd0MTa1XLpc5zlxInjtOJc4f0Sd5h5TBsJJumBh3WUYyxsZHY+BWUAYJINEvaqEpcTxDFIsPM56zk7lylOnvyM1GYPmrvRMARKeXeF4PJMzU1jUo6HwZzcmuGFE10Dx5QmU3JKdgNoGCnJdk2G2yBXmG1qur8H9BnuvLZvXVcWWl0kl7ZL5cWLsrKvPYwWT+XQFxcChQ3kFmFSl6xmbn3QhGK7DX9JY7/E86d2BHxxDHDc9oCHAGKYCScDZqPvOw36vpPRR+Pi6PVkNv6xWWCFkx5fGeyvC9+mKuyoSteqUssXaGioLToJ2uN9R1bLQvwbf431ir3QThayKpgU4x0u3hukBDfEohN3SfZJLIS9QUyA8xVKxqbToaBNQnVWPyePTS+tcnubzu0qrMvMrHevHBRXWFs2f61JpepWqc7ZRZWxldYYx/uY/eFAsGQa2kQw5+D0eaGYXnblfLiUFjAbA5lVddH/Coepq98yfE55akpXsq5/4jm2CkvEFeU32PyBncUF3VbGT8R0W+FErtCMojavwVUxsX0ScB5ZNNEVW09GBpxeUBbXki+JryVTPG0rmxCPMwnrsAo5FzOpOXPiEDMgzCoUl2LDK4MD9eJiLC4kP4q2hIVZQz+bNZQEC1Ffl8X1dU4ak29rxBZl6qmezRcYxznZebrA7OlCKde/fNnihPnCwONU9ezccwXN3HOFhLpjc4WYbjxrrpAIQuJcYVln4lxh8u3HqOTuGXMF3IV1OWBuw/lmMm5sYG+uBPIKTgOlsdO7kMiG/KM1Y6VOnpnUcIvuoIRmZTuteHrLuxKep4svfUny8iXDC9d296Mrr/e4bWnNjeZoi+gbik2enrCEGg2TV4ot/QHQwYwtbVApeBmz4ChDz8hrBLkNilHMphXM2HRao0nA3yPWHbdJ7RbsVHMfQGt38xz/QNu/83z32fd952zW6xNtU8MMCmLRkjnGV+ZNkHkWc4mexW5n9wumPqGvsFG1URxV9yWkv0JID9PptcTOTuVw8VM5Qs4XxJwysva/RR/yfIDVuy9WPp/PueD3PYTM8F2bLcJxfYKf+tdj/usBjoNsnlED9+8GrRL9FISCQQmaL8QXSh3TZ8XiRgKnzUZzXegjwm6zZFozjQaNWiFDi8yxDSKBGSvxwGSxA2MGk4l2hLYW+Td0b72hq+3Kdev31nDJ8t0jI7vl0aWg6e2zaPs0ppV3n7XlrhUr7t7i2rVv8sdfOad9Uw1ggF5bJxFTKngJZ5AjBWlEpGDNLAoKOYCCmAMp+MG0JnRFTBOCfHfOOg8laEIviJoQ5BtgFm/Qwx7L9ych39TLs/IJVvcx3wkh3y+xz7ohnxZ6TRr6k6dUIjVTIgH9iU+Ov+XgUC+KeSDMjitOfirObHVZnizh/bYx9gY+UetwByqcAfrXv+259mvXVE/kF24uGR7aui70LholaD0uGV2zeqfW1GeytoVC9Yte6wGY1FMa+hvoP/YYTFZocxii+ZS5YfIlKnPw1E7seKIrBpNwnmkuoL7/YtNZjQvO7a1Z7XCOVHcObVlR82L0CGcJfiwJDC9q3VSn1/Ro0vo7l7TX/bVt2kPfcsFDH1D5SfIfsyzWCHZn7hbtzsjIk7un810Rz7eW9M9qHSHfC/F8a42Yj53gZPmKxHxjs7hIOEWJ+XqEfCnxfNyzwI298f7lZdzZR6bLvRB4rzdeLvqQ5gUf0onlYg4sVyX2Z66dwfPRPFwmWArGfDohH/OuKvhOXS74TmV02z2LboLdwbsFu4NIt8bpfFfE860lxtmnA1m+F+L51r40nS8Sz3f4pF4keKyPxj3WH16B+ZivLVbfcbG+rFn5BJvbWJ9KqO9/RP2B7dpTosUecQWcoL8RaYLqJNirwzGdvfA2OsXVOdyst3TpAPdUz+QfUWt9SnzzTG9mVp3nKNE3T4mxFXV683vdy3tiy+mcReTADxhmH4iY7WeY8QkciFasETNNTK7gfsSpaoaZnfQFu2MWn0H+Knm02ruHmVzhlRL0VpqEfuHHmY0HIgoKLx7Pnjbdm8psxIE4tlN7cqKd0EBA2F7gFHYxGtFF+3X6zCRFmqaov62N3oTbGbuqfq6QLOJlZS1sO2PPR11/vjqI9qkUAOOtTF58Rhh9nxFGttLvFPdCIoyXiDAu6+igiz68997OOIjvNL3bdkfT3ZcGmadayVQ1N8ykbEswZNSlqiSyuPlsvgMtRkhkMJencgaewDTiHiK0y2/QazXqFAZVwg7VGFSJa/MAEz0uApWwSP/DBNrNWqu/WoBQBxCa2drmmULoO3MIE1fzEcI7RQjzp5f1r1kUh3B6df/Ipax9QWvjWph/atDsUAdIAd0SzYqApiCREslaQb8TDdKzbTo6QUXXlwqEgfbSMzq5665/YvSBB4aevPGbz43/6Imh526ld9Cc6FvUGn2uO/pdRpw+IuxioVPMsuwp6vTNXacXUZVDnWbEvMJdufd2xPGOfQfuHwWMv7OPlh976qljTR/98Y8foZYj6g7MWxBoOUYY7QzCWi4np3GXTGx/3HbmkwmHuq20ywJajiXDkmFPm3YZpBDs+81Ub9yC2sMLyzr/6NyBHoOaRgN0C9ffwzwGBWh9qGGRnHPV7x4QPAYFVgwyj0HR7zct7V2ItvPoAs5AD57ebqmeWTs9ThcsWoQy9aKpVHoP9ylofKuuQbmyajP5XBY5TSbBxKc7FqE5Crua2focgEjQWqiWcU+V7a8u31OWLF4QKC/9JTfCLAfKBf/KCqmcl0nRMBgzQrOedikUEgkhimRFcpJSIpfARIEho8RqgXucjI1Kebr/ooE7ouPw7xwIaJAwGo0F5Bm96PHUjCexY+JEMBfPUY1gaC5mG5Vt7NrAixMArdYqTbHmlQbk3goWBDfmFWY5Cx+dnXUj/L3Mmf9LiN3VE1g3CuG57u67egPrxiAcFXf6EJgHxKwk0k2i4U3BSmIpjA/3h8Nsp7ABxr/zSC+0hzOYgcSAyRLcvpRNTLYwNUpGZFqtBPKZYVoEnGy43Xdb7Tm7PqALoj/++GO0mUkeIodpNS9nNjOfFOzyPSmMJo9PfUQryS4oJHUHEexr0t/Ab7SsKYycqWx+3USO0YWcHC0IPUTx5FuFVtpEJceo5xrB6i1NQ6u3RM30llm/p96ERhhldh7fIt9idh7fwlLxPnmStTmzGUvJPmYzlqEVZ1OQCMGLqu9Am5GUE0vjZEJptBnnpzNKVaKfO+kL3B+IimhATvpIOUDfRcJkhPxWWCaqNCeZFEZ8z2xVW6QqqUzFzHqmSOk6A7Nkoed1zBaoNpVLSeGGk5XoFIJZAw3On1XPLIIKBeimLYKyMuTDzIYOswnaPtDf093SXFmRm2O36bQpKZQMre4fGRhZtqQ73BPuaGvuaulqqKtoqmwqLswpzy13O20+u89i0qbp0lI0KTD0gfhWUZVtWobMYyRUfCSaCZ3311xmQxMMiJY3OTo7F3a1cWnRHe30iugFaCG0Q1IcaHJ0dAZCme2TV7EkZRCl9yVEWboTn7IL1bEL94fq0QWbdpy7fsMOZli0squ7u+e2W/9UPRbctKNmPLhx+1yxUGdPd/c3b038T7jJv3Orp4a5KEkCbbOOnYUrMaiVPPNVw0QUcNRyQVaxLXSUdCeDqEk2Jhs1qZAryYACi51JxDNteN424I7H/qYpNpaYyguSu2MRLupamq7SVVVrk+IRqCIa4KqnbmOeXwcQCmHDUjqogpQ7i+CQsBXGZp4uB7j4IdzlxPfg4h1600E233fSU8GytY5oXVkuqXhsksrERhaW/7HxotfwRrPVaEz7E28yF5rSuLUmS5o1zWg2l9iMAFclt2bqW9xLUFA5o04ewZOk/WxRlBm+wiGK7antpQQ9fyjlUgk6v8QTs4wsJXi2pkwwZsRs7ZQfCdQ2ZBrtzcsrFbLSvkXcS4GAJstktzfY06HGe7mVUw4+iaQQC6sRVDSOvYo8x0XFI4ZUNPMP3GU2ZkfvddmLLJbqndzTdrdXm6JMses8WNJ9s0uCDiiUlBsriTfEz+uXlpheObfaYimyO7mn+9I9OjuUpPWizeuphTCmfY/fBuNXjAroX4FRQZieQjPh6i/lgAqJlgISqDDLWkBLonmFOn6bYCYhNcD86BJeSqv4fZ/bCuutzT2KvqQFwaQ+eS8vDdU3NdWHEI+vcKtJC3C7FMd1ZlNOHApQZJ4jeF3U8UAbvTdQajYmf23dELf6+qTrVISb2sFtJldwfwSYzGi3XcpJpt0lkK4UFXrEUplTzILtYUScT7BbW5oQX2G0240Gu/1Ovd2uN6Snc5vT0uwWiz0tLXZFq+fnAeNfyr2KdplxdzF2QEL7eeaWgFVOSa9SQUlKsiJVmSpFXwZymQxrFVwtxFwuLC0qKtpdWFTInVVVWVmFASnxW6DETWdCCT5QUWqUFw6uv5Jbrbou6XphfxL9G5UQC84uoCluICfIV+HeZWoV7hsmwsdPlpB7qZc+zrVz49xB7rvcm7yaL+AX8Wv5S/gf8a9LPJK9kv+QaqVbpdfLONka2Q2yp2WvylVyl/w8hUcxqHhYcUKZp1yuPF/5K+XHSfakzqTdSTck/RaoW5e8K/knKoVqleo81b2qZ1NcKZ0pW1NuSflhynMpn6jT1dXqUfVLqUtTb9ZYNZs0T2qD2v3aP+vW6R7Q/VpfpN+lf9CQYdhreN5YYDzb+LjxXVOFach0h+lXZrW50LzV/DB8X7UstNxilVtD1u3WybRA2pO2c2032n5o+6m9177Ffsj+Rro3/UD6AxmyjO6M1Rk3ZvwiU5VZkHmzQ+142xl09jpHnNudlzi/7rzH+YbzQxfn0oMYCrhaXMtda127XE+6fud6zfWxW+o2ub3uJve97kfdT7lfdB93T2ZVZT2d9cesY1l/yfrUw3tSPY96fub5jedPnrc8H3kmsxXZ+uzM7AuzD2Zfn31n9v3Zj2T/1Kvxbvbu9u7zXu29xXuvT+Oz+Xp923zf832UU5RzQc7Pc57LXZw7mvtwXmqeL29N3oa89/2l/q3+i/1f8z/qf9L/j/z2/PX5kfz/KnAUXFDwUMGPC94v7Cu8vPDhwv8uSivqLfpG0W1FrxePFl9T/B/FH5dklPSWHCx5umSqtKf0N2WpZReWvQXzxN7ADYF3yr3le8u/X/5k+fsVPRX7Kh6oeK9SW7m78oeVf6pyVW2vuq3q6arJ6uzqcPWV1UdqSE1nzcM1f6ultRfWXl77fF1R3da6n9Q9Vd9Rf3n9O/V/a5A1FDcsa7i84Z6GJxv+s+HDoCZYGKwPDgW/HvxZ8A8LlAu6F2xdcFHjgsZw42jjrsavNU6F8kK1oc5Qf2gs9IMmaVNn03XNjub7mt9uyWo5q+XxVm3raOvkwrMXuRY9vej3i15sy207p+2Z9vz2+va29ifbn+kIdFwLwzPturbb1b2+O9L9fM+7vVf2/rVvSd8tfa8vLlv8/cWvL9Eu2bPkD0vTl44s/duyS5f9aNlHy/3Lx5ffvfz1sCncGj4//ED45f6U/t39vxtYOvD3FWeteH1l6srqlY0rz1p598pjq9JW9ay6dNVjqyZX167eu/qpQTKoGLxiSDt0x7BvuGh4wXDn8MMjkpGJkaNrCtectebONc+O6kf7Rr8xenT0ldHjo5+OKccMY/axrLGisdqxq8duHPv3se+P/Xzst2PHxv4yXjF+yfjXx28fPzT++Pgz40fHXxl/e/x/JiQTxgnHRPFE7UTnRHhi3cSOiUsnrpp4dOLViY8mJtd2r7197YfrGtbtWvfAem59xvqc9avXX7v+D+vf2ZC8wbrBuSF/Q+2Gpg0dG8Ibtm/Yu/HcjT/cJN8U3DS26eCmn2x6b7Nqc9Pm7ZuvZr2d45/bsuLa6wdTa/9G5Pzb2Plf2vN71CPJa2ue+MHktdHzkj6Q5DFNmBOEAxcmq9lRtRSykN5AFnD7iJWrJfV8Aynm/kQC5FWygPphHuYnGZyX5MCzEtClc2gj3FNBnh0kCe4VQ+iHUAQhH4IRQgOECgh+8XkJS68imRiHUMnuPUhU/F5SzV0IsBwkw9xOUse9AFc/BDmEo/D7DTJMF0N92qkHuQ1wT0WG+cvh+ilcU+D5KvG6Ge55SCnkTeJeJAOAG+HvJCquDXQFdJRQS7LpItKDMMPVyn4/PhWlVuLjikkBN0GW0lcA5gkIZaSChkkqi6+H+xzpotzUf3ImFl/K/xtZivehbky/FNPRW+HZy6SUriMaeNZNT0D9OpLMaUEPicLQ/EfQ7s8ndqDj+3B1MPxF2kN8BQS8VwNBjWlgLKjhmsjX+SAppmPEQScBTswDtGf3Pp6apN9hNC6hq4kFgpbhsgXguRLgAXpD+6nhvofuZPm93DvEBUqcCeiVCrS3MLrPEfitU1OsLfxiW4iBtYMQKIQMaKuMWDvMDgBXkF2xLRIDtgW0GXcuwIl0nyPwQ6SAtUXZzABtMAX074DrUQh/Y/SPtcPsgHwmPO9ODNgWrK2xTe4EXHYx/vbRH0P4AdA2ADD+BdIizr8CXpmE64WkFnmL2oEGdpKOvMh/hIcY4NnTwG9b4bqWSAG/Ye4CwG8crsDPLO/z8BzK4i8DrWkBtMHHcA8D5nmMSBgvvwXhf6COl+CKtNkDceRjKJMvJmX4RpN7He7fQdolyaB6gfrF3U+S+F64DpIRbj/Q7C1Wdwbky+eWkgDQayl9GGgzCOV4oW/+N1HQt4mL2wT3MOghtKPWDtdxCH2QZjVchyDfX0gR/S3wyCTg8irEp4iSGyXLuE5Sy19A+viLIN0W6B//DVcnpH+P5PCZEF9A3KyuDUSKdbNy/gB0Zf2HmLEP8Sugzt0MBinCwOrAeg1Ar+/B74+hDd4WAr15KkoegNkvhr+TTLzSCTHcDrKEgMwipBb4u5M3k4WSG0kxeRv62Q0QyiF/OfHyJ5j3D8LaE+mO8AH+/DeIlTcSHfctwG03UfI3wbM3AY5vM1kh4e+ANlPB7+ehD+8hMv4o/O5lNMugfwa5lQV88j+km1czGVTB4WEQtHItXiWHSZ2klVQAP9Vx15IKaLM6/gCpjte7F+A+DvmGSSkhk7+A8AKvBRiuZfLEDO2h5MbgN8oXHdDuQaLgkFeMAPsB0PztwMfAT6xNvwn38yEd8pSWXVNAVim57xM5tJOO+yvcvxryFcL1GFkqcQAug/A7GWC7GGCAvs76m58o6YvEgH0U5Vf8ei7IUB/R8auhzD/A8x+THqBhG/BvD7QdXoexHwJ9bNyNIF/EK8oKxvfAe9wjkKYIYPs1wN0OcGFfQT7ENrkerljWGGnjvw6//wp8AHmZPEKZIF5RLqFsYG2JMuE1kJFlIPPFa7yuGF0WEjf9COTpxwl1YdsL40ZFrO3ibQj9CHkZ+x3jy8Qryg3of9gHoD2G6SGG7zDrA7H22Ql0ygZ6t8GEDOQ+g60W8PCSi5BnAR4v/NbjGEKvJAY2Jn5MHucscD0LZpQ4rmJ4ZOpN8vbUm9zA1JsyBckH3vh7NBCtjN4bvW9qISFTX5naMXXe1G9x3JfkR18kJNkyee3kdUkfCOP+9Ie+CxAtoFcxz2EHcUwEDNgVxgUcSwiXDNMYqYTjJHsIGkUmSbG8rd3dreQJ4nCahDoko/RyNiUh7M3hU8zAgETwDIdihBgIzzQRA5qbhquLPefIBWRKQiQqSYqkW9IjWSkZlFwsuVoy5fA6qh3fdZrY238HuR3SUEijhjS9klWSIZiXXOPQOIqENFOvTj0xWXPi55OFJ3524i8nDhNy4mUI+CabvFr4ijs+45n+6BgshBSQlSI16qmTuui79Dj9C32Pvk9H6Bo6SsfoOJ2ga+k66qZZ9HX6Bn2eemg2zJpeoD6aQ3NpHvXTfFpAC+mLtIgW0xL6Gn2VHqOl9BVaRt+hAVpO/0Tfom/St+nLtIJWEhIhfkeELA039zsc7Y8QdW97RLZ4IBwps0V8/UPjjoNLwxHOM/yogijImjXuEZvTGSH9ERJyNz0IuISGGvMj1B9xDI3nRzi/2+l25kd4v2P0Id5gJI2hiD7kGBpqPMQZQo2HPHwowoWW7HREVG6IhIZHI5KenQ9yHAfFRJxjdifefVBtpI12B0TdjQ/qqR6euSOkJzzW/6CJcqxCiT/C50WMoTDWFzGFQmICm2PUEXmiJyLJHnjQR1NCzWuaI7LmsDPCe/r7VoQhse1g2BHp6YFbQUgdqcRYZX+/45CQGiDywS3xlyNShM+LMOUTPWEHUOPgsCOS1BMegjsOfJaEsXKMlQ/Zhvr7+21ArYgqtCZC+sIR0o6JnfDb1h7JwFhG+/AjGrIGUzwiJSP9/aPD/RGa198vYtDvGAV83I39+RGp3wEQSDzDgJM81BOOyN2NEYW7EVoAsgzlR2SM3EAJx+gh+UijAx8iujYBfPwfUQ41r4lIc53wMOQ46DgIdR0qknqAQr3hoR7bcF9/2N3v7HdEgovD8MyGdBFByY/I/RFlKO9B6BqM6gr46W50A7u4G4cj3Mh4hK4BQCLy3PyI0u9AaNWAloSMOLCESHCoH5MMNTFok/wPKtUk1NyY64wzTrJ/JiOphFJoHoAQAtSHHM0H3cPYqIzYxIYNEnHYAMgYlNC07uEmoYqUebJHsiAXsU2jlphJ7WcIPZSiInwz1GJzO/tzgYlT/Yc4rjkyOtyUH9H4IanDEUkNtWEBEIEWimjwVx/80rD20kJBGkYUB9BgDdQc0YaGHAeHHBEtkC0/ovO3Lwkfkow29WdFUsbcO/Mjen97b7h9sXDT5oT7enbf4D9EdKGl4UM6XShChxsj2jzscsBajYdS8Z8G/kWoCdqC9/SEDyH5AN/Gg9DCUK0m1+mGbLG4TXiOWaAn451+wKQV4G+FuzMba54mPESI3g30CkVI/YOUUtZaRj85RLjmJeGIzt3oaI6ogf1S3MByjY6hH+ArOC3Rk8bGRqSAAZ7R4UMGRV7k8jybC8hlAhyNefkRs/8QxasF6I1Xq/8Qj9c0/yEJXm3+Q1K82v2HZHhN9x+S4zXDf0iB10z/ISVe8/zuGP0jsiGgtNtREKGrsLfkR/wJD03xh1uFh/kJD7PjD7cJDx1+EknNmxdPQOr7AqqIZyJ+TsDPAXC5AD+8ugE/vGYBfnj1AH54zQb88OoF/PDqA/zwmgP44TUX8MNrgd9Ryxi20A/VWoYcIPToUIg1KXTCAuTZIn+kMC9SCP2xGLpCq2Oe1nQPV7pRsJ8yhQ2xL4k18SG1rBk5LlKce0hKjc1hEIqIZWkCeeZLU+Z3BBjkAShNSNN8cp3QbeeEBe8T0/fYwNhU7648VEaNiGs50AMQmBt+6CzDlfmRCn+BuTY/Unm6pMDYayB5FTQRMXkcBY5WFAlA2kUHD7a6W0GGhGHgA6kLI1IlpUYDULgaZJcpYoZkEhCnHpbskIo0RpJDeWMHC9wOR+1BKLNmZjJHgVBeROZujKV2RIZQpgR7ww9JHFKH7SFJtjStvxElbRIIbTfL4W4ZishCs7vrEEo7YVSShIZG3REpDKrwWBIatkF8CCXd7DzDABrIf3cLtLEbamjBESspxGqB8uaoxC3IVBkIEWgMKTCc9KRSoUQEwoNA8PBflKTTdQEj1MZo4YC70myRFu5aIFNd/FEkiT1vcbdipdiK9XESIjICpSNkSbjAUQsDOkIv3nQgXGJTRGQe+LUoUXcRGnEubhdby40s35AASSjWXEOo4MxGOdbEQZAfBUjFlog5FO6xwZjqqO0vOFREDdBvF8x42mfrmfG0cc68p8oR8keq805VYZM/UpN3EGBDHgOk5k0KDVoQKYIczQxl5M9sgfLDoKA1Cqgjg7qh+xRAzxPKb/EfSoKxJpblM7J065fFxYgTyrFaN4iqBH5x9otwtoIArs6LUWUh/KrJc7pFuojYxEmwCEhgFLo9aCPQw/UFkXLo5W3z3G+H4qhBH6mAeIc/UgWXTqRiM5Db0QIDb4xaXX5k6EgnRLv9DxLSApEeiFCM9PofpOxOH0TYncWYphUiSzANRpZiGowswzQYWe5/CGRhCGJhiFEW6/c/RIV7AxAT7q3AdBRjKzEdi63CdCy2GtOx2CDW2QyRIawTI8NYJ0ZGsE6MrME0CyEyimkwMoZpMDKOaTAyweBqgthaBhfG1jG4MLaewYWxDQwujG1kcGFsE4MLY5sZXBjbAjSujTfgWexXJAjRrUJ0AUS3IdHZr0b4tR3GWjHNDiGKac5maaiY5hzIXBcv9Vz2i+XYKUQxxy4hisl3QzligvOEKCY4X4higq9A2vp4eRewXyz5hUIUk+8Ropj8IsgpJrhYiGKCvUIUE1wCaRvi5V3KfrHk+4QoJt8vRDH5AcgpJrhMiGKCg0IUE1zufzCZabYRme1BCcc3w6QJxGB/Y15EMRbhs3p2xgbrfAITwF/2gTpJvwZjnSA2zzpE5I3B5Gv3biereheQfCXJZXcMBxQ7FWsVI9wyWYuiWlYiyZIrk8RHV8n2yM6SjZGVki5ZUFLO5UnZI03jgmRXMCOYFrQ8YXxC+4T6CdUTyiBRkmR4aIWHJHjSFx8+irP2pkNZ9EAvdP8DYfw92nTIh78fURDhBgEF+pAXbz2m2EOoJHhgzZLYA/wEDQdlu2XrZaM0LFkoq5WUcdlSpTr3ETp1aUTyVRj3mx6SjspIUxP5kj6r4LuILML1BzRDM6Xhnp36hHNNfTKlgXn+StJO2rla9NE49en0b7zD/DbiXUJWwJeVATk/5SyYl5UyKZazEL71pJ6uJW9P3T6lYdebEu5n0szpMqDc4wmQHBfLqIGvn/hp7tQFdJgcY+WUTJ0DcaEs8Tn3NL2de4UbhhKv5F6hN0B8glrJlYLPDVxRkSgh/jBbY8E47hR8WIxzRE1+KcZ5Uk7+KMYlxEVVYhxdExWIcRlx0ItJiGwhZ5FdZBtZRybIWrKDOEgJKYJQArElbG+2g3RBqh0QHKQHUm4h6+HuGpZ2ATkbrmvh3jayHX77WBk7oMztpJoUwncCSsYUZ5MRUgC5tpBNcHezWOI4hM0Q2w73NpJhiK2D3/mQaxvUMUY2QHyNCN9G+K6DXzkJ8KBd8c2Quw/STkAdWMY2gL0AcCgmAaBrK+mGbyvEYrliefJn5Tq5VMesFMvgF+K5jkHtmFGPg+E9DunOZqWsZZjsYDQ5B9IUkEoIZRAqoOYAGYUwkoDLfFDxAqtP3QK1zfXBc5FTBL1iIwcIn40QRyu7aHnDRdCeTiNwKIV2Ww//dxO0KrqHXA//bwD+oeQR8mP4/wuaBSNFDQ3D/xV0CP6P4IFBOkp3QPwc+hz8f5e+z1b2OGZADQNHOJaOsGccW3tLAqoEiaSppWMJSVuza9tGkjaxbWwDSds4vGMzSWMrhbijDtPSDWPbNuO5EjEvR2TFLvivgJDEHYR7Z7H0peQF+gL5gLPQZdxuLoNuhP8F3G76XfoIVwnfLPoC/Qn9JYtXQvx1eBblLAnfjPh394xvFpSDueq5HRxSphR6m5LYgHJu4kFfvayNS+B+ANquEvi6FrBrIstJGHrlSmil88iFQM+LyMVkL7mEXEr2kQPkMnKQXE6uIteQa8l15OtA7RvIreSb5EdA60+oiVZCbwxMHSYVU8dJJYTqqWPkVghW8kv4/1sIL059Qt6C6ztw/TOE4xDenzpGVVOf0G4ImyFcAr8PwvVrEK6EcBWEqyHcCOFbEO6C8D0Iv4LwDIQ/QPgjlCMlKfA/FX7lQSiEUAq/NdByBnhyGJ4cBs41EBdAVg/X1RD2QPwiCBdD2AvhEgiXTh2HEg5DCYehhMPQZhugrAooiyNyeI5lUJJHBqENeYgriIHmQiiAOAf3B0Am+0AW5QF9A5Aec1ZCiFEDn0BPmToKT47Bk2Pw5Cg8OcpKLWH/a1ldx1hdGPuEVEFJlP1OAWoeB2oeF6l5nFHyfYBaoN5xRr0bRSrFqEOpncGN5XCeXyH/eUtyj5EW0jxXF4RUX/ADo8Qn5P/E5/PCMT8NgCtisaMJdx87bYmPfUFMjs+PWyKWU8dOhu6LUOL/nQ9w3fHZlEJOREqw8MlsGn3eNvjcXHWKeqf+8S+i2tF5H/n+Ka3z4QxuPY53BRimIZmWH7PSJtydvw1O2zqGhLQfTl/jPedYQoqMeNz6mVp+VLzWzgfhNJeKdJkT47lxYr8MM54fmU3naYqekTzPSCj9rTkhyYin9CXEP4scHhB/tHwxyfTFx6fPUv7M1knkvvngiLfkh/OWnDHzeTzHEeDxY9iW06PMGcJ8GPIe/Wz0moqcXg5OQybifItY27EZ1DmQ0Efj49zULVP3sEgJ4iVy7NEYp8Zl6THg2CMxyQ2/jrFUx6Y5ej6IGDzH5sc1QZ4ci9d2ZLYEOL3c+7yjxWf8lPxf6gNnXtd8MiqRbjNa5bSQT0U+H5RsrD9+yhFt7pxHPru+ilz7ebVRBuNj8X77Cfb1mXBP/f4k3CLz4SxCcyxR8sevh9mzo7H6YjXAL8P0bhi0x44yid2Fr9gXWZnwK9bXMxJ7JJRsmL+lZtEm4wzpcniabxBedp3FQzM46TGRbkfEVjwq0FIcBYWx76XP2rP+tX38TPr16dLM1ixOunvs5LkJcNIRbM04X54ODkOcfx87eayarc+dNFZ9ZomKbXsqCTOPtBdiGZ9F2n/RmeT/I/Mswz97dJjBe0fOXBZ/OeMbkwsJOkpMxiboDyfPp+851Xg/m8vnH/f+dWPxF817Miafe6Z75KQ585GZdATt83Cs34LseSzWSme2jgIy5PAcbXJ0vhnXGeN7/MvuO6enoDj6zZr3gcQ7eqat/Vk1nnk06qOn1uLm7sfT0vZ/k8u/GMbz1fh5MJkamreFfV8yjJ+cvLolakmfnCnHfd5ncT3y+MkyWqTd4bhOcGQOPpm5WnFUSDs9Tn+29bO4Hnt0WjeYnpkzPTYGcxzWqbfi6xoMkzhESSfXEa/npdga1dz8hnJrenyZTROAS4QEZN2ReIqjiTP1WB9H/WuWnHwspikxur/0f3kO+E9Ye5xrxeyTLxMLVuLR2TB8eSPgv+bDOPeUa4//jJb+clpnRg8X5Qy7Hj/1HHCGVnF0hu5xhmNTXDKwdaiTRsAjCXVfkDCLOZw4N5lbSxRm5Sev7c7BZ0c+I6UuOBM+nSlZv7BWfTRRun229LNl62dYaTkyc9yZWy9n+tLhU+tqM97YffLFtYj5eP7kld9Tcd3/D2aTp+jNJ9P45HY8Yyy/JI3qFP2g9suo68z1mv+lteVZdU3LI3GV7391ZWN6NRPX+xPl6T9nvvO/qSd9uXLknzff+Sw0mrHue2w+zk188zPPOsnxfxJt/uUy8otx2JnDD3MYYcbz4YxZ+Us4OxDuzFgFfStxNJpe95qlE3wylxb3RfbNfDkybf51un/BJ+PzrPyc0XrRZ36THv8koU1vtMAHcQVRMm+8qfDLBV8ZySLZRE78JJ/tXiwhKhKAsS2VNJIQMZMW0kqsuMeX2EgX6SV2shi+DrIUvk6ynAxAGbjDOJtsgK+XnAdfH9lDLic55Cr4Bsg15HpSTm4g3wQYbif3QLn3km9Ded8lEdJJHiQPkx7yCHyXsh2Cy8gvyNOkn/ya/J6sJs+SP5E15GX4biCvwXcjeYO8SzaR98j7ZAf5kPyVnEP+Rq1kF7VRL/kmzaF55Ns0nxaS77ITyIdoDa0hD9E6uoh8j7bTdvIk7aSd5Ce0hw6Sn9JRuoH8nm6mXyEv0ovoleRdeh39Bvk7vZHeRKL0VvpNSugd9E7K0bvpPVRC76U/oDL6Q/ia6I/o09RMn6G/ptn0t/Q5moM2U+mzxBSnu4kUijEXUNl1Rm2F+0t1aEA/4Z4fbVwS3PtcKu6KTYNWwjdwfqKGtihMSDt9Arxqxi8aj3shoNcMOXzr0DfxjPwnf2pOA3FtAuzTXwlgIRG/sQ/PQuyLcZX4VaP9BwZj7Dv7o4Xv/B+5GBI/FlJMcoF3F4i/M+FbDDyOFjDNJAg8mUuSIVUSxEjC6g7uyC2BfLmsDyRBGvwkQ24sQ8GeFxApcLmN4M7yFLaPUwZXGftKWXDDUw17qmR3lcQI/41ozIw9r4TnbuhhhDSTJnQ5CHdSIAfu+/QAt+CXeWlgfBO7zmyXWhFPwspUQB8sg3KsUK6ZNLBQAc8w5LOUUkgjBayyWdDAVyHew7zWeMnJAC2WVAJPcpgfSJQ6dijFx65oxy8WMG0OQEzEGrB2xCBA6lnA9JgGQ+xTBJIDA2ElxGo8+WoGOmOwQFoMMWgxV35c65axMI1JDEtNPBCRqnhFfAQc7GJ/zYvDlcdgE7DNmVfOVjCKkoTauYS+O7svc2J/lYvvzlOZD4ZYPQR6h0rkeBNwl4rdwx7Bs93mQnAA7jxauGRf/4z8J38qT9NfqxJgn/4WnwT97D6Ncbn4TRVliiThO3ffTbxL430/CTBMOqkuK+NUgasbGP/jHZvI4/hBl9ZqZtMCP1nsf7743wop69hJAH28NMH+RT1wU5D1POxhWrEXYg/G/xrxvxl6GD6VgnTEO2b2H9M2wn0vS4OypAl6LebEOy5mCUQB3IJfAryVx/gmdk0crysTKI91JoOE8YgSx8L6gSIugXQiFtgPSiFdKZNVyoSQO6NHKaAkr3gVfqsBEx1AL5SqYHK/EHCa/q2Il2aF+3iSAwPmw3R6oIKejRMKkAPlLBD2FO8UxOFVxFNhK9njgTAZYmdhGhZBRhCG/TQ2+AxPHcTCdIlShg/mx4BnIyg7H2Fio0o2yRXslIuchh6EFMxWST4tEDlWyfiNY3KbQ0frkC4VT41AqlzC0TzQGCgtwPS0EPQGSktpqcitKJ9KAIPE8xxZ7DxHFjvPkRU/z5Hw+f8AKxMMew=="
+};
+var BOLD = {
+  psName: "NotoSans-Bold",
+  length1: 78460,
+  ascent: 1069,
+  descent: -293,
+  capHeight: 714,
+  bbox: [-644, -389, 2801, 1069],
+  widths: [589, 260, 282, 479, 646, 572, 902, 750, 266, 339, 339, 542, 572, 285, 320, 281, 415, 572, 572, 572, 572, 572, 572, 572, 572, 572, 572, 281, 285, 572, 572, 572, 477, 898, 692, 665, 642, 732, 560, 549, 724, 765, 389, 331, 664, 559, 943, 813, 791, 621, 791, 656, 551, 577, 756, 650, 967, 670, 626, 579, 331, 415, 331, 572, 411, 365, 599, 632, 516, 632, 597, 387, 632, 650, 299, 298, 620, 298, 975, 650, 625, 632, 632, 447, 502, 434, 650, 571, 856, 578, 571, 493, 394, 551, 394, 572, 260, 286, 572, 572, 568, 572, 551, 486, 593, 832, 381, 614, 572, 320, 832, 500, 424, 572, 379, 380, 365, 653, 648, 281, 263, 380, 386, 614, 830, 874, 845, 477, 692, 692, 692, 692, 692, 692, 952, 642, 560, 560, 560, 560, 389, 389, 389, 389, 732, 805, 791, 791, 791, 791, 791, 572, 791, 756, 756, 756, 756, 626, 628, 704, 599, 599, 599, 599, 599, 599, 917, 516, 597, 597, 597, 597, 299, 299, 299, 299, 627, 650, 625, 625, 625, 625, 625, 572, 619, 650, 650, 650, 650, 571, 632, 571, 482, 412, 326, 485, 516, 880, 832, 561, 765, 563, 651, 547, 323, 331, 331, 1034, 1063, 778, 684, 645, 766, 692, 649, 662, 563, 776, 561, 997, 593, 791, 791, 693, 733, 943, 770, 777, 762, 623, 645, 577, 645, 902, 667, 776, 719, 1067, 1074, 754, 920, 645, 656, 1017, 681, 596, 624, 596, 475, 637, 584, 866, 515, 674, 674, 616, 623, 837, 656, 621, 650, 635, 524, 505, 571, 810, 577, 650, 637, 953, 954, 671, 854, 591, 524, 851, 605, 584, 653, 480, 524, 498, 308, 299, 298, 897, 926, 653, 616, 571, 650, 578, 512, 500, 1e3, 1e3, 411, 217, 217, 286, 217, 445, 445, 513, 513, 519, 376, 855, 1280, 303, 524, 365, 365, 1028, 0, 561, 791, 584, 674, 953, 885, 673, 666, 950, 803, 730, 640, 1005, 902, 804, 623, 1073, 880, 632, 555, 881, 842, 791, 619, 717, 605, 717, 605, 1319, 1176, 831, 685, 1088, 958, 956, 885, 677, 524, 609, 0, 0, 916, 802, 638, 614, 628, 633, 559, 491, 734, 602, 1029, 936, 593, 515, 756, 658, 669, 619, 693, 627, 733, 695, 841, 743, 834, 758, 1125, 889, 777, 656, 642, 516, 579, 550, 626, 574, 626, 574, 743, 634, 930, 791, 804, 726, 735, 659, 735, 650, 948, 708, 948, 708, 389, 1e3, 866, 760, 653, 838, 727, 765, 662, 858, 744, 735, 656, 1036, 926, 389, 692, 599, 692, 599, 952, 917, 560, 597, 817, 597, 817, 597, 1e3, 866, 593, 515, 591, 581, 791, 674, 791, 674, 791, 625, 791, 625, 791, 625, 652, 524, 645, 571, 645, 571, 645, 571, 720, 637, 561, 478, 920, 854, 559, 491, 730, 645, 670, 578, 597, 577, 551, 445, 745, 572, 299, 408, 281, 500, 575, 376, 320, 320, 643, 422, 864, 1667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+  cmap: [[32, 1], [33, 2], [34, 3], [35, 4], [36, 5], [37, 6], [38, 7], [39, 8], [40, 9], [41, 10], [42, 11], [43, 12], [44, 13], [45, 14], [46, 15], [47, 16], [48, 17], [49, 18], [50, 19], [51, 20], [52, 21], [53, 22], [54, 23], [55, 24], [56, 25], [57, 26], [58, 27], [59, 28], [60, 29], [61, 30], [62, 31], [63, 32], [64, 33], [65, 34], [66, 35], [67, 36], [68, 37], [69, 38], [70, 39], [71, 40], [72, 41], [73, 42], [74, 43], [75, 44], [76, 45], [77, 46], [78, 47], [79, 48], [80, 49], [81, 50], [82, 51], [83, 52], [84, 53], [85, 54], [86, 55], [87, 56], [88, 57], [89, 58], [90, 59], [91, 60], [92, 61], [93, 62], [94, 63], [95, 64], [96, 65], [97, 66], [98, 67], [99, 68], [100, 69], [101, 70], [102, 71], [103, 72], [104, 73], [105, 74], [106, 75], [107, 76], [108, 77], [109, 78], [110, 79], [111, 80], [112, 81], [113, 82], [114, 83], [115, 84], [116, 85], [117, 86], [118, 87], [119, 88], [120, 89], [121, 90], [122, 91], [123, 92], [124, 93], [125, 94], [126, 95], [160, 96], [161, 97], [162, 98], [163, 99], [164, 100], [165, 101], [166, 102], [167, 103], [168, 104], [169, 105], [170, 106], [171, 107], [172, 108], [173, 109], [174, 110], [175, 111], [176, 112], [177, 113], [178, 114], [179, 115], [180, 116], [181, 117], [182, 118], [183, 119], [184, 120], [185, 121], [186, 122], [187, 123], [188, 124], [189, 125], [190, 126], [191, 127], [192, 128], [193, 129], [194, 130], [195, 131], [196, 132], [197, 133], [198, 134], [199, 135], [200, 136], [201, 137], [202, 138], [203, 139], [204, 140], [205, 141], [206, 142], [207, 143], [208, 144], [209, 145], [210, 146], [211, 147], [212, 148], [213, 149], [214, 150], [215, 151], [216, 152], [217, 153], [218, 154], [219, 155], [220, 156], [221, 157], [222, 158], [223, 159], [224, 160], [225, 161], [226, 162], [227, 163], [228, 164], [229, 165], [230, 166], [231, 167], [232, 168], [233, 169], [234, 170], [235, 171], [236, 172], [237, 173], [238, 174], [239, 175], [240, 176], [241, 177], [242, 178], [243, 179], [244, 180], [245, 181], [246, 182], [247, 183], [248, 184], [249, 185], [250, 186], [251, 187], [252, 188], [253, 189], [254, 190], [255, 191], [1024, 315], [1025, 199], [1026, 200], [1027, 201], [1028, 202], [1029, 203], [1030, 204], [1031, 205], [1032, 206], [1033, 207], [1034, 208], [1035, 209], [1036, 210], [1037, 316], [1038, 211], [1039, 212], [1040, 213], [1041, 214], [1042, 215], [1043, 216], [1044, 217], [1045, 218], [1046, 219], [1047, 220], [1048, 221], [1049, 222], [1050, 223], [1051, 224], [1052, 225], [1053, 226], [1054, 227], [1055, 228], [1056, 229], [1057, 230], [1058, 231], [1059, 232], [1060, 233], [1061, 234], [1062, 235], [1063, 236], [1064, 237], [1065, 238], [1066, 239], [1067, 240], [1068, 241], [1069, 242], [1070, 243], [1071, 244], [1072, 245], [1073, 246], [1074, 247], [1075, 248], [1076, 249], [1077, 250], [1078, 251], [1079, 252], [1080, 253], [1081, 254], [1082, 255], [1083, 256], [1084, 257], [1085, 258], [1086, 259], [1087, 260], [1088, 261], [1089, 262], [1090, 263], [1091, 264], [1092, 265], [1093, 266], [1094, 267], [1095, 268], [1096, 269], [1097, 270], [1098, 271], [1099, 272], [1100, 273], [1101, 274], [1102, 275], [1103, 276], [1104, 317], [1105, 277], [1106, 278], [1107, 279], [1108, 280], [1109, 281], [1110, 282], [1111, 283], [1112, 284], [1113, 285], [1114, 286], [1115, 287], [1116, 288], [1117, 318], [1118, 289], [1119, 290], [1120, 319], [1121, 320], [1122, 321], [1123, 322], [1124, 323], [1125, 324], [1126, 325], [1127, 326], [1128, 327], [1129, 328], [1130, 329], [1131, 330], [1132, 331], [1133, 332], [1134, 333], [1135, 334], [1136, 335], [1137, 336], [1138, 337], [1139, 338], [1140, 339], [1141, 340], [1142, 341], [1143, 342], [1144, 343], [1145, 344], [1146, 345], [1147, 346], [1148, 347], [1149, 348], [1150, 349], [1151, 350], [1152, 351], [1153, 352], [1154, 353], [1155, 491], [1156, 492], [1157, 493], [1158, 494], [1159, 495], [1160, 354], [1161, 355], [1162, 356], [1163, 357], [1164, 358], [1165, 359], [1166, 360], [1167, 361], [1168, 291], [1169, 292], [1170, 362], [1171, 363], [1172, 364], [1173, 365], [1174, 366], [1175, 367], [1176, 368], [1177, 369], [1178, 370], [1179, 371], [1180, 372], [1181, 373], [1182, 374], [1183, 375], [1184, 376], [1185, 377], [1186, 378], [1187, 379], [1188, 380], [1189, 381], [1190, 382], [1191, 383], [1192, 384], [1193, 385], [1194, 386], [1195, 387], [1196, 388], [1197, 389], [1198, 390], [1199, 391], [1200, 392], [1201, 393], [1202, 394], [1203, 395], [1204, 396], [1205, 397], [1206, 398], [1207, 399], [1208, 400], [1209, 401], [1210, 402], [1211, 403], [1212, 404], [1213, 405], [1214, 406], [1215, 407], [1216, 408], [1217, 409], [1218, 410], [1219, 411], [1220, 412], [1221, 413], [1222, 414], [1223, 415], [1224, 416], [1225, 417], [1226, 418], [1227, 419], [1228, 420], [1229, 421], [1230, 422], [1231, 423], [1232, 424], [1233, 425], [1234, 426], [1235, 427], [1236, 428], [1237, 429], [1238, 430], [1239, 431], [1240, 432], [1241, 433], [1242, 434], [1243, 435], [1244, 436], [1245, 437], [1246, 438], [1247, 439], [1248, 440], [1249, 441], [1250, 442], [1251, 443], [1252, 444], [1253, 445], [1254, 446], [1255, 447], [1256, 448], [1257, 449], [1258, 450], [1259, 451], [1260, 452], [1261, 453], [1262, 454], [1263, 455], [1264, 456], [1265, 457], [1266, 458], [1267, 459], [1268, 460], [1269, 461], [1270, 462], [1271, 463], [1272, 464], [1273, 465], [1274, 466], [1275, 467], [1276, 468], [1277, 469], [1278, 470], [1279, 471], [8208, 484], [8209, 485], [8210, 473], [8211, 293], [8212, 294], [8213, 295], [8214, 474], [8215, 296], [8216, 297], [8217, 298], [8218, 299], [8219, 300], [8220, 301], [8221, 302], [8222, 303], [8223, 475], [8224, 304], [8225, 305], [8226, 306], [8227, 483], [8228, 481], [8229, 482], [8230, 307], [8231, 480], [8240, 308], [8241, 489], [8242, 309], [8243, 310], [8244, 476], [8245, 487], [8246, 486], [8247, 488], [8248, 479], [8249, 311], [8250, 312], [8366, 477], [8470, 313]],
+  stream: "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"
+};
+
+// src/pades/pdf/inflate.ts
+var LEN_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+var LEN_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+var DIST_BASE = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+];
+var DIST_EXTRA = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+var CL_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function build(lengths, n) {
+  const counts = new Uint16Array(16);
+  const symbols = new Uint16Array(n);
+  for (let i = 0; i < n; i++) counts[lengths[i]]++;
+  counts[0] = 0;
+  const offs = new Uint16Array(16);
+  for (let i = 1; i < 16; i++) offs[i] = offs[i - 1] + counts[i - 1];
+  for (let i = 0; i < n; i++) if (lengths[i]) symbols[offs[lengths[i]]++] = i;
+  return { counts, symbols };
+}
+var fixedLit;
+var fixedDist;
+function fixed() {
+  if (!fixedLit || !fixedDist) {
+    const l = new Uint8Array(288);
+    l.fill(8, 0, 144);
+    l.fill(9, 144, 256);
+    l.fill(7, 256, 280);
+    l.fill(8, 280, 288);
+    fixedLit = build(l, 288);
+    fixedDist = build(new Uint8Array(30).fill(5), 30);
+  }
+  return [fixedLit, fixedDist];
+}
+var InflateError = class extends Error {
+};
+var Truncated = class extends InflateError {
+};
+function zlibInflate(src, limit = 64 << 20) {
+  if (src.length < 2) throw new InflateError("zlib: header \u0430\u043B\u0433\u0430");
+  const cmf = src[0];
+  const flg = src[1];
+  if ((cmf & 15) !== 8 || cmf >> 4 > 7 || (cmf << 8 | flg) % 31 !== 0) throw new InflateError("zlib: header \u0431\u0443\u0440\u0443\u0443");
+  if (flg & 32) throw new InflateError("zlib: preset dictionary");
+  return inflateRaw(src.subarray(2), limit);
+}
+function inflateRaw(src, limit = 64 << 20) {
+  let pos = 0;
+  let bitBuf = 0;
+  let bitCnt = 0;
+  let out = new Uint8Array(Math.min(limit, Math.max(1024, src.length * 4)));
+  let len = 0;
+  const need = (n) => {
+    if (len + n <= out.length) return;
+    if (len + n > limit) throw new InflateError("inflate: \u0445\u044D\u043C\u0436\u044D\u044D\u043D\u0438\u0439 \u0445\u044F\u0437\u0433\u0430\u0430\u0440");
+    let cap = out.length * 2;
+    while (cap < len + n) cap *= 2;
+    const nb = new Uint8Array(Math.min(cap, limit));
+    nb.set(out.subarray(0, len));
+    out = nb;
+  };
+  const bits = (n) => {
+    while (bitCnt < n) {
+      if (pos >= src.length) throw new Truncated("inflate: \u04E9\u0433\u04E9\u0433\u0434\u04E9\u043B \u0434\u0443\u0442\u0443\u0443");
+      bitBuf |= src[pos++] << bitCnt;
+      bitCnt += 8;
+    }
+    const v = bitBuf & (1 << n) - 1;
+    bitBuf >>>= n;
+    bitCnt -= n;
+    return v;
+  };
+  const decode = (h) => {
+    let code = 0;
+    let first = 0;
+    let index = 0;
+    for (let l = 1; l < 16; l++) {
+      code |= bits(1);
+      const count = h.counts[l];
+      if (code - count < first) return h.symbols[index + (code - first)];
+      index += count;
+      first += count;
+      first <<= 1;
+      code <<= 1;
+    }
+    throw new InflateError("inflate: \u043A\u043E\u0434 \u0431\u0443\u0440\u0443\u0443");
+  };
+  try {
+    inflateBlocks();
+  } catch (e) {
+    if (!(e instanceof Truncated)) throw e;
+  }
+  return out.slice(0, len);
+  function inflateBlocks() {
+    for (; ; ) {
+      const final = bits(1);
+      const type = bits(2);
+      if (type === 0) {
+        bitBuf = 0;
+        bitCnt = 0;
+        if (pos + 4 > src.length) throw new InflateError("inflate: stored header");
+        const n = src[pos] | src[pos + 1] << 8;
+        const nn = src[pos + 2] | src[pos + 3] << 8;
+        pos += 4;
+        if ((n ^ 65535) !== nn) throw new InflateError("inflate: stored \u0443\u0440\u0442");
+        if (pos + n > src.length) throw new InflateError("inflate: stored \u0434\u0443\u0442\u0443\u0443");
+        need(n);
+        out.set(src.subarray(pos, pos + n), len);
+        len += n;
+        pos += n;
+      } else if (type === 1 || type === 2) {
+        let lit;
+        let dist;
+        if (type === 1) {
+          [lit, dist] = fixed();
+        } else {
+          const hlit = bits(5) + 257;
+          const hdist = bits(5) + 1;
+          const hclen = bits(4) + 4;
+          const cl = new Uint8Array(19);
+          for (let i = 0; i < hclen; i++) cl[CL_ORDER[i]] = bits(3);
+          const clh = build(cl, 19);
+          const lens = new Uint8Array(hlit + hdist);
+          for (let i = 0; i < hlit + hdist; ) {
+            const sym = decode(clh);
+            if (sym < 16) {
+              lens[i++] = sym;
+              continue;
+            }
+            let rep = 0;
+            let val = 0;
+            if (sym === 16) {
+              if (i === 0) throw new InflateError("inflate: \u0434\u0430\u0432\u0442\u0430\u043B\u0442 \u044D\u0445\u044D\u043D\u0434");
+              val = lens[i - 1];
+              rep = 3 + bits(2);
+            } else if (sym === 17) rep = 3 + bits(3);
+            else rep = 11 + bits(7);
+            if (i + rep > hlit + hdist) throw new InflateError("inflate: \u0443\u0440\u0442 \u0445\u044D\u0442\u044D\u0440\u0441\u044D\u043D");
+            lens.fill(val, i, i + rep);
+            i += rep;
+          }
+          lit = build(lens.subarray(0, hlit), hlit);
+          dist = build(lens.subarray(hlit), hdist);
+        }
+        for (; ; ) {
+          const sym = decode(lit);
+          if (sym < 256) {
+            need(1);
+            out[len++] = sym;
+          } else if (sym === 256) {
+            break;
+          } else {
+            const li = sym - 257;
+            if (li >= 29) throw new InflateError("inflate: \u0443\u0440\u0442 \u043A\u043E\u0434");
+            const l = LEN_BASE[li] + bits(LEN_EXTRA[li]);
+            const di = decode(dist);
+            if (di >= 30) throw new InflateError("inflate: \u0437\u0430\u0439 \u043A\u043E\u0434");
+            const d = DIST_BASE[di] + bits(DIST_EXTRA[di]);
+            if (d > len) throw new InflateError("inflate: \u0437\u0430\u0439 \u0445\u044D\u0442\u044D\u0440\u0441\u044D\u043D");
+            need(l);
+            for (let k = 0; k < l; k++, len++) out[len] = out[len - d];
+          }
+        }
+      } else {
+        throw new InflateError("inflate: block \u0442\u04E9\u0440\u04E9\u043B");
+      }
+      if (final) break;
+    }
+  }
+}
+
+// src/pades/pdf/reader.ts
+var PdfError = class extends Error {
+};
+var NO_PTR = { id: 0, gen: 0 };
+var PInt = class {
+  constructor(v) {
+    this.v = v;
+  }
+  v;
+};
+var PReal = class {
+  constructor(v) {
+    this.v = v;
+  }
+  v;
+};
+var PStr = class {
+  constructor(b) {
+    this.b = b;
+  }
+  b;
+};
+var PName = class {
+  constructor(n) {
+    this.n = n;
+  }
+  n;
+};
+var PRef = class {
+  constructor(id, gen) {
+    this.id = id;
+    this.gen = gen;
+  }
+  id;
+  gen;
+};
+var PKeyword = class {
+  constructor(k) {
+    this.k = k;
+  }
+  k;
+};
+var PStream = class {
+  constructor(hdr, ptr, offset) {
+    this.hdr = hdr;
+    this.ptr = ptr;
+    this.offset = offset;
+  }
+  hdr;
+  ptr;
+  offset;
+};
+var ObjDef = class {
+  constructor(ptr, obj) {
+    this.ptr = ptr;
+    this.obj = obj;
+  }
+  ptr;
+  obj;
+};
+var EOF_TOKEN = /* @__PURE__ */ Symbol("eof");
+var isSpace = (c) => c === 0 || c === 9 || c === 10 || c === 12 || c === 13 || c === 32;
+var isDelim = (c) => c === 60 || c === 62 || c === 40 || c === 41 || c === 91 || c === 93 || c === 123 || c === 125 || c === 47 || c === 37;
+function unhex(c) {
+  if (c >= 48 && c <= 57) return c - 48;
+  if (c >= 97 && c <= 102) return c - 97 + 10;
+  if (c >= 65 && c <= 70) return c - 65 + 10;
+  return -1;
+}
+var isKw = (t, k) => t instanceof PKeyword && t.k === k;
+var Lexer = class {
+  constructor(data, start, allowEOF = false) {
+    this.data = data;
+    this.allowEOF = allowEOF;
+    this.pos = start;
+  }
+  data;
+  allowEOF;
+  pos;
+  eof = false;
+  unread = [];
+  objptr = NO_PTR;
+  readByte() {
+    if (this.pos >= this.data.length) {
+      if (!this.allowEOF) throw new PdfError(`malformed PDF: reading at offset ${this.pos}: EOF`);
+      this.eof = true;
+      this.pos = this.data.length + 1;
+      return 10;
+    }
+    return this.data[this.pos++];
+  }
+  unreadByte() {
+    if (this.pos > 0) this.pos--;
+  }
+  unreadToken(t) {
+    this.unread.push(t);
+  }
+  /** Stream-ийн өгөгдлийн эхлэл (readOffset). */
+  offset() {
+    return this.pos;
+  }
+  seek(p) {
+    this.pos = p;
+  }
+  readToken() {
+    const u = this.unread.pop();
+    if (u !== void 0) return u;
+    let c = this.readByte();
+    for (; ; ) {
+      if (isSpace(c)) {
+        if (this.eof) return EOF_TOKEN;
+        c = this.readByte();
+      } else if (c === 37) {
+        while (c !== 13 && c !== 10) c = this.readByte();
+      } else break;
+    }
+    switch (c) {
+      case 60:
+        if (this.readByte() === 60) return new PKeyword("<<");
+        this.unreadByte();
+        return this.readHexString();
+      case 40:
+        return this.readLiteralString();
+      case 91:
+      case 93:
+      case 123:
+      case 125:
+        return new PKeyword(String.fromCharCode(c));
+      case 47:
+        return this.readName();
+      case 62:
+        if (this.readByte() === 62) return new PKeyword(">>");
+        this.unreadByte();
+      // fallthrough
+      default:
+        if (isDelim(c)) throw new PdfError(`unexpected delimiter ${String.fromCharCode(c)}`);
+        this.unreadByte();
+        return this.readKeyword();
+    }
+  }
+  readHexString() {
+    const out = [];
+    for (; ; ) {
+      let c = this.readByte();
+      while (isSpace(c)) c = this.readByte();
+      if (c === 62) break;
+      let c2 = this.readByte();
+      while (isSpace(c2)) c2 = this.readByte();
+      const x = unhex(c) << 4 | unhex(c2);
+      if (unhex(c) < 0 || unhex(c2) < 0 || x < 0) throw new PdfError("malformed hex string");
+      out.push(x);
+    }
+    return new PStr(Uint8Array.from(out));
+  }
+  readLiteralString() {
+    const out = [];
+    let depth = 1;
+    for (; ; ) {
+      let c = this.readByte();
+      if (c === 40) {
+        depth++;
+        out.push(c);
+      } else if (c === 41) {
+        if (--depth === 0) break;
+        out.push(c);
+      } else if (c === 92) {
+        c = this.readByte();
+        switch (c) {
+          case 110:
+            out.push(10);
+            break;
+          case 114:
+            out.push(13);
+            break;
+          case 98:
+            out.push(8);
+            break;
+          case 116:
+            out.push(9);
+            break;
+          case 102:
+            out.push(12);
+            break;
+          case 40:
+          case 41:
+          case 92:
+            out.push(c);
+            break;
+          case 13:
+            if (this.readByte() !== 10) this.unreadByte();
+            break;
+          case 10:
+            break;
+          default:
+            if (c >= 48 && c <= 55) {
+              let x = c - 48;
+              for (let i = 0; i < 2; i++) {
+                c = this.readByte();
+                if (c < 48 || c > 55) {
+                  this.unreadByte();
+                  break;
+                }
+                x = x * 8 + (c - 48);
+              }
+              if (x > 255) throw new PdfError("invalid octal escape");
+              out.push(x);
+            } else {
+              throw new PdfError(`invalid escape sequence \\${String.fromCharCode(c)}`);
+            }
+        }
+      } else {
+        out.push(c);
+      }
+    }
+    return new PStr(Uint8Array.from(out));
+  }
+  readName() {
+    let s = "";
+    for (; ; ) {
+      const c = this.readByte();
+      if (isDelim(c) || isSpace(c)) {
+        this.unreadByte();
+        break;
+      }
+      if (c === 35) {
+        const h = unhex(this.readByte());
+        const l = unhex(this.readByte());
+        if (h < 0 || l < 0) throw new PdfError("malformed name");
+        s += String.fromCharCode(h << 4 | l);
+        continue;
+      }
+      s += String.fromCharCode(c);
+    }
+    return new PName(s);
+  }
+  readKeyword() {
+    let s = "";
+    for (; ; ) {
+      const c = this.readByte();
+      if (isDelim(c) || isSpace(c)) {
+        this.unreadByte();
+        break;
+      }
+      s += String.fromCharCode(c);
+    }
+    if (s === "true") return true;
+    if (s === "false") return false;
+    if (/^[+-]?[0-9]+$/.test(s)) {
+      const v = BigInt(s);
+      if (v > 0x7fffffffffffffffn || v < -0x8000000000000000n) throw new PdfError(`invalid integer ${s}`);
+      return new PInt(v);
+    }
+    if (/^[+-]?[0-9.]+$/.test(s) && /^[+-]?[^.]*\.[^.]*$/.test(s) && /[0-9]/.test(s)) {
+      return new PReal(parseFloat(s.startsWith("+") ? s.slice(1) : s));
+    }
+    if (/^[+-]?\.$/.test(s)) throw new PdfError(`invalid real ${s}`);
+    return new PKeyword(s);
+  }
+  readObject() {
+    const tok = this.readToken();
+    if (tok instanceof PKeyword) {
+      switch (tok.k) {
+        case "null":
+          return null;
+        case "endobj":
+          this.unreadToken(tok);
+          return null;
+        case "<<":
+          return this.readDict();
+        case "[":
+          return this.readArray();
+      }
+      throw new PdfError(`unexpected keyword ${tok.k} parsing object`);
+    }
+    if (tok instanceof PInt && tok.v >= 0n && tok.v <= 0xffffffffn) {
+      const tok2 = this.readToken();
+      if (tok2 instanceof PInt && tok2.v >= 0n && tok2.v <= 0xffffn) {
+        const tok3 = this.readToken();
+        if (isKw(tok3, "R")) return new PRef(Number(tok.v), Number(tok2.v));
+        if (isKw(tok3, "obj")) {
+          const old = this.objptr;
+          const ptr = { id: Number(tok.v), gen: Number(tok2.v) };
+          this.objptr = ptr;
+          const obj = this.readObject();
+          if (!(obj instanceof PStream)) {
+            const tok4 = this.readToken();
+            if (!isKw(tok4, "endobj")) throw new PdfError("missing endobj after indirect object definition");
+          }
+          this.objptr = old;
+          return new ObjDef(ptr, asObj(obj));
+        }
+        this.unreadToken(tok3);
+      }
+      this.unreadToken(tok2);
+    }
+    return tok;
+  }
+  readArray() {
+    const x = [];
+    for (; ; ) {
+      const tok = this.readToken();
+      if (isKw(tok, "]")) break;
+      if (tok === EOF_TOKEN) throw new PdfError("unterminated array");
+      this.unreadToken(tok);
+      x.push(asObj(this.readObject()));
+    }
+    return x;
+  }
+  readDict() {
+    const x = /* @__PURE__ */ new Map();
+    for (; ; ) {
+      const tok2 = this.readToken();
+      if (isKw(tok2, ">>")) break;
+      if (tok2 === EOF_TOKEN) throw new PdfError("unterminated dictionary");
+      if (!(tok2 instanceof PName)) throw new PdfError("unexpected non-name key parsing dictionary");
+      x.set(tok2.n, asObj(this.readObject()));
+    }
+    const tok = this.readToken();
+    if (!isKw(tok, "stream")) {
+      this.unreadToken(tok);
+      return x;
+    }
+    const c = this.readByte();
+    if (c === 13) {
+      if (this.readByte() !== 10) this.unreadByte();
+    } else if (c !== 10) {
+      throw new PdfError("stream keyword not followed by newline");
+    }
+    return new PStream(x, this.objptr, this.offset());
+  }
+};
+function asObj(o) {
+  if (o instanceof ObjDef || o === EOF_TOKEN || o instanceof PKeyword) throw new PdfError("unexpected token in object");
+  return o;
+}
+var ZERO_XREF = () => ({ ptr: NO_PTR, inStream: false, stream: NO_PTR, offset: 0 });
+var ptrEq = (a, b) => a.id === b.id && a.gen === b.gen;
+var Value = class _Value {
+  constructor(r, ptr, data) {
+    this.r = r;
+    this.ptr = ptr;
+    this.data = data;
+  }
+  r;
+  ptr;
+  data;
+  isNull() {
+    return this.data === null || this.data === void 0;
+  }
+  kind() {
+    const d = this.data;
+    if (d === null || d === void 0 || d instanceof PRef) return "null";
+    if (typeof d === "boolean") return "bool";
+    if (d instanceof PInt) return "int";
+    if (d instanceof PReal) return "real";
+    if (d instanceof PStr) return "string";
+    if (d instanceof PName) return "name";
+    if (d instanceof Map) return "dict";
+    if (Array.isArray(d)) return "array";
+    return "stream";
+  }
+  dict() {
+    const d = this.data;
+    if (d instanceof Map) return d;
+    if (d instanceof PStream) return d.hdr;
+    return void 0;
+  }
+  key(k) {
+    const d = this.dict();
+    if (!d) return new _Value(this.r, NO_PTR, void 0);
+    return this.r.resolve(this.ptr, d.has(k) ? d.get(k) : void 0);
+  }
+  /** Байтын эрэмбээр (Go sort.Strings). */
+  keys() {
+    const d = this.dict();
+    if (!d) return [];
+    return [...d.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  }
+  index(i) {
+    const d = this.data;
+    if (!Array.isArray(d) || i < 0 || i >= d.length) return new _Value(this.r, NO_PTR, void 0);
+    return this.r.resolve(this.ptr, d[i]);
+  }
+  len() {
+    return Array.isArray(this.data) ? this.data.length : 0;
+  }
+  name() {
+    return this.data instanceof PName ? this.data.n : "";
+  }
+  int64() {
+    return this.data instanceof PInt ? Number(this.data.v) : 0;
+  }
+  bool() {
+    return this.data === true;
+  }
+  float64() {
+    if (this.data instanceof PReal) return this.data.v;
+    if (this.data instanceof PInt) return Number(this.data.v);
+    return 0;
+  }
+  rawString() {
+    return this.data instanceof PStr ? this.data.b : new Uint8Array();
+  }
+  /** digitorus Text(): UTF-16BE (BOM) эсвэл PDFDocEncoding (ASCII хэсэгт ижил). */
+  text() {
+    if (!(this.data instanceof PStr)) return "";
+    const b = this.data.b;
+    if (b.length >= 2 && b[0] === 254 && b[1] === 255) {
+      let s = "";
+      for (let i = 2; i + 1 < b.length; i += 2) s += String.fromCharCode(b[i] << 8 | b[i + 1]);
+      return s;
+    }
+    return fromLatin1(b);
+  }
+  /** Stream-ийн тайлсан өгөгдөл (Value.Reader). */
+  streamData() {
+    const x = this.data;
+    if (!(x instanceof PStream)) throw new PdfError("stream not present");
+    const n = this.key("Length").int64();
+    if (n < 0 || x.offset + n > this.r.bytes.length) throw new PdfError("stream \u0443\u0440\u0442 \u0444\u0430\u0439\u043B\u0430\u0430\u0441 \u0445\u044D\u0442\u044D\u0440\u0441\u044D\u043D");
+    let data = this.r.bytes.subarray(x.offset, x.offset + n);
+    const filter = this.key("Filter");
+    const param = this.key("DecodeParms");
+    switch (filter.kind()) {
+      case "null":
+        break;
+      case "name":
+        data = applyFilter(data, filter.name(), param);
+        break;
+      case "array":
+        for (let i = 0; i < filter.len(); i++) data = applyFilter(data, filter.index(i).name(), param.index(i));
+        break;
+      default:
+        throw new PdfError("unsupported filter");
+    }
+    return data;
+  }
+};
+function applyFilter(data, name, param) {
+  if (name !== "FlateDecode") throw new PdfError(`unknown filter ${name}`);
+  const out = zlibInflate(data);
+  const pred = param.key("Predictor");
+  if (pred.kind() === "null") return out;
+  if (pred.int64() !== 12) throw new PdfError("unknown predictor");
+  const columns = param.key("Columns").int64();
+  const row = 1 + columns;
+  const hist = new Uint8Array(row);
+  const rows = Math.floor(out.length / row);
+  const res = new Uint8Array(rows * columns);
+  for (let r = 0; r < rows; r++) {
+    if (out[r * row] !== 2) {
+      return res.slice(0, r * columns);
+    }
+    for (let i = 0; i < row; i++) hist[i] = hist[i] + out[r * row + i] & 255;
+    res.set(hist.subarray(1), r * columns);
+  }
+  return res;
+}
+var Reader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    const b = bytes;
+    const ok17 = b.length >= 8 && fromLatin1(b, 0, 7) === "%PDF-1." && b[7] >= 48 && b[7] <= 55;
+    const ok20 = b.length >= 8 && fromLatin1(b, 0, 7) === "%PDF-2." && b[7] === 48;
+    if (!ok17 && !ok20) throw new PdfError("not a PDF file: invalid header");
+    this.pdfVersion = fromLatin1(b, 5, 8);
+    const startxrefPos = findStartXref(b);
+    const lx = new Lexer(b, startxrefPos);
+    if (!isKw(lx.readToken(), "startxref")) throw new PdfError("malformed PDF file: missing startxref");
+    const sx = lx.readToken();
+    if (!(sx instanceof PInt)) throw new PdfError("malformed PDF file: startxref not followed by integer");
+    this.startXref = Number(sx.v);
+    if (this.startXref < 0 || this.startXref >= b.length) throw new PdfError("startxref \u0431\u0443\u0440\u0443\u0443");
+    const x = new Lexer(b, this.startXref);
+    const tok = x.readToken();
+    if (isKw(tok, "xref")) this.readXrefTable(x);
+    else if (tok instanceof PInt) {
+      x.unreadToken(tok);
+      this.readXrefStream(x);
+    } else throw new PdfError("malformed PDF: cross-reference table not found");
+  }
+  bytes;
+  xref = [];
+  trailer = /* @__PURE__ */ new Map();
+  trailerPtr = NO_PTR;
+  /** "table" | "stream" */
+  xrefType = "";
+  /** Сүүлийн startxref (шинэ revision-ий /Prev). */
+  startXref = 0;
+  /** Header-ийн "1.x". */
+  pdfVersion = "";
+  cache = /* @__PURE__ */ new Map();
+  trailerValue() {
+    return new Value(this, this.trailerPtr, this.trailer);
+  }
+  readXrefStream(b) {
+    const def = b.readObject();
+    if (!(def instanceof ObjDef) || !(def.obj instanceof PStream)) throw new PdfError("malformed PDF: cross-reference table not found");
+    const strm = def.obj;
+    const type = strm.hdr.get("Type");
+    if (!(type instanceof PName) || type.n !== "XRef") throw new PdfError("malformed PDF: xref stream does not have type XRef");
+    const sizeObj = strm.hdr.get("Size");
+    if (!(sizeObj instanceof PInt)) throw new PdfError("malformed PDF: xref stream missing Size");
+    const size = Number(sizeObj.v);
+    if (size < 0 || size > 1 << 24) throw new PdfError("xref Size \u0431\u0443\u0440\u0443\u0443");
+    const table = Array.from({ length: size }, ZERO_XREF);
+    this.readXrefStreamData(strm, table, size);
+    const seen = /* @__PURE__ */ new Set();
+    let prevoff = strm.hdr.get("Prev");
+    while (prevoff !== void 0 && prevoff !== null) {
+      if (!(prevoff instanceof PInt)) throw new PdfError("malformed PDF: xref Prev is not integer");
+      const off = Number(prevoff.v);
+      if (seen.has(off)) throw new PdfError("malformed PDF: xref Prev loop detected");
+      seen.add(off);
+      if (off < 0 || off >= this.bytes.length) throw new PdfError("xref Prev \u0431\u0443\u0440\u0443\u0443");
+      const pd = new Lexer(this.bytes, off).readObject();
+      if (!(pd instanceof ObjDef) || !(pd.obj instanceof PStream)) throw new PdfError("malformed PDF: xref prev stream not found");
+      const ps = pd.obj;
+      prevoff = ps.hdr.get("Prev");
+      const prev = new Value(this, NO_PTR, ps);
+      if (prev.key("Type").name() !== "XRef") throw new PdfError("malformed PDF: xref prev stream does not have type XRef");
+      const psize = prev.key("Size").int64();
+      if (psize > size) throw new PdfError("malformed PDF: xref prev stream larger than last stream");
+      this.readXrefStreamData(ps, table, psize);
+    }
+    this.xrefType = "stream";
+    this.xref = table;
+    this.trailerPtr = def.ptr;
+    this.trailer = strm.hdr;
+  }
+  readXrefStreamData(strm, table, size) {
+    let index = strm.hdr.get("Index");
+    if (!Array.isArray(index)) index = [new PInt(0n), new PInt(BigInt(size))];
+    if (index.length % 2 !== 0) throw new PdfError("invalid Index array");
+    const ww = strm.hdr.get("W");
+    if (!Array.isArray(ww)) throw new PdfError("xref stream missing W array");
+    const w = ww.map((x) => {
+      if (!(x instanceof PInt) || x.v < 0n || x.v > 8n) throw new PdfError("invalid W array");
+      return Number(x.v);
+    });
+    if (w.length < 3) throw new PdfError("invalid W array");
+    const wtotal = w.reduce((a, c) => a + c, 0);
+    const data = new Value(this, NO_PTR, strm).streamData();
+    let p = 0;
+    const dec = (n) => {
+      let x = 0;
+      for (let i = 0; i < n; i++) x = x * 256 + data[p + i];
+      p += n;
+      return x;
+    };
+    for (let k = 0; k + 1 < index.length; k += 2) {
+      const s = index[k];
+      const n = index[k + 1];
+      if (!(s instanceof PInt) || !(n instanceof PInt)) throw new PdfError("malformed Index pair");
+      const start = Number(s.v);
+      for (let i = 0; i < Number(n.v); i++) {
+        if (p + wtotal > data.length) throw new PdfError("error reading xref stream: EOF");
+        const base = p;
+        let v1 = dec(w[0]);
+        if (w[0] === 0) v1 = 1;
+        const v2 = dec(w[1]);
+        const v3 = dec(w[2]);
+        p = base + wtotal;
+        const x = start + i;
+        if (x >= table.length) {
+          if (x !== table.length) throw new PdfError("xref stream: index out of range");
+          table.push(ZERO_XREF());
+        }
+        if (!ptrEq(table[x].ptr, NO_PTR)) continue;
+        if (v1 === 0) table[x] = { ptr: { id: 0, gen: 65535 }, inStream: false, stream: NO_PTR, offset: 0 };
+        else if (v1 === 1) table[x] = { ptr: { id: x, gen: v3 & 65535 }, inStream: false, stream: NO_PTR, offset: v2 };
+        else if (v1 === 2) table[x] = { ptr: { id: x, gen: 0 }, inStream: true, stream: { id: v2, gen: 0 }, offset: v3 };
+      }
+    }
+  }
+  readXrefTable(b) {
+    let table = [];
+    this.readXrefTableData(b, table);
+    const trailer = b.readObject();
+    if (!(trailer instanceof Map)) throw new PdfError("malformed PDF: xref table not followed by trailer dictionary");
+    const seen = /* @__PURE__ */ new Set();
+    let prevoff = trailer.get("Prev");
+    while (prevoff !== void 0 && prevoff !== null) {
+      if (!(prevoff instanceof PInt)) throw new PdfError("malformed PDF: xref Prev is not integer");
+      const off = Number(prevoff.v);
+      if (seen.has(off)) throw new PdfError("malformed PDF: xref Prev loop detected");
+      seen.add(off);
+      if (off < 0 || off >= this.bytes.length) throw new PdfError("xref Prev \u0431\u0443\u0440\u0443\u0443");
+      const pb = new Lexer(this.bytes, off);
+      if (!isKw(pb.readToken(), "xref")) throw new PdfError("malformed PDF: xref Prev does not point to xref");
+      this.readXrefTableData(pb, table);
+      const t2 = pb.readObject();
+      if (!(t2 instanceof Map)) throw new PdfError("malformed PDF: xref Prev table not followed by trailer dictionary");
+      prevoff = t2.get("Prev");
+    }
+    const size = trailer.get("Size");
+    if (!(size instanceof PInt)) throw new PdfError("malformed PDF: trailer missing /Size entry");
+    if (Number(size.v) < table.length) table = table.slice(0, Math.max(0, Number(size.v)));
+    this.xrefType = "table";
+    this.xref = table;
+    this.trailer = trailer;
+    this.trailerPtr = NO_PTR;
+  }
+  readXrefTableData(b, table) {
+    for (; ; ) {
+      const tok = b.readToken();
+      if (isKw(tok, "trailer")) break;
+      const n = b.readToken();
+      if (!(tok instanceof PInt) || !(n instanceof PInt)) throw new PdfError("malformed xref table");
+      const start = Number(tok.v);
+      const count = Number(n.v);
+      if (start < 0 || count < 0 || start + count > 1 << 24) throw new PdfError("malformed xref table");
+      for (let i = 0; i < count; i++) {
+        const off = b.readToken();
+        const gen = b.readToken();
+        const alloc = b.readToken();
+        if (!(off instanceof PInt) || !(gen instanceof PInt) || !(alloc instanceof PKeyword) || alloc.k !== "f" && alloc.k !== "n") {
+          throw new PdfError("malformed xref table");
+        }
+        const x = start + i;
+        while (table.length <= x) table.push(ZERO_XREF());
+        if (alloc.k === "n" && table[x].offset === 0) {
+          table[x] = { ptr: { id: x, gen: Number(gen.v) & 65535 }, inStream: false, stream: NO_PTR, offset: Number(off.v) };
+        }
+      }
+    }
+  }
+  /** digitorus resolve(parent, x). */
+  resolve(parent, x) {
+    if (x instanceof PRef) {
+      const key = `${x.id} ${x.gen}`;
+      const hit = this.cache.get(key);
+      if (hit) return hit;
+      const v = this.load(x);
+      this.cache.set(key, v);
+      return v;
+    }
+    return new Value(this, parent, x);
+  }
+  load(ptr) {
+    if (ptr.id >= this.xref.length) return new Value(this, NO_PTR, void 0);
+    const xr = this.xref[ptr.id];
+    if (xr.ptr.id !== ptr.id || xr.ptr.gen !== ptr.gen || !xr.inStream && xr.offset === 0) return new Value(this, NO_PTR, void 0);
+    const p = { id: ptr.id, gen: ptr.gen };
+    let x;
+    if (xr.inStream) {
+      let strm = this.resolve(p, new PRef(xr.stream.id, xr.stream.gen));
+      for (let guard = 0; ; guard++) {
+        if (guard > 64) throw new PdfError("object stream /Extends \u0433\u0438\u043D\u0436 \u0445\u044D\u0442 \u0443\u0440\u0442");
+        if (strm.kind() !== "stream") throw new PdfError("not a stream");
+        if (strm.key("Type").name() !== "ObjStm") throw new PdfError("not an object stream");
+        const n = strm.key("N").int64();
+        const first = strm.key("First").int64();
+        if (first === 0) throw new PdfError("missing First");
+        const data = strm.streamData();
+        const b = new Lexer(data, 0, true);
+        let found;
+        let ok = false;
+        for (let i = 0; i < n; i++) {
+          const id = b.readToken();
+          const off = b.readToken();
+          const idn = id instanceof PInt ? Number(BigInt.asUintN(32, id.v)) : 0;
+          if (idn === ptr.id) {
+            const o = off instanceof PInt ? Number(off.v) : 0;
+            b.seek(first + o);
+            found = asObj(b.readObject());
+            ok = true;
+            break;
+          }
+        }
+        if (ok) {
+          x = found ?? null;
+          break;
+        }
+        const ext = strm.key("Extends");
+        if (ext.kind() !== "stream") throw new PdfError("cannot find object in stream");
+        strm = ext;
+      }
+    } else {
+      const b = new Lexer(this.bytes, xr.offset);
+      const def = b.readObject();
+      if (!(def instanceof ObjDef)) throw new PdfError(`loading ${ptr.id} ${ptr.gen}: not an objdef`);
+      if (!ptrEq(def.ptr, p)) throw new PdfError(`loading ${ptr.id} ${ptr.gen}: found ${def.ptr.id} ${def.ptr.gen}`);
+      x = def.obj;
+    }
+    return new Value(this, p, x);
+  }
+};
+function findStartXref(b) {
+  const end = b.length;
+  let searchSize = 200;
+  let eofEnd = -1;
+  for (; ; ) {
+    const from = Math.max(0, end - searchSize);
+    if (end - searchSize >= 0) {
+      let hi = end;
+      while (hi > from && (b[hi - 1] === 10 || b[hi - 1] === 13)) hi--;
+      while (hi > from && (b[hi - 1] === 10 || b[hi - 1] === 13 || b[hi - 1] === 9 || b[hi - 1] === 32)) hi--;
+      for (; ; ) {
+        if (hi - from === 5) break;
+        if (hi - from >= 5 && fromLatin1(b, hi - 5, hi) === "%%EOF") {
+          eofEnd = hi;
+          break;
+        }
+        if (hi - from < 5) break;
+        hi--;
+      }
+      if (eofEnd >= 0) break;
+    }
+    searchSize += 200;
+    if (searchSize > end) throw new PdfError("not a PDF file: missing %%EOF");
+  }
+  const winStart = eofEnd - 200;
+  if (winStart < 0) throw new PdfError("malformed PDF file: missing final startxref");
+  const buf = b.subarray(winStart, eofEnd);
+  const i = findLastLine(buf, "startxref");
+  if (i < 0) throw new PdfError("malformed PDF file: missing final startxref");
+  return winStart + i;
+}
+function findLastLine(buf, s) {
+  const str = fromLatin1(buf);
+  let max = buf.length;
+  for (; ; ) {
+    const i = str.lastIndexOf(s, max - s.length);
+    if (i <= 0 || i + s.length >= buf.length) return -1;
+    const before = buf[i - 1];
+    const after2 = buf[i + s.length];
+    if ((before === 10 || before === 13) && (after2 === 10 || after2 === 13)) return i;
+    max = i;
+  }
+}
+
+// src/pades/pdf/serialize.ts
+var MAX_DEPTH = 32;
+function serialize(v, container, depth = 0) {
+  if (depth > MAX_DEPTH) throw new PdfError("pades: \u0443\u0442\u0433\u0430 \u0445\u044D\u0442 \u0433\u04AF\u043D \u0434\u0430\u0432\u0445\u0430\u0440\u043B\u0430\u0441\u0430\u043D");
+  if (v.isNull()) return "null";
+  if (v.ptr.id !== container) return `${v.ptr.id} ${v.ptr.gen} R`;
+  const d = v.data;
+  if (d instanceof PStr) return hexString(d.b);
+  if (typeof d === "boolean") return d ? "true" : "false";
+  if (d instanceof PInt) return d.v.toString();
+  if (d instanceof PReal) return formatFloat(d.v);
+  if (d instanceof PName) return "/" + escapeName(d.n);
+  if (d instanceof Map) {
+    let s = "<<";
+    for (const k of v.keys()) s += " /" + escapeName(k) + " " + serialize(v.key(k), container, depth + 1);
+    return s + " >>";
+  }
+  if (Array.isArray(d)) {
+    const parts = [];
+    for (let i = 0; i < v.len(); i++) parts.push(serialize(v.index(i), container, depth + 1));
+    return "[" + parts.join(" ") + "]";
+  }
+  throw new PdfError("pades: \u0448\u0443\u0443\u0434 stream (\u044D\u0441\u0432\u044D\u043B \u0442\u0430\u043D\u0438\u0445\u0433\u04AF\u0439 \u0443\u0442\u0433\u0430) \u0445\u0443\u0443\u043B\u0430\u0445 \u0431\u043E\u043B\u043E\u043C\u0436\u0433\u04AF\u0439");
+}
+function hexString(raw) {
+  return "<" + toHex(raw) + ">";
+}
+function escapeName(n) {
+  let s = "";
+  for (let i = 0; i < n.length; i++) {
+    const c = n.charCodeAt(i) & 255;
+    if (c < 33 || c > 126 || "#()<>[]{}/%".includes(String.fromCharCode(c))) {
+      s += "#" + c.toString(16).toUpperCase().padStart(2, "0");
+    } else s += String.fromCharCode(c);
+  }
+  return s;
+}
+function formatFloat(f) {
+  if (Number.isNaN(f)) return "NaN";
+  if (!Number.isFinite(f)) return f > 0 ? "+Inf" : "-Inf";
+  if (Object.is(f, -0)) return "-0";
+  const s = String(f);
+  const m = /^(-?)(\d+)(?:\.(\d+))?e([+-]\d+)$/.exec(s);
+  if (!m) return s;
+  const [, sign, ip, fp = "", es] = m;
+  const digits = ip + fp;
+  const point = ip.length + Number(es);
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`.replace(/0+$/, "");
+  if (point >= digits.length) return sign + digits + "0".repeat(point - digits.length);
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+
+// src/pades/pdf/incremental.ts
+var Incremental = class {
+  rdr;
+  out = new ByteWriter();
+  nextID;
+  entries = [];
+  stream;
+  constructor(base) {
+    const rdr = new Reader(base);
+    const tr = rdr.trailerValue();
+    if (!tr.key("Encrypt").isNull()) throw new PdfError("\u0448\u0438\u0444\u0440\u043B\u044D\u0433\u0434\u0441\u044D\u043D PDF");
+    if (tr.key("Root").kind() !== "dict") throw new PdfError("Catalog \u0430\u043B\u0433\u0430");
+    if (rdr.xrefType !== "table" && rdr.xrefType !== "stream") throw new PdfError(`xref \u0442\u04E9\u0440\u04E9\u043B ${rdr.xrefType}`);
+    this.rdr = rdr;
+    this.stream = rdr.xrefType === "stream";
+    let maxID = 0;
+    for (const x of rdr.xref) if (x.ptr.id > maxID) maxID = x.ptr.id;
+    const size = tr.key("Size").int64();
+    if (size <= 0 || size > 1 << 23) throw new PdfError("/Size \u0431\u0443\u0440\u0443\u0443");
+    this.nextID = Math.max(size, maxID + 1);
+    this.out.bytes(base);
+    this.out.byte(10);
+  }
+  root() {
+    return this.rdr.trailerValue().key("Root");
+  }
+  reserve() {
+    return this.nextID++;
+  }
+  /** Объект бичиж xref-д бүртгэнэ; body-ийн эхлэх байрлал. `body` — latin1 мөр эсвэл байт. */
+  writeObject(id, body, gen = 0) {
+    this.out.byte(10);
+    this.entries.push({ id, gen, offset: this.out.len });
+    this.out.str(`${id} ${gen} obj
+`);
+    const start = this.out.len;
+    this.out.bytes(trimSpace(typeof body === "string" ? latin1(body) : body));
+    this.out.str("\nendobj\n");
+    return start;
+  }
+  addObject(body) {
+    const id = this.reserve();
+    return [id, this.writeObject(id, body)];
+  }
+  finish(root) {
+    if (this.entries.length === 0) throw new PdfError("pades: \u0448\u0438\u043D\u044D \u043E\u0431\u044A\u0435\u043A\u0442 \u0430\u043B\u0433\u0430");
+    this.out.byte(10);
+    const xrefStart = this.out.len;
+    let xid = 0;
+    if (this.stream) {
+      xid = this.reserve();
+      this.entries.push({ id: xid, gen: 0, offset: xrefStart });
+    }
+    this.entries.sort((a, b) => a.id - b.id);
+    const runs = [];
+    this.entries.forEach((e, i) => {
+      const prev2 = this.entries[i - 1];
+      if (prev2 && e.id === prev2.id) throw new PdfError("pades: \u043E\u0431\u044A\u0435\u043A\u0442\u044B\u043D \u0434\u0443\u0433\u0430\u0430\u0440 \u0434\u0430\u0432\u0445\u0430\u0440\u0434\u0441\u0430\u043D");
+      if (prev2 && e.id === prev2.id + 1) {
+        runs[runs.length - 1][1]++;
+        return;
+      }
+      runs.push([i, 1]);
+    });
+    const prev = this.rdr.startXref;
+    const tr = this.rdr.trailerValue();
+    let extra = "";
+    const info = tr.key("Info");
+    if (!info.isNull()) {
+      const p = info.ptr;
+      const tp = tr.ptr;
+      if (p.id === tp.id && p.gen === tp.gen) extra += " /Info " + serialize(info, tp.id, 0);
+      else extra += ` /Info ${p.id} ${p.gen} R`;
+    }
+    const idv = tr.key("ID");
+    if (idv.kind() === "array" && idv.len() === 2) {
+      extra += ` /ID [${hexString(idv.index(0).rawString())} ${hexString(idv.index(1).rawString())}]`;
+    }
+    if (!this.stream) {
+      this.out.str("xref\n");
+      for (const [s, n] of runs) {
+        this.out.str(`${this.entries[s].id} ${n}
+`);
+        for (const e of this.entries.slice(s, s + n)) {
+          this.out.str(`${String(e.offset).padStart(10, "0")} ${String(e.gen).padStart(5, "0")} n\r
+`);
+        }
+      }
+      this.out.str(`trailer
+<< /Size ${this.nextID} /Root ${root} 0 R${extra} /Prev ${prev} >>
+startxref
+${xrefStart}
+%%EOF
+`);
+      return this.out.result();
+    }
+    const rows = new Uint8Array(this.entries.length * 6);
+    this.entries.forEach((e, i) => {
+      if (e.offset > 4294967295) throw new PdfError("pades: offset 4 \u0431\u0430\u0439\u0442\u0430\u0434 \u0431\u0430\u0433\u0442\u0430\u0445\u0433\u04AF\u0439");
+      if (e.gen > 255) throw new PdfError("pades: \u04AF\u0435\u0438\u0439\u043D \u0434\u0443\u0433\u0430\u0430\u0440 1 \u0431\u0430\u0439\u0442\u0430\u0434 \u0431\u0430\u0433\u0442\u0430\u0445\u0433\u04AF\u0439");
+      const o = i * 6;
+      rows[o] = 1;
+      rows[o + 1] = e.offset >>> 24 & 255;
+      rows[o + 2] = e.offset >>> 16 & 255;
+      rows[o + 3] = e.offset >>> 8 & 255;
+      rows[o + 4] = e.offset & 255;
+      rows[o + 5] = e.gen;
+    });
+    const index = runs.map(([s, n]) => `${this.entries[s].id} ${n}`).join(" ");
+    this.out.str(
+      `${xid} 0 obj
+<< /Type /XRef /Length ${rows.length} /W [1 4 1] /Prev ${prev} /Size ${this.nextID} /Index [${index}] /Root ${root} 0 R${extra} >>
+stream
+`
+    );
+    this.out.bytes(rows);
+    this.out.str(`
+endstream
+endobj
+startxref
+${xrefStart}
+%%EOF
+`);
+    return this.out.result();
+  }
+  /** Catalog-ийн skip-ээс бусад түлхүүрийг "  /Key value\n" хэлбэрээр (digitorus createCatalog). */
+  catalogCopy(...skip) {
+    const root = this.root();
+    const rp = root.ptr;
+    let s = "";
+    for (const key of root.keys()) {
+      if (key === "Type" || skip.includes(key)) continue;
+      s += `  /${escapeName(key)} ` + serialize(root.key(key), rp.id, 0) + "\n";
+    }
+    return s;
+  }
+};
+function trimSpace(b) {
+  const ws = (c) => c === 9 || c === 10 || c === 11 || c === 12 || c === 13 || c === 32;
+  let lo = 0;
+  let hi = b.length;
+  while (lo < hi && ws(b[lo])) lo++;
+  while (hi > lo && ws(b[hi - 1])) hi--;
+  return b.subarray(lo, hi);
+}
+
+// src/pades/page/qr.ts
+var VERSIONS = [
+  { ecPerBlock: 0, blocks: 0, dataPerBlock: 0, align: [] },
+  { ecPerBlock: 10, blocks: 1, dataPerBlock: 16, align: [] },
+  { ecPerBlock: 16, blocks: 1, dataPerBlock: 28, align: [6, 18] },
+  { ecPerBlock: 26, blocks: 1, dataPerBlock: 44, align: [6, 22] },
+  { ecPerBlock: 18, blocks: 2, dataPerBlock: 32, align: [6, 26] },
+  { ecPerBlock: 24, blocks: 2, dataPerBlock: 43, align: [6, 30] },
+  { ecPerBlock: 16, blocks: 4, dataPerBlock: 27, align: [6, 34] }
+];
+var MASK = 0;
+function qrEncode(data) {
+  let ver = 0;
+  for (let v = 1; v <= 6; v++) {
+    if (4 + 8 + 8 * data.length <= VERSIONS[v].blocks * VERSIONS[v].dataPerBlock * 8) {
+      ver = v;
+      break;
+    }
+  }
+  if (ver === 0) throw new Error("qr: \u04E9\u0433\u04E9\u0433\u0434\u04E9\u043B \u0445\u044D\u0442 \u0443\u0440\u0442 (\u2264 106 \u0431\u0430\u0439\u0442)");
+  const vi = VERSIONS[ver];
+  const total = vi.blocks * vi.dataPerBlock;
+  const bits = [];
+  const put = (v, n) => {
+    for (let i = n - 1; i >= 0; i--) bits.push((v >> i & 1) === 1);
+  };
+  put(4, 4);
+  put(data.length, 8);
+  for (const b of data) put(b, 8);
+  put(0, Math.min(4, total * 8 - bits.length));
+  while (bits.length % 8 !== 0) bits.push(false);
+  const cw = [];
+  for (let i = 0; i < bits.length; i += 8) {
+    let b = 0;
+    for (let j = 0; j < 8; j++) if (bits[i + j]) b |= 1 << 7 - j;
+    cw.push(b);
+  }
+  for (let i = 0; cw.length < total; i++) cw.push(i % 2 === 0 ? 236 : 17);
+  const gen = rsGenerator(vi.ecPerBlock);
+  const dataBlocks = [];
+  const ecBlocks = [];
+  for (let b = 0; b < vi.blocks; b++) {
+    dataBlocks.push(cw.slice(b * vi.dataPerBlock, (b + 1) * vi.dataPerBlock));
+    ecBlocks.push(rsRemainder(dataBlocks[b], gen));
+  }
+  const final = [];
+  for (let i = 0; i < vi.dataPerBlock; i++) for (let b = 0; b < vi.blocks; b++) final.push(dataBlocks[b][i]);
+  for (let i = 0; i < vi.ecPerBlock; i++) for (let b = 0; b < vi.blocks; b++) final.push(ecBlocks[b][i]);
+  return place(ver, vi, final);
+}
+function place(ver, vi, final) {
+  const n = 17 + 4 * ver;
+  const m = Array.from({ length: n }, () => new Array(n).fill(false));
+  const fn = Array.from({ length: n }, () => new Array(n).fill(false));
+  const set2 = (r, c, dark) => {
+    m[r][c] = dark;
+    fn[r][c] = true;
+  };
+  const finder = (r0, c0) => {
+    for (let r = -1; r <= 7; r++) {
+      for (let c = -1; c <= 7; c++) {
+        const rr = r0 + r;
+        const cc = c0 + c;
+        if (rr < 0 || cc < 0 || rr >= n || cc >= n) continue;
+        const dark = r >= 0 && r <= 6 && c >= 0 && c <= 6 && (r === 0 || r === 6 || c === 0 || c === 6 || r >= 2 && r <= 4 && c >= 2 && c <= 4);
+        set2(rr, cc, dark);
+      }
+    }
+  };
+  finder(0, 0);
+  finder(0, n - 7);
+  finder(n - 7, 0);
+  for (let i = 8; i < n - 8; i++) {
+    set2(6, i, i % 2 === 0);
+    set2(i, 6, i % 2 === 0);
+  }
+  for (const r of vi.align) {
+    for (const c of vi.align) {
+      if (r < 9 && c < 9 || r < 9 && c > n - 9 || r > n - 9 && c < 9) continue;
+      for (let dr = -2; dr <= 2; dr++) for (let dc = -2; dc <= 2; dc++) set2(r + dr, c + dc, Math.max(Math.abs(dr), Math.abs(dc)) !== 1);
+    }
+  }
+  const f = formatBits(0 << 3 | MASK);
+  const fb = (i) => (f >> i & 1) === 1;
+  for (let i = 0; i <= 5; i++) set2(i, 8, fb(i));
+  set2(7, 8, fb(6));
+  set2(8, 8, fb(7));
+  set2(8, 7, fb(8));
+  for (let i = 9; i < 15; i++) set2(8, 14 - i, fb(i));
+  for (let i = 0; i < 8; i++) set2(8, n - 1 - i, fb(i));
+  for (let i = 8; i < 15; i++) set2(n - 15 + i, 8, fb(i));
+  set2(n - 8, 8, true);
+  let bit = 0;
+  let up = true;
+  for (let col = n - 1; col > 0; col -= 2) {
+    if (col === 6) col--;
+    for (let k = 0; k < n; k++) {
+      const r = up ? n - 1 - k : k;
+      for (const c of [col, col - 1]) {
+        if (fn[r][c]) continue;
+        let dark = false;
+        if (bit < final.length * 8) dark = (final[bit >> 3] >> 7 - bit % 8 & 1) === 1;
+        bit++;
+        if ((r + c) % 2 === 0) dark = !dark;
+        m[r][c] = dark;
+      }
+    }
+    up = !up;
+  }
+  return m;
+}
+function formatBits(data) {
+  const g = 1335;
+  let v = data << 10;
+  for (let i = 14; i >= 10; i--) if (v >> i & 1) v ^= g << i - 10;
+  return (data << 10 | v) ^ 21522;
+}
+var GF_EXP = new Uint8Array(512);
+var GF_LOG = new Uint8Array(256);
+{
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    GF_EXP[i] = x;
+    GF_LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 512; i++) GF_EXP[i] = GF_EXP[i - 255];
+}
+function gfMul(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return GF_EXP[GF_LOG[a] + GF_LOG[b]];
+}
+function rsGenerator(n) {
+  let g = [1];
+  for (let i = 0; i < n; i++) {
+    const next = new Array(g.length + 1).fill(0);
+    g.forEach((c, j) => {
+      next[j] ^= c;
+      next[j + 1] ^= gfMul(c, GF_EXP[i]);
+    });
+    g = next;
+  }
+  return g.slice(1);
+}
+function rsRemainder(data, gen) {
+  const rem = new Array(gen.length).fill(0);
+  for (const d of data) {
+    const f = d ^ rem[0];
+    rem.copyWithin(0, 1);
+    rem[rem.length - 1] = 0;
+    gen.forEach((g, i) => {
+      rem[i] ^= gfMul(g, f);
+    });
+  }
+  return rem;
+}
+
+// src/pades/page/page.ts
+var PAGE_TEXTS = {
+  mn: {
+    title: "-\u0430\u0430\u0440 \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0437\u0443\u0440\u0441\u0430\u043D \u0431\u0430\u0440\u0438\u043C\u0442",
+    subtitle: "\u0413\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u04AF\u04AF\u0434 \u044D\u043D\u044D PDF-\u0434 \u0448\u0438\u043D\u0433\u044D\u0441\u044D\u043D. \u0414\u043E\u043E\u0440\u0445 \u0445\u043E\u043B\u0431\u043E\u043E\u0441\u043E\u043E\u0440 \u044D\u0441\u0432\u044D\u043B Adobe Acrobat-\u044B\u043D Signatures \u0441\u0430\u043C\u0431\u0430\u0440\u0430\u0430\u0440 \u0448\u0430\u043B\u0433\u0430\u043D\u0430 \u0443\u0443.",
+    document: "\u0411\u0410\u0420\u0418\u041C\u0422",
+    fileName: "\u0411\u0410\u0420\u0418\u041C\u0422\u042B\u041D \u041D\u042D\u0420",
+    hashAlg: "HASH \u0410\u041B\u0413\u041E\u0420\u0418\u0422\u041C",
+    size: "\u0425\u042D\u041C\u0416\u042D\u042D",
+    docHash: "\u0411\u0410\u0420\u0418\u041C\u0422\u042B\u041D HASH",
+    docID: "\u0411\u0410\u0420\u0418\u041C\u0422\u042B\u041D ID",
+    verification: "\u0428\u0410\u041B\u0413\u0410\u0425",
+    scan: "\u0413\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u0433 \u0448\u0430\u043B\u0433\u0430\u0445",
+    scanHint: "QR \u043A\u043E\u0434\u044B\u0433 \u0443\u0442\u0430\u0441\u043D\u044B \u043A\u0430\u043C\u0435\u0440\u0430\u0430\u0440 \u0443\u043D\u0448\u0443\u0443\u043B\u0430\u0445 \u044D\u0441\u0432\u044D\u043B \u0445\u043E\u043B\u0431\u043E\u043E\u0441\u044B\u0433 \u043D\u044D\u044D\u043D\u044D \u04AF\u04AF.",
+    trust: "Adobe Acrobat-\u0434 \u041C\u043E\u043D\u0433\u043E\u043B \u0423\u043B\u0441\u044B\u043D \u04AF\u043D\u0434\u044D\u0441\u043D\u0438\u0439 Root CA-\u0434 \u0438\u0442\u0433\u044D\u0445 \u0437\u0430\u0430\u0432\u0430\u0440:",
+    provider: "\u04AE\u0439\u043B\u0447\u0438\u043B\u0433\u044D\u044D"
+  },
+  en: {
+    title: " \u2014 Electronically signed document",
+    subtitle: "Signatures are embedded in this PDF. Verify them with the link below or in Adobe Acrobat's Signatures panel.",
+    document: "DOCUMENT",
+    fileName: "FILE NAME",
+    hashAlg: "HASH ALGORITHM",
+    size: "SIZE",
+    docHash: "DOCUMENT HASH",
+    docID: "DOCUMENT ID",
+    verification: "VERIFICATION",
+    scan: "Scan to verify",
+    scanHint: "Scan this QR code with your phone camera to verify.",
+    trust: "Adobe Acrobat: trust the Mongolian National Root CA",
+    provider: "Provider"
+  }
+};
+var MEDIA_BOX = "[0 0 595.28 841.89]";
+var LEFT = 42;
+var WIDTH = 510;
+var COL2 = 297;
+var QR_MODULE = 2;
+var QR_TEXT_X = 136;
+var FILE_NAME_MAX = 3;
+var C_TEXT = "0.118 0.118 0.118";
+var C_MUTED = "0.431 0.431 0.431";
+var C_OK = "0.086 0.541 0.31";
+var C_BANNER = "0.863 0.961 0.902";
+var C_LINE = "0.863 0.863 0.863";
+var C_LINK = "0.118 0.431 0.863";
+var BANNER = "48 800 m\n546 800 l\n549.31 800 552 797.31 552 794 c\n552 754 l\n552 750.69 549.31 748 546 748 c\n48 748 l\n44.69 748 42 750.69 42 754 c\n42 794 l\n42 797.31 44.69 800 48 800 c\nh\nf";
+var fonts;
+function loadFonts() {
+  fonts ??= [REGULAR, BOLD].map((a) => ({ a, gid: new Map(a.cmap) }));
+  return fonts;
+}
+var PageWriter = class {
+  constructor(reg, bld) {
+    this.reg = reg;
+    this.bld = bld;
+  }
+  reg;
+  bld;
+  ops = "";
+  links = [];
+  op(s) {
+    this.ops += s + "\n";
+  }
+  font(id) {
+    return id === 2 ? this.bld : this.reg;
+  }
+  gids(id, s) {
+    const f = this.font(id);
+    const q = f.gid.get(63) ?? 0;
+    return Array.from(s, (ch) => f.gid.get(ch.codePointAt(0)) ?? q);
+  }
+  width1000(id, size, s) {
+    if (id === 3) return 600 * Array.from(s).length * size;
+    const w = this.font(id).a.widths;
+    let sum = 0;
+    for (const g of this.gids(id, s)) sum += w[Math.min(g, w.length - 1)];
+    return sum * size;
+  }
+  text(id, size, x, y, color, s) {
+    const str = id === 3 ? "(" + s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)") + ")" : "<" + this.gids(id, s).map((g) => g.toString(16).toUpperCase().padStart(4, "0")).join("") + ">";
+    this.op(`${color} rg`);
+    this.op(`BT /F${id} ${size} Tf ${x} ${y} Td ${str} Tj ET`);
+  }
+  link(id, size, x, y, s) {
+    const wd = Math.floor((this.width1000(id, size, s) + 999) / 1e3);
+    this.links.push([x, y - 3, x + wd, y + size, s]);
+  }
+  hline(y) {
+    this.op(`${C_LINE} RG`);
+    this.op(`0.75 w ${LEFT} ${y} m ${LEFT + WIDTH} ${y} l S`);
+  }
+  wrap(id, size, s, maxW, maxLines) {
+    const limit = maxW * 1e3;
+    const fits = (t) => this.width1000(id, size, t) <= limit;
+    const lines = [];
+    let cur = "";
+    for (let word of s.split(" ")) {
+      if (word === "") continue;
+      const cand = cur === "" ? word : cur + " " + word;
+      if (fits(cand)) {
+        cur = cand;
+        continue;
+      }
+      if (cur !== "") {
+        lines.push(cur);
+        cur = "";
+      }
+      while (!fits(word)) {
+        const r = Array.from(word);
+        let n = 1;
+        while (n < r.length && fits(r.slice(0, n + 1).join(""))) n++;
+        lines.push(r.slice(0, n).join(""));
+        word = r.slice(n).join("");
+      }
+      cur = word;
+    }
+    if (cur !== "") lines.push(cur);
+    if (lines.length > maxLines) {
+      let last = Array.from(lines[maxLines - 1]);
+      while (last.length > 0 && !fits(last.join("") + "\u2026")) last = last.slice(0, -1);
+      lines.splice(maxLines - 1, lines.length, last.join("") + "\u2026");
+    }
+    return lines;
+  }
+};
+function humanSize(b) {
+  const tenths = (unit) => {
+    const t = Math.floor((b * 10 + Math.floor(unit / 2)) / unit);
+    return `${Math.floor(t / 10)}.${t % 10}`;
+  };
+  if (b < 1 << 10) return `${b} B`;
+  if (b < 1 << 20) return tenths(1 << 10) + " KB";
+  if (b < 1 << 30) return tenths(1 << 20) + " MB";
+  return tenths(1 << 30) + " GB";
+}
+function urlHost(u) {
+  let s = u.startsWith("https://") ? u.slice(8) : u;
+  if (s.startsWith("http://")) s = s.slice(7);
+  const i = s.indexOf("/");
+  if (i > 0) {
+    const next = s.slice(i + 1).indexOf("/");
+    if (next > 0) return s.slice(0, i + 1 + next);
+  }
+  return s;
+}
+function asciiURL(u) {
+  if (u === "") return false;
+  for (let i = 0; i < u.length; i++) {
+    const c = u.charCodeAt(i);
+    if (c < 33 || c > 126 || c === 40 || c === 41 || c === 92) return false;
+  }
+  return true;
+}
+function pageContent(p) {
+  if (!asciiURL(p.verifyUrl) || p.trustUrl !== "" && !asciiURL(p.trustUrl)) throw new PdfError("pades: URL ASCII \u0431\u0438\u0448");
+  const m = qrEncode(latin1(p.verifyUrl));
+  const tx = PAGE_TEXTS[p.lang === "" ? "mn" : p.lang];
+  if (!tx) throw new PdfError(`pades: \u0445\u0443\u0443\u0434\u0430\u0441\u043D\u044B \u0445\u044D\u043B ${p.lang}`);
+  const [reg, bld] = loadFonts();
+  const w = new PageWriter(reg, bld);
+  w.op(`${C_BANNER} rg`);
+  w.op(BANNER);
+  w.text(2, 13, 56, 778, C_OK, p.brand + tx.title);
+  w.text(1, 9, 56, 760, C_OK, tx.subtitle);
+  let y = 724;
+  w.hline(y);
+  w.text(2, 11, LEFT, y - 17, C_TEXT, tx.document);
+  y -= 34;
+  w.text(1, 8, LEFT, y, C_MUTED, tx.fileName);
+  y -= 14;
+  w.wrap(2, 10, p.fileName, WIDTH, FILE_NAME_MAX).forEach((line, i) => {
+    if (i > 0) y -= 14;
+    w.text(2, 10, LEFT, y, C_TEXT, line);
+  });
+  y -= 20;
+  w.text(1, 8, LEFT, y, C_MUTED, tx.hashAlg);
+  w.text(1, 8, COL2, y, C_MUTED, tx.size);
+  w.text(2, 10, LEFT, y - 14, C_TEXT, "SHA256");
+  w.text(2, 10, COL2, y - 14, C_TEXT, humanSize(p.fileSize));
+  y -= 34;
+  w.text(1, 8, LEFT, y, C_MUTED, tx.docHash);
+  w.text(3, 9, LEFT, y - 13, C_TEXT, p.documentHash);
+  y -= 31;
+  w.text(1, 8, LEFT, y, C_MUTED, tx.docID);
+  w.text(3, 9, LEFT, y - 13, C_TEXT, p.docId);
+  y -= 35;
+  w.hline(y);
+  w.text(2, 11, LEFT, y - 17, C_TEXT, tx.verification);
+  y -= 35;
+  w.text(1, 9, LEFT, y, C_LINK, p.verifyUrl);
+  w.link(1, 9, LEFT, y, p.verifyUrl);
+  y -= 14;
+  w.op("0 0 0 rg");
+  const n = m.length;
+  for (let r = 0; r < n; r++) {
+    for (let c = 0; c < n; ) {
+      if (!m[r][c]) {
+        c++;
+        continue;
+      }
+      const s = c;
+      while (c < n && m[r][c]) c++;
+      w.op(`${LEFT + QR_MODULE * s} ${y - QR_MODULE * (r + 1)} ${QR_MODULE * (c - s)} ${QR_MODULE} re`);
+    }
+  }
+  w.op("f");
+  w.text(2, 11, QR_TEXT_X, y - 14, C_TEXT, tx.scan);
+  w.text(1, 9, QR_TEXT_X, y - 29, C_MUTED, tx.scanHint);
+  w.text(2, 9, QR_TEXT_X, y - 43, C_LINK, urlHost(p.verifyUrl));
+  if (p.trustUrl !== "") {
+    w.text(1, 9, QR_TEXT_X, y - 60, C_MUTED, tx.trust);
+    w.text(2, 9, QR_TEXT_X, y - 74, C_LINK, p.trustUrl);
+    w.link(2, 9, QR_TEXT_X, y - 74, p.trustUrl);
+  }
+  w.hline(71);
+  w.text(1, 8, LEFT, 58, C_MUTED, `CA: ${p.caName}  |  TSA: ${p.tsaName}  |  ${tx.provider}: ${p.provider}`);
+  return { content: w.ops, links: w.links };
+}
+var asciiBytes = (s) => latin1(s);
+function streamObj(extra, data) {
+  return concat([latin1(`<< /Length ${data.length}${extra} >>
+stream
+`), data, latin1("\nendstream")]);
+}
+function appendVerifyPage(base, p) {
+  const [reg, bld] = loadFonts();
+  const { content, links } = pageContent(p);
+  const inc = new Incremental(base);
+  const root = inc.root();
+  const pages = root.key("Pages");
+  const pp = pages.ptr;
+  const rp = root.ptr;
+  if (pages.kind() !== "dict" || pages.key("Type").name() !== "Pages" || pp.id === rp.id && pp.gen === rp.gen || pp.id === 0) {
+    throw new PdfError("/Pages \u04AF\u043D\u0434\u044D\u0441 \u0430\u043B\u0433\u0430");
+  }
+  const count = pages.key("Count").int64();
+  if (count < 0 || pages.key("Kids").kind() !== "array") throw new PdfError("/Pages /Kids /Count \u0431\u0443\u0440\u0443\u0443");
+  if (rp.gen !== 0) throw new PdfError("Catalog-\u0438\u0439\u043D \u04AF\u0435 0 \u0431\u0438\u0448");
+  const pageID = inc.reserve();
+  const contentID = inc.reserve();
+  const fontIDs = [0, 1].map(() => [inc.reserve(), inc.reserve(), inc.reserve(), inc.reserve(), inc.reserve()]);
+  const courierID = inc.reserve();
+  const linkIDs = links.map(() => inc.reserve());
+  let pg = `<< /Type /Page /Parent ${pp.id} ${pp.gen} R /MediaBox ${MEDIA_BOX} /CropBox ${MEDIA_BOX} /Rotate 0 /Resources << /Font << /F1 ${fontIDs[0][0]} 0 R /F2 ${fontIDs[1][0]} 0 R /F3 ${courierID} 0 R >> >> /Contents ${contentID} 0 R`;
+  if (linkIDs.length > 0) pg += " /Annots [" + linkIDs.map((id) => `${id} 0 R`).join(" ") + "]";
+  pg += " >>";
+  inc.writeObject(pageID, pg);
+  inc.writeObject(contentID, streamObj("", asciiBytes(content)));
+  [reg, bld].forEach((f, i) => writeFont(inc, fontIDs[i], f));
+  inc.writeObject(courierID, "<< /Type /Font /Subtype /Type1 /BaseFont /Courier /Encoding /WinAnsiEncoding >>");
+  links.forEach((l, i) => {
+    inc.writeObject(linkIDs[i], `<< /Type /Annot /Subtype /Link /Rect [${l[0]} ${l[1]} ${l[2]} ${l[3]}] /Border [0 0 0] /A << /S /URI /URI (${l[4]}) >> >>`);
+  });
+  let pn = "<<";
+  for (const key of pages.keys()) {
+    if (key === "Kids" || key === "Count") continue;
+    pn += " /" + escapeName(key) + " " + serialize(pages.key(key), pp.id, 0);
+  }
+  const kids = pages.key("Kids");
+  const kp = kids.ptr;
+  pn += " /Kids [";
+  for (let i = 0; i < kids.len(); i++) pn += serialize(kids.index(i), kp.id, 0) + " ";
+  pn += `${pageID} 0 R] /Count ${count + 1} >>`;
+  inc.writeObject(pp.id, pn, pp.gen);
+  return inc.finish(rp.id);
+}
+function writeFont(inc, ids, f) {
+  const a = f.a;
+  inc.writeObject(ids[0], `<< /Type /Font /Subtype /Type0 /BaseFont /${a.psName} /Encoding /Identity-H /DescendantFonts [${ids[1]} 0 R] /ToUnicode ${ids[4]} 0 R >>`);
+  inc.writeObject(
+    ids[1],
+    `<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${a.psName} /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor ${ids[2]} 0 R /CIDToGIDMap /Identity /W [0 [${a.widths.join(" ")}]] >>`
+  );
+  inc.writeObject(
+    ids[2],
+    `<< /Type /FontDescriptor /FontName /${a.psName} /Flags 32 /FontBBox [${a.bbox.join(" ")}] /ItalicAngle 0 /Ascent ${a.ascent} /Descent ${a.descent} /CapHeight ${a.capHeight} /StemV 80 /FontFile2 ${ids[3]} 0 R >>`
+  );
+  inc.writeObject(ids[3], streamObj(` /Length1 ${a.length1} /Filter /FlateDecode`, fromB64(a.stream)));
+  inc.writeObject(ids[4], streamObj("", latin1(toUnicode(f))));
+}
+function toUnicode(f) {
+  const uni = /* @__PURE__ */ new Map();
+  for (const [r, g] of f.a.cmap) {
+    const old = uni.get(g);
+    if (old === void 0 || r < old) uni.set(g, r);
+  }
+  const pairs = [];
+  for (let g = 0; g < f.a.widths.length; g++) {
+    const r = uni.get(g);
+    if (r !== void 0) pairs.push([g, r]);
+  }
+  const hx = (n) => n.toString(16).toUpperCase().padStart(4, "0");
+  let b = "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n";
+  for (let i = 0; i < pairs.length; i += 100) {
+    const chunk = pairs.slice(i, i + 100);
+    b += `${chunk.length} beginbfchar
+`;
+    for (const [g, r] of chunk) b += `<${hx(g)}> <${hx(r)}>
+`;
+    b += "endbfchar\n";
+  }
+  return b + "endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend";
+}
+
+// src/pades/pdf/dss.ts
+var MAX_DSS_STREAM = 4 << 20;
+async function appendDSS(signed, d) {
+  if (d.certs.length + d.ocsps.length + d.crls.length === 0) throw new PdfError("pades: DSS \u0445\u043E\u043E\u0441\u043E\u043D");
+  const inc = new Incremental(signed);
+  const root = inc.root();
+  const old = root.key("DSS");
+  if (!old.isNull() && old.kind() !== "dict") throw new PdfError("/DSS \u0442\u043E\u043B\u044C \u0431\u0438\u0448");
+  const known = /* @__PURE__ */ new Map();
+  const lists = /* @__PURE__ */ new Map();
+  const push = (k, ref) => {
+    const l = lists.get(k) ?? [];
+    l.push(ref);
+    lists.set(k, l);
+  };
+  for (const key of ["Certs", "OCSPs", "CRLs"]) {
+    const arr = old.key(key);
+    const ap = arr.ptr;
+    for (let i = 0; i < arr.len(); i++) {
+      const e = arr.index(i);
+      const ref = serialize(e, ap.id, 0);
+      push(key, ref);
+      if (e.kind() === "stream") {
+        let data;
+        try {
+          data = e.streamData();
+        } catch {
+          data = void 0;
+        }
+        if (data) known.set(toHex(await sha256(data.length > MAX_DSS_STREAM ? data.subarray(0, MAX_DSS_STREAM) : data)), ref);
+      }
+    }
+  }
+  const vriEntry = [[], [], []];
+  const add = async (slot, key, items) => {
+    for (const der2 of items) {
+      const sum = toHex(await sha256(der2));
+      let ref = known.get(sum);
+      if (ref === void 0) {
+        const body = concat([latin1(`<< /Length ${der2.length} >>
+stream
+`), der2, latin1("\nendstream")]);
+        const [id] = inc.addObject(body);
+        ref = `${id} 0 R`;
+        known.set(sum, ref);
+        push(key, ref);
+      }
+      if (!vriEntry[slot].includes(ref)) vriEntry[slot].push(ref);
+    }
+  };
+  await add(0, "Certs", d.certs);
+  await add(1, "OCSPs", d.ocsps);
+  await add(2, "CRLs", d.crls);
+  let dss = "<<";
+  for (const key of ["Certs", "OCSPs", "CRLs"]) {
+    const l = lists.get(key) ?? [];
+    if (l.length > 0) dss += ` /${key} [${l.join(" ")}]`;
+  }
+  const vri = old.key("VRI");
+  if (d.contents.length > 0 || vri.kind() === "dict") {
+    dss += " /VRI <<";
+    const vp = vri.ptr;
+    const newKey = d.contents.length > 0 ? toHex(await sha1(d.contents)).toUpperCase() : "";
+    for (const key of vri.keys()) {
+      if (key === newKey) continue;
+      dss += " /" + escapeName(key) + " " + serialize(vri.key(key), vp.id, 0);
+    }
+    if (newKey !== "") {
+      dss += " /" + newKey + " <<";
+      ["Cert", "OCSP", "CRL"].forEach((k, i) => {
+        if (vriEntry[i].length > 0) dss += ` /${k} [${vriEntry[i].join(" ")}]`;
+      });
+      dss += " >>";
+    }
+    dss += " >>";
+  }
+  dss += " >>";
+  const [dssID] = inc.addObject(dss);
+  let cat = "<<\n  /Type /Catalog\n";
+  cat += inc.catalogCopy("DSS");
+  cat += `  /DSS ${dssID} 0 R
+>>`;
+  const [catID] = inc.addObject(cat);
+  return inc.finish(catID);
+}
+
+// src/pades/pdf/signature.ts
+var MEASURED_MAX_CMS = 14 << 10;
+var PLACEHOLDER_BYTES = 2 * MEASURED_MAX_CMS;
+var SUB_FILTER = "ETSI.CAdES.detached";
+var REASON_MAX_UNITS = 127;
+var BYTE_RANGE_WIDTH = 40;
+var MAX_DEPTH2 = 32;
+var PlaceholderOverflowError = class extends Error {
+};
+function pdfDate(t) {
+  const z = new Date(t.getTime() + 8 * 36e5);
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `(D:${p(z.getUTCFullYear(), 4)}${p(z.getUTCMonth() + 1)}${p(z.getUTCDate())}${p(z.getUTCHours())}${p(z.getUTCMinutes())}${p(z.getUTCSeconds())}+08'00')`;
+}
+async function prepareSignature(base, signingTime, signerName, reason) {
+  const inc = new Incremental(base);
+  const root = inc.root();
+  const acro = root.key("AcroForm");
+  const fields = acro.key("Fields");
+  const names = /* @__PURE__ */ new Set();
+  let sigFields = 0;
+  for (let i = 0; i < fields.len(); i++) {
+    const f = fields.index(i);
+    names.add(f.key("T").text());
+    if (f.key("FT").name() === "Sig") sigFields++;
+  }
+  let k = sigFields + 1;
+  while (names.has(`Signature ${k}`)) k++;
+  const fieldName = `Signature ${k}`;
+  const sigID = inc.reserve();
+  const fieldID = inc.reserve();
+  const catID = inc.reserve();
+  let sig = `<<
+ /Type /Sig
+ /Filter /Adobe.PPKLite
+ /SubFilter /${SUB_FILTER}
+ /ByteRange `;
+  const brAt = sig.length;
+  sig += " ".repeat(BYTE_RANGE_WIDTH);
+  sig += "\n /Contents <";
+  const contentsAt = sig.length - 1;
+  sig += "0".repeat(2 * PLACEHOLDER_BYTES);
+  sig += ">\n /M " + pdfDate(signingTime);
+  const n = sigText(signerName, 120);
+  if (n) sig += "\n /Name " + n;
+  const r = sigText(reason, REASON_MAX_UNITS);
+  if (r) sig += "\n /Reason " + r;
+  sig += "\n>>";
+  const sigStart = inc.writeObject(sigID, sig);
+  let fld = "<<\n  /Type /Annot\n  /Subtype /Widget\n  /Rect [0 0 0 0]\n";
+  const page = firstPage(root.key("Pages"), 0);
+  if (page) fld += `  /P ${page.ptr.id} ${page.ptr.gen} R
+`;
+  fld += `  /F 132
+  /FT /Sig
+  /T (${fieldName})
+  /V ${sigID} 0 R
+>>`;
+  inc.writeObject(fieldID, fld);
+  if (page) addWidgetToPage(inc, page, fieldID);
+  let cat = "<<\n  /Type /Catalog\n";
+  if (root.key("Version").isNull()) {
+    const v = parseGoFloat(inc.rdr.pdfVersion);
+    if (v !== void 0 && v < 1.5) cat += "  /Version /1.5\n";
+  }
+  cat += inc.catalogCopy("AcroForm");
+  cat += "  /AcroForm <<";
+  if (acro.kind() === "dict") {
+    const ap = acro.ptr;
+    for (const key of acro.keys()) {
+      if (key === "Fields" || key === "SigFlags") continue;
+      cat += " /" + escapeName(key) + " " + serialize(acro.key(key), ap.id, 0);
+    }
+  }
+  cat += " /Fields [";
+  const fp = fields.ptr;
+  for (let i = 0; i < fields.len(); i++) cat += serialize(fields.index(i), fp.id, 0) + " ";
+  cat += `${fieldID} 0 R] /SigFlags 3 >>
+>>`;
+  inc.writeObject(catID, cat);
+  const doc = inc.finish(catID);
+  const a = sigStart + contentsAt;
+  const b = a + 2 * PLACEHOLDER_BYTES + 2;
+  if (doc[a] !== 60 || doc[b - 1] !== 62) throw new PdfError("pades: placeholder-\u0438\u0439\u043D \u0431\u0430\u0439\u0440\u043B\u0430\u043B \u0431\u0443\u0440\u0443\u0443");
+  const br = [0, a, b, doc.length - b];
+  const field = `[${br[0]} ${br[1]} ${br[2]} ${br[3]}]`;
+  if (field.length > BYTE_RANGE_WIDTH) throw new PdfError("pades: ByteRange \u0442\u0430\u043B\u0431\u0430\u0440\u0442 \u0431\u0430\u0433\u0442\u0441\u0430\u043D\u0433\u04AF\u0439");
+  doc.set(latin1(field), sigStart + brAt);
+  return { pdf: doc, byteRange: br, digest: await rangeDigest(doc, br), fieldName };
+}
+async function rangeDigest(doc, br) {
+  const buf = new Uint8Array(br[1] + br[3]);
+  buf.set(doc.subarray(0, br[1]), 0);
+  buf.set(doc.subarray(br[2], br[2] + br[3]), br[1]);
+  return sha256(buf);
+}
+function embedCMS(prepared, br, cms) {
+  if (cms.length === 0) throw new PdfError("pades: CMS \u0445\u043E\u043E\u0441\u043E\u043D");
+  if (cms.length > PLACEHOLDER_BYTES) throw new PlaceholderOverflowError(`${cms.length} > ${PLACEHOLDER_BYTES} \u0431\u0430\u0439\u0442`);
+  const [z, a, b, c] = br;
+  if (z !== 0 || a <= 0 || b !== a + 2 * PLACEHOLDER_BYTES + 2 || b + c !== prepared.length || prepared[a] !== 60 || prepared[b - 1] !== 62) {
+    throw new PdfError("pades: ByteRange \u043D\u044C prepared \u0431\u0430\u0440\u0438\u043C\u0442\u0442\u0430\u0439 \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
+  }
+  for (let i = a + 1; i < b - 1; i++) if (prepared[i] !== 48) throw new PdfError("pades: placeholder \u0430\u043B\u044C \u0445\u044D\u0434\u0438\u0439\u043D \u0431\u04E9\u0433\u043B\u04E9\u0433\u0434\u0441\u04E9\u043D");
+  const out = prepared.slice();
+  out.set(latin1(toHex(cms)), a + 1);
+  return out;
+}
+function signatureContents(signed, br) {
+  const [z, a, b] = br;
+  if (z !== 0 || a <= 0 || b <= a + 2 || b > signed.length || signed[a] !== 60 || signed[b - 1] !== 62) {
+    throw new PdfError("pades: ByteRange \u043D\u044C /Contents-\u0438\u0439\u0433 \u0437\u0430\u0430\u0445\u0433\u04AF\u0439");
+  }
+  let s = "";
+  for (let i = a + 1; i < b - 1; i++) s += String.fromCharCode(signed[i]);
+  if (s.length % 2 !== 0) throw new PdfError("pades: /Contents hex: odd length");
+  return fromHex(s);
+}
+function addWidgetToPage(inc, page, widget) {
+  const pgp = page.ptr;
+  const annots = page.key("Annots");
+  if (!annots.isNull() && annots.kind() !== "array") throw new PdfError("\u0445\u0443\u0443\u0434\u0430\u0441\u043D\u044B /Annots \u043C\u0430\u0441\u0441\u0438\u0432 \u0431\u0438\u0448");
+  const ap = annots.ptr;
+  let arr = "[";
+  for (let i = 0; i < annots.len(); i++) arr += serialize(annots.index(i), ap.id, 0) + " ";
+  arr += `${widget} 0 R]`;
+  if (!annots.isNull() && (ap.id !== pgp.id || ap.gen !== pgp.gen)) {
+    inc.writeObject(ap.id, arr, ap.gen);
+    return;
+  }
+  let b = "<<";
+  for (const key of page.keys()) {
+    if (key === "Annots") continue;
+    b += " /" + escapeName(key) + " " + serialize(page.key(key), pgp.id, 0);
+  }
+  b += " /Annots " + arr + " >>";
+  inc.writeObject(pgp.id, b, pgp.gen);
+}
+function firstPage(v, depth) {
+  if (depth > MAX_DEPTH2) return void 0;
+  switch (v.key("Type").name()) {
+    case "Page":
+      return v;
+    case "Pages": {
+      const kids = v.key("Kids");
+      for (let i = 0; i < kids.len(); i++) {
+        const p = firstPage(kids.index(i), depth + 1);
+        if (p) return p;
+      }
+    }
+  }
+  return void 0;
+}
+function parseGoFloat(s) {
+  return /^[+-]?(\d+\.?\d*|\.\d+)$/.test(s) ? parseFloat(s) : void 0;
+}
+var BAD_WORDS = [" obj", "endobj", "stream", "xref", "trailer", "%%EOF"];
+function goTrimSpace(s) {
+  const sp = (c) => c >= 9 && c <= 13 || c === 32 || c === 133 || c === 160 || c === 5760 || c >= 8192 && c <= 8202 || c === 8232 || c === 8233 || c === 8239 || c === 8287 || c === 12288;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi && sp(s.charCodeAt(lo))) lo++;
+  while (hi > lo && sp(s.charCodeAt(hi - 1))) hi--;
+  return s.slice(lo, hi);
+}
+function sigText(input, maxUnits) {
+  const s = goTrimSpace(input);
+  if (s === "" || s.length > maxUnits || /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/.test(s)) return "";
+  let ascii = true;
+  for (const ch of s) {
+    const r = ch.codePointAt(0);
+    if (r < 32 || r === 127 || r >= 128 && r <= 159) return "";
+    if (r > 126) ascii = false;
+  }
+  if (BAD_WORDS.some((w) => s.includes(w))) return "";
+  if (ascii) return hexString(latin1(s));
+  const raw = new Uint8Array(2 + s.length * 2);
+  raw[0] = 254;
+  raw[1] = 255;
+  for (let i = 0; i < s.length; i++) {
+    const u = s.charCodeAt(i);
+    raw[2 + i * 2] = u >> 8;
+    raw[3 + i * 2] = u & 255;
+  }
+  return hexString(raw);
+}
+
+// src/pades/precheck.ts
+var MAX_SIGNATURES = 16;
+var VERIFY_URL_PREFIX = "https://ca.eidmongolia.mn/verify/";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var PrecheckError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var ENCRYPT_KEY = /\/Encrypt\s+\d+\s+\d+\s+R/;
+function openReader(doc) {
+  try {
+    return new Reader(doc);
+  } catch {
+    return void 0;
+  }
+}
+function encrypted(doc) {
+  const r = openReader(doc);
+  if (!r) return ENCRYPT_KEY.test(fromLatin1(doc));
+  try {
+    return !r.trailerValue().key("Encrypt").isNull();
+  } catch {
+    return false;
+  }
+}
+function docMDPP1(sig) {
+  const ref = sig.key("Reference");
+  for (let i = 0; i < ref.len(); i++) {
+    const e = ref.index(i);
+    const m = e.key("TransformMethod");
+    const p = e.key("TransformParams").key("P");
+    if ((m.isNull() || m.name() === "DocMDP") && p.kind() === "int" && p.int64() === 1) return true;
+  }
+  return false;
+}
+function scanSignatures(doc) {
+  const r = new Reader(doc);
+  const root = r.trailerValue().key("Root");
+  if (root.kind() !== "dict") throw new PdfError("Catalog \u0430\u043B\u0433\u0430");
+  const hasDSS = root.key("DSS").kind() === "dict";
+  let locked = docMDPP1(root.key("Perms").key("DocMDP"));
+  const sigs = [];
+  for (const x of r.xref) {
+    const v = r.resolve(x.ptr, new PRef(x.ptr.id, x.ptr.gen));
+    if (v.kind() !== "dict" || v.key("ByteRange").isNull() || v.key("Contents").isNull()) continue;
+    const s = { obj: x.ptr.id, byteRange: [], subFilter: v.key("SubFilter").name() };
+    const br = v.key("ByteRange");
+    for (let i = 0; i < br.len(); i++) {
+      const e = br.index(i);
+      if (e.kind() !== "int") {
+        s.byteRange = void 0;
+        break;
+      }
+      s.byteRange.push(e.int64());
+    }
+    if (docMDPP1(v)) locked = true;
+    sigs.push(s);
+  }
+  sigs.sort((a, b) => a.obj - b.obj);
+  return { sigs, locked, hasDSS };
+}
+async function checkPriorSignature(doc, s) {
+  const br = s.byteRange;
+  if (!br || br.length !== 4 || br[0] !== 0 || br[1] <= 0 || br[2] <= br[1] + 1 || br[3] < 0 || br[2] + br[3] > doc.length) {
+    throw new Error("ByteRange \u0431\u0443\u0440\u0443\u0443");
+  }
+  const [, a, b, c] = br;
+  if (doc[a] !== 60 || doc[b - 1] !== 62) throw new Error("ByteRange \u043D\u044C /Contents-\u0438\u0439\u0433 \u0437\u0430\u0430\u0445\u0433\u04AF\u0439");
+  let end = b + c;
+  while (end > 0 && (doc[end - 1] === 10 || doc[end - 1] === 13)) end--;
+  if (end < 5 || fromLatin1(doc, end - 5, end) !== "%%EOF") throw new Error("ByteRange \u043D\u044C revision-\u0438\u0439 \u0442\u04E9\u0433\u0441\u0433\u04E9\u043B (%%EOF) \u0445\u04AF\u0440\u0442\u044D\u043B \u0431\u0438\u0448");
+  if ((b - a - 2) % 2 !== 0) throw new Error("/Contents hex \u0441\u043E\u043D\u0434\u0433\u043E\u0439");
+  const hex = fromLatin1(doc, a + 1, b - 1);
+  if (/[^0-9a-fA-F]/.test(hex)) throw new Error("/Contents hex");
+  const raw = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < raw.length; i++) raw[i] = parseInt(hex.substr(i * 2, 2), 16);
+  const der2 = readNode(raw, 0);
+  if (der2.tag !== TAG.SEQUENCE) throw new Error("CMS DER \u0431\u0438\u0448");
+  const sd = parseSignedData(der2.raw);
+  if (sd.signerInfos.length !== 1) throw new Error("signer \u0433\u0430\u043D\u0446 \u0431\u0438\u0448");
+  const sid = children(sd.signerInfos[0])[1];
+  if (sid.tag !== TAG.SEQUENCE) throw new Error("signer cert \u0430\u043B\u0433\u0430");
+  const [iss, ser] = children(sid);
+  const leaf = sd.certificates.find((x) => eq(x.rawIssuer, iss.raw) && eq(x.serial, ser.value));
+  if (!leaf) throw new Error("signer cert \u0430\u043B\u0433\u0430");
+  const signed = new Uint8Array(a + c);
+  signed.set(doc.subarray(0, a), 0);
+  signed.set(doc.subarray(b, b + c), a);
+  if (!await verifySignedData({ ...sd, content: signed })) throw new Error("\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433");
+  let stamped = false;
+  for (const f of children(sd.signerInfos[0])) {
+    if (f.tag !== 161) continue;
+    for (const at of children(f)) {
+      const t = children(at)[0];
+      if (t?.tag === TAG.OID && oidString(t.value) === OID_TST) stamped = true;
+    }
+  }
+  return { leaf, stamped };
+}
+var OID_TST = "1.2.840.113549.1.9.16.2.14";
+var eq = (x, y) => x.length === y.length && x.every((v, i) => v === y[i]);
+async function issuedByAny(leaf, issuers) {
+  for (const is of issuers) if (eq(leaf.rawIssuer, is.rawSubject) && await checkSignatureFrom(leaf, is)) return true;
+  return false;
+}
+async function precheck(doc, issuers) {
+  if (encrypted(doc)) throw new PrecheckError("PDF_ENCRYPTED", "\u0448\u0438\u0444\u0440\u043B\u044D\u0433\u0434\u0441\u044D\u043D PDF \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439");
+  let scan;
+  try {
+    scan = scanSignatures(doc);
+  } catch (e) {
+    throw new PrecheckError("PDF_INVALID", `PDF \u0431\u0438\u0448 \u044D\u0441\u0432\u044D\u043B \u044D\u0432\u0434\u044D\u0440\u0441\u044D\u043D: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const { sigs, locked, hasDSS } = scan;
+  if (sigs.length === 0) return { newDoc: true, revIndex: 1 };
+  if (sigs.length >= MAX_SIGNATURES) throw new PrecheckError("PDF_TOO_MANY_SIGNATURES", "\u0431\u0430\u0440\u0438\u043C\u0442\u0430\u0434 \u0445\u044D\u0442 \u043E\u043B\u043E\u043D \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0431\u0430\u0439\u043D\u0430");
+  const leaves = [];
+  for (const s of sigs) {
+    try {
+      leaves.push(await checkPriorSignature(doc, s));
+    } catch (e) {
+      throw new PrecheckError("PDF_PRIOR_SIGNATURE_INVALID", `\u04E9\u043C\u043D\u04E9\u0445 \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0445\u04AF\u0447\u0438\u043D\u0433\u04AF\u0439: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  if (locked) throw new PrecheckError("PDF_LOCKED", "\u0431\u0430\u0440\u0438\u043C\u0442 certification (DocMDP P=1) \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u044D\u044D\u0440 \u0442\u04AF\u0433\u0436\u0438\u0433\u0434\u0441\u044D\u043D");
+  for (let i = 0; i < sigs.length; i++) {
+    const l = leaves[i];
+    if (sigs[i].subFilter !== "ETSI.CAdES.detached" || !await issuedByAny(l.leaf, issuers) || !l.stamped || !hasDSS) {
+      throw new PrecheckError("PDF_FOREIGN_SIGNATURE", "\u0431\u0430\u0440\u0438\u043C\u0442\u0430\u0434 eID-\u0438\u0439\u043D \u0431\u0438\u0448 \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0431\u0430\u0439\u043D\u0430");
+    }
+  }
+  return { newDoc: false, revIndex: sigs.length + 1 };
+}
+function docIdFromPage(doc) {
+  try {
+    const r = new Reader(doc);
+    for (const x of r.xref) {
+      const v = r.resolve(x.ptr, new PRef(x.ptr.id, x.ptr.gen));
+      if (v.kind() !== "dict" || v.key("Subtype").name() !== "Link") continue;
+      const u = fromLatin1(v.key("A").key("URI").rawString());
+      if (u.startsWith(VERIFY_URL_PREFIX) && UUID_RE.test(u.slice(VERIFY_URL_PREFIX.length))) return u.slice(VERIFY_URL_PREFIX.length);
+    }
+  } catch {
+  }
+  return "";
+}
+function signatureCMSList(doc) {
+  const r = new Reader(doc);
+  const out = [];
+  for (const x of r.xref) {
+    const v = r.resolve(x.ptr, new PRef(x.ptr.id, x.ptr.gen));
+    if (v.kind() !== "dict" || v.key("Contents").isNull() || v.key("ByteRange").isNull()) continue;
+    const t = v.key("Type").name();
+    if (t !== "" && t !== "Sig") continue;
+    try {
+      const n = readNode(v.key("Contents").rawString(), 0);
+      out.push(n.tag === TAG.SEQUENCE ? n.raw : void 0);
+    } catch {
+      out.push(void 0);
+    }
+  }
+  return out;
+}
+
+// src/pades/state.ts
+var MAGIC = enc.encode("EIDPADES1");
+function encodeState(s) {
+  const head = {
+    docId: s.docId,
+    signerCert: toB64(s.signerCert),
+    chain: s.chain.map(toB64),
+    signedAttrs: toB64(s.signedAttrs),
+    byteRange: s.byteRange,
+    revIndex: s.revIndex,
+    inSha256: s.inSha256,
+    hasPage: s.hasPage
+  };
+  if (s.pageSha256) head.pageSha256 = s.pageSha256;
+  if (s.claimedRole) head.claimedRole = s.claimedRole;
+  head.preparedSha256 = s.preparedSha256;
+  const h = enc.encode(JSON.stringify(head));
+  const len = new Uint8Array(4);
+  new DataView(len.buffer).setUint32(0, h.length);
+  return concat([MAGIC, len, h, s.pdf]);
+}
+async function decodeState(b) {
+  if (b.length < MAGIC.length + 4 || !MAGIC.every((x, i) => b[i] === x)) throw new Error("state-\u0438\u0439\u043D \u0442\u043E\u043B\u0433\u043E\u0439 \u0442\u0430\u043D\u0438\u0433\u0434\u0441\u0430\u043D\u0433\u04AF\u0439");
+  const n = new DataView(b.buffer, b.byteOffset + MAGIC.length, 4).getUint32(0);
+  const off = MAGIC.length + 4;
+  if (n > b.length - off) throw new Error("state \u0442\u0430\u0441\u043B\u0430\u0433\u0434\u0441\u0430\u043D");
+  const j = JSON.parse(new TextDecoder().decode(b.subarray(off, off + n)));
+  const pdf = b.slice(off + n);
+  const str = (k) => typeof j[k] === "string" ? j[k] : "";
+  const s = {
+    docId: str("docId"),
+    signerCert: fromB64(str("signerCert")),
+    chain: Array.isArray(j.chain) ? j.chain.map((x) => fromB64(String(x))) : [],
+    signedAttrs: fromB64(str("signedAttrs")),
+    byteRange: Array.isArray(j.byteRange) ? j.byteRange.map(Number) : [0, 0, 0, 0],
+    revIndex: Number(j.revIndex ?? 0),
+    inSha256: str("inSha256"),
+    hasPage: j.hasPage === true,
+    pageSha256: str("pageSha256"),
+    claimedRole: str("claimedRole"),
+    preparedSha256: str("preparedSha256"),
+    pdf
+  };
+  if (toHex(await sha256(pdf)) !== s.preparedSha256) throw new Error("prepared PDF-\u0438\u0439\u043D hash \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
+  if (s.signedAttrs.length === 0 || s.signerCert.length === 0 || pdf.length === 0 || !(s.revIndex >= 1) || s.byteRange.length !== 4) {
+    throw new Error("state \u0434\u0443\u0442\u0443\u0443");
+  }
+  return s;
+}
+
+// src/pades.ts
+var PROFILE_VERSION = "pades-client/1";
+var PADES_ERROR_CODES = [
+  "PDF_INVALID",
+  "PDF_ENCRYPTED",
+  "PDF_LOCKED",
+  "PDF_TOO_LARGE",
+  "PDF_TOO_MANY_SIGNATURES",
+  "PDF_PRIOR_SIGNATURE_INVALID",
+  "PDF_FOREIGN_SIGNATURE",
+  "SIGNER_INVALID",
+  "REQUEST_INVALID",
+  "SIGNATURE_INVALID",
+  "TSA_UNAVAILABLE",
+  "LTV_UNAVAILABLE",
+  "SELF_VALIDATION_FAILED",
+  "PLACEHOLDER_OVERFLOW",
+  "STATE_INVALID",
+  "INTERNAL"
+];
+var PadesError = class extends EidError {
+  constructor(code, message, options) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    if (options?.cause !== void 0) this.cause = options.cause;
+  }
+  code;
+  get retryable() {
+    return this.code === "TSA_UNAVAILABLE" || this.code === "LTV_UNAVAILABLE";
+  }
+};
+var MAX_INPUT_BYTES = (10 << 20) - (256 << 10);
+var MAX_OUTPUT_BYTES = 10 << 20;
+var MAX_FILE_NAME = 120;
+var PAGE_BRAND = "eID Mongolia";
+var PAGE_PROVIDER = "ca.eidmongolia.mn";
+var PAGE_TRUST_URL = "https://eidmongolia.mn/trust";
+var PAGE_TSA_NAME = "eID Mongolia TSA (tsa.timeserver.mn)";
+function profileVersion() {
+  return PROFILE_VERSION;
+}
+function u8(v, name) {
+  if (v instanceof Uint8Array) return v;
+  if (v instanceof ArrayBuffer) return new Uint8Array(v);
+  throw new PadesError("REQUEST_INVALID", `${name} Uint8Array \u0431\u0430\u0439\u0445 \u0451\u0441\u0442\u043E\u0439`);
+}
+var der = (b64s) => b64s.map((s) => parseCertificate(fromB64(s)));
+function parseDERs(list, code, what) {
+  return list.map((d, i) => {
+    try {
+      return parseCertificate(u8(d, `${what}[${i}]`));
+    } catch (e) {
+      throw new PadesError(code, `${what} #${i}`, { cause: e });
+    }
+  });
+}
+async function signerChain(signer, chain) {
+  if (chain && chain.length > 0) return parseDERs(chain, "SIGNER_INVALID", "chain");
+  const pool = der(INTERMEDIATES);
+  const out = [];
+  let cur = signer;
+  for (let k = 0; k < pool.length + 1; k++) {
+    let next;
+    for (const c of pool) {
+      if (eq2(c.rawSubject, cur.rawIssuer) && await checkSignatureFrom(cur, c)) {
+        next = c;
+        break;
+      }
+    }
+    if (!next) break;
+    out.push(next);
+    cur = next;
+  }
+  if (out.length === 0) throw new PadesError("SIGNER_INVALID", "signer-\u0438\u0439\u043D \u043E\u043B\u0433\u043E\u0433\u0447 \u0448\u0438\u0433\u0442\u0433\u044D\u0441\u044D\u043D eID \u0433\u0438\u043D\u0436\u0438\u0434 \u0430\u043B\u0433\u0430 \u2014 chain \u04E9\u0433\u043D\u04E9 \u04AF\u04AF");
+  return out;
+}
+var eq2 = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+function cleanFileName(s) {
+  const out = goTrim(s.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}�]/gu, "").normalize("NFC"));
+  if (out === "" || Array.from(out).length > MAX_FILE_NAME) return void 0;
+  return out;
+}
+function goTrim(s) {
+  const sp = (c) => c >= 9 && c <= 13 || c === 32 || c === 133 || c === 160 || c === 5760 || c >= 8192 && c <= 8202 || c === 8232 || c === 8233 || c === 8239 || c === 8287 || c === 12288;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi && sp(s.charCodeAt(lo))) lo++;
+  while (hi > lo && sp(s.charCodeAt(hi - 1))) hi--;
+  return s.slice(lo, hi);
+}
+async function randUUID() {
+  const b = await randomBytes(16);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = toHex(b);
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+function signerDisplayName(c) {
+  const n = goTrim(`${c.givenName} ${c.surname}`);
+  return n !== "" ? n : c.subjectCN;
+}
+async function prepare(pdf, opts) {
+  const doc = u8(pdf, "pdf");
+  if (doc.length > MAX_INPUT_BYTES) throw new PadesError("PDF_TOO_LARGE", "PDF 9.75 MB-\u0430\u0430\u0441 \u0438\u0445 \u0431\u0430\u0439\u043D\u0430");
+  if (doc.length < 5 || String.fromCharCode(...doc.subarray(0, 5)) !== "%PDF-") throw new PadesError("PDF_INVALID", "PDF \u0431\u0438\u0448 \u044D\u0441\u0432\u044D\u043B \u044D\u0432\u0434\u044D\u0440\u0441\u044D\u043D");
+  let cert;
+  try {
+    cert = parseCertificate(u8(opts.signerCert, "signerCert"));
+  } catch (e) {
+    throw new PadesError("SIGNER_INVALID", "signerCert \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  if (cert.keyAlg !== OID.rsaEncryption && cert.keyAlg !== OID.ecPublicKey) {
+    throw new PadesError("SIGNER_INVALID", "\u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0442\u04AF\u043B\u0445\u04AF\u04AF\u0440\u0438\u0439\u043D \u0442\u04E9\u0440\u04E9\u043B \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439");
+  }
+  const chain = await signerChain(cert, opts.chain);
+  const docIdOpt = opts.docId ?? "";
+  if (docIdOpt !== "" && !UUID_RE.test(docIdOpt)) throw new PadesError("REQUEST_INVALID", "docId \u043D\u044C \u0436\u0438\u0436\u0438\u0433 \u04AF\u0441\u0433\u0438\u0439\u043D UUID \u0431\u0430\u0439\u0445 \u0451\u0441\u0442\u043E\u0439");
+  if (opts.lang !== void 0 && opts.lang !== "" && opts.lang !== "mn" && opts.lang !== "en") {
+    throw new PadesError("REQUEST_INVALID", "lang: mn | en");
+  }
+  const now = opts.signingTime ?? /* @__PURE__ */ new Date();
+  if (Number.isNaN(now.getTime())) throw new PadesError("REQUEST_INVALID", "signingTime \u0431\u0443\u0440\u0443\u0443 Date");
+  const inHex = toHex(await sha256(doc));
+  let pc;
+  try {
+    pc = await precheck(doc, [...der(EID_ISSUERS), chain[0]]);
+  } catch (e) {
+    if (e instanceof PrecheckError) throw new PadesError(e.code, e.message, { cause: e });
+    throw new PadesError("PDF_INVALID", "PDF \u0431\u0438\u0448 \u044D\u0441\u0432\u044D\u043B \u044D\u0432\u0434\u044D\u0440\u0441\u044D\u043D", { cause: e });
+  }
+  let docId = docIdOpt;
+  let base = doc;
+  let pageHex = "";
+  const hasPage = pc.newDoc && opts.verifyPage === true;
+  if (!pc.newDoc) {
+    const fromPage = docIdFromPage(doc);
+    if (fromPage !== "") {
+      if (docId !== "" && docId !== fromPage) throw new PadesError("REQUEST_INVALID", "docId \u043D\u044C \u0431\u0430\u0440\u0438\u043C\u0442\u044B\u043D \u0445\u0443\u0443\u0434\u0441\u0430\u043D \u0434\u044D\u044D\u0440\u0445\u0442\u044D\u0439 \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
+      docId = fromPage;
+    }
+  }
+  if (pc.newDoc && docId === "") docId = await randUUID();
+  if (hasPage) {
+    const fileName = cleanFileName(opts.fileName ?? "");
+    if (fileName === void 0) throw new PadesError("REQUEST_INVALID", "fileName \u0437\u0430\u0430\u0432\u0430\u043B, \u2264 120 \u0442\u044D\u043C\u0434\u044D\u0433\u0442");
+    try {
+      base = appendVerifyPage(doc, {
+        brand: PAGE_BRAND,
+        fileName,
+        documentHash: inHex,
+        fileSize: doc.length,
+        docId,
+        verifyUrl: VERIFY_URL_PREFIX + docId,
+        trustUrl: PAGE_TRUST_URL,
+        caName: cert.issuerCN,
+        tsaName: PAGE_TSA_NAME,
+        provider: PAGE_PROVIDER,
+        lang: opts.lang ?? ""
+      });
+    } catch (e) {
+      throw new PadesError("PDF_INVALID", "PDF \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439 (\u0445\u0443\u0443\u0434\u0430\u0441 \u043D\u044D\u043C\u0436 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439)", { cause: e });
+    }
+    pageHex = toHex(await sha256(base));
+  }
+  const name = goTrim(opts.signerName ?? "") === "" ? signerDisplayName(cert) : opts.signerName ?? "";
+  let prep;
+  try {
+    prep = await prepareSignature(base, now, name, opts.reason ?? "");
+  } catch (e) {
+    throw new PadesError("PDF_INVALID", "PDF-\u0434 \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u043D revision \u0431\u0438\u0447\u0438\u0436 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  if (prep.pdf.length + (256 << 10) > MAX_OUTPUT_BYTES) throw new PadesError("PDF_TOO_LARGE", "\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433\u0442\u044D\u0439 \u0433\u0430\u0440\u0430\u043B\u0442 10 MB-\u0430\u0430\u0441 \u0445\u044D\u0442\u044D\u0440\u043D\u044D");
+  const role = opts.claimedRole ?? "";
+  if (role !== "" && Array.from(role).length > CLAIMED_ROLE_MAX_RUNES) throw new PadesError("REQUEST_INVALID", "claimedRole \u0445\u044D\u0442 \u0443\u0440\u0442");
+  let attrs;
+  try {
+    attrs = await signedAttributes(prep.digest, cert, role);
+  } catch (e) {
+    throw new PadesError("REQUEST_INVALID", "claimedRole", { cause: e });
+  }
+  const state = encodeState({
+    docId,
+    signerCert: cert.raw,
+    chain: chain.map((c) => c.raw),
+    signedAttrs: attrs,
+    byteRange: prep.byteRange,
+    revIndex: pc.revIndex,
+    inSha256: inHex,
+    hasPage,
+    pageSha256: pageHex,
+    claimedRole: role,
+    preparedSha256: toHex(await sha256(prep.pdf)),
+    pdf: prep.pdf
+  });
+  return { dtbs: await sha256(attrs), digest: prep.digest, docId, state };
+}
+async function complete(state, signature, opts = {}) {
+  let st;
+  let cert;
+  let chain;
+  try {
+    st = await decodeState(u8(state, "state"));
+    cert = parseCertificate(st.signerCert);
+    chain = st.chain.map((c) => parseCertificate(c));
+  } catch (e) {
+    throw new PadesError("STATE_INVALID", "state \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  const roots = opts.roots && opts.roots.length > 0 ? parseDERs(opts.roots, "REQUEST_INVALID", "roots") : der(NATIONAL_ROOT);
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const fetchFn = opts.fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!fetchFn) throw new PadesError("TSA_UNAVAILABLE", "fetch \u0430\u043B\u0433\u0430 (Node \u2265 18 \u044D\u0441\u0432\u044D\u043B opts.fetch)");
+  let sigBytes;
+  try {
+    sigBytes = typeof signature === "string" ? fromB64(signature) : u8(signature, "signature");
+  } catch (e) {
+    throw new PadesError("SIGNATURE_INVALID", "\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 base64 \u0431\u0438\u0448", { cause: e });
+  }
+  const sig = await verifyCitizen(cert, st.signedAttrs, sigBytes);
+  if (!sig) throw new PadesError("SIGNATURE_INVALID", "\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 DTBS-\u0442\u044D\u0439 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439");
+  const f = new Fetcher(fetchFn, opts.httpsUpgrade ?? isBrowser());
+  let ts;
+  try {
+    const nonce = opts.nonce ? await opts.nonce() : await randomBytes(8);
+    if (nonce.length !== 8) throw new Error("nonce 8 \u0431\u0430\u0439\u0442 \u0431\u0438\u0448");
+    ts = await timestampToken(f, opts.tsaUrl || DEFAULT_TSA_URL, sig, roots, chain, now(), nonce);
+  } catch (e) {
+    throw new PadesError("TSA_UNAVAILABLE", "TSA timestamp \u0430\u0432\u0447 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  let cms;
+  try {
+    cms = assembleCMS(st.signedAttrs, cert, chain, sig, ts.rawToken);
+  } catch (e) {
+    throw new PadesError("SELF_VALIDATION_FAILED", "CMS \u0443\u0433\u0441\u0430\u0440\u0447 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  let signed;
+  try {
+    signed = embedCMS(st.pdf, st.byteRange, cms);
+  } catch (e) {
+    if (e instanceof PlaceholderOverflowError) throw new PadesError("PLACEHOLDER_OVERFLOW", "CMS placeholder-\u0442 \u0431\u0430\u0433\u0442\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+    throw new PadesError("STATE_INVALID", "CMS-\u0438\u0439\u0433 placeholder-\u0442 \u0431\u0438\u0447\u0438\u0436 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  let dss;
+  try {
+    dss = await collectLTVWithWait(f, now, sleep, ts.time, roots, [[cert, ...chain], ts.certificates]);
+  } catch (e) {
+    throw new PadesError("LTV_UNAVAILABLE", `OCSP/CRL \u0431\u04AF\u0440\u044D\u043D \u0430\u0432\u0447 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439${e instanceof LTVError ? ": " + e.message : ""}`, { cause: e });
+  }
+  let out;
+  try {
+    out = await appendDSS(signed, { ...dss, contents: signatureContents(signed, st.byteRange) });
+  } catch (e) {
+    throw new PadesError("SELF_VALIDATION_FAILED", "DSS revision \u0431\u0438\u0447\u0438\u0436 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  if (out.length > MAX_OUTPUT_BYTES) throw new PadesError("PDF_TOO_LARGE", "\u0433\u0430\u0440\u0430\u043B\u0442 10 MiB-\u0430\u0430\u0441 \u0438\u0445");
+  const prior = [];
+  try {
+    const list = signatureCMSList(signed);
+    for (const c of list.slice(0, -1)) prior.push(c ? toHex(await sha256(c)) : "");
+  } catch (e) {
+    throw new PadesError("SELF_VALIDATION_FAILED", "\u0433\u0430\u0440\u0430\u043B\u0442\u044B\u0433 \u0437\u0430\u0434\u0430\u043B\u0436 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
+  }
+  return {
+    pdf: out,
+    cms,
+    docId: st.docId,
+    outSha256: toHex(await sha256(out)),
+    inSha256: st.inSha256,
+    hasPage: st.hasPage,
+    pageSha256: st.pageSha256,
+    revIndex: st.revIndex,
+    sigRevSha256: toHex(await sha256(signed)),
+    priorCmsSha256: prior,
+    signerCert: cert.raw
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PADES_ERROR_CODES,
+  PROFILE_VERSION,
+  PadesError,
+  complete,
+  prepare,
+  profileVersion
+});