@grind-t/tinkoff-invest-api 1.0.0

package/dist/index.js

@@ -0,0 +1,3087 @@
+// src/client/environments.ts
+var T_INVEST_PROD_URL = "https://invest-public-api.tbank.ru:443";
+var T_INVEST_SANDBOX_URL = "https://sandbox-invest-public-api.tbank.ru:443";
+
+// src/client/index.ts
+import {
+  createClient
+} from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js
+function protoCamelCase(snakeCase) {
+  let capNext = false;
+  const b = [];
+  for (let i = 0; i < snakeCase.length; i++) {
+    let c = snakeCase.charAt(i);
+    switch (c) {
+      case "_":
+        capNext = true;
+        break;
+      case "0":
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9":
+        b.push(c);
+        capNext = false;
+        break;
+      default:
+        if (capNext) {
+          capNext = false;
+          c = c.toUpperCase();
+        }
+        b.push(c);
+        break;
+    }
+  }
+  return b.join("");
+}
+var reservedObjectProperties = /* @__PURE__ */ new Set([
+  // names reserved by JavaScript
+  "constructor",
+  "toString",
+  "toJSON",
+  "valueOf"
+]);
+function safeObjectProperty(name) {
+  return reservedObjectProperties.has(name) ? name + "$" : name;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
+function varint64read() {
+  let lowBits = 0;
+  let highBits = 0;
+  for (let shift = 0; shift < 28; shift += 7) {
+    let b = this.buf[this.pos++];
+    lowBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  let middleByte = this.buf[this.pos++];
+  lowBits |= (middleByte & 15) << 28;
+  highBits = (middleByte & 112) >> 4;
+  if ((middleByte & 128) == 0) {
+    this.assertBounds();
+    return [lowBits, highBits];
+  }
+  for (let shift = 3; shift <= 31; shift += 7) {
+    let b = this.buf[this.pos++];
+    highBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  throw new Error("invalid varint");
+}
+var TWO_PWR_32_DBL = 4294967296;
+function int64FromString(dec) {
+  const minus = dec[0] === "-";
+  if (minus) {
+    dec = dec.slice(1);
+  }
+  const base = 1e6;
+  let lowBits = 0;
+  let highBits = 0;
+  function add1e6digit(begin, end) {
+    const digit1e6 = Number(dec.slice(begin, end));
+    highBits *= base;
+    lowBits = lowBits * base + digit1e6;
+    if (lowBits >= TWO_PWR_32_DBL) {
+      highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
+      lowBits = lowBits % TWO_PWR_32_DBL;
+    }
+  }
+  add1e6digit(-24, -18);
+  add1e6digit(-18, -12);
+  add1e6digit(-12, -6);
+  add1e6digit(-6);
+  return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+function int64ToString(lo, hi) {
+  let bits = newBits(lo, hi);
+  const negative = bits.hi & 2147483648;
+  if (negative) {
+    bits = negate(bits.lo, bits.hi);
+  }
+  const result = uInt64ToString(bits.lo, bits.hi);
+  return negative ? "-" + result : result;
+}
+function uInt64ToString(lo, hi) {
+  ({ lo, hi } = toUnsigned(lo, hi));
+  if (hi <= 2097151) {
+    return String(TWO_PWR_32_DBL * hi + lo);
+  }
+  const low = lo & 16777215;
+  const mid = (lo >>> 24 | hi << 8) & 16777215;
+  const high = hi >> 16 & 65535;
+  let digitA = low + mid * 6777216 + high * 6710656;
+  let digitB = mid + high * 8147497;
+  let digitC = high * 2;
+  const base = 1e7;
+  if (digitA >= base) {
+    digitB += Math.floor(digitA / base);
+    digitA %= base;
+  }
+  if (digitB >= base) {
+    digitC += Math.floor(digitB / base);
+    digitB %= base;
+  }
+  return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
+}
+function toUnsigned(lo, hi) {
+  return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+  return { lo: lo | 0, hi: hi | 0 };
+}
+function negate(lowBits, highBits) {
+  highBits = ~highBits;
+  if (lowBits) {
+    lowBits = ~lowBits + 1;
+  } else {
+    highBits += 1;
+  }
+  return newBits(lowBits, highBits);
+}
+var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+  const partial = String(digit1e7);
+  return "0000000".slice(partial.length) + partial;
+};
+function varint32write(value, bytes) {
+  if (value >= 0) {
+    while (value > 127) {
+      bytes.push(value & 127 | 128);
+      value = value >>> 7;
+    }
+    bytes.push(value);
+  } else {
+    for (let i = 0; i < 9; i++) {
+      bytes.push(value & 127 | 128);
+      value = value >> 7;
+    }
+    bytes.push(1);
+  }
+}
+function varint32read() {
+  let b = this.buf[this.pos++];
+  let result = b & 127;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 7;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 14;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 21;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 15) << 28;
+  for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
+    b = this.buf[this.pos++];
+  if ((b & 128) != 0)
+    throw new Error("invalid varint");
+  this.assertBounds();
+  return result >>> 0;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js
+var protoInt64 = /* @__PURE__ */ makeInt64Support();
+function makeInt64Support() {
+  const dv = new DataView(new ArrayBuffer(8));
+  const ok = typeof BigInt === "function" && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" && (!!globalThis.Deno || typeof process != "object" || typeof process.env != "object" || process.env.BUF_BIGINT_DISABLE !== "1");
+  if (ok) {
+    const MIN = BigInt("-9223372036854775808");
+    const MAX = BigInt("9223372036854775807");
+    const UMIN = BigInt("0");
+    const UMAX = BigInt("18446744073709551615");
+    return {
+      zero: BigInt(0),
+      supported: true,
+      parse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > MAX || bi < MIN) {
+          throw new Error(`invalid int64: ${value}`);
+        }
+        return bi;
+      },
+      uParse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > UMAX || bi < UMIN) {
+          throw new Error(`invalid uint64: ${value}`);
+        }
+        return bi;
+      },
+      enc(value) {
+        dv.setBigInt64(0, this.parse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      uEnc(value) {
+        dv.setBigInt64(0, this.uParse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      dec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigInt64(0, true);
+      },
+      uDec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigUint64(0, true);
+      }
+    };
+  }
+  return {
+    zero: "0",
+    supported: false,
+    parse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return value;
+    },
+    uParse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return value;
+    },
+    enc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return int64FromString(value);
+    },
+    uEnc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return int64FromString(value);
+    },
+    dec(lo, hi) {
+      return int64ToString(lo, hi);
+    },
+    uDec(lo, hi) {
+      return uInt64ToString(lo, hi);
+    }
+  };
+}
+function assertInt64String(value) {
+  if (!/^-?[0-9]+$/.test(value)) {
+    throw new Error("invalid int64: " + value);
+  }
+}
+function assertUInt64String(value) {
+  if (!/^[0-9]+$/.test(value)) {
+    throw new Error("invalid uint64: " + value);
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/descriptors.js
+var ScalarType;
+(function(ScalarType2) {
+  ScalarType2[ScalarType2["DOUBLE"] = 1] = "DOUBLE";
+  ScalarType2[ScalarType2["FLOAT"] = 2] = "FLOAT";
+  ScalarType2[ScalarType2["INT64"] = 3] = "INT64";
+  ScalarType2[ScalarType2["UINT64"] = 4] = "UINT64";
+  ScalarType2[ScalarType2["INT32"] = 5] = "INT32";
+  ScalarType2[ScalarType2["FIXED64"] = 6] = "FIXED64";
+  ScalarType2[ScalarType2["FIXED32"] = 7] = "FIXED32";
+  ScalarType2[ScalarType2["BOOL"] = 8] = "BOOL";
+  ScalarType2[ScalarType2["STRING"] = 9] = "STRING";
+  ScalarType2[ScalarType2["BYTES"] = 12] = "BYTES";
+  ScalarType2[ScalarType2["UINT32"] = 13] = "UINT32";
+  ScalarType2[ScalarType2["SFIXED32"] = 15] = "SFIXED32";
+  ScalarType2[ScalarType2["SFIXED64"] = 16] = "SFIXED64";
+  ScalarType2[ScalarType2["SINT32"] = 17] = "SINT32";
+  ScalarType2[ScalarType2["SINT64"] = 18] = "SINT64";
+})(ScalarType || (ScalarType = {}));
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.js
+function scalarZeroValue(type, longAsString) {
+  switch (type) {
+    case ScalarType.STRING:
+      return "";
+    case ScalarType.BOOL:
+      return false;
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      return 0;
+    case ScalarType.INT64:
+    case ScalarType.UINT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.FIXED64:
+    case ScalarType.SINT64:
+      return longAsString ? "0" : protoInt64.zero;
+    case ScalarType.BYTES:
+      return new Uint8Array(0);
+    default:
+      return 0;
+  }
+}
+function isScalarZeroValue(type, value) {
+  switch (type) {
+    case ScalarType.BOOL:
+      return value === false;
+    case ScalarType.STRING:
+      return value === "";
+    case ScalarType.BYTES:
+      return value instanceof Uint8Array && !value.byteLength;
+    default:
+      return value == 0;
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.js
+var IMPLICIT = 2;
+var unsafeLocal = /* @__PURE__ */ Symbol.for("reflect unsafe local");
+function unsafeOneofCase(target, oneof) {
+  const c = target[oneof.localName].case;
+  if (c === void 0) {
+    return c;
+  }
+  return oneof.fields.find((f) => f.localName === c);
+}
+function unsafeIsSet(target, field) {
+  const name = field.localName;
+  if (field.oneof) {
+    return target[field.oneof.localName].case === name;
+  }
+  if (field.presence != IMPLICIT) {
+    return target[name] !== void 0 && Object.prototype.hasOwnProperty.call(target, name);
+  }
+  switch (field.fieldKind) {
+    case "list":
+      return target[name].length > 0;
+    case "map":
+      return Object.keys(target[name]).length > 0;
+    case "scalar":
+      return !isScalarZeroValue(field.scalar, target[name]);
+    case "enum":
+      return target[name] !== field.enum.values[0].number;
+  }
+  throw new Error("message field with implicit presence");
+}
+function unsafeIsSetExplicit(target, localName) {
+  return Object.prototype.hasOwnProperty.call(target, localName) && target[localName] !== void 0;
+}
+function unsafeGet(target, field) {
+  if (field.oneof) {
+    const oneof = target[field.oneof.localName];
+    if (oneof.case === field.localName) {
+      return oneof.value;
+    }
+    return void 0;
+  }
+  return target[field.localName];
+}
+function unsafeSet(target, field, value) {
+  if (field.oneof) {
+    target[field.oneof.localName] = {
+      case: field.localName,
+      value
+    };
+  } else {
+    target[field.localName] = value;
+  }
+}
+function unsafeClear(target, field) {
+  const name = field.localName;
+  if (field.oneof) {
+    const oneofLocalName = field.oneof.localName;
+    if (target[oneofLocalName].case === name) {
+      target[oneofLocalName] = { case: void 0 };
+    }
+  } else if (field.presence != IMPLICIT) {
+    delete target[name];
+  } else {
+    switch (field.fieldKind) {
+      case "map":
+        target[name] = {};
+        break;
+      case "list":
+        target[name] = [];
+        break;
+      case "enum":
+        target[name] = field.enum.values[0].number;
+        break;
+      case "scalar":
+        target[name] = scalarZeroValue(field.scalar, field.longAsString);
+        break;
+    }
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.js
+function restoreJsonNames(message) {
+  for (const f of message.field) {
+    if (!unsafeIsSetExplicit(f, "jsonName")) {
+      f.jsonName = protoCamelCase(f.name);
+    }
+  }
+  message.nestedType.forEach(restoreJsonNames);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.js
+function parseTextFormatEnumValue(descEnum, value) {
+  const enumValue = descEnum.values.find((v) => v.name === value);
+  if (!enumValue) {
+    throw new Error(`cannot parse ${descEnum} default value: ${value}`);
+  }
+  return enumValue.number;
+}
+function parseTextFormatScalarValue(type, value) {
+  switch (type) {
+    case ScalarType.STRING:
+      return value;
+    case ScalarType.BYTES: {
+      const u = unescapeBytesDefaultValue(value);
+      if (u === false) {
+        throw new Error(`cannot parse ${ScalarType[type]} default value: ${value}`);
+      }
+      return u;
+    }
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      return protoInt64.parse(value);
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      return protoInt64.uParse(value);
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      switch (value) {
+        case "inf":
+          return Number.POSITIVE_INFINITY;
+        case "-inf":
+          return Number.NEGATIVE_INFINITY;
+        case "nan":
+          return Number.NaN;
+        default:
+          return parseFloat(value);
+      }
+    case ScalarType.BOOL:
+      return value === "true";
+    case ScalarType.INT32:
+    case ScalarType.UINT32:
+    case ScalarType.SINT32:
+    case ScalarType.FIXED32:
+    case ScalarType.SFIXED32:
+      return parseInt(value, 10);
+  }
+}
+function unescapeBytesDefaultValue(str) {
+  const b = [];
+  const input = {
+    tail: str,
+    c: "",
+    next() {
+      if (this.tail.length == 0) {
+        return false;
+      }
+      this.c = this.tail[0];
+      this.tail = this.tail.substring(1);
+      return true;
+    },
+    take(n) {
+      if (this.tail.length >= n) {
+        const r = this.tail.substring(0, n);
+        this.tail = this.tail.substring(n);
+        return r;
+      }
+      return false;
+    }
+  };
+  while (input.next()) {
+    switch (input.c) {
+      case "\\":
+        if (input.next()) {
+          switch (input.c) {
+            case "\\":
+              b.push(input.c.charCodeAt(0));
+              break;
+            case "b":
+              b.push(8);
+              break;
+            case "f":
+              b.push(12);
+              break;
+            case "n":
+              b.push(10);
+              break;
+            case "r":
+              b.push(13);
+              break;
+            case "t":
+              b.push(9);
+              break;
+            case "v":
+              b.push(11);
+              break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 8);
+              if (Number.isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "x": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (Number.isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "u": {
+              const s = input.c;
+              const t = input.take(4);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (Number.isNaN(n)) {
+                return false;
+              }
+              const chunk = new Uint8Array(4);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, n, true);
+              b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+              break;
+            }
+            case "U": {
+              const s = input.c;
+              const t = input.take(8);
+              if (t === false) {
+                return false;
+              }
+              const tc = protoInt64.uEnc(s + t);
+              const chunk = new Uint8Array(8);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, tc.lo, true);
+              view.setInt32(4, tc.hi, true);
+              b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
+              break;
+            }
+          }
+        }
+        break;
+      default:
+        b.push(input.c.charCodeAt(0));
+    }
+  }
+  return new Uint8Array(b);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js
+function* nestedTypes(desc) {
+  switch (desc.kind) {
+    case "file":
+      for (const message of desc.messages) {
+        yield message;
+        yield* nestedTypes(message);
+      }
+      yield* desc.enums;
+      yield* desc.services;
+      yield* desc.extensions;
+      break;
+    case "message":
+      for (const message of desc.nestedMessages) {
+        yield message;
+        yield* nestedTypes(message);
+      }
+      yield* desc.nestedEnums;
+      yield* desc.nestedExtensions;
+      break;
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/registry.js
+function createFileRegistry(...args) {
+  const registry = createBaseRegistry();
+  if (!args.length) {
+    return registry;
+  }
+  if ("$typeName" in args[0] && args[0].$typeName == "google.protobuf.FileDescriptorSet") {
+    for (const file of args[0].file) {
+      addFile(file, registry);
+    }
+    return registry;
+  }
+  if ("$typeName" in args[0]) {
+    let recurseDeps2 = function(file) {
+      const deps = [];
+      for (const protoFileName of file.dependency) {
+        if (registry.getFile(protoFileName) != void 0) {
+          continue;
+        }
+        if (seen.has(protoFileName)) {
+          continue;
+        }
+        const dep = resolve(protoFileName);
+        if (!dep) {
+          throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`);
+        }
+        if ("kind" in dep) {
+          registry.addFile(dep, false, true);
+        } else {
+          seen.add(dep.name);
+          deps.push(dep);
+        }
+      }
+      return deps.concat(...deps.map(recurseDeps2));
+    };
+    var recurseDeps = recurseDeps2;
+    const input = args[0];
+    const resolve = args[1];
+    const seen = /* @__PURE__ */ new Set();
+    for (const file of [input, ...recurseDeps2(input)].reverse()) {
+      addFile(file, registry);
+    }
+  } else {
+    for (const fileReg of args) {
+      for (const file of fileReg.files) {
+        registry.addFile(file);
+      }
+    }
+  }
+  return registry;
+}
+function createBaseRegistry() {
+  const types = /* @__PURE__ */ new Map();
+  const extendees = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  return {
+    kind: "registry",
+    types,
+    extendees,
+    [Symbol.iterator]() {
+      return types.values();
+    },
+    get files() {
+      return files.values();
+    },
+    addFile(file, skipTypes, withDeps) {
+      files.set(file.proto.name, file);
+      if (!skipTypes) {
+        for (const type of nestedTypes(file)) {
+          this.add(type);
+        }
+      }
+      if (withDeps) {
+        for (const f of file.dependencies) {
+          this.addFile(f, skipTypes, withDeps);
+        }
+      }
+    },
+    add(desc) {
+      if (desc.kind == "extension") {
+        let numberToExt = extendees.get(desc.extendee.typeName);
+        if (!numberToExt) {
+          extendees.set(
+            desc.extendee.typeName,
+            // biome-ignore lint/suspicious/noAssignInExpressions: no
+            numberToExt = /* @__PURE__ */ new Map()
+          );
+        }
+        numberToExt.set(desc.number, desc);
+      }
+      types.set(desc.typeName, desc);
+    },
+    get(typeName) {
+      return types.get(typeName);
+    },
+    getFile(fileName) {
+      return files.get(fileName);
+    },
+    getMessage(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "message" ? t : void 0;
+    },
+    getEnum(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "enum" ? t : void 0;
+    },
+    getExtension(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "extension" ? t : void 0;
+    },
+    getExtensionFor(extendee, no) {
+      var _a;
+      return (_a = extendees.get(extendee.typeName)) === null || _a === void 0 ? void 0 : _a.get(no);
+    },
+    getService(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "service" ? t : void 0;
+    }
+  };
+}
+var EDITION_PROTO2 = 998;
+var EDITION_PROTO3 = 999;
+var TYPE_STRING = 9;
+var TYPE_GROUP = 10;
+var TYPE_MESSAGE = 11;
+var TYPE_BYTES = 12;
+var TYPE_ENUM = 14;
+var LABEL_REPEATED = 3;
+var LABEL_REQUIRED = 2;
+var JS_STRING = 1;
+var IDEMPOTENCY_UNKNOWN = 0;
+var EXPLICIT = 1;
+var IMPLICIT2 = 2;
+var LEGACY_REQUIRED = 3;
+var PACKED = 1;
+var DELIMITED = 2;
+var OPEN = 1;
+var featureDefaults = {
+  // EDITION_PROTO2
+  998: {
+    fieldPresence: 1,
+    // EXPLICIT,
+    enumType: 2,
+    // CLOSED,
+    repeatedFieldEncoding: 2,
+    // EXPANDED,
+    utf8Validation: 3,
+    // NONE,
+    messageEncoding: 1,
+    // LENGTH_PREFIXED,
+    jsonFormat: 2,
+    // LEGACY_BEST_EFFORT,
+    enforceNamingStyle: 2,
+    // STYLE_LEGACY,
+    defaultSymbolVisibility: 1
+    // EXPORT_ALL,
+  },
+  // EDITION_PROTO3
+  999: {
+    fieldPresence: 2,
+    // IMPLICIT,
+    enumType: 1,
+    // OPEN,
+    repeatedFieldEncoding: 1,
+    // PACKED,
+    utf8Validation: 2,
+    // VERIFY,
+    messageEncoding: 1,
+    // LENGTH_PREFIXED,
+    jsonFormat: 1,
+    // ALLOW,
+    enforceNamingStyle: 2,
+    // STYLE_LEGACY,
+    defaultSymbolVisibility: 1
+    // EXPORT_ALL,
+  },
+  // EDITION_2023
+  1e3: {
+    fieldPresence: 1,
+    // EXPLICIT,
+    enumType: 1,
+    // OPEN,
+    repeatedFieldEncoding: 1,
+    // PACKED,
+    utf8Validation: 2,
+    // VERIFY,
+    messageEncoding: 1,
+    // LENGTH_PREFIXED,
+    jsonFormat: 1,
+    // ALLOW,
+    enforceNamingStyle: 2,
+    // STYLE_LEGACY,
+    defaultSymbolVisibility: 1
+    // EXPORT_ALL,
+  },
+  // EDITION_2024
+  1001: {
+    fieldPresence: 1,
+    // EXPLICIT,
+    enumType: 1,
+    // OPEN,
+    repeatedFieldEncoding: 1,
+    // PACKED,
+    utf8Validation: 2,
+    // VERIFY,
+    messageEncoding: 1,
+    // LENGTH_PREFIXED,
+    jsonFormat: 1,
+    // ALLOW,
+    enforceNamingStyle: 1,
+    // STYLE2024,
+    defaultSymbolVisibility: 2
+    // EXPORT_TOP_LEVEL,
+  }
+};
+function addFile(proto, reg) {
+  var _a, _b;
+  const file = {
+    kind: "file",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    edition: getFileEdition(proto),
+    name: proto.name.replace(/\.proto$/, ""),
+    dependencies: findFileDependencies(proto, reg),
+    enums: [],
+    messages: [],
+    extensions: [],
+    services: [],
+    toString() {
+      return `file ${proto.name}`;
+    }
+  };
+  const mapEntriesStore = /* @__PURE__ */ new Map();
+  const mapEntries = {
+    get(typeName) {
+      return mapEntriesStore.get(typeName);
+    },
+    add(desc) {
+      var _a2;
+      assert(((_a2 = desc.proto.options) === null || _a2 === void 0 ? void 0 : _a2.mapEntry) === true);
+      mapEntriesStore.set(desc.typeName, desc);
+    }
+  };
+  for (const enumProto of proto.enumType) {
+    addEnum(enumProto, file, void 0, reg);
+  }
+  for (const messageProto of proto.messageType) {
+    addMessage(messageProto, file, void 0, reg, mapEntries);
+  }
+  for (const serviceProto of proto.service) {
+    addService(serviceProto, file, reg);
+  }
+  addExtensions(file, reg);
+  for (const mapEntry of mapEntriesStore.values()) {
+    addFields(mapEntry, reg, mapEntries);
+  }
+  for (const message of file.messages) {
+    addFields(message, reg, mapEntries);
+    addExtensions(message, reg);
+  }
+  reg.addFile(file, true);
+}
+function addExtensions(desc, reg) {
+  switch (desc.kind) {
+    case "file":
+      for (const proto of desc.proto.extension) {
+        const ext = newField(proto, desc, reg);
+        desc.extensions.push(ext);
+        reg.add(ext);
+      }
+      break;
+    case "message":
+      for (const proto of desc.proto.extension) {
+        const ext = newField(proto, desc, reg);
+        desc.nestedExtensions.push(ext);
+        reg.add(ext);
+      }
+      for (const message of desc.nestedMessages) {
+        addExtensions(message, reg);
+      }
+      break;
+  }
+}
+function addFields(message, reg, mapEntries) {
+  const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message));
+  const oneofsSeen = /* @__PURE__ */ new Set();
+  for (const proto of message.proto.field) {
+    const oneof = findOneof(proto, allOneofs);
+    const field = newField(proto, message, reg, oneof, mapEntries);
+    message.fields.push(field);
+    message.field[field.localName] = field;
+    if (oneof === void 0) {
+      message.members.push(field);
+    } else {
+      oneof.fields.push(field);
+      if (!oneofsSeen.has(oneof)) {
+        oneofsSeen.add(oneof);
+        message.members.push(oneof);
+      }
+    }
+  }
+  for (const oneof of allOneofs.filter((o) => oneofsSeen.has(o))) {
+    message.oneofs.push(oneof);
+  }
+  for (const child of message.nestedMessages) {
+    addFields(child, reg, mapEntries);
+  }
+}
+function addEnum(proto, file, parent, reg) {
+  var _a, _b, _c, _d, _e;
+  const sharedPrefix = findEnumSharedPrefix(proto.name, proto.value);
+  const desc = {
+    kind: "enum",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    file,
+    parent,
+    open: true,
+    name: proto.name,
+    typeName: makeTypeName(proto, parent, file),
+    value: {},
+    values: [],
+    sharedPrefix,
+    toString() {
+      return `enum ${this.typeName}`;
+    }
+  };
+  desc.open = isEnumOpen(desc);
+  reg.add(desc);
+  for (const p of proto.value) {
+    const name = p.name;
+    desc.values.push(
+      // biome-ignore lint/suspicious/noAssignInExpressions: no
+      desc.value[p.number] = {
+        kind: "enum_value",
+        proto: p,
+        deprecated: (_d = (_c = p.options) === null || _c === void 0 ? void 0 : _c.deprecated) !== null && _d !== void 0 ? _d : false,
+        parent: desc,
+        name,
+        localName: safeObjectProperty(sharedPrefix == void 0 ? name : name.substring(sharedPrefix.length)),
+        number: p.number,
+        toString() {
+          return `enum value ${desc.typeName}.${name}`;
+        }
+      }
+    );
+  }
+  ((_e = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _e !== void 0 ? _e : file.enums).push(desc);
+}
+function addMessage(proto, file, parent, reg, mapEntries) {
+  var _a, _b, _c, _d;
+  const desc = {
+    kind: "message",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    file,
+    parent,
+    name: proto.name,
+    typeName: makeTypeName(proto, parent, file),
+    fields: [],
+    field: {},
+    oneofs: [],
+    members: [],
+    nestedEnums: [],
+    nestedMessages: [],
+    nestedExtensions: [],
+    toString() {
+      return `message ${this.typeName}`;
+    }
+  };
+  if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) {
+    mapEntries.add(desc);
+  } else {
+    ((_d = parent === null || parent === void 0 ? void 0 : parent.nestedMessages) !== null && _d !== void 0 ? _d : file.messages).push(desc);
+    reg.add(desc);
+  }
+  for (const enumProto of proto.enumType) {
+    addEnum(enumProto, file, desc, reg);
+  }
+  for (const messageProto of proto.nestedType) {
+    addMessage(messageProto, file, desc, reg, mapEntries);
+  }
+}
+function addService(proto, file, reg) {
+  var _a, _b;
+  const desc = {
+    kind: "service",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    file,
+    name: proto.name,
+    typeName: makeTypeName(proto, void 0, file),
+    methods: [],
+    method: {},
+    toString() {
+      return `service ${this.typeName}`;
+    }
+  };
+  file.services.push(desc);
+  reg.add(desc);
+  for (const methodProto of proto.method) {
+    const method = newMethod(methodProto, desc, reg);
+    desc.methods.push(method);
+    desc.method[method.localName] = method;
+  }
+}
+function newMethod(proto, parent, reg) {
+  var _a, _b, _c, _d;
+  let methodKind;
+  if (proto.clientStreaming && proto.serverStreaming) {
+    methodKind = "bidi_streaming";
+  } else if (proto.clientStreaming) {
+    methodKind = "client_streaming";
+  } else if (proto.serverStreaming) {
+    methodKind = "server_streaming";
+  } else {
+    methodKind = "unary";
+  }
+  const input = reg.getMessage(trimLeadingDot(proto.inputType));
+  const output = reg.getMessage(trimLeadingDot(proto.outputType));
+  assert(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`);
+  assert(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`);
+  const name = proto.name;
+  return {
+    kind: "rpc",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    parent,
+    name,
+    localName: safeObjectProperty(name.length ? safeObjectProperty(name[0].toLowerCase() + name.substring(1)) : name),
+    methodKind,
+    input,
+    output,
+    idempotency: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.idempotencyLevel) !== null && _d !== void 0 ? _d : IDEMPOTENCY_UNKNOWN,
+    toString() {
+      return `rpc ${parent.typeName}.${name}`;
+    }
+  };
+}
+function newOneof(proto, parent) {
+  return {
+    kind: "oneof",
+    proto,
+    deprecated: false,
+    parent,
+    fields: [],
+    name: proto.name,
+    localName: safeObjectProperty(protoCamelCase(proto.name)),
+    toString() {
+      return `oneof ${parent.typeName}.${this.name}`;
+    }
+  };
+}
+function newField(proto, parentOrFile, reg, oneof, mapEntries) {
+  var _a, _b, _c;
+  const isExtension = mapEntries === void 0;
+  const field = {
+    kind: "field",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    name: proto.name,
+    number: proto.number,
+    scalar: void 0,
+    message: void 0,
+    enum: void 0,
+    presence: getFieldPresence(proto, oneof, isExtension, parentOrFile),
+    listKind: void 0,
+    mapKind: void 0,
+    mapKey: void 0,
+    delimitedEncoding: void 0,
+    packed: void 0,
+    longAsString: false,
+    getDefaultValue: void 0
+  };
+  if (isExtension) {
+    const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file;
+    const parent = parentOrFile.kind == "file" ? void 0 : parentOrFile;
+    const typeName = makeTypeName(proto, parent, file);
+    field.kind = "extension";
+    field.file = file;
+    field.parent = parent;
+    field.oneof = void 0;
+    field.typeName = typeName;
+    field.jsonName = `[${typeName}]`;
+    field.toString = () => `extension ${typeName}`;
+    const extendee = reg.getMessage(trimLeadingDot(proto.extendee));
+    assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
+    field.extendee = extendee;
+  } else {
+    const parent = parentOrFile;
+    assert(parent.kind == "message");
+    field.parent = parent;
+    field.oneof = oneof;
+    field.localName = oneof ? protoCamelCase(proto.name) : safeObjectProperty(protoCamelCase(proto.name));
+    field.jsonName = proto.jsonName;
+    field.toString = () => `field ${parent.typeName}.${proto.name}`;
+  }
+  const label = proto.label;
+  const type = proto.type;
+  const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype;
+  if (label === LABEL_REPEATED) {
+    const mapEntry = type == TYPE_MESSAGE ? mapEntries === null || mapEntries === void 0 ? void 0 : mapEntries.get(trimLeadingDot(proto.typeName)) : void 0;
+    if (mapEntry) {
+      field.fieldKind = "map";
+      const { key, value } = findMapEntryFields(mapEntry);
+      field.mapKey = key.scalar;
+      field.mapKind = value.fieldKind;
+      field.message = value.message;
+      field.delimitedEncoding = false;
+      field.enum = value.enum;
+      field.scalar = value.scalar;
+      return field;
+    }
+    field.fieldKind = "list";
+    switch (type) {
+      case TYPE_MESSAGE:
+      case TYPE_GROUP:
+        field.listKind = "message";
+        field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+        assert(field.message);
+        field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+        break;
+      case TYPE_ENUM:
+        field.listKind = "enum";
+        field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+        assert(field.enum);
+        break;
+      default:
+        field.listKind = "scalar";
+        field.scalar = type;
+        field.longAsString = jstype == JS_STRING;
+        break;
+    }
+    field.packed = isPackedField(proto, parentOrFile);
+    return field;
+  }
+  switch (type) {
+    case TYPE_MESSAGE:
+    case TYPE_GROUP:
+      field.fieldKind = "message";
+      field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+      assert(field.message, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+      field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+      field.getDefaultValue = () => void 0;
+      break;
+    case TYPE_ENUM: {
+      const enumeration = reg.getEnum(trimLeadingDot(proto.typeName));
+      assert(enumeration !== void 0, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+      field.fieldKind = "enum";
+      field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+      field.getDefaultValue = () => {
+        return unsafeIsSetExplicit(proto, "defaultValue") ? parseTextFormatEnumValue(enumeration, proto.defaultValue) : void 0;
+      };
+      break;
+    }
+    default: {
+      field.fieldKind = "scalar";
+      field.scalar = type;
+      field.longAsString = jstype == JS_STRING;
+      field.getDefaultValue = () => {
+        return unsafeIsSetExplicit(proto, "defaultValue") ? parseTextFormatScalarValue(type, proto.defaultValue) : void 0;
+      };
+      break;
+    }
+  }
+  return field;
+}
+function getFileEdition(proto) {
+  switch (proto.syntax) {
+    case "":
+    case "proto2":
+      return EDITION_PROTO2;
+    case "proto3":
+      return EDITION_PROTO3;
+    case "editions":
+      if (proto.edition in featureDefaults) {
+        return proto.edition;
+      }
+      throw new Error(`${proto.name}: unsupported edition`);
+    default:
+      throw new Error(`${proto.name}: unsupported syntax "${proto.syntax}"`);
+  }
+}
+function findFileDependencies(proto, reg) {
+  return proto.dependency.map((wantName) => {
+    const dep = reg.getFile(wantName);
+    if (!dep) {
+      throw new Error(`Cannot find ${wantName}, imported by ${proto.name}`);
+    }
+    return dep;
+  });
+}
+function findEnumSharedPrefix(enumName, values) {
+  const prefix = camelToSnakeCase(enumName) + "_";
+  for (const value of values) {
+    if (!value.name.toLowerCase().startsWith(prefix)) {
+      return void 0;
+    }
+    const shortName = value.name.substring(prefix.length);
+    if (shortName.length == 0) {
+      return void 0;
+    }
+    if (/^\d/.test(shortName)) {
+      return void 0;
+    }
+  }
+  return prefix;
+}
+function camelToSnakeCase(camel) {
+  return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
+}
+function makeTypeName(proto, parent, file) {
+  let typeName;
+  if (parent) {
+    typeName = `${parent.typeName}.${proto.name}`;
+  } else if (file.proto.package.length > 0) {
+    typeName = `${file.proto.package}.${proto.name}`;
+  } else {
+    typeName = `${proto.name}`;
+  }
+  return typeName;
+}
+function trimLeadingDot(typeName) {
+  return typeName.startsWith(".") ? typeName.substring(1) : typeName;
+}
+function findOneof(proto, allOneofs) {
+  if (!unsafeIsSetExplicit(proto, "oneofIndex")) {
+    return void 0;
+  }
+  if (proto.proto3Optional) {
+    return void 0;
+  }
+  const oneof = allOneofs[proto.oneofIndex];
+  assert(oneof, `invalid FieldDescriptorProto: oneof #${proto.oneofIndex} for field #${proto.number} not found`);
+  return oneof;
+}
+function getFieldPresence(proto, oneof, isExtension, parent) {
+  if (proto.label == LABEL_REQUIRED) {
+    return LEGACY_REQUIRED;
+  }
+  if (proto.label == LABEL_REPEATED) {
+    return IMPLICIT2;
+  }
+  if (!!oneof || proto.proto3Optional) {
+    return EXPLICIT;
+  }
+  if (isExtension) {
+    return EXPLICIT;
+  }
+  const resolved = resolveFeature("fieldPresence", { proto, parent });
+  if (resolved == IMPLICIT2 && (proto.type == TYPE_MESSAGE || proto.type == TYPE_GROUP)) {
+    return EXPLICIT;
+  }
+  return resolved;
+}
+function isPackedField(proto, parent) {
+  if (proto.label != LABEL_REPEATED) {
+    return false;
+  }
+  switch (proto.type) {
+    case TYPE_STRING:
+    case TYPE_BYTES:
+    case TYPE_GROUP:
+    case TYPE_MESSAGE:
+      return false;
+  }
+  const o = proto.options;
+  if (o && unsafeIsSetExplicit(o, "packed")) {
+    return o.packed;
+  }
+  return PACKED == resolveFeature("repeatedFieldEncoding", {
+    proto,
+    parent
+  });
+}
+function findMapEntryFields(mapEntry) {
+  const key = mapEntry.fields.find((f) => f.number === 1);
+  const value = mapEntry.fields.find((f) => f.number === 2);
+  assert(key && key.fieldKind == "scalar" && key.scalar != ScalarType.BYTES && key.scalar != ScalarType.FLOAT && key.scalar != ScalarType.DOUBLE && value && value.fieldKind != "list" && value.fieldKind != "map");
+  return { key, value };
+}
+function isEnumOpen(desc) {
+  var _a;
+  return OPEN == resolveFeature("enumType", {
+    proto: desc.proto,
+    parent: (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file
+  });
+}
+function isDelimitedEncoding(proto, parent) {
+  if (proto.type == TYPE_GROUP) {
+    return true;
+  }
+  return DELIMITED == resolveFeature("messageEncoding", {
+    proto,
+    parent
+  });
+}
+function resolveFeature(name, ref) {
+  var _a, _b;
+  const featureSet = (_a = ref.proto.options) === null || _a === void 0 ? void 0 : _a.features;
+  if (featureSet) {
+    const val = featureSet[name];
+    if (val != 0) {
+      return val;
+    }
+  }
+  if ("kind" in ref) {
+    if (ref.kind == "message") {
+      return resolveFeature(name, (_b = ref.parent) !== null && _b !== void 0 ? _b : ref.file);
+    }
+    const editionDefaults = featureDefaults[ref.edition];
+    if (!editionDefaults) {
+      throw new Error(`feature default for edition ${ref.edition} not found`);
+    }
+    return editionDefaults[name];
+  }
+  return resolveFeature(name, ref.parent);
+}
+function assert(condition, msg) {
+  if (!condition) {
+    throw new Error(msg);
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.js
+function boot(boot2) {
+  const root = bootFileDescriptorProto(boot2);
+  root.messageType.forEach(restoreJsonNames);
+  const reg = createFileRegistry(root, () => void 0);
+  return reg.getFile(root.name);
+}
+function bootFileDescriptorProto(init) {
+  const proto = /* @__PURE__ */ Object.create({
+    syntax: "",
+    edition: 0
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FileDescriptorProto", dependency: [], publicDependency: [], weakDependency: [], optionDependency: [], service: [], extension: [] }, init), { messageType: init.messageType.map(bootDescriptorProto), enumType: init.enumType.map(bootEnumDescriptorProto) }));
+}
+function bootDescriptorProto(init) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const proto = /* @__PURE__ */ Object.create({
+    visibility: 0
+  });
+  return Object.assign(proto, {
+    $typeName: "google.protobuf.DescriptorProto",
+    name: init.name,
+    field: (_b = (_a = init.field) === null || _a === void 0 ? void 0 : _a.map(bootFieldDescriptorProto)) !== null && _b !== void 0 ? _b : [],
+    extension: [],
+    nestedType: (_d = (_c = init.nestedType) === null || _c === void 0 ? void 0 : _c.map(bootDescriptorProto)) !== null && _d !== void 0 ? _d : [],
+    enumType: (_f = (_e = init.enumType) === null || _e === void 0 ? void 0 : _e.map(bootEnumDescriptorProto)) !== null && _f !== void 0 ? _f : [],
+    extensionRange: (_h = (_g = init.extensionRange) === null || _g === void 0 ? void 0 : _g.map((e) => Object.assign({ $typeName: "google.protobuf.DescriptorProto.ExtensionRange" }, e))) !== null && _h !== void 0 ? _h : [],
+    oneofDecl: [],
+    reservedRange: [],
+    reservedName: []
+  });
+}
+function bootFieldDescriptorProto(init) {
+  const proto = /* @__PURE__ */ Object.create({
+    label: 1,
+    typeName: "",
+    extendee: "",
+    defaultValue: "",
+    oneofIndex: 0,
+    jsonName: "",
+    proto3Optional: false
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldDescriptorProto" }, init), { options: init.options ? bootFieldOptions(init.options) : void 0 }));
+}
+function bootFieldOptions(init) {
+  var _a, _b, _c;
+  const proto = /* @__PURE__ */ Object.create({
+    ctype: 0,
+    packed: false,
+    jstype: 0,
+    lazy: false,
+    unverifiedLazy: false,
+    deprecated: false,
+    weak: false,
+    debugRedact: false,
+    retention: 0
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldOptions" }, init), { targets: (_a = init.targets) !== null && _a !== void 0 ? _a : [], editionDefaults: (_c = (_b = init.editionDefaults) === null || _b === void 0 ? void 0 : _b.map((e) => Object.assign({ $typeName: "google.protobuf.FieldOptions.EditionDefault" }, e))) !== null && _c !== void 0 ? _c : [], uninterpretedOption: [] }));
+}
+function bootEnumDescriptorProto(init) {
+  const proto = /* @__PURE__ */ Object.create({
+    visibility: 0
+  });
+  return Object.assign(proto, {
+    $typeName: "google.protobuf.EnumDescriptorProto",
+    name: init.name,
+    reservedName: [],
+    reservedRange: [],
+    value: init.value.map((e) => Object.assign({ $typeName: "google.protobuf.EnumValueDescriptorProto" }, e))
+  });
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.js
+function base64Decode(base64Str) {
+  const table = getDecodeTable();
+  let es = base64Str.length * 3 / 4;
+  if (base64Str[base64Str.length - 2] == "=")
+    es -= 2;
+  else if (base64Str[base64Str.length - 1] == "=")
+    es -= 1;
+  let bytes = new Uint8Array(es), bytePos = 0, groupPos = 0, b, p = 0;
+  for (let i = 0; i < base64Str.length; i++) {
+    b = table[base64Str.charCodeAt(i)];
+    if (b === void 0) {
+      switch (base64Str[i]) {
+        // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
+        case "=":
+          groupPos = 0;
+        // reset state when padding found
+        case "\n":
+        case "\r":
+        case "	":
+        case " ":
+          continue;
+        // skip white-space, and padding
+        default:
+          throw Error("invalid base64 string");
+      }
+    }
+    switch (groupPos) {
+      case 0:
+        p = b;
+        groupPos = 1;
+        break;
+      case 1:
+        bytes[bytePos++] = p << 2 | (b & 48) >> 4;
+        p = b;
+        groupPos = 2;
+        break;
+      case 2:
+        bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2;
+        p = b;
+        groupPos = 3;
+        break;
+      case 3:
+        bytes[bytePos++] = (p & 3) << 6 | b;
+        groupPos = 0;
+        break;
+    }
+  }
+  if (groupPos == 1)
+    throw Error("invalid base64 string");
+  return bytes.subarray(0, bytePos);
+}
+var encodeTableStd;
+var encodeTableUrl;
+var decodeTable;
+function getEncodeTable(encoding) {
+  if (!encodeTableStd) {
+    encodeTableStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+    encodeTableUrl = encodeTableStd.slice(0, -2).concat("-", "_");
+  }
+  return encoding == "url" ? (
+    // biome-ignore lint/style/noNonNullAssertion: TS fails to narrow down
+    encodeTableUrl
+  ) : encodeTableStd;
+}
+function getDecodeTable() {
+  if (!decodeTable) {
+    decodeTable = [];
+    const encodeTable = getEncodeTable("std");
+    for (let i = 0; i < encodeTable.length; i++)
+      decodeTable[encodeTable[i].charCodeAt(0)] = i;
+    decodeTable["-".charCodeAt(0)] = encodeTable.indexOf("+");
+    decodeTable["_".charCodeAt(0)] = encodeTable.indexOf("/");
+  }
+  return decodeTable;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/is-message.js
+function isMessage(arg, schema) {
+  const isMessage2 = arg !== null && typeof arg == "object" && "$typeName" in arg && typeof arg.$typeName == "string";
+  if (!isMessage2) {
+    return false;
+  }
+  if (schema === void 0) {
+    return true;
+  }
+  return schema.typeName === arg.$typeName;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/error.js
+var FieldError = class extends Error {
+  constructor(fieldOrOneof, message, name = "FieldValueInvalidError") {
+    super(message);
+    this.name = name;
+    this.field = () => fieldOrOneof;
+  }
+};
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.js
+function isObject(arg) {
+  return arg !== null && typeof arg == "object" && !Array.isArray(arg);
+}
+function isReflectList(arg, field) {
+  var _a, _b, _c, _d;
+  if (isObject(arg) && unsafeLocal in arg && "add" in arg && "field" in arg && typeof arg.field == "function") {
+    if (field !== void 0) {
+      const a = field;
+      const b = arg.field();
+      return a.listKind == b.listKind && a.scalar === b.scalar && ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName);
+    }
+    return true;
+  }
+  return false;
+}
+function isReflectMap(arg, field) {
+  var _a, _b, _c, _d;
+  if (isObject(arg) && unsafeLocal in arg && "has" in arg && "field" in arg && typeof arg.field == "function") {
+    if (field !== void 0) {
+      const a = field, b = arg.field();
+      return a.mapKey === b.mapKey && a.mapKind == b.mapKind && a.scalar === b.scalar && ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName);
+    }
+    return true;
+  }
+  return false;
+}
+function isReflectMessage(arg, messageDesc2) {
+  return isObject(arg) && unsafeLocal in arg && "desc" in arg && isObject(arg.desc) && arg.desc.kind === "message" && (messageDesc2 === void 0 || arg.desc.typeName == messageDesc2.typeName);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js
+var symbol = /* @__PURE__ */ Symbol.for("@bufbuild/protobuf/text-encoding");
+function getTextEncoding() {
+  if (globalThis[symbol] == void 0) {
+    const te = new globalThis.TextEncoder();
+    const td = new globalThis.TextDecoder();
+    globalThis[symbol] = {
+      encodeUtf8(text) {
+        return te.encode(text);
+      },
+      decodeUtf8(bytes) {
+        return td.decode(bytes);
+      },
+      checkUtf8(text) {
+        try {
+          encodeURIComponent(text);
+          return true;
+        } catch (_) {
+          return false;
+        }
+      }
+    };
+  }
+  return globalThis[symbol];
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js
+var WireType;
+(function(WireType2) {
+  WireType2[WireType2["Varint"] = 0] = "Varint";
+  WireType2[WireType2["Bit64"] = 1] = "Bit64";
+  WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
+  WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
+  WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
+  WireType2[WireType2["Bit32"] = 5] = "Bit32";
+})(WireType || (WireType = {}));
+var FLOAT32_MAX = 34028234663852886e22;
+var FLOAT32_MIN = -34028234663852886e22;
+var UINT32_MAX = 4294967295;
+var INT32_MAX = 2147483647;
+var INT32_MIN = -2147483648;
+var BinaryReader = class {
+  constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
+    this.decodeUtf8 = decodeUtf8;
+    this.varint64 = varint64read;
+    this.uint32 = varint32read;
+    this.buf = buf;
+    this.len = buf.length;
+    this.pos = 0;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag() {
+    let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+    if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+      throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+    return [fieldNo, wireType];
+  }
+  /**
+   * Skip one element and return the skipped data.
+   *
+   * When skipping StartGroup, provide the tags field number to check for
+   * matching field number in the EndGroup tag.
+   */
+  skip(wireType, fieldNo) {
+    let start = this.pos;
+    switch (wireType) {
+      case WireType.Varint:
+        while (this.buf[this.pos++] & 128) {
+        }
+        break;
+      // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
+      case WireType.Bit64:
+        this.pos += 4;
+      case WireType.Bit32:
+        this.pos += 4;
+        break;
+      case WireType.LengthDelimited:
+        let len = this.uint32();
+        this.pos += len;
+        break;
+      case WireType.StartGroup:
+        for (; ; ) {
+          const [fn, wt] = this.tag();
+          if (wt === WireType.EndGroup) {
+            if (fieldNo !== void 0 && fn !== fieldNo) {
+              throw new Error("invalid end group tag");
+            }
+            break;
+          }
+          this.skip(wt, fn);
+        }
+        break;
+      default:
+        throw new Error("cant skip wire type " + wireType);
+    }
+    this.assertBounds();
+    return this.buf.subarray(start, this.pos);
+  }
+  /**
+   * Throws error if position in byte array is out of range.
+   */
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  int32() {
+    return this.uint32() | 0;
+  }
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32() {
+    let zze = this.uint32();
+    return zze >>> 1 ^ -(zze & 1);
+  }
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64() {
+    return protoInt64.dec(...this.varint64());
+  }
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64() {
+    return protoInt64.uDec(...this.varint64());
+  }
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64() {
+    let [lo, hi] = this.varint64();
+    let s = -(lo & 1);
+    lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
+    hi = hi >>> 1 ^ s;
+    return protoInt64.dec(lo, hi);
+  }
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool() {
+    let [lo, hi] = this.varint64();
+    return lo !== 0 || hi !== 0;
+  }
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64() {
+    return protoInt64.uDec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64() {
+    return protoInt64.dec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, true);
+  }
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes() {
+    let len = this.uint32(), start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string() {
+    return this.decodeUtf8(this.bytes());
+  }
+};
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.js
+function checkField(field, value) {
+  const check = field.fieldKind == "list" ? isReflectList(value, field) : field.fieldKind == "map" ? isReflectMap(value, field) : checkSingular(field, value);
+  if (check === true) {
+    return void 0;
+  }
+  let reason;
+  switch (field.fieldKind) {
+    case "list":
+      reason = `expected ${formatReflectList(field)}, got ${formatVal(value)}`;
+      break;
+    case "map":
+      reason = `expected ${formatReflectMap(field)}, got ${formatVal(value)}`;
+      break;
+    default: {
+      reason = reasonSingular(field, value, check);
+    }
+  }
+  return new FieldError(field, reason);
+}
+function checkListItem(field, index, value) {
+  const check = checkSingular(field, value);
+  if (check !== true) {
+    return new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
+  }
+  return void 0;
+}
+function checkMapEntry(field, key, value) {
+  const checkKey = checkScalarValue(key, field.mapKey);
+  if (checkKey !== true) {
+    return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`);
+  }
+  const checkVal = checkSingular(field, value);
+  if (checkVal !== true) {
+    return new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`);
+  }
+  return void 0;
+}
+function checkSingular(field, value) {
+  if (field.scalar !== void 0) {
+    return checkScalarValue(value, field.scalar);
+  }
+  if (field.enum !== void 0) {
+    if (field.enum.open) {
+      return Number.isInteger(value);
+    }
+    return field.enum.values.some((v) => v.number === value);
+  }
+  return isReflectMessage(value, field.message);
+}
+function checkScalarValue(value, scalar) {
+  switch (scalar) {
+    case ScalarType.DOUBLE:
+      return typeof value == "number";
+    case ScalarType.FLOAT:
+      if (typeof value != "number") {
+        return false;
+      }
+      if (Number.isNaN(value) || !Number.isFinite(value)) {
+        return true;
+      }
+      if (value > FLOAT32_MAX || value < FLOAT32_MIN) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.INT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      if (value > INT32_MAX || value < INT32_MIN) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      if (value > UINT32_MAX || value < 0) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.BOOL:
+      return typeof value == "boolean";
+    case ScalarType.STRING:
+      if (typeof value != "string") {
+        return false;
+      }
+      return getTextEncoding().checkUtf8(value) || "invalid UTF8";
+    case ScalarType.BYTES:
+      return value instanceof Uint8Array;
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if (typeof value == "bigint" || typeof value == "number" || typeof value == "string" && value.length > 0) {
+        try {
+          protoInt64.parse(value);
+          return true;
+        } catch (_) {
+          return `${value} out of range`;
+        }
+      }
+      return false;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if (typeof value == "bigint" || typeof value == "number" || typeof value == "string" && value.length > 0) {
+        try {
+          protoInt64.uParse(value);
+          return true;
+        } catch (_) {
+          return `${value} out of range`;
+        }
+      }
+      return false;
+  }
+}
+function reasonSingular(field, val, details) {
+  details = typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`;
+  if (field.scalar !== void 0) {
+    return `expected ${scalarTypeDescription(field.scalar)}` + details;
+  }
+  if (field.enum !== void 0) {
+    return `expected ${field.enum.toString()}` + details;
+  }
+  return `expected ${formatReflectMessage(field.message)}` + details;
+}
+function formatVal(val) {
+  switch (typeof val) {
+    case "object":
+      if (val === null) {
+        return "null";
+      }
+      if (val instanceof Uint8Array) {
+        return `Uint8Array(${val.length})`;
+      }
+      if (Array.isArray(val)) {
+        return `Array(${val.length})`;
+      }
+      if (isReflectList(val)) {
+        return formatReflectList(val.field());
+      }
+      if (isReflectMap(val)) {
+        return formatReflectMap(val.field());
+      }
+      if (isReflectMessage(val)) {
+        return formatReflectMessage(val.desc);
+      }
+      if (isMessage(val)) {
+        return `message ${val.$typeName}`;
+      }
+      return "object";
+    case "string":
+      return val.length > 30 ? "string" : `"${val.split('"').join('\\"')}"`;
+    case "boolean":
+      return String(val);
+    case "number":
+      return String(val);
+    case "bigint":
+      return String(val) + "n";
+    default:
+      return typeof val;
+  }
+}
+function formatReflectMessage(desc) {
+  return `ReflectMessage (${desc.typeName})`;
+}
+function formatReflectList(field) {
+  switch (field.listKind) {
+    case "message":
+      return `ReflectList (${field.message.toString()})`;
+    case "enum":
+      return `ReflectList (${field.enum.toString()})`;
+    case "scalar":
+      return `ReflectList (${ScalarType[field.scalar]})`;
+  }
+}
+function formatReflectMap(field) {
+  switch (field.mapKind) {
+    case "message":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${field.message.toString()})`;
+    case "enum":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${field.enum.toString()})`;
+    case "scalar":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${ScalarType[field.scalar]})`;
+  }
+}
+function scalarTypeDescription(scalar) {
+  switch (scalar) {
+    case ScalarType.STRING:
+      return "string";
+    case ScalarType.BOOL:
+      return "boolean";
+    case ScalarType.INT64:
+    case ScalarType.SINT64:
+    case ScalarType.SFIXED64:
+      return "bigint (int64)";
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      return "bigint (uint64)";
+    case ScalarType.BYTES:
+      return "Uint8Array";
+    case ScalarType.DOUBLE:
+      return "number (float64)";
+    case ScalarType.FLOAT:
+      return "number (float32)";
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+      return "number (uint32)";
+    case ScalarType.INT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      return "number (int32)";
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wkt/wrappers.js
+function isWrapper(arg) {
+  return isWrapperTypeName(arg.$typeName);
+}
+function isWrapperDesc(messageDesc2) {
+  const f = messageDesc2.fields[0];
+  return isWrapperTypeName(messageDesc2.typeName) && f !== void 0 && f.fieldKind == "scalar" && f.name == "value" && f.number == 1;
+}
+function isWrapperTypeName(name) {
+  return name.startsWith("google.protobuf.") && [
+    "DoubleValue",
+    "FloatValue",
+    "Int64Value",
+    "UInt64Value",
+    "Int32Value",
+    "UInt32Value",
+    "BoolValue",
+    "StringValue",
+    "BytesValue"
+  ].includes(name.substring(16));
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/create.js
+var EDITION_PROTO32 = 999;
+var EDITION_PROTO22 = 998;
+var IMPLICIT3 = 2;
+function create(schema, init) {
+  if (isMessage(init, schema)) {
+    return init;
+  }
+  const message = createZeroMessage(schema);
+  if (init !== void 0) {
+    initMessage(schema, message, init);
+  }
+  return message;
+}
+function initMessage(messageDesc2, message, init) {
+  for (const member of messageDesc2.members) {
+    let value = init[member.localName];
+    if (value == null) {
+      continue;
+    }
+    let field;
+    if (member.kind == "oneof") {
+      const oneofField = unsafeOneofCase(init, member);
+      if (!oneofField) {
+        continue;
+      }
+      field = oneofField;
+      value = unsafeGet(init, oneofField);
+    } else {
+      field = member;
+    }
+    switch (field.fieldKind) {
+      case "message":
+        value = toMessage(field, value);
+        break;
+      case "scalar":
+        value = initScalar(field, value);
+        break;
+      case "list":
+        value = initList(field, value);
+        break;
+      case "map":
+        value = initMap(field, value);
+        break;
+    }
+    unsafeSet(message, field, value);
+  }
+  return message;
+}
+function initScalar(field, value) {
+  if (field.scalar == ScalarType.BYTES) {
+    return toU8Arr(value);
+  }
+  return value;
+}
+function initMap(field, value) {
+  if (isObject(value)) {
+    if (field.scalar == ScalarType.BYTES) {
+      return convertObjectValues(value, toU8Arr);
+    }
+    if (field.mapKind == "message") {
+      return convertObjectValues(value, (val) => toMessage(field, val));
+    }
+  }
+  return value;
+}
+function initList(field, value) {
+  if (Array.isArray(value)) {
+    if (field.scalar == ScalarType.BYTES) {
+      return value.map(toU8Arr);
+    }
+    if (field.listKind == "message") {
+      return value.map((item) => toMessage(field, item));
+    }
+  }
+  return value;
+}
+function toMessage(field, value) {
+  if (field.fieldKind == "message" && !field.oneof && isWrapperDesc(field.message)) {
+    return initScalar(field.message.fields[0], value);
+  }
+  if (isObject(value)) {
+    if (field.message.typeName == "google.protobuf.Struct" && field.parent.typeName !== "google.protobuf.Value") {
+      return value;
+    }
+    if (!isMessage(value, field.message)) {
+      return create(field.message, value);
+    }
+  }
+  return value;
+}
+function toU8Arr(value) {
+  return Array.isArray(value) ? new Uint8Array(value) : value;
+}
+function convertObjectValues(obj, fn) {
+  const ret = {};
+  for (const entry of Object.entries(obj)) {
+    ret[entry[0]] = fn(entry[1]);
+  }
+  return ret;
+}
+var tokenZeroMessageField = /* @__PURE__ */ Symbol();
+var messagePrototypes = /* @__PURE__ */ new WeakMap();
+function createZeroMessage(desc) {
+  let msg;
+  if (!needsPrototypeChain(desc)) {
+    msg = {
+      $typeName: desc.typeName
+    };
+    for (const member of desc.members) {
+      if (member.kind == "oneof" || member.presence == IMPLICIT3) {
+        msg[member.localName] = createZeroField(member);
+      }
+    }
+  } else {
+    const cached = messagePrototypes.get(desc);
+    let prototype;
+    let members;
+    if (cached) {
+      ({ prototype, members } = cached);
+    } else {
+      prototype = {};
+      members = /* @__PURE__ */ new Set();
+      for (const member of desc.members) {
+        if (member.kind == "oneof") {
+          continue;
+        }
+        if (member.fieldKind != "scalar" && member.fieldKind != "enum") {
+          continue;
+        }
+        if (member.presence == IMPLICIT3) {
+          continue;
+        }
+        members.add(member);
+        prototype[member.localName] = createZeroField(member);
+      }
+      messagePrototypes.set(desc, { prototype, members });
+    }
+    msg = Object.create(prototype);
+    msg.$typeName = desc.typeName;
+    for (const member of desc.members) {
+      if (members.has(member)) {
+        continue;
+      }
+      if (member.kind == "field") {
+        if (member.fieldKind == "message") {
+          continue;
+        }
+        if (member.fieldKind == "scalar" || member.fieldKind == "enum") {
+          if (member.presence != IMPLICIT3) {
+            continue;
+          }
+        }
+      }
+      msg[member.localName] = createZeroField(member);
+    }
+  }
+  return msg;
+}
+function needsPrototypeChain(desc) {
+  switch (desc.file.edition) {
+    case EDITION_PROTO32:
+      return false;
+    case EDITION_PROTO22:
+      return true;
+    default:
+      return desc.fields.some((f) => f.presence != IMPLICIT3 && f.fieldKind != "message" && !f.oneof);
+  }
+}
+function createZeroField(field) {
+  if (field.kind == "oneof") {
+    return { case: void 0 };
+  }
+  if (field.fieldKind == "list") {
+    return [];
+  }
+  if (field.fieldKind == "map") {
+    return {};
+  }
+  if (field.fieldKind == "message") {
+    return tokenZeroMessageField;
+  }
+  const defaultValue = field.getDefaultValue();
+  if (defaultValue !== void 0) {
+    return field.fieldKind == "scalar" && field.longAsString ? defaultValue.toString() : defaultValue;
+  }
+  return field.fieldKind == "scalar" ? scalarZeroValue(field.scalar, field.longAsString) : field.enum.values[0].number;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.js
+function reflect(messageDesc2, message, check = true) {
+  return new ReflectMessageImpl(messageDesc2, message, check);
+}
+var messageSortedFields = /* @__PURE__ */ new WeakMap();
+var ReflectMessageImpl = class {
+  get sortedFields() {
+    const cached = messageSortedFields.get(this.desc);
+    if (cached) {
+      return cached;
+    }
+    const sortedFields = this.desc.fields.concat().sort((a, b) => a.number - b.number);
+    messageSortedFields.set(this.desc, sortedFields);
+    return sortedFields;
+  }
+  constructor(messageDesc2, message, check = true) {
+    this.lists = /* @__PURE__ */ new Map();
+    this.maps = /* @__PURE__ */ new Map();
+    this.check = check;
+    this.desc = messageDesc2;
+    this.message = this[unsafeLocal] = message !== null && message !== void 0 ? message : create(messageDesc2);
+    this.fields = messageDesc2.fields;
+    this.oneofs = messageDesc2.oneofs;
+    this.members = messageDesc2.members;
+  }
+  findNumber(number) {
+    if (!this._fieldsByNumber) {
+      this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f]));
+    }
+    return this._fieldsByNumber.get(number);
+  }
+  oneofCase(oneof) {
+    assertOwn(this.message, oneof);
+    return unsafeOneofCase(this.message, oneof);
+  }
+  isSet(field) {
+    assertOwn(this.message, field);
+    return unsafeIsSet(this.message, field);
+  }
+  clear(field) {
+    assertOwn(this.message, field);
+    unsafeClear(this.message, field);
+  }
+  get(field) {
+    assertOwn(this.message, field);
+    const value = unsafeGet(this.message, field);
+    switch (field.fieldKind) {
+      case "list":
+        let list = this.lists.get(field);
+        if (!list || list[unsafeLocal] !== value) {
+          this.lists.set(
+            field,
+            // biome-ignore lint/suspicious/noAssignInExpressions: no
+            list = new ReflectListImpl(field, value, this.check)
+          );
+        }
+        return list;
+      case "map":
+        let map = this.maps.get(field);
+        if (!map || map[unsafeLocal] !== value) {
+          this.maps.set(
+            field,
+            // biome-ignore lint/suspicious/noAssignInExpressions: no
+            map = new ReflectMapImpl(field, value, this.check)
+          );
+        }
+        return map;
+      case "message":
+        return messageToReflect(field, value, this.check);
+      case "scalar":
+        return value === void 0 ? scalarZeroValue(field.scalar, false) : longToReflect(field, value);
+      case "enum":
+        return value !== null && value !== void 0 ? value : field.enum.values[0].number;
+    }
+  }
+  set(field, value) {
+    assertOwn(this.message, field);
+    if (this.check) {
+      const err = checkField(field, value);
+      if (err) {
+        throw err;
+      }
+    }
+    let local;
+    if (field.fieldKind == "message") {
+      local = messageToLocal(field, value);
+    } else if (isReflectMap(value) || isReflectList(value)) {
+      local = value[unsafeLocal];
+    } else {
+      local = longToLocal(field, value);
+    }
+    unsafeSet(this.message, field, local);
+  }
+  getUnknown() {
+    return this.message.$unknown;
+  }
+  setUnknown(value) {
+    this.message.$unknown = value;
+  }
+};
+function assertOwn(owner, member) {
+  if (member.parent.typeName !== owner.$typeName) {
+    throw new FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
+  }
+}
+var ReflectListImpl = class {
+  field() {
+    return this._field;
+  }
+  get size() {
+    return this._arr.length;
+  }
+  constructor(field, unsafeInput, check) {
+    this._field = field;
+    this._arr = this[unsafeLocal] = unsafeInput;
+    this.check = check;
+  }
+  get(index) {
+    const item = this._arr[index];
+    return item === void 0 ? void 0 : listItemToReflect(this._field, item, this.check);
+  }
+  set(index, item) {
+    if (index < 0 || index >= this._arr.length) {
+      throw new FieldError(this._field, `list item #${index + 1}: out of range`);
+    }
+    if (this.check) {
+      const err = checkListItem(this._field, index, item);
+      if (err) {
+        throw err;
+      }
+    }
+    this._arr[index] = listItemToLocal(this._field, item);
+  }
+  add(item) {
+    if (this.check) {
+      const err = checkListItem(this._field, this._arr.length, item);
+      if (err) {
+        throw err;
+      }
+    }
+    this._arr.push(listItemToLocal(this._field, item));
+    return void 0;
+  }
+  clear() {
+    this._arr.splice(0, this._arr.length);
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  keys() {
+    return this._arr.keys();
+  }
+  *values() {
+    for (const item of this._arr) {
+      yield listItemToReflect(this._field, item, this.check);
+    }
+  }
+  *entries() {
+    for (let i = 0; i < this._arr.length; i++) {
+      yield [i, listItemToReflect(this._field, this._arr[i], this.check)];
+    }
+  }
+};
+var ReflectMapImpl = class {
+  constructor(field, unsafeInput, check = true) {
+    this.obj = this[unsafeLocal] = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {};
+    this.check = check;
+    this._field = field;
+  }
+  field() {
+    return this._field;
+  }
+  set(key, value) {
+    if (this.check) {
+      const err = checkMapEntry(this._field, key, value);
+      if (err) {
+        throw err;
+      }
+    }
+    this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
+    return this;
+  }
+  delete(key) {
+    const k = mapKeyToLocal(key);
+    const has = Object.prototype.hasOwnProperty.call(this.obj, k);
+    if (has) {
+      delete this.obj[k];
+    }
+    return has;
+  }
+  clear() {
+    for (const key of Object.keys(this.obj)) {
+      delete this.obj[key];
+    }
+  }
+  get(key) {
+    let val = this.obj[mapKeyToLocal(key)];
+    if (val !== void 0) {
+      val = mapValueToReflect(this._field, val, this.check);
+    }
+    return val;
+  }
+  has(key) {
+    return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key));
+  }
+  *keys() {
+    for (const objKey of Object.keys(this.obj)) {
+      yield mapKeyToReflect(objKey, this._field.mapKey);
+    }
+  }
+  *entries() {
+    for (const objEntry of Object.entries(this.obj)) {
+      yield [
+        mapKeyToReflect(objEntry[0], this._field.mapKey),
+        mapValueToReflect(this._field, objEntry[1], this.check)
+      ];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return Object.keys(this.obj).length;
+  }
+  *values() {
+    for (const val of Object.values(this.obj)) {
+      yield mapValueToReflect(this._field, val, this.check);
+    }
+  }
+  forEach(callbackfn, thisArg) {
+    for (const mapEntry of this.entries()) {
+      callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+    }
+  }
+};
+function messageToLocal(field, value) {
+  if (!isReflectMessage(value)) {
+    return value;
+  }
+  if (isWrapper(value.message) && !field.oneof && field.fieldKind == "message") {
+    return value.message.value;
+  }
+  if (value.desc.typeName == "google.protobuf.Struct" && field.parent.typeName != "google.protobuf.Value") {
+    return wktStructToLocal(value.message);
+  }
+  return value.message;
+}
+function messageToReflect(field, value, check) {
+  if (value !== void 0) {
+    if (isWrapperDesc(field.message) && !field.oneof && field.fieldKind == "message") {
+      value = {
+        $typeName: field.message.typeName,
+        value: longToReflect(field.message.fields[0], value)
+      };
+    } else if (field.message.typeName == "google.protobuf.Struct" && field.parent.typeName != "google.protobuf.Value" && isObject(value)) {
+      value = wktStructToReflect(value);
+    }
+  }
+  return new ReflectMessageImpl(field.message, value, check);
+}
+function listItemToLocal(field, value) {
+  if (field.listKind == "message") {
+    return messageToLocal(field, value);
+  }
+  return longToLocal(field, value);
+}
+function listItemToReflect(field, value, check) {
+  if (field.listKind == "message") {
+    return messageToReflect(field, value, check);
+  }
+  return longToReflect(field, value);
+}
+function mapValueToLocal(field, value) {
+  if (field.mapKind == "message") {
+    return messageToLocal(field, value);
+  }
+  return longToLocal(field, value);
+}
+function mapValueToReflect(field, value, check) {
+  if (field.mapKind == "message") {
+    return messageToReflect(field, value, check);
+  }
+  return value;
+}
+function mapKeyToLocal(key) {
+  return typeof key == "string" || typeof key == "number" ? key : String(key);
+}
+function mapKeyToReflect(key, type) {
+  switch (type) {
+    case ScalarType.STRING:
+      return key;
+    case ScalarType.INT32:
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32: {
+      const n = Number.parseInt(key);
+      if (Number.isFinite(n)) {
+        return n;
+      }
+      break;
+    }
+    case ScalarType.BOOL:
+      switch (key) {
+        case "true":
+          return true;
+        case "false":
+          return false;
+      }
+      break;
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      try {
+        return protoInt64.uParse(key);
+      } catch (_a) {
+      }
+      break;
+    default:
+      try {
+        return protoInt64.parse(key);
+      } catch (_b) {
+      }
+      break;
+  }
+  return key;
+}
+function longToReflect(field, value) {
+  switch (field.scalar) {
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if ("longAsString" in field && field.longAsString && typeof value == "string") {
+        value = protoInt64.parse(value);
+      }
+      break;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if ("longAsString" in field && field.longAsString && typeof value == "string") {
+        value = protoInt64.uParse(value);
+      }
+      break;
+  }
+  return value;
+}
+function longToLocal(field, value) {
+  switch (field.scalar) {
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if ("longAsString" in field && field.longAsString) {
+        value = String(value);
+      } else if (typeof value == "string" || typeof value == "number") {
+        value = protoInt64.parse(value);
+      }
+      break;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if ("longAsString" in field && field.longAsString) {
+        value = String(value);
+      } else if (typeof value == "string" || typeof value == "number") {
+        value = protoInt64.uParse(value);
+      }
+      break;
+  }
+  return value;
+}
+function wktStructToReflect(json) {
+  const struct = {
+    $typeName: "google.protobuf.Struct",
+    fields: {}
+  };
+  if (isObject(json)) {
+    for (const [k, v] of Object.entries(json)) {
+      struct.fields[k] = wktValueToReflect(v);
+    }
+  }
+  return struct;
+}
+function wktStructToLocal(val) {
+  const json = {};
+  for (const [k, v] of Object.entries(val.fields)) {
+    json[k] = wktValueToLocal(v);
+  }
+  return json;
+}
+function wktValueToLocal(val) {
+  switch (val.kind.case) {
+    case "structValue":
+      return wktStructToLocal(val.kind.value);
+    case "listValue":
+      return val.kind.value.values.map(wktValueToLocal);
+    case "nullValue":
+    case void 0:
+      return null;
+    default:
+      return val.kind.value;
+  }
+}
+function wktValueToReflect(json) {
+  const value = {
+    $typeName: "google.protobuf.Value",
+    kind: { case: void 0 }
+  };
+  switch (typeof json) {
+    case "number":
+      value.kind = { case: "numberValue", value: json };
+      break;
+    case "string":
+      value.kind = { case: "stringValue", value: json };
+      break;
+    case "boolean":
+      value.kind = { case: "boolValue", value: json };
+      break;
+    case "object":
+      if (json === null) {
+        const nullValue = 0;
+        value.kind = { case: "nullValue", value: nullValue };
+      } else if (Array.isArray(json)) {
+        const listValue = {
+          $typeName: "google.protobuf.ListValue",
+          values: []
+        };
+        if (Array.isArray(json)) {
+          for (const e of json) {
+            listValue.values.push(wktValueToReflect(e));
+          }
+        }
+        value.kind = {
+          case: "listValue",
+          value: listValue
+        };
+      } else {
+        value.kind = {
+          case: "structValue",
+          value: wktStructToReflect(json)
+        };
+      }
+      break;
+  }
+  return value;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.js
+function messageDesc(file, path, ...paths) {
+  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.js
+var file_google_protobuf_descriptor = /* @__PURE__ */ boot({ "name": "google/protobuf/descriptor.proto", "package": "google.protobuf", "messageType": [{ "name": "FileDescriptorSet", "field": [{ "name": "file", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FileDescriptorProto" }], "extensionRange": [{ "start": 536e6, "end": 536000001 }] }, { "name": "FileDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "package", "number": 2, "type": 9, "label": 1 }, { "name": "dependency", "number": 3, "type": 9, "label": 3 }, { "name": "public_dependency", "number": 10, "type": 5, "label": 3 }, { "name": "weak_dependency", "number": 11, "type": 5, "label": 3 }, { "name": "option_dependency", "number": 15, "type": 9, "label": 3 }, { "name": "message_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "service", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.ServiceDescriptorProto" }, { "name": "extension", "number": 7, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FileOptions" }, { "name": "source_code_info", "number": 9, "type": 11, "label": 1, "typeName": ".google.protobuf.SourceCodeInfo" }, { "name": "syntax", "number": 12, "type": 9, "label": 1 }, { "name": "edition", "number": 14, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }, { "name": "DescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "field", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "extension", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "nested_type", "number": 3, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "extension_range", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ExtensionRange" }, { "name": "oneof_decl", "number": 8, "type": 11, "label": 3, "typeName": ".google.protobuf.OneofDescriptorProto" }, { "name": "options", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.MessageOptions" }, { "name": "reserved_range", "number": 9, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ReservedRange" }, { "name": "reserved_name", "number": 10, "type": 9, "label": 3 }, { "name": "visibility", "number": 11, "type": 14, "label": 1, "typeName": ".google.protobuf.SymbolVisibility" }], "nestedType": [{ "name": "ExtensionRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions" }] }, { "name": "ReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "ExtensionRangeOptions", "field": [{ "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }, { "name": "declaration", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.ExtensionRangeOptions.Declaration", "options": { "retention": 2 } }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "verification", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions.VerificationState", "defaultValue": "UNVERIFIED", "options": { "retention": 2 } }], "nestedType": [{ "name": "Declaration", "field": [{ "name": "number", "number": 1, "type": 5, "label": 1 }, { "name": "full_name", "number": 2, "type": 9, "label": 1 }, { "name": "type", "number": 3, "type": 9, "label": 1 }, { "name": "reserved", "number": 5, "type": 8, "label": 1 }, { "name": "repeated", "number": 6, "type": 8, "label": 1 }] }], "enumType": [{ "name": "VerificationState", "value": [{ "name": "DECLARATION", "number": 0 }, { "name": "UNVERIFIED", "number": 1 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "FieldDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 3, "type": 5, "label": 1 }, { "name": "label", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Label" }, { "name": "type", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Type" }, { "name": "type_name", "number": 6, "type": 9, "label": 1 }, { "name": "extendee", "number": 2, "type": 9, "label": 1 }, { "name": "default_value", "number": 7, "type": 9, "label": 1 }, { "name": "oneof_index", "number": 9, "type": 5, "label": 1 }, { "name": "json_name", "number": 10, "type": 9, "label": 1 }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions" }, { "name": "proto3_optional", "number": 17, "type": 8, "label": 1 }], "enumType": [{ "name": "Type", "value": [{ "name": "TYPE_DOUBLE", "number": 1 }, { "name": "TYPE_FLOAT", "number": 2 }, { "name": "TYPE_INT64", "number": 3 }, { "name": "TYPE_UINT64", "number": 4 }, { "name": "TYPE_INT32", "number": 5 }, { "name": "TYPE_FIXED64", "number": 6 }, { "name": "TYPE_FIXED32", "number": 7 }, { "name": "TYPE_BOOL", "number": 8 }, { "name": "TYPE_STRING", "number": 9 }, { "name": "TYPE_GROUP", "number": 10 }, { "name": "TYPE_MESSAGE", "number": 11 }, { "name": "TYPE_BYTES", "number": 12 }, { "name": "TYPE_UINT32", "number": 13 }, { "name": "TYPE_ENUM", "number": 14 }, { "name": "TYPE_SFIXED32", "number": 15 }, { "name": "TYPE_SFIXED64", "number": 16 }, { "name": "TYPE_SINT32", "number": 17 }, { "name": "TYPE_SINT64", "number": 18 }] }, { "name": "Label", "value": [{ "name": "LABEL_OPTIONAL", "number": 1 }, { "name": "LABEL_REPEATED", "number": 3 }, { "name": "LABEL_REQUIRED", "number": 2 }] }] }, { "name": "OneofDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "options", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.OneofOptions" }] }, { "name": "EnumDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "value", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumValueDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumOptions" }, { "name": "reserved_range", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto.EnumReservedRange" }, { "name": "reserved_name", "number": 5, "type": 9, "label": 3 }, { "name": "visibility", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.SymbolVisibility" }], "nestedType": [{ "name": "EnumReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "EnumValueDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumValueOptions" }] }, { "name": "ServiceDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "method", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.MethodDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ServiceOptions" }] }, { "name": "MethodDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "input_type", "number": 2, "type": 9, "label": 1 }, { "name": "output_type", "number": 3, "type": 9, "label": 1 }, { "name": "options", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.MethodOptions" }, { "name": "client_streaming", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "server_streaming", "number": 6, "type": 8, "label": 1, "defaultValue": "false" }] }, { "name": "FileOptions", "field": [{ "name": "java_package", "number": 1, "type": 9, "label": 1 }, { "name": "java_outer_classname", "number": 8, "type": 9, "label": 1 }, { "name": "java_multiple_files", "number": 10, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generate_equals_and_hash", "number": 20, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "java_string_check_utf8", "number": 27, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "optimize_for", "number": 9, "type": 14, "label": 1, "typeName": ".google.protobuf.FileOptions.OptimizeMode", "defaultValue": "SPEED" }, { "name": "go_package", "number": 11, "type": 9, "label": 1 }, { "name": "cc_generic_services", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generic_services", "number": 17, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "py_generic_services", "number": 18, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 23, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "cc_enable_arenas", "number": 31, "type": 8, "label": 1, "defaultValue": "true" }, { "name": "objc_class_prefix", "number": 36, "type": 9, "label": 1 }, { "name": "csharp_namespace", "number": 37, "type": 9, "label": 1 }, { "name": "swift_prefix", "number": 39, "type": 9, "label": 1 }, { "name": "php_class_prefix", "number": 40, "type": 9, "label": 1 }, { "name": "php_namespace", "number": 41, "type": 9, "label": 1 }, { "name": "php_metadata_namespace", "number": 44, "type": 9, "label": 1 }, { "name": "ruby_package", "number": 45, "type": 9, "label": 1 }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "OptimizeMode", "value": [{ "name": "SPEED", "number": 1 }, { "name": "CODE_SIZE", "number": 2 }, { "name": "LITE_RUNTIME", "number": 3 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "MessageOptions", "field": [{ "name": "message_set_wire_format", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "no_standard_descriptor_accessor", "number": 2, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "map_entry", "number": 7, "type": 8, "label": 1 }, { "name": "deprecated_legacy_json_field_conflicts", "number": 11, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 12, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "FieldOptions", "field": [{ "name": "ctype", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.CType", "defaultValue": "STRING" }, { "name": "packed", "number": 2, "type": 8, "label": 1 }, { "name": "jstype", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.JSType", "defaultValue": "JS_NORMAL" }, { "name": "lazy", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "unverified_lazy", "number": 15, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "weak", "number": 10, "type": 8, "label": 1, "defaultValue": "false", "options": { "deprecated": true } }, { "name": "debug_redact", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "retention", "number": 17, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.OptionRetention" }, { "name": "targets", "number": 19, "type": 14, "label": 3, "typeName": ".google.protobuf.FieldOptions.OptionTargetType" }, { "name": "edition_defaults", "number": 20, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldOptions.EditionDefault" }, { "name": "features", "number": 21, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "feature_support", "number": 22, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "nestedType": [{ "name": "EditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "value", "number": 2, "type": 9, "label": 1 }] }, { "name": "FeatureSupport", "field": [{ "name": "edition_introduced", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "edition_deprecated", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "deprecation_warning", "number": 3, "type": 9, "label": 1 }, { "name": "edition_removed", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }], "enumType": [{ "name": "CType", "value": [{ "name": "STRING", "number": 0 }, { "name": "CORD", "number": 1 }, { "name": "STRING_PIECE", "number": 2 }] }, { "name": "JSType", "value": [{ "name": "JS_NORMAL", "number": 0 }, { "name": "JS_STRING", "number": 1 }, { "name": "JS_NUMBER", "number": 2 }] }, { "name": "OptionRetention", "value": [{ "name": "RETENTION_UNKNOWN", "number": 0 }, { "name": "RETENTION_RUNTIME", "number": 1 }, { "name": "RETENTION_SOURCE", "number": 2 }] }, { "name": "OptionTargetType", "value": [{ "name": "TARGET_TYPE_UNKNOWN", "number": 0 }, { "name": "TARGET_TYPE_FILE", "number": 1 }, { "name": "TARGET_TYPE_EXTENSION_RANGE", "number": 2 }, { "name": "TARGET_TYPE_MESSAGE", "number": 3 }, { "name": "TARGET_TYPE_FIELD", "number": 4 }, { "name": "TARGET_TYPE_ONEOF", "number": 5 }, { "name": "TARGET_TYPE_ENUM", "number": 6 }, { "name": "TARGET_TYPE_ENUM_ENTRY", "number": 7 }, { "name": "TARGET_TYPE_SERVICE", "number": 8 }, { "name": "TARGET_TYPE_METHOD", "number": 9 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "OneofOptions", "field": [{ "name": "features", "number": 1, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "EnumOptions", "field": [{ "name": "allow_alias", "number": 2, "type": 8, "label": 1 }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated_legacy_json_field_conflicts", "number": 6, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "EnumValueOptions", "field": [{ "name": "deprecated", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "features", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "debug_redact", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "feature_support", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "ServiceOptions", "field": [{ "name": "features", "number": 34, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "MethodOptions", "field": [{ "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "idempotency_level", "number": 34, "type": 14, "label": 1, "typeName": ".google.protobuf.MethodOptions.IdempotencyLevel", "defaultValue": "IDEMPOTENCY_UNKNOWN" }, { "name": "features", "number": 35, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "IdempotencyLevel", "value": [{ "name": "IDEMPOTENCY_UNKNOWN", "number": 0 }, { "name": "NO_SIDE_EFFECTS", "number": 1 }, { "name": "IDEMPOTENT", "number": 2 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "UninterpretedOption", "field": [{ "name": "name", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption.NamePart" }, { "name": "identifier_value", "number": 3, "type": 9, "label": 1 }, { "name": "positive_int_value", "number": 4, "type": 4, "label": 1 }, { "name": "negative_int_value", "number": 5, "type": 3, "label": 1 }, { "name": "double_value", "number": 6, "type": 1, "label": 1 }, { "name": "string_value", "number": 7, "type": 12, "label": 1 }, { "name": "aggregate_value", "number": 8, "type": 9, "label": 1 }], "nestedType": [{ "name": "NamePart", "field": [{ "name": "name_part", "number": 1, "type": 9, "label": 2 }, { "name": "is_extension", "number": 2, "type": 8, "label": 2 }] }] }, { "name": "FeatureSet", "field": [{ "name": "field_presence", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.FieldPresence", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPLICIT", "edition": 900 }, { "value": "IMPLICIT", "edition": 999 }, { "value": "EXPLICIT", "edition": 1e3 }] } }, { "name": "enum_type", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnumType", "options": { "retention": 1, "targets": [6, 1], "editionDefaults": [{ "value": "CLOSED", "edition": 900 }, { "value": "OPEN", "edition": 999 }] } }, { "name": "repeated_field_encoding", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.RepeatedFieldEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPANDED", "edition": 900 }, { "value": "PACKED", "edition": 999 }] } }, { "name": "utf8_validation", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.Utf8Validation", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "NONE", "edition": 900 }, { "value": "VERIFY", "edition": 999 }] } }, { "name": "message_encoding", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.MessageEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "LENGTH_PREFIXED", "edition": 900 }] } }, { "name": "json_format", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.JsonFormat", "options": { "retention": 1, "targets": [3, 6, 1], "editionDefaults": [{ "value": "LEGACY_BEST_EFFORT", "edition": 900 }, { "value": "ALLOW", "edition": 999 }] } }, { "name": "enforce_naming_style", "number": 7, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnforceNamingStyle", "options": { "retention": 2, "targets": [1, 2, 3, 4, 5, 6, 7, 8, 9], "editionDefaults": [{ "value": "STYLE_LEGACY", "edition": 900 }, { "value": "STYLE2024", "edition": 1001 }] } }, { "name": "default_symbol_visibility", "number": 8, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility", "options": { "retention": 2, "targets": [1], "editionDefaults": [{ "value": "EXPORT_ALL", "edition": 900 }, { "value": "EXPORT_TOP_LEVEL", "edition": 1001 }] } }], "nestedType": [{ "name": "VisibilityFeature", "enumType": [{ "name": "DefaultSymbolVisibility", "value": [{ "name": "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN", "number": 0 }, { "name": "EXPORT_ALL", "number": 1 }, { "name": "EXPORT_TOP_LEVEL", "number": 2 }, { "name": "LOCAL_ALL", "number": 3 }, { "name": "STRICT", "number": 4 }] }] }], "enumType": [{ "name": "FieldPresence", "value": [{ "name": "FIELD_PRESENCE_UNKNOWN", "number": 0 }, { "name": "EXPLICIT", "number": 1 }, { "name": "IMPLICIT", "number": 2 }, { "name": "LEGACY_REQUIRED", "number": 3 }] }, { "name": "EnumType", "value": [{ "name": "ENUM_TYPE_UNKNOWN", "number": 0 }, { "name": "OPEN", "number": 1 }, { "name": "CLOSED", "number": 2 }] }, { "name": "RepeatedFieldEncoding", "value": [{ "name": "REPEATED_FIELD_ENCODING_UNKNOWN", "number": 0 }, { "name": "PACKED", "number": 1 }, { "name": "EXPANDED", "number": 2 }] }, { "name": "Utf8Validation", "value": [{ "name": "UTF8_VALIDATION_UNKNOWN", "number": 0 }, { "name": "VERIFY", "number": 2 }, { "name": "NONE", "number": 3 }] }, { "name": "MessageEncoding", "value": [{ "name": "MESSAGE_ENCODING_UNKNOWN", "number": 0 }, { "name": "LENGTH_PREFIXED", "number": 1 }, { "name": "DELIMITED", "number": 2 }] }, { "name": "JsonFormat", "value": [{ "name": "JSON_FORMAT_UNKNOWN", "number": 0 }, { "name": "ALLOW", "number": 1 }, { "name": "LEGACY_BEST_EFFORT", "number": 2 }] }, { "name": "EnforceNamingStyle", "value": [{ "name": "ENFORCE_NAMING_STYLE_UNKNOWN", "number": 0 }, { "name": "STYLE2024", "number": 1 }, { "name": "STYLE_LEGACY", "number": 2 }] }], "extensionRange": [{ "start": 1e3, "end": 9995 }, { "start": 9995, "end": 1e4 }, { "start": 1e4, "end": 10001 }] }, { "name": "FeatureSetDefaults", "field": [{ "name": "defaults", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault" }, { "name": "minimum_edition", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "maximum_edition", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }], "nestedType": [{ "name": "FeatureSetEditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "overridable_features", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "fixed_features", "number": 5, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }] }] }, { "name": "SourceCodeInfo", "field": [{ "name": "location", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.SourceCodeInfo.Location" }], "nestedType": [{ "name": "Location", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "span", "number": 2, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "leading_comments", "number": 3, "type": 9, "label": 1 }, { "name": "trailing_comments", "number": 4, "type": 9, "label": 1 }, { "name": "leading_detached_comments", "number": 6, "type": 9, "label": 3 }] }], "extensionRange": [{ "start": 536e6, "end": 536000001 }] }, { "name": "GeneratedCodeInfo", "field": [{ "name": "annotation", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation" }], "nestedType": [{ "name": "Annotation", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "source_file", "number": 2, "type": 9, "label": 1 }, { "name": "begin", "number": 3, "type": 5, "label": 1 }, { "name": "end", "number": 4, "type": 5, "label": 1 }, { "name": "semantic", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation.Semantic" }], "enumType": [{ "name": "Semantic", "value": [{ "name": "NONE", "number": 0 }, { "name": "SET", "number": 1 }, { "name": "ALIAS", "number": 2 }] }] }] }], "enumType": [{ "name": "Edition", "value": [{ "name": "EDITION_UNKNOWN", "number": 0 }, { "name": "EDITION_LEGACY", "number": 900 }, { "name": "EDITION_PROTO2", "number": 998 }, { "name": "EDITION_PROTO3", "number": 999 }, { "name": "EDITION_2023", "number": 1e3 }, { "name": "EDITION_2024", "number": 1001 }, { "name": "EDITION_UNSTABLE", "number": 9999 }, { "name": "EDITION_1_TEST_ONLY", "number": 1 }, { "name": "EDITION_2_TEST_ONLY", "number": 2 }, { "name": "EDITION_99997_TEST_ONLY", "number": 99997 }, { "name": "EDITION_99998_TEST_ONLY", "number": 99998 }, { "name": "EDITION_99999_TEST_ONLY", "number": 99999 }, { "name": "EDITION_MAX", "number": 2147483647 }] }, { "name": "SymbolVisibility", "value": [{ "name": "VISIBILITY_UNSET", "number": 0 }, { "name": "VISIBILITY_LOCAL", "number": 1 }, { "name": "VISIBILITY_EXPORT", "number": 2 }] }] });
+var FileDescriptorProtoSchema = /* @__PURE__ */ messageDesc(file_google_protobuf_descriptor, 1);
+var ExtensionRangeOptions_VerificationState;
+(function(ExtensionRangeOptions_VerificationState2) {
+  ExtensionRangeOptions_VerificationState2[ExtensionRangeOptions_VerificationState2["DECLARATION"] = 0] = "DECLARATION";
+  ExtensionRangeOptions_VerificationState2[ExtensionRangeOptions_VerificationState2["UNVERIFIED"] = 1] = "UNVERIFIED";
+})(ExtensionRangeOptions_VerificationState || (ExtensionRangeOptions_VerificationState = {}));
+var FieldDescriptorProto_Type;
+(function(FieldDescriptorProto_Type2) {
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["DOUBLE"] = 1] = "DOUBLE";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FLOAT"] = 2] = "FLOAT";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["INT64"] = 3] = "INT64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["UINT64"] = 4] = "UINT64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["INT32"] = 5] = "INT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FIXED64"] = 6] = "FIXED64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FIXED32"] = 7] = "FIXED32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["BOOL"] = 8] = "BOOL";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["STRING"] = 9] = "STRING";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["GROUP"] = 10] = "GROUP";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["MESSAGE"] = 11] = "MESSAGE";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["BYTES"] = 12] = "BYTES";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["UINT32"] = 13] = "UINT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["ENUM"] = 14] = "ENUM";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SFIXED32"] = 15] = "SFIXED32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SFIXED64"] = 16] = "SFIXED64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SINT32"] = 17] = "SINT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SINT64"] = 18] = "SINT64";
+})(FieldDescriptorProto_Type || (FieldDescriptorProto_Type = {}));
+var FieldDescriptorProto_Label;
+(function(FieldDescriptorProto_Label2) {
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["OPTIONAL"] = 1] = "OPTIONAL";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REPEATED"] = 3] = "REPEATED";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REQUIRED"] = 2] = "REQUIRED";
+})(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {}));
+var FileOptions_OptimizeMode;
+(function(FileOptions_OptimizeMode2) {
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["SPEED"] = 1] = "SPEED";
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["CODE_SIZE"] = 2] = "CODE_SIZE";
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["LITE_RUNTIME"] = 3] = "LITE_RUNTIME";
+})(FileOptions_OptimizeMode || (FileOptions_OptimizeMode = {}));
+var FieldOptions_CType;
+(function(FieldOptions_CType2) {
+  FieldOptions_CType2[FieldOptions_CType2["STRING"] = 0] = "STRING";
+  FieldOptions_CType2[FieldOptions_CType2["CORD"] = 1] = "CORD";
+  FieldOptions_CType2[FieldOptions_CType2["STRING_PIECE"] = 2] = "STRING_PIECE";
+})(FieldOptions_CType || (FieldOptions_CType = {}));
+var FieldOptions_JSType;
+(function(FieldOptions_JSType2) {
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_NORMAL"] = 0] = "JS_NORMAL";
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_STRING"] = 1] = "JS_STRING";
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_NUMBER"] = 2] = "JS_NUMBER";
+})(FieldOptions_JSType || (FieldOptions_JSType = {}));
+var FieldOptions_OptionRetention;
+(function(FieldOptions_OptionRetention2) {
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_UNKNOWN"] = 0] = "RETENTION_UNKNOWN";
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_RUNTIME"] = 1] = "RETENTION_RUNTIME";
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_SOURCE"] = 2] = "RETENTION_SOURCE";
+})(FieldOptions_OptionRetention || (FieldOptions_OptionRetention = {}));
+var FieldOptions_OptionTargetType;
+(function(FieldOptions_OptionTargetType2) {
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_UNKNOWN"] = 0] = "TARGET_TYPE_UNKNOWN";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_FILE"] = 1] = "TARGET_TYPE_FILE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_EXTENSION_RANGE"] = 2] = "TARGET_TYPE_EXTENSION_RANGE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_MESSAGE"] = 3] = "TARGET_TYPE_MESSAGE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_FIELD"] = 4] = "TARGET_TYPE_FIELD";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ONEOF"] = 5] = "TARGET_TYPE_ONEOF";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ENUM"] = 6] = "TARGET_TYPE_ENUM";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ENUM_ENTRY"] = 7] = "TARGET_TYPE_ENUM_ENTRY";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_SERVICE"] = 8] = "TARGET_TYPE_SERVICE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_METHOD"] = 9] = "TARGET_TYPE_METHOD";
+})(FieldOptions_OptionTargetType || (FieldOptions_OptionTargetType = {}));
+var MethodOptions_IdempotencyLevel;
+(function(MethodOptions_IdempotencyLevel2) {
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN";
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS";
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["IDEMPOTENT"] = 2] = "IDEMPOTENT";
+})(MethodOptions_IdempotencyLevel || (MethodOptions_IdempotencyLevel = {}));
+var FeatureSet_VisibilityFeature_DefaultSymbolVisibility;
+(function(FeatureSet_VisibilityFeature_DefaultSymbolVisibility2) {
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"] = 0] = "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["EXPORT_ALL"] = 1] = "EXPORT_ALL";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["EXPORT_TOP_LEVEL"] = 2] = "EXPORT_TOP_LEVEL";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["LOCAL_ALL"] = 3] = "LOCAL_ALL";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["STRICT"] = 4] = "STRICT";
+})(FeatureSet_VisibilityFeature_DefaultSymbolVisibility || (FeatureSet_VisibilityFeature_DefaultSymbolVisibility = {}));
+var FeatureSet_FieldPresence;
+(function(FeatureSet_FieldPresence2) {
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["EXPLICIT"] = 1] = "EXPLICIT";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["IMPLICIT"] = 2] = "IMPLICIT";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED";
+})(FeatureSet_FieldPresence || (FeatureSet_FieldPresence = {}));
+var FeatureSet_EnumType;
+(function(FeatureSet_EnumType2) {
+  FeatureSet_EnumType2[FeatureSet_EnumType2["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN";
+  FeatureSet_EnumType2[FeatureSet_EnumType2["OPEN"] = 1] = "OPEN";
+  FeatureSet_EnumType2[FeatureSet_EnumType2["CLOSED"] = 2] = "CLOSED";
+})(FeatureSet_EnumType || (FeatureSet_EnumType = {}));
+var FeatureSet_RepeatedFieldEncoding;
+(function(FeatureSet_RepeatedFieldEncoding2) {
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN";
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["PACKED"] = 1] = "PACKED";
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["EXPANDED"] = 2] = "EXPANDED";
+})(FeatureSet_RepeatedFieldEncoding || (FeatureSet_RepeatedFieldEncoding = {}));
+var FeatureSet_Utf8Validation;
+(function(FeatureSet_Utf8Validation2) {
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN";
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["VERIFY"] = 2] = "VERIFY";
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["NONE"] = 3] = "NONE";
+})(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {}));
+var FeatureSet_MessageEncoding;
+(function(FeatureSet_MessageEncoding2) {
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN";
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED";
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["DELIMITED"] = 2] = "DELIMITED";
+})(FeatureSet_MessageEncoding || (FeatureSet_MessageEncoding = {}));
+var FeatureSet_JsonFormat;
+(function(FeatureSet_JsonFormat2) {
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN";
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["ALLOW"] = 1] = "ALLOW";
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT";
+})(FeatureSet_JsonFormat || (FeatureSet_JsonFormat = {}));
+var FeatureSet_EnforceNamingStyle;
+(function(FeatureSet_EnforceNamingStyle2) {
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["ENFORCE_NAMING_STYLE_UNKNOWN"] = 0] = "ENFORCE_NAMING_STYLE_UNKNOWN";
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["STYLE2024"] = 1] = "STYLE2024";
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["STYLE_LEGACY"] = 2] = "STYLE_LEGACY";
+})(FeatureSet_EnforceNamingStyle || (FeatureSet_EnforceNamingStyle = {}));
+var GeneratedCodeInfo_Annotation_Semantic;
+(function(GeneratedCodeInfo_Annotation_Semantic2) {
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["NONE"] = 0] = "NONE";
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["SET"] = 1] = "SET";
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["ALIAS"] = 2] = "ALIAS";
+})(GeneratedCodeInfo_Annotation_Semantic || (GeneratedCodeInfo_Annotation_Semantic = {}));
+var Edition;
+(function(Edition2) {
+  Edition2[Edition2["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN";
+  Edition2[Edition2["EDITION_LEGACY"] = 900] = "EDITION_LEGACY";
+  Edition2[Edition2["EDITION_PROTO2"] = 998] = "EDITION_PROTO2";
+  Edition2[Edition2["EDITION_PROTO3"] = 999] = "EDITION_PROTO3";
+  Edition2[Edition2["EDITION_2023"] = 1e3] = "EDITION_2023";
+  Edition2[Edition2["EDITION_2024"] = 1001] = "EDITION_2024";
+  Edition2[Edition2["EDITION_UNSTABLE"] = 9999] = "EDITION_UNSTABLE";
+  Edition2[Edition2["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY";
+  Edition2[Edition2["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY";
+  Edition2[Edition2["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY";
+  Edition2[Edition2["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY";
+  Edition2[Edition2["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY";
+  Edition2[Edition2["EDITION_MAX"] = 2147483647] = "EDITION_MAX";
+})(Edition || (Edition = {}));
+var SymbolVisibility;
+(function(SymbolVisibility2) {
+  SymbolVisibility2[SymbolVisibility2["VISIBILITY_UNSET"] = 0] = "VISIBILITY_UNSET";
+  SymbolVisibility2[SymbolVisibility2["VISIBILITY_LOCAL"] = 1] = "VISIBILITY_LOCAL";
+  SymbolVisibility2[SymbolVisibility2["VISIBILITY_EXPORT"] = 2] = "VISIBILITY_EXPORT";
+})(SymbolVisibility || (SymbolVisibility = {}));
+
+// node_modules/@bufbuild/protobuf/dist/esm/from-binary.js
+var readDefaults = {
+  readUnknownFields: true
+};
+function makeReadOptions(options) {
+  return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
+}
+function fromBinary(schema, bytes, options) {
+  const msg = reflect(schema, void 0, false);
+  readMessage(msg, new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+  return msg.message;
+}
+function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) {
+  var _a;
+  const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo;
+  let fieldNo;
+  let wireType;
+  const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
+  while (reader.pos < end) {
+    [fieldNo, wireType] = reader.tag();
+    if (delimited && wireType == WireType.EndGroup) {
+      break;
+    }
+    const field = message.findNumber(fieldNo);
+    if (!field) {
+      const data = reader.skip(wireType, fieldNo);
+      if (options.readUnknownFields) {
+        unknownFields.push({ no: fieldNo, wireType, data });
+      }
+      continue;
+    }
+    readField(message, reader, field, wireType, options);
+  }
+  if (delimited) {
+    if (wireType != WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) {
+      throw new Error("invalid end group tag");
+    }
+  }
+  if (unknownFields.length > 0) {
+    message.setUnknown(unknownFields);
+  }
+}
+function readField(message, reader, field, wireType, options) {
+  var _a;
+  switch (field.fieldKind) {
+    case "scalar":
+      message.set(field, readScalar(reader, field.scalar));
+      break;
+    case "enum":
+      const val = readScalar(reader, ScalarType.INT32);
+      if (field.enum.open) {
+        message.set(field, val);
+      } else {
+        const ok = field.enum.values.some((v) => v.number === val);
+        if (ok) {
+          message.set(field, val);
+        } else if (options.readUnknownFields) {
+          const bytes = [];
+          varint32write(val, bytes);
+          const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
+          unknownFields.push({
+            no: field.number,
+            wireType,
+            data: new Uint8Array(bytes)
+          });
+          message.setUnknown(unknownFields);
+        }
+      }
+      break;
+    case "message":
+      message.set(field, readMessageField(reader, options, field, message.get(field)));
+      break;
+    case "list":
+      readListField(reader, wireType, message.get(field), options);
+      break;
+    case "map":
+      readMapEntry(reader, message.get(field), options);
+      break;
+  }
+}
+function readMapEntry(reader, map, options) {
+  const field = map.field();
+  let key;
+  let val;
+  const len = reader.uint32();
+  const end = reader.pos + len;
+  while (reader.pos < end) {
+    const [fieldNo] = reader.tag();
+    switch (fieldNo) {
+      case 1:
+        key = readScalar(reader, field.mapKey);
+        break;
+      case 2:
+        switch (field.mapKind) {
+          case "scalar":
+            val = readScalar(reader, field.scalar);
+            break;
+          case "enum":
+            val = reader.int32();
+            break;
+          case "message":
+            val = readMessageField(reader, options, field);
+            break;
+        }
+        break;
+    }
+  }
+  if (key === void 0) {
+    key = scalarZeroValue(field.mapKey, false);
+  }
+  if (val === void 0) {
+    switch (field.mapKind) {
+      case "scalar":
+        val = scalarZeroValue(field.scalar, false);
+        break;
+      case "enum":
+        val = field.enum.values[0].number;
+        break;
+      case "message":
+        val = reflect(field.message, void 0, false);
+        break;
+    }
+  }
+  map.set(key, val);
+}
+function readListField(reader, wireType, list, options) {
+  var _a;
+  const field = list.field();
+  if (field.listKind === "message") {
+    list.add(readMessageField(reader, options, field));
+    return;
+  }
+  const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
+  const packed = wireType == WireType.LengthDelimited && scalarType != ScalarType.STRING && scalarType != ScalarType.BYTES;
+  if (!packed) {
+    list.add(readScalar(reader, scalarType));
+    return;
+  }
+  const e = reader.uint32() + reader.pos;
+  while (reader.pos < e) {
+    list.add(readScalar(reader, scalarType));
+  }
+}
+function readMessageField(reader, options, field, mergeMessage) {
+  const delimited = field.delimitedEncoding;
+  const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message, void 0, false);
+  readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
+  return message;
+}
+function readScalar(reader, type) {
+  switch (type) {
+    case ScalarType.STRING:
+      return reader.string();
+    case ScalarType.BOOL:
+      return reader.bool();
+    case ScalarType.DOUBLE:
+      return reader.double();
+    case ScalarType.FLOAT:
+      return reader.float();
+    case ScalarType.INT32:
+      return reader.int32();
+    case ScalarType.INT64:
+      return reader.int64();
+    case ScalarType.UINT64:
+      return reader.uint64();
+    case ScalarType.FIXED64:
+      return reader.fixed64();
+    case ScalarType.BYTES:
+      return reader.bytes();
+    case ScalarType.FIXED32:
+      return reader.fixed32();
+    case ScalarType.SFIXED32:
+      return reader.sfixed32();
+    case ScalarType.SFIXED64:
+      return reader.sfixed64();
+    case ScalarType.SINT64:
+      return reader.sint64();
+    case ScalarType.UINT32:
+      return reader.uint32();
+    case ScalarType.SINT32:
+      return reader.sint32();
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.js
+function fileDesc(b64, imports) {
+  var _a;
+  const root = fromBinary(FileDescriptorProtoSchema, base64Decode(b64));
+  root.messageType.forEach(restoreJsonNames);
+  root.dependency = (_a = imports === null || imports === void 0 ? void 0 : imports.map((f) => f.proto.name)) !== null && _a !== void 0 ? _a : [];
+  const reg = createFileRegistry(root, (protoFileName) => imports === null || imports === void 0 ? void 0 : imports.find((f) => f.proto.name === protoFileName));
+  return reg.getFile(root.name);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.js
+function serviceDesc(file, path, ...paths) {
+  if (paths.length > 0) {
+    throw new Error();
+  }
+  return file.services[path];
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/timestamp_pb.js
+var file_google_protobuf_timestamp = /* @__PURE__ */ fileDesc("Ch9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnByb3RvEg9nb29nbGUucHJvdG9idWYiKwoJVGltZXN0YW1wEg8KB3NlY29uZHMYASABKAMSDQoFbmFub3MYAiABKAVChQEKE2NvbS5nb29nbGUucHJvdG9idWZCDlRpbWVzdGFtcFByb3RvUAFaMmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3RpbWVzdGFtcHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM");
+
+// src/gen/common_pb.ts
+var file_common = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp]);
+
+// src/gen/google/api/field_behavior_pb.ts
+var file_google_api_field_behavior = /* @__PURE__ */ fileDesc("Ch9nb29nbGUvYXBpL2ZpZWxkX2JlaGF2aW9yLnByb3RvEgpnb29nbGUuYXBpKqYBCg1GaWVsZEJlaGF2aW9yEh4KGkZJRUxEX0JFSEFWSU9SX1VOU1BFQ0lGSUVEEAASDAoIT1BUSU9OQUwQARIMCghSRVFVSVJFRBACEg8KC09VVFBVVF9PTkxZEAMSDgoKSU5QVVRfT05MWRAEEg0KCUlNTVVUQUJMRRAFEhIKDlVOT1JERVJFRF9MSVNUEAYSFQoRTk9OX0VNUFRZX0RFRkFVTFQQBzpgCg5maWVsZF9iZWhhdmlvchIdLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlvbnMYnAggAygOMhkuZ29vZ2xlLmFwaS5GaWVsZEJlaGF2aW9yUg1maWVsZEJlaGF2aW9yQnAKDmNvbS5nb29nbGUuYXBpQhJGaWVsZEJlaGF2aW9yUHJvdG9QAVpBZ29vZ2xlLmdvbGFuZy5vcmcvZ2VucHJvdG8vZ29vZ2xlYXBpcy9hcGkvYW5ub3RhdGlvbnM7YW5ub3RhdGlvbnOiAgRHQVBJYgZwcm90bzM", [file_google_protobuf_descriptor]);
+
+// src/gen/instruments_pb.ts
+var file_instruments = /* @__PURE__ */ fileDesc("ChFpbnN0cnVtZW50cy5wcm90bxIldGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MSKpAQoXVHJhZGluZ1NjaGVkdWxlc1JlcXVlc3QSFQoIZXhjaGFuZ2UYASABKAlIAIgBARItCgRmcm9tGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgBiAEBEisKAnRvGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgCiAEBQgsKCV9leGNoYW5nZUIHCgVfZnJvbUIFCgNfdG8iZQoYVHJhZGluZ1NjaGVkdWxlc1Jlc3BvbnNlEkkKCWV4Y2hhbmdlcxgBIAMoCzI2LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuVHJhZGluZ1NjaGVkdWxlImQKD1RyYWRpbmdTY2hlZHVsZRIQCghleGNoYW5nZRgBIAEoCRI/CgRkYXlzGAIgAygLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5UcmFkaW5nRGF5IpcHCgpUcmFkaW5nRGF5EigKBGRhdGUYASABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhYKDmlzX3RyYWRpbmdfZGF5GAIgASgIEi4KCnN0YXJ0X3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEiwKCGVuZF90aW1lGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI+ChpvcGVuaW5nX2F1Y3Rpb25fc3RhcnRfdGltZRgHIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPAoYY2xvc2luZ19hdWN0aW9uX2VuZF90aW1lGAggASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJGCiJldmVuaW5nX29wZW5pbmdfYXVjdGlvbl9zdGFydF90aW1lGAkgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI2ChJldmVuaW5nX3N0YXJ0X3RpbWUYCiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjQKEGV2ZW5pbmdfZW5kX3RpbWUYCyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjcKE2NsZWFyaW5nX3N0YXJ0X3RpbWUYDCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjUKEWNsZWFyaW5nX2VuZF90aW1lGA0gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI4ChRwcmVtYXJrZXRfc3RhcnRfdGltZRgOIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASNgoScHJlbWFya2V0X2VuZF90aW1lGA8gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI+ChpjbG9zaW5nX2F1Y3Rpb25fc3RhcnRfdGltZRgQIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPAoYb3BlbmluZ19hdWN0aW9uX2VuZF90aW1lGBEgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJJCglpbnRlcnZhbHMYEiADKAsyNi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlRyYWRpbmdJbnRlcnZhbEoECAUQBkoECAYQByKdAQoRSW5zdHJ1bWVudFJlcXVlc3QSTgoHaWRfdHlwZRgBIAEoDjI3LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudElkVHlwZUIE4kEBAhIXCgpjbGFzc19jb2RlGAIgASgJSACIAQESEAoCaWQYAyABKAlCBOJBAQJCDQoLX2NsYXNzX2NvZGUi/AEKEkluc3RydW1lbnRzUmVxdWVzdBJXChFpbnN0cnVtZW50X3N0YXR1cxgBIAEoDjI3LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFN0YXR1c0gAiAEBEl8KE2luc3RydW1lbnRfZXhjaGFuZ2UYAiABKA4yPS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRFeGNoYW5nZVR5cGVIAYgBAUIUChJfaW5zdHJ1bWVudF9zdGF0dXNCFgoUX2luc3RydW1lbnRfZXhjaGFuZ2UixgEKFEZpbHRlck9wdGlvbnNSZXF1ZXN0EhwKD2Jhc2ljX2Fzc2V0X3VpZBgBIAEoCUgAiAEBEiUKGGJhc2ljX2Fzc2V0X3Bvc2l0aW9uX3VpZBgCIAEoCUgBiAEBEiAKE2Jhc2ljX2luc3RydW1lbnRfaWQYAyABKAlIAogBAUISChBfYmFzaWNfYXNzZXRfdWlkQhsKGV9iYXNpY19hc3NldF9wb3NpdGlvbl91aWRCFgoUX2Jhc2ljX2luc3RydW1lbnRfaWQiTwoMQm9uZFJlc3BvbnNlEj8KCmluc3RydW1lbnQYASABKAsyKy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkJvbmQiUQoNQm9uZHNSZXNwb25zZRJACgtpbnN0cnVtZW50cxgBIAMoCzIrLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQm9uZCKyAQoVR2V0Qm9uZENvdXBvbnNSZXF1ZXN0EhAKBGZpZ2kYASABKAlCAhgBEi0KBGZyb20YAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSACIAQESKwoCdG8YAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSAGIAQESGwoNaW5zdHJ1bWVudF9pZBgEIAEoCUIE4kEBAkIHCgVfZnJvbUIFCgNfdG8iVwoWR2V0Qm9uZENvdXBvbnNSZXNwb25zZRI9CgZldmVudHMYASADKAsyLS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkNvdXBvbiLvAgoUR2V0Qm9uZEV2ZW50c1JlcXVlc3QSLQoEZnJvbRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBIAIgBARIrCgJ0bxgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBIAYgBARIbCg1pbnN0cnVtZW50X2lkGAQgASgJQgTiQQECElMKBHR5cGUYBSABKA4yRS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEJvbmRFdmVudHNSZXF1ZXN0LkV2ZW50VHlwZSJ5CglFdmVudFR5cGUSGgoWRVZFTlRfVFlQRV9VTlNQRUNJRklFRBAAEhIKDkVWRU5UX1RZUEVfQ1BOEAESEwoPRVZFTlRfVFlQRV9DQUxMEAISEgoORVZFTlRfVFlQRV9NVFkQAxITCg9FVkVOVF9UWVBFX0NPTlYQBEIHCgVfZnJvbUIFCgNfdG8i8QgKFUdldEJvbmRFdmVudHNSZXNwb25zZRJWCgZldmVudHMYASADKAsyRi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEJvbmRFdmVudHNSZXNwb25zZS5Cb25kRXZlbnQa/wcKCUJvbmRFdmVudBIVCg1pbnN0cnVtZW50X2lkGAIgASgJEhQKDGV2ZW50X251bWJlchgDIAEoBRIuCgpldmVudF9kYXRlGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJZCgpldmVudF90eXBlGAUgASgOMkUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRCb25kRXZlbnRzUmVxdWVzdC5FdmVudFR5cGUSSQoPZXZlbnRfdG90YWxfdm9sGAYgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SLAoIZml4X2RhdGUYByABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEi0KCXJhdGVfZGF0ZRgIIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASMAoMZGVmYXVsdF9kYXRlGAkgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIxCg1yZWFsX3BheV9kYXRlGAogASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIsCghwYXlfZGF0ZRgLIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASRwoMcGF5X29uZV9ib25kGAwgASgLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Nb25leVZhbHVlEkkKDm1vbmV5X2Zsb3dfdmFsGA0gASgLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Nb25leVZhbHVlEhEKCWV4ZWN1dGlvbhgOIAEoCRIWCg5vcGVyYXRpb25fdHlwZRgPIAEoCRI/CgV2YWx1ZRgQIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEgwKBG5vdGUYESABKAkSHgoWY29udmVydF90b19maW5fdG9vbF9pZBgSIAEoCRI1ChFjb3Vwb25fc3RhcnRfZGF0ZRgTIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASMwoPY291cG9uX2VuZF9kYXRlGBQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIVCg1jb3Vwb25fcGVyaW9kGBUgASgFEk4KFGNvdXBvbl9pbnRlcmVzdF9yYXRlGBYgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24ioAMKBkNvdXBvbhIMCgRmaWdpGAEgASgJEi8KC2NvdXBvbl9kYXRlGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIVCg1jb3Vwb25fbnVtYmVyGAMgASgDEiwKCGZpeF9kYXRlGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJHCgxwYXlfb25lX2JvbmQYBSABKAsyMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk1vbmV5VmFsdWUSRgoLY291cG9uX3R5cGUYBiABKA4yMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkNvdXBvblR5cGUSNQoRY291cG9uX3N0YXJ0X2RhdGUYByABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjMKD2NvdXBvbl9lbmRfZGF0ZRgIIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASFQoNY291cG9uX3BlcmlvZBgJIAEoBSJXChBDdXJyZW5jeVJlc3BvbnNlEkMKCmluc3RydW1lbnQYASABKAsyLy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkN1cnJlbmN5IloKEkN1cnJlbmNpZXNSZXNwb25zZRJECgtpbnN0cnVtZW50cxgBIAMoCzIvLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQ3VycmVuY3kiTQoLRXRmUmVzcG9uc2USPgoKaW5zdHJ1bWVudBgBIAEoCzIqLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRXRmIk8KDEV0ZnNSZXNwb25zZRI/CgtpbnN0cnVtZW50cxgBIAMoCzIqLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRXRmIlMKDkZ1dHVyZVJlc3BvbnNlEkEKCmluc3RydW1lbnQYASABKAsyLS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkZ1dHVyZSJVCg9GdXR1cmVzUmVzcG9uc2USQgoLaW5zdHJ1bWVudHMYASADKAsyLS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkZ1dHVyZSJTCg5PcHRpb25SZXNwb25zZRJBCgppbnN0cnVtZW50GAEgASgLMi0udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5PcHRpb24iVQoPT3B0aW9uc1Jlc3BvbnNlEkIKC2luc3RydW1lbnRzGAEgAygLMi0udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5PcHRpb24ioxEKBk9wdGlvbhILCgN1aWQYASABKAkSFAoMcG9zaXRpb25fdWlkGAIgASgJEg4KBnRpY2tlchgDIAEoCRISCgpjbGFzc19jb2RlGAQgASgJEiAKGGJhc2ljX2Fzc2V0X3Bvc2l0aW9uX3VpZBgFIAEoCRJUCg50cmFkaW5nX3N0YXR1cxgVIAEoDjI8LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU2VjdXJpdHlUcmFkaW5nU3RhdHVzEkoKDXJlYWxfZXhjaGFuZ2UYHyABKA4yMy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlJlYWxFeGNoYW5nZRJJCglkaXJlY3Rpb24YKSABKA4yNi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk9wdGlvbkRpcmVjdGlvbhJOCgxwYXltZW50X3R5cGUYKiABKA4yOC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk9wdGlvblBheW1lbnRUeXBlEkEKBXN0eWxlGCsgASgOMjIudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5PcHRpb25TdHlsZRJUCg9zZXR0bGVtZW50X3R5cGUYLCABKA4yOy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk9wdGlvblNldHRsZW1lbnRUeXBlEgwKBG5hbWUYZSABKAkSEAoIY3VycmVuY3kYbyABKAkSGwoTc2V0dGxlbWVudF9jdXJyZW5jeRhwIAEoCRITCgphc3NldF90eXBlGIMBIAEoCRIUCgtiYXNpY19hc3NldBiEASABKAkSEQoIZXhjaGFuZ2UYjQEgASgJEhgKD2NvdW50cnlfb2ZfcmlzaxiXASABKAkSHQoUY291bnRyeV9vZl9yaXNrX25hbWUYmAEgASgJEg8KBnNlY3RvchihASABKAkSQAoFYnJhbmQYogEgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5CcmFuZERhdGESDAoDbG90GMkBIAEoBRJLChBiYXNpY19hc3NldF9zaXplGNMBIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkQKBWtsb25nGN0BIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uQgIYARJFCgZrc2hvcnQY3gEgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb25CAhgBEkAKBWRsb25nGN8BIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkEKBmRzaG9ydBjgASABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJECglkbG9uZ19taW4Y4QEgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRQoKZHNob3J0X21pbhjiASABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJOChNtaW5fcHJpY2VfaW5jcmVtZW50GOcBIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkgKDHN0cmlrZV9wcmljZRjxASABKAsyMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk1vbmV5VmFsdWUSRwoMZGxvbmdfY2xpZW50GKICIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkgKDWRzaG9ydF9jbGllbnQYowIgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SNAoPZXhwaXJhdGlvbl9kYXRlGK0CIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASNQoQZmlyc3RfdHJhZGVfZGF0ZRi3AiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjQKD2xhc3RfdHJhZGVfZGF0ZRi4AiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjsKFmZpcnN0XzFtaW5fY2FuZGxlX2RhdGUYwQIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI7ChZmaXJzdF8xZGF5X2NhbmRsZV9kYXRlGMICIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASGwoSc2hvcnRfZW5hYmxlZF9mbGFnGJEDIAEoCBIVCgxmb3JfaWlzX2ZsYWcYkgMgASgIEhEKCG90Y19mbGFnGJMDIAEoCBIbChJidXlfYXZhaWxhYmxlX2ZsYWcYlAMgASgIEhwKE3NlbGxfYXZhaWxhYmxlX2ZsYWcYlQMgASgIEh8KFmZvcl9xdWFsX2ludmVzdG9yX2ZsYWcYlgMgASgIEhUKDHdlZWtlbmRfZmxhZxiXAyABKAgSGQoQYmxvY2tlZF90Y2FfZmxhZxiYAyABKAgSIQoYYXBpX3RyYWRlX2F2YWlsYWJsZV9mbGFnGJkDIAEoCBIXCg5yZXF1aXJlZF90ZXN0cxiaAyADKAkiUQoNU2hhcmVSZXNwb25zZRJACgppbnN0cnVtZW50GAEgASgLMiwudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TaGFyZSJTCg5TaGFyZXNSZXNwb25zZRJBCgtpbnN0cnVtZW50cxgBIAMoCzIsLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU2hhcmUiYwoWU3RydWN0dXJlZE5vdGVSZXNwb25zZRJJCgppbnN0cnVtZW50GAEgASgLMjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TdHJ1Y3R1cmVkTm90ZSJlChdTdHJ1Y3R1cmVkTm90ZXNSZXNwb25zZRJKCgtpbnN0cnVtZW50cxgBIAMoCzI1LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU3RydWN0dXJlZE5vdGUiuhIKBEJvbmQSDAoEZmlnaRgBIAEoCRIOCgZ0aWNrZXIYAiABKAkSEgoKY2xhc3NfY29kZRgDIAEoCRIMCgRpc2luGAQgASgJEgsKA2xvdBgFIAEoBRIQCghjdXJyZW5jeRgGIAEoCRJDCgVrbG9uZxgHIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uQgIYARJECgZrc2hvcnQYCCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbkICGAESPwoFZGxvbmcYCSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJACgZkc2hvcnQYCiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJDCglkbG9uZ19taW4YCyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJECgpkc2hvcnRfbWluGAwgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGgoSc2hvcnRfZW5hYmxlZF9mbGFnGA0gASgIEgwKBG5hbWUYDyABKAkSEAoIZXhjaGFuZ2UYECABKAkSIAoYY291cG9uX3F1YW50aXR5X3Blcl95ZWFyGBEgASgFEjEKDW1hdHVyaXR5X2RhdGUYEiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkIKB25vbWluYWwYEyABKAsyMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk1vbmV5VmFsdWUSSgoPaW5pdGlhbF9ub21pbmFsGBQgASgLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Nb25leVZhbHVlEjIKDnN0YXRlX3JlZ19kYXRlGBUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIyCg5wbGFjZW1lbnRfZGF0ZRgWIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASSgoPcGxhY2VtZW50X3ByaWNlGBcgASgLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Nb25leVZhbHVlEkQKCWFjaV92YWx1ZRgYIAEoCzIxLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuTW9uZXlWYWx1ZRIXCg9jb3VudHJ5X29mX3Jpc2sYGSABKAkSHAoUY291bnRyeV9vZl9yaXNrX25hbWUYGiABKAkSDgoGc2VjdG9yGBsgASgJEhIKCmlzc3VlX2tpbmQYHCABKAkSEgoKaXNzdWVfc2l6ZRgdIAEoAxIXCg9pc3N1ZV9zaXplX3BsYW4YHiABKAMSVAoOdHJhZGluZ19zdGF0dXMYHyABKA4yPC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlNlY3VyaXR5VHJhZGluZ1N0YXR1cxIQCghvdGNfZmxhZxggIAEoCBIaChJidXlfYXZhaWxhYmxlX2ZsYWcYISABKAgSGwoTc2VsbF9hdmFpbGFibGVfZmxhZxgiIAEoCBIcChRmbG9hdGluZ19jb3Vwb25fZmxhZxgjIAEoCBIWCg5wZXJwZXR1YWxfZmxhZxgkIAEoCBIZChFhbW9ydGl6YXRpb25fZmxhZxglIAEoCBJNChNtaW5fcHJpY2VfaW5jcmVtZW50GCYgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SIAoYYXBpX3RyYWRlX2F2YWlsYWJsZV9mbGFnGCcgASgIEgsKA3VpZBgoIAEoCRJKCg1yZWFsX2V4Y2hhbmdlGCkgASgOMjMudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5SZWFsRXhjaGFuZ2USFAoMcG9zaXRpb25fdWlkGCogASgJEhEKCWFzc2V0X3VpZBgrIAEoCRIWCg5yZXF1aXJlZF90ZXN0cxgsIAMoCRIUCgxmb3JfaWlzX2ZsYWcYMyABKAgSHgoWZm9yX3F1YWxfaW52ZXN0b3JfZmxhZxg0IAEoCBIUCgx3ZWVrZW5kX2ZsYWcYNSABKAgSGAoQYmxvY2tlZF90Y2FfZmxhZxg2IAEoCBIZChFzdWJvcmRpbmF0ZWRfZmxhZxg3IAEoCBIWCg5saXF1aWRpdHlfZmxhZxg4IAEoCBI6ChZmaXJzdF8xbWluX2NhbmRsZV9kYXRlGD0gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI6ChZmaXJzdF8xZGF5X2NhbmRsZV9kYXRlGD4gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJECgpyaXNrX2xldmVsGD8gASgOMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5SaXNrTGV2ZWwSPwoFYnJhbmQYQCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkJyYW5kRGF0YRJCCglib25kX3R5cGUYQSABKA4yLy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkJvbmRUeXBlEi0KCWNhbGxfZGF0ZRhFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASRgoMZGxvbmdfY2xpZW50GFogASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRwoNZHNob3J0X2NsaWVudBhbIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uIrAMCghDdXJyZW5jeRIMCgRmaWdpGAEgASgJEg4KBnRpY2tlchgCIAEoCRISCgpjbGFzc19jb2RlGAMgASgJEgwKBGlzaW4YBCABKAkSCwoDbG90GAUgASgFEhAKCGN1cnJlbmN5GAYgASgJEkMKBWtsb25nGAcgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb25CAhgBEkQKBmtzaG9ydBgIIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uQgIYARI/CgVkbG9uZxgJIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkAKBmRzaG9ydBgKIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkMKCWRsb25nX21pbhgLIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkQKCmRzaG9ydF9taW4YDCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIaChJzaG9ydF9lbmFibGVkX2ZsYWcYDSABKAgSDAoEbmFtZRgPIAEoCRIQCghleGNoYW5nZRgQIAEoCRJCCgdub21pbmFsGBEgASgLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Nb25leVZhbHVlEhcKD2NvdW50cnlfb2ZfcmlzaxgSIAEoCRIcChRjb3VudHJ5X29mX3Jpc2tfbmFtZRgTIAEoCRJUCg50cmFkaW5nX3N0YXR1cxgUIAEoDjI8LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU2VjdXJpdHlUcmFkaW5nU3RhdHVzEhAKCG90Y19mbGFnGBUgASgIEhoKEmJ1eV9hdmFpbGFibGVfZmxhZxgWIAEoCBIbChNzZWxsX2F2YWlsYWJsZV9mbGFnGBcgASgIEhkKEWlzb19jdXJyZW5jeV9uYW1lGBggASgJEk0KE21pbl9wcmljZV9pbmNyZW1lbnQYGSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIgChhhcGlfdHJhZGVfYXZhaWxhYmxlX2ZsYWcYGiABKAgSCwoDdWlkGBsgASgJEkoKDXJlYWxfZXhjaGFuZ2UYHCABKA4yMy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlJlYWxFeGNoYW5nZRIUCgxwb3NpdGlvbl91aWQYHSABKAkSFgoOcmVxdWlyZWRfdGVzdHMYHiADKAkSEQoJYXNzZXRfdWlkGB8gASgJEhQKDGZvcl9paXNfZmxhZxgpIAEoCBIeChZmb3JfcXVhbF9pbnZlc3Rvcl9mbGFnGDQgASgIEhQKDHdlZWtlbmRfZmxhZxg1IAEoCBIYChBibG9ja2VkX3RjYV9mbGFnGDYgASgIEjoKFmZpcnN0XzFtaW5fY2FuZGxlX2RhdGUYOCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjoKFmZpcnN0XzFkYXlfY2FuZGxlX2RhdGUYOSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEj8KBWJyYW5kGDwgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5CcmFuZERhdGESRgoMZGxvbmdfY2xpZW50GFogASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRwoNZHNob3J0X2NsaWVudBhbIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uIsMOCgNFdGYSDAoEZmlnaRgBIAEoCRIOCgZ0aWNrZXIYAiABKAkSEgoKY2xhc3NfY29kZRgDIAEoCRIMCgRpc2luGAQgASgJEgsKA2xvdBgFIAEoBRIQCghjdXJyZW5jeRgGIAEoCRJDCgVrbG9uZxgHIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uQgIYARJECgZrc2hvcnQYCCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbkICGAESPwoFZGxvbmcYCSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJACgZkc2hvcnQYCiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJDCglkbG9uZ19taW4YCyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJECgpkc2hvcnRfbWluGAwgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGgoSc2hvcnRfZW5hYmxlZF9mbGFnGA0gASgIEgwKBG5hbWUYDyABKAkSEAoIZXhjaGFuZ2UYECABKAkSSgoQZml4ZWRfY29tbWlzc2lvbhgRIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEhIKCmZvY3VzX3R5cGUYEiABKAkSMQoNcmVsZWFzZWRfZGF0ZRgTIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASRAoKbnVtX3NoYXJlcxgUIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEhcKD2NvdW50cnlfb2ZfcmlzaxgVIAEoCRIcChRjb3VudHJ5X29mX3Jpc2tfbmFtZRgWIAEoCRIOCgZzZWN0b3IYFyABKAkSGAoQcmViYWxhbmNpbmdfZnJlcRgYIAEoCRJUCg50cmFkaW5nX3N0YXR1cxgZIAEoDjI8LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU2VjdXJpdHlUcmFkaW5nU3RhdHVzEhAKCG90Y19mbGFnGBogASgIEhoKEmJ1eV9hdmFpbGFibGVfZmxhZxgbIAEoCBIbChNzZWxsX2F2YWlsYWJsZV9mbGFnGBwgASgIEk0KE21pbl9wcmljZV9pbmNyZW1lbnQYHSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIgChhhcGlfdHJhZGVfYXZhaWxhYmxlX2ZsYWcYHiABKAgSCwoDdWlkGB8gASgJEkoKDXJlYWxfZXhjaGFuZ2UYICABKA4yMy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlJlYWxFeGNoYW5nZRIUCgxwb3NpdGlvbl91aWQYISABKAkSEQoJYXNzZXRfdWlkGCIgASgJEloKE2luc3RydW1lbnRfZXhjaGFuZ2UYIyABKA4yPS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRFeGNoYW5nZVR5cGUSFgoOcmVxdWlyZWRfdGVzdHMYJCADKAkSFAoMZm9yX2lpc19mbGFnGCkgASgIEh4KFmZvcl9xdWFsX2ludmVzdG9yX2ZsYWcYKiABKAgSFAoMd2Vla2VuZF9mbGFnGCsgASgIEhgKEGJsb2NrZWRfdGNhX2ZsYWcYLCABKAgSFgoObGlxdWlkaXR5X2ZsYWcYLSABKAgSOgoWZmlyc3RfMW1pbl9jYW5kbGVfZGF0ZRg4IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASOgoWZmlyc3RfMWRheV9jYW5kbGVfZGF0ZRg5IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPwoFYnJhbmQYPCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkJyYW5kRGF0YRJGCgxkbG9uZ19jbGllbnQYWiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJHCg1kc2hvcnRfY2xpZW50GFsgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24ihhAKBkZ1dHVyZRIMCgRmaWdpGAEgASgJEg4KBnRpY2tlchgCIAEoCRISCgpjbGFzc19jb2RlGAMgASgJEgsKA2xvdBgEIAEoBRIQCghjdXJyZW5jeRgFIAEoCRJDCgVrbG9uZxgGIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uQgIYARJECgZrc2hvcnQYByABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbkICGAESPwoFZGxvbmcYCCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJACgZkc2hvcnQYCSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJDCglkbG9uZ19taW4YCiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJECgpkc2hvcnRfbWluGAsgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGgoSc2hvcnRfZW5hYmxlZF9mbGFnGAwgASgIEgwKBG5hbWUYDSABKAkSEAoIZXhjaGFuZ2UYDiABKAkSNAoQZmlyc3RfdHJhZGVfZGF0ZRgPIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASMwoPbGFzdF90cmFkZV9kYXRlGBAgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIUCgxmdXR1cmVzX3R5cGUYESABKAkSEgoKYXNzZXRfdHlwZRgSIAEoCRITCgtiYXNpY19hc3NldBgTIAEoCRJKChBiYXNpY19hc3NldF9zaXplGBQgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SFwoPY291bnRyeV9vZl9yaXNrGBUgASgJEhwKFGNvdW50cnlfb2Zfcmlza19uYW1lGBYgASgJEg4KBnNlY3RvchgXIAEoCRIzCg9leHBpcmF0aW9uX2RhdGUYGCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wElQKDnRyYWRpbmdfc3RhdHVzGBkgASgOMjwudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TZWN1cml0eVRyYWRpbmdTdGF0dXMSEAoIb3RjX2ZsYWcYGiABKAgSGgoSYnV5X2F2YWlsYWJsZV9mbGFnGBsgASgIEhsKE3NlbGxfYXZhaWxhYmxlX2ZsYWcYHCABKAgSTQoTbWluX3ByaWNlX2luY3JlbWVudBgdIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEiAKGGFwaV90cmFkZV9hdmFpbGFibGVfZmxhZxgeIAEoCBILCgN1aWQYHyABKAkSSgoNcmVhbF9leGNoYW5nZRggIAEoDjIzLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUmVhbEV4Y2hhbmdlEhQKDHBvc2l0aW9uX3VpZBghIAEoCRIgChhiYXNpY19hc3NldF9wb3NpdGlvbl91aWQYIiABKAkSFgoOcmVxdWlyZWRfdGVzdHMYIyADKAkSFAoMZm9yX2lpc19mbGFnGCkgASgIEh4KFmZvcl9xdWFsX2ludmVzdG9yX2ZsYWcYKiABKAgSFAoMd2Vla2VuZF9mbGFnGCsgASgIEhgKEGJsb2NrZWRfdGNhX2ZsYWcYLCABKAgSOgoWZmlyc3RfMW1pbl9jYW5kbGVfZGF0ZRg4IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASOgoWZmlyc3RfMWRheV9jYW5kbGVfZGF0ZRg5IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASUAoVaW5pdGlhbF9tYXJnaW5fb25fYnV5GD0gASgLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Nb25leVZhbHVlElEKFmluaXRpYWxfbWFyZ2luX29uX3NlbGwYPiABKAsyMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk1vbmV5VmFsdWUSVAoabWluX3ByaWNlX2luY3JlbWVudF9hbW91bnQYPyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhI/CgVicmFuZBhAIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQnJhbmREYXRhEkYKDGRsb25nX2NsaWVudBhaIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkcKDWRzaG9ydF9jbGllbnQYWyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbiLPDgoFU2hhcmUSDAoEZmlnaRgBIAEoCRIOCgZ0aWNrZXIYAiABKAkSEgoKY2xhc3NfY29kZRgDIAEoCRIMCgRpc2luGAQgASgJEgsKA2xvdBgFIAEoBRIQCghjdXJyZW5jeRgGIAEoCRJDCgVrbG9uZxgHIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uQgIYARJECgZrc2hvcnQYCCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbkICGAESPwoFZGxvbmcYCSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJACgZkc2hvcnQYCiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJDCglkbG9uZ19taW4YCyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJECgpkc2hvcnRfbWluGAwgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGgoSc2hvcnRfZW5hYmxlZF9mbGFnGA0gASgIEgwKBG5hbWUYDyABKAkSEAoIZXhjaGFuZ2UYECABKAkSLAoIaXBvX2RhdGUYESABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhIKCmlzc3VlX3NpemUYEiABKAMSFwoPY291bnRyeV9vZl9yaXNrGBMgASgJEhwKFGNvdW50cnlfb2Zfcmlza19uYW1lGBQgASgJEg4KBnNlY3RvchgVIAEoCRIXCg9pc3N1ZV9zaXplX3BsYW4YFiABKAMSQgoHbm9taW5hbBgXIAEoCzIxLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuTW9uZXlWYWx1ZRJUCg50cmFkaW5nX3N0YXR1cxgZIAEoDjI8LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU2VjdXJpdHlUcmFkaW5nU3RhdHVzEhAKCG90Y19mbGFnGBogASgIEhoKEmJ1eV9hdmFpbGFibGVfZmxhZxgbIAEoCBIbChNzZWxsX2F2YWlsYWJsZV9mbGFnGBwgASgIEhYKDmRpdl95aWVsZF9mbGFnGB0gASgIEkQKCnNoYXJlX3R5cGUYHiABKA4yMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlNoYXJlVHlwZRJNChNtaW5fcHJpY2VfaW5jcmVtZW50GB8gASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SIAoYYXBpX3RyYWRlX2F2YWlsYWJsZV9mbGFnGCAgASgIEgsKA3VpZBghIAEoCRJKCg1yZWFsX2V4Y2hhbmdlGCIgASgOMjMudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5SZWFsRXhjaGFuZ2USFAoMcG9zaXRpb25fdWlkGCMgASgJEhEKCWFzc2V0X3VpZBgkIAEoCRJaChNpbnN0cnVtZW50X2V4Y2hhbmdlGCUgASgOMj0udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50RXhjaGFuZ2VUeXBlEhYKDnJlcXVpcmVkX3Rlc3RzGCYgAygJEhQKDGZvcl9paXNfZmxhZxguIAEoCBIeChZmb3JfcXVhbF9pbnZlc3Rvcl9mbGFnGC8gASgIEhQKDHdlZWtlbmRfZmxhZxgwIAEoCBIYChBibG9ja2VkX3RjYV9mbGFnGDEgASgIEhYKDmxpcXVpZGl0eV9mbGFnGDIgASgIEjoKFmZpcnN0XzFtaW5fY2FuZGxlX2RhdGUYOCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjoKFmZpcnN0XzFkYXlfY2FuZGxlX2RhdGUYOSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEj8KBWJyYW5kGDwgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5CcmFuZERhdGESRgoMZGxvbmdfY2xpZW50GFogASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRwoNZHNob3J0X2NsaWVudBhbIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uIoEXCg5TdHJ1Y3R1cmVkTm90ZRILCgN1aWQYASABKAkSDAoEZmlnaRgCIAEoCRIOCgZ0aWNrZXIYAyABKAkSEgoKY2xhc3NfY29kZRgEIAEoCRIMCgRpc2luGAUgASgJEgwKBG5hbWUYBiABKAkSEQoJYXNzZXRfdWlkGAcgASgJEhQKDHBvc2l0aW9uX3VpZBgIIAEoCRJNChNtaW5fcHJpY2VfaW5jcmVtZW50GAkgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SCwoDbG90GAogASgFEkIKB25vbWluYWwYCyABKAsyMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk1vbmV5VmFsdWUSEAoIY3VycmVuY3kYDCABKAkSMQoNbWF0dXJpdHlfZGF0ZRgNIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASMgoOcGxhY2VtZW50X2RhdGUYDiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhIKCmlzc3VlX2tpbmQYDyABKAkSEgoKaXNzdWVfc2l6ZRgQIAEoBRIXCg9pc3N1ZV9zaXplX3BsYW4YESABKAUSRgoMZGxvbmdfY2xpZW50GBIgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRwoNZHNob3J0X2NsaWVudBgTIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEhoKEnNob3J0X2VuYWJsZWRfZmxhZxgUIAEoCBIQCghleGNoYW5nZRgVIAEoCRJUCg50cmFkaW5nX3N0YXR1cxgWIAEoDjI8LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU2VjdXJpdHlUcmFkaW5nU3RhdHVzEiAKGGFwaV90cmFkZV9hdmFpbGFibGVfZmxhZxgXIAEoCBIaChJidXlfYXZhaWxhYmxlX2ZsYWcYGCABKAgSGwoTc2VsbF9hdmFpbGFibGVfZmxhZxgZIAEoCBIiChpsaW1pdF9vcmRlcl9hdmFpbGFibGVfZmxhZxgaIAEoCBIjChttYXJrZXRfb3JkZXJfYXZhaWxhYmxlX2ZsYWcYGyABKAgSJgoeYmVzdHByaWNlX29yZGVyX2F2YWlsYWJsZV9mbGFnGBwgASgIEhQKDHdlZWtlbmRfZmxhZxgdIAEoCBIWCg5saXF1aWRpdHlfZmxhZxgeIAEoCBIUCgxmb3JfaWlzX2ZsYWcYHyABKAgSHgoWZm9yX3F1YWxfaW52ZXN0b3JfZmxhZxggIAEoCBIaChJwYXduc2hvcF9saXN0X2ZsYWcYISABKAgSSgoNcmVhbF9leGNoYW5nZRgiIAEoDjIzLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUmVhbEV4Y2hhbmdlEjoKFmZpcnN0XzFtaW5fY2FuZGxlX2RhdGUYIyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjoKFmZpcnN0XzFkYXlfY2FuZGxlX2RhdGUYJCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhMKC2JvcnJvd19uYW1lGCUgASgJEgwKBHR5cGUYJiABKAkSXQoPbG9naWNfcG9ydGZvbGlvGCcgASgOMkQudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TdHJ1Y3R1cmVkTm90ZS5Mb2dpY1BvcnRmb2xpbxJECgphc3NldF90eXBlGCggASgOMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldFR5cGUSVgoMYmFzaWNfYXNzZXRzGCkgAygLMkAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TdHJ1Y3R1cmVkTm90ZS5CYXNpY0Fzc2V0EkgKDnNhZmV0eV9iYXJyaWVyGCogASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGgoSY291cG9uX3BlcmlvZF9iYXNlGCsgASgJEmkKFW9ic2VydmF0aW9uX3ByaW5jaXBsZRgsIAEoDjJKLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU3RydWN0dXJlZE5vdGUuT2JzZXJ2YXRpb25QcmluY2lwbGUSHQoVb2JzZXJ2YXRpb25fZnJlcXVlbmN5GC0gASgJEj0KGWluaXRpYWxfcHJpY2VfZml4aW5nX2RhdGUYLiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkoKBXlpZWxkGC8gAygLMjsudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TdHJ1Y3R1cmVkTm90ZS5ZaWVsZBIaChJjb3Vwb25fc2F2aW5nX2ZsYWcYMCABKAgSDgoGc2VjdG9yGDEgASgJEhcKD2NvdW50cnlfb2ZfcmlzaxgyIAEoCRIcChRjb3VudHJ5X29mX3Jpc2tfbmFtZRgzIAEoCRIRCglsb2dvX25hbWUYNCABKAkSFgoOcmVxdWlyZWRfdGVzdHMYNSADKAkaogEKCkJhc2ljQXNzZXQSCwoDdWlkGAEgASgJEj4KBHR5cGUYAiABKA4yMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkFzc2V0VHlwZRJHCg1pbml0aWFsX3ByaWNlGAMgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24alwEKBVlpZWxkEk0KBHR5cGUYASABKA4yPy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlN0cnVjdHVyZWROb3RlLllpZWxkVHlwZRI/CgV2YWx1ZRgCIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uInIKDkxvZ2ljUG9ydGZvbGlvEh8KG0xPR0lDX1BPUlRGT0xJT19VTlNQRUNJRklFRBAAEh4KGkxPR0lDX1BPUlRGT0xJT19WT0xBVElMSVRZEAESHwobTE9HSUNfUE9SVEZPTElPX0NPUlJFTEFUSU9OEAIigwIKFE9ic2VydmF0aW9uUHJpbmNpcGxlEiUKIU9CU0VSVkFUSU9OX1BSSU5DSVBMRV9VTlNQRUNJRklFRBAAEisKJ09CU0VSVkFUSU9OX1BSSU5DSVBMRV9XT1JTVF9CQVNJQ19BU1NFVBABEioKJk9CU0VSVkFUSU9OX1BSSU5DSVBMRV9CRVNUX0JBU0lDX0FTU0VUEAISMQotT0JTRVJWQVRJT05fUFJJTkNJUExFX0FWRVJBR0VfT0ZfQkFTSUNfQVNTRVRTEAMSOAo0T0JTRVJWQVRJT05fUFJJTkNJUExFX1NJTkdMRV9CQVNJQ19BU1NFVF9QRVJGT1JNQU5DRRAEIokBCglZaWVsZFR5cGUSGgoWWUlFTERfVFlQRV9VTlNQRUNJRklFRBAAEh8KG1lJRUxEX1RZUEVfR1VBUkFOVEVEX0NPVVBPThABEiEKHVlJRUxEX1RZUEVfQ09ORElUSU9OQUxfQ09VUE9OEAISHAoYWUlFTERfVFlQRV9QQVJUSUNJUEFUSU9OEAMiqQEKGkdldEFjY3J1ZWRJbnRlcmVzdHNSZXF1ZXN0EhAKBGZpZ2kYASABKAlCAhgBEi4KBGZyb20YAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgTiQQECEiwKAnRvGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEIE4kEBAhIbCg1pbnN0cnVtZW50X2lkGAQgASgJQgTiQQECInAKG0dldEFjY3J1ZWRJbnRlcmVzdHNSZXNwb25zZRJRChFhY2NydWVkX2ludGVyZXN0cxgBIAMoCzI2LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQWNjcnVlZEludGVyZXN0IogCCg9BY2NydWVkSW50ZXJlc3QSKAoEZGF0ZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPwoFdmFsdWUYAiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJHCg12YWx1ZV9wZXJjZW50GAMgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SQQoHbm9taW5hbBgEIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uIkgKF0dldEZ1dHVyZXNNYXJnaW5SZXF1ZXN0EhAKBGZpZ2kYASABKAlCAhgBEhsKDWluc3RydW1lbnRfaWQYBCABKAlCBOJBAQIi5AIKGEdldEZ1dHVyZXNNYXJnaW5SZXNwb25zZRJQChVpbml0aWFsX21hcmdpbl9vbl9idXkYASABKAsyMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk1vbmV5VmFsdWUSUQoWaW5pdGlhbF9tYXJnaW5fb25fc2VsbBgCIAEoCzIxLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuTW9uZXlWYWx1ZRJNChNtaW5fcHJpY2VfaW5jcmVtZW50GAMgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SVAoabWluX3ByaWNlX2luY3JlbWVudF9hbW91bnQYBCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbiJbChJJbnN0cnVtZW50UmVzcG9uc2USRQoKaW5zdHJ1bWVudBgBIAEoCzIxLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudCK+DAoKSW5zdHJ1bWVudBIMCgRmaWdpGAEgASgJEg4KBnRpY2tlchgCIAEoCRISCgpjbGFzc19jb2RlGAMgASgJEgwKBGlzaW4YBCABKAkSCwoDbG90GAUgASgFEhAKCGN1cnJlbmN5GAYgASgJEkMKBWtsb25nGAcgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb25CAhgBEkQKBmtzaG9ydBgIIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uQgIYARI/CgVkbG9uZxgJIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkAKBmRzaG9ydBgKIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkMKCWRsb25nX21pbhgLIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkQKCmRzaG9ydF9taW4YDCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIaChJzaG9ydF9lbmFibGVkX2ZsYWcYDSABKAgSDAoEbmFtZRgOIAEoCRIQCghleGNoYW5nZRgPIAEoCRIXCg9jb3VudHJ5X29mX3Jpc2sYECABKAkSHAoUY291bnRyeV9vZl9yaXNrX25hbWUYESABKAkSFwoPaW5zdHJ1bWVudF90eXBlGBIgASgJElQKDnRyYWRpbmdfc3RhdHVzGBMgASgOMjwudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TZWN1cml0eVRyYWRpbmdTdGF0dXMSEAoIb3RjX2ZsYWcYFCABKAgSGgoSYnV5X2F2YWlsYWJsZV9mbGFnGBUgASgIEhsKE3NlbGxfYXZhaWxhYmxlX2ZsYWcYFiABKAgSTQoTbWluX3ByaWNlX2luY3JlbWVudBgXIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEiAKGGFwaV90cmFkZV9hdmFpbGFibGVfZmxhZxgYIAEoCBILCgN1aWQYGSABKAkSSgoNcmVhbF9leGNoYW5nZRgaIAEoDjIzLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUmVhbEV4Y2hhbmdlEhQKDHBvc2l0aW9uX3VpZBgbIAEoCRIRCglhc3NldF91aWQYHCABKAkSFgoOcmVxdWlyZWRfdGVzdHMYHSADKAkSFAoMZm9yX2lpc19mbGFnGCQgASgIEh4KFmZvcl9xdWFsX2ludmVzdG9yX2ZsYWcYJSABKAgSFAoMd2Vla2VuZF9mbGFnGCYgASgIEhgKEGJsb2NrZWRfdGNhX2ZsYWcYJyABKAgSTgoPaW5zdHJ1bWVudF9raW5kGCggASgOMjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50VHlwZRI6ChZmaXJzdF8xbWluX2NhbmRsZV9kYXRlGDggASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI6ChZmaXJzdF8xZGF5X2NhbmRsZV9kYXRlGDkgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI/CgVicmFuZBg8IAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQnJhbmREYXRhEkcKDGRsb25nX2NsaWVudBjqAyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJICg1kc2hvcnRfY2xpZW50GOsDIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uIrABChNHZXREaXZpZGVuZHNSZXF1ZXN0EhAKBGZpZ2kYASABKAlCAhgBEi0KBGZyb20YAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSACIAQESKwoCdG8YAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSAGIAQESGwoNaW5zdHJ1bWVudF9pZBgEIAEoCUIE4kEBAkIHCgVfZnJvbUIFCgNfdG8iWgoUR2V0RGl2aWRlbmRzUmVzcG9uc2USQgoJZGl2aWRlbmRzGAEgAygLMi8udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5EaXZpZGVuZCKGBAoIRGl2aWRlbmQSRwoMZGl2aWRlbmRfbmV0GAEgASgLMjEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Nb25leVZhbHVlEjAKDHBheW1lbnRfZGF0ZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASMQoNZGVjbGFyZWRfZGF0ZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASMQoNbGFzdF9idXlfZGF0ZRgEIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASFQoNZGl2aWRlbmRfdHlwZRgFIAEoCRIvCgtyZWNvcmRfZGF0ZRgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASEgoKcmVndWxhcml0eRgHIAEoCRJGCgtjbG9zZV9wcmljZRgIIAEoCzIxLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuTW9uZXlWYWx1ZRJFCgt5aWVsZF92YWx1ZRgJIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEi4KCmNyZWF0ZWRfYXQYCiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wIiAKDEFzc2V0UmVxdWVzdBIQCgJpZBgBIAEoCUIE4kEBAiJQCg1Bc3NldFJlc3BvbnNlEj8KBWFzc2V0GAEgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldEZ1bGwi5wEKDUFzc2V0c1JlcXVlc3QSUwoPaW5zdHJ1bWVudF90eXBlGAEgASgOMjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50VHlwZUgAiAEBElcKEWluc3RydW1lbnRfc3RhdHVzGAIgASgOMjcudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50U3RhdHVzSAGIAQFCEgoQX2luc3RydW1lbnRfdHlwZUIUChJfaW5zdHJ1bWVudF9zdGF0dXMiTgoOQXNzZXRzUmVzcG9uc2USPAoGYXNzZXRzGAEgAygLMiwudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldCKYBQoJQXNzZXRGdWxsEgsKA3VpZBgBIAEoCRI+CgR0eXBlGAIgASgOMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldFR5cGUSDAoEbmFtZRgDIAEoCRISCgpuYW1lX2JyaWVmGAQgASgJEhMKC2Rlc2NyaXB0aW9uGAUgASgJEi4KCmRlbGV0ZWRfYXQYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhYKDnJlcXVpcmVkX3Rlc3RzGAcgAygJEkgKCGN1cnJlbmN5GAggASgLMjQudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldEN1cnJlbmN5SAASSAoIc2VjdXJpdHkYCSABKAsyNC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkFzc2V0U2VjdXJpdHlIABIUCgxnb3NfcmVnX2NvZGUYCiABKAkSCwoDY2ZpGAsgASgJEhAKCGNvZGVfbnNkGAwgASgJEg4KBnN0YXR1cxgNIAEoCRI7CgVicmFuZBgOIAEoCzIsLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQnJhbmQSLgoKdXBkYXRlZF9hdBgPIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASDwoHYnJfY29kZRgQIAEoCRIUCgxicl9jb2RlX25hbWUYESABKAkSSwoLaW5zdHJ1bWVudHMYEiADKAsyNi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkFzc2V0SW5zdHJ1bWVudEIFCgNleHQirwEKBUFzc2V0EgsKA3VpZBgBIAEoCRI+CgR0eXBlGAIgASgOMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldFR5cGUSDAoEbmFtZRgDIAEoCRJLCgtpbnN0cnVtZW50cxgEIAMoCzI2LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQXNzZXRJbnN0cnVtZW50IiYKDUFzc2V0Q3VycmVuY3kSFQoNYmFzZV9jdXJyZW5jeRgBIAEoCSL2AwoNQXNzZXRTZWN1cml0eRIMCgRpc2luGAEgASgJEgwKBHR5cGUYAiABKAkSTgoPaW5zdHJ1bWVudF9raW5kGAogASgOMjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50VHlwZRJCCgVzaGFyZRgDIAEoCzIxLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQXNzZXRTaGFyZUgAEkAKBGJvbmQYBCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkFzc2V0Qm9uZEgAEksKAnNwGAUgASgLMj0udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldFN0cnVjdHVyZWRQcm9kdWN0SAASPgoDZXRmGAYgASgLMi8udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldEV0ZkgAEl8KFGNsZWFyaW5nX2NlcnRpZmljYXRlGAcgASgLMj8udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldENsZWFyaW5nQ2VydGlmaWNhdGVIAEIFCgNleHQi1QUKCkFzc2V0U2hhcmUSPgoEdHlwZRgBIAEoDjIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuU2hhcmVUeXBlEkQKCmlzc3VlX3NpemUYAiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJBCgdub21pbmFsGAMgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGAoQbm9taW5hbF9jdXJyZW5jeRgEIAEoCRIVCg1wcmltYXJ5X2luZGV4GAUgASgJEkcKDWRpdmlkZW5kX3JhdGUYBiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIcChRwcmVmZXJyZWRfc2hhcmVfdHlwZRgHIAEoCRIsCghpcG9fZGF0ZRgIIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASMQoNcmVnaXN0cnlfZGF0ZRgJIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASFgoOZGl2X3lpZWxkX2ZsYWcYCiABKAgSEgoKaXNzdWVfa2luZBgLIAEoCRIyCg5wbGFjZW1lbnRfZGF0ZRgMIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASEwoLcmVwcmVzX2lzaW4YDSABKAkSSQoPaXNzdWVfc2l6ZV9wbGFuGA4gASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRQoLdG90YWxfZmxvYXQYDyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbiLgBgoJQXNzZXRCb25kEkkKD2N1cnJlbnRfbm9taW5hbBgBIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEhMKC2JvcnJvd19uYW1lGAIgASgJEkQKCmlzc3VlX3NpemUYAyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJBCgdub21pbmFsGAQgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGAoQbm9taW5hbF9jdXJyZW5jeRgFIAEoCRISCgppc3N1ZV9raW5kGAYgASgJEhUKDWludGVyZXN0X2tpbmQYByABKAkSIAoYY291cG9uX3F1YW50aXR5X3Blcl95ZWFyGAggASgFEhwKFGluZGV4ZWRfbm9taW5hbF9mbGFnGAkgASgIEhkKEXN1Ym9yZGluYXRlZF9mbGFnGAogASgIEhcKD2NvbGxhdGVyYWxfZmxhZxgLIAEoCBIVCg10YXhfZnJlZV9mbGFnGAwgASgIEhkKEWFtb3J0aXphdGlvbl9mbGFnGA0gASgIEhwKFGZsb2F0aW5nX2NvdXBvbl9mbGFnGA4gASgIEhYKDnBlcnBldHVhbF9mbGFnGA8gASgIEjEKDW1hdHVyaXR5X2RhdGUYECABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhgKEHJldHVybl9jb25kaXRpb24YESABKAkSMgoOc3RhdGVfcmVnX2RhdGUYEiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjIKDnBsYWNlbWVudF9kYXRlGBMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJJCg9wbGFjZW1lbnRfcHJpY2UYFCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJJCg9pc3N1ZV9zaXplX3BsYW4YFSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbiKgBQoWQXNzZXRTdHJ1Y3R1cmVkUHJvZHVjdBITCgtib3Jyb3dfbmFtZRgBIAEoCRJBCgdub21pbmFsGAIgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGAoQbm9taW5hbF9jdXJyZW5jeRgDIAEoCRJKCgR0eXBlGAQgASgOMjwudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TdHJ1Y3R1cmVkUHJvZHVjdFR5cGUSFwoPbG9naWNfcG9ydGZvbGlvGAUgASgJEkQKCmFzc2V0X3R5cGUYBiABKA4yMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkFzc2V0VHlwZRITCgtiYXNpY19hc3NldBgHIAEoCRJICg5zYWZldHlfYmFycmllchgIIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEjEKDW1hdHVyaXR5X2RhdGUYCSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkkKD2lzc3VlX3NpemVfcGxhbhgKIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkQKCmlzc3VlX3NpemUYCyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIyCg5wbGFjZW1lbnRfZGF0ZRgMIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASEgoKaXNzdWVfa2luZBgNIAEoCSLYCgoIQXNzZXRFdGYSRwoNdG90YWxfZXhwZW5zZRgBIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkUKC2h1cmRsZV9yYXRlGAIgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SSQoPcGVyZm9ybWFuY2VfZmVlGAMgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SSgoQZml4ZWRfY29tbWlzc2lvbhgEIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEhQKDHBheW1lbnRfdHlwZRgFIAEoCRIWCg53YXRlcm1hcmtfZmxhZxgGIAEoCBJFCgtidXlfcHJlbWl1bRgHIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkcKDXNlbGxfZGlzY291bnQYCCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIYChByZWJhbGFuY2luZ19mbGFnGAkgASgIEhgKEHJlYmFsYW5jaW5nX2ZyZXEYCiABKAkSFwoPbWFuYWdlbWVudF90eXBlGAsgASgJEhUKDXByaW1hcnlfaW5kZXgYDCABKAkSEgoKZm9jdXNfdHlwZRgNIAEoCRIWCg5sZXZlcmFnZWRfZmxhZxgOIAEoCBJDCgludW1fc2hhcmUYDyABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhISCgp1Y2l0c19mbGFnGBAgASgIEjEKDXJlbGVhc2VkX2RhdGUYESABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhMKC2Rlc2NyaXB0aW9uGBIgASgJEiEKGXByaW1hcnlfaW5kZXhfZGVzY3JpcHRpb24YEyABKAkSHQoVcHJpbWFyeV9pbmRleF9jb21wYW55GBQgASgJEk8KFWluZGV4X3JlY292ZXJ5X3BlcmlvZBgVIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEhEKCWluYXZfY29kZRgWIAEoCRIWCg5kaXZfeWllbGRfZmxhZxgXIAEoCBJMChJleHBlbnNlX2NvbW1pc3Npb24YGCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJWChxwcmltYXJ5X2luZGV4X3RyYWNraW5nX2Vycm9yGBkgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGAoQcmViYWxhbmNpbmdfcGxhbhgaIAEoCRIQCgh0YXhfcmF0ZRgbIAEoCRI1ChFyZWJhbGFuY2luZ19kYXRlcxgcIAMoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASEgoKaXNzdWVfa2luZBgdIAEoCRJBCgdub21pbmFsGB4gASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SGAoQbm9taW5hbF9jdXJyZW5jeRgfIAEoCSJ3ChhBc3NldENsZWFyaW5nQ2VydGlmaWNhdGUSQQoHbm9taW5hbBgBIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEhgKEG5vbWluYWxfY3VycmVuY3kYAiABKAkinQEKBUJyYW5kEgsKA3VpZBgBIAEoCRIMCgRuYW1lGAIgASgJEhMKC2Rlc2NyaXB0aW9uGAMgASgJEgwKBGluZm8YBCABKAkSDwoHY29tcGFueRgFIAEoCRIOCgZzZWN0b3IYBiABKAkSFwoPY291bnRyeV9vZl9yaXNrGAcgASgJEhwKFGNvdW50cnlfb2Zfcmlza19uYW1lGAggASgJIpUCCg9Bc3NldEluc3RydW1lbnQSCwoDdWlkGAEgASgJEgwKBGZpZ2kYAiABKAkSFwoPaW5zdHJ1bWVudF90eXBlGAMgASgJEg4KBnRpY2tlchgEIAEoCRISCgpjbGFzc19jb2RlGAUgASgJEkQKBWxpbmtzGAYgAygLMjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50TGluaxJOCg9pbnN0cnVtZW50X2tpbmQYCiABKA4yNS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRUeXBlEhQKDHBvc2l0aW9uX3VpZBgLIAEoCSI2Cg5JbnN0cnVtZW50TGluaxIMCgR0eXBlGAEgASgJEhYKDmluc3RydW1lbnRfdWlkGAIgASgJIjkKE0dldEZhdm9yaXRlc1JlcXVlc3QSFQoIZ3JvdXBfaWQYASABKAlIAIgBAUILCglfZ3JvdXBfaWQikwEKFEdldEZhdm9yaXRlc1Jlc3BvbnNlElcKFGZhdm9yaXRlX2luc3RydW1lbnRzGAEgAygLMjkudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5GYXZvcml0ZUluc3RydW1lbnQSFQoIZ3JvdXBfaWQYAiABKAlIAIgBAUILCglfZ3JvdXBfaWQijAIKEkZhdm9yaXRlSW5zdHJ1bWVudBIMCgRmaWdpGAEgASgJEg4KBnRpY2tlchgCIAEoCRISCgpjbGFzc19jb2RlGAMgASgJEgwKBGlzaW4YBCABKAkSFwoPaW5zdHJ1bWVudF90eXBlGAsgASgJEgwKBG5hbWUYDCABKAkSCwoDdWlkGA0gASgJEhAKCG90Y19mbGFnGBAgASgIEiAKGGFwaV90cmFkZV9hdmFpbGFibGVfZmxhZxgRIAEoCBJOCg9pbnN0cnVtZW50X2tpbmQYEiABKA4yNS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRUeXBlIvcBChRFZGl0RmF2b3JpdGVzUmVxdWVzdBJgCgtpbnN0cnVtZW50cxgBIAMoCzJFLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRWRpdEZhdm9yaXRlc1JlcXVlc3RJbnN0cnVtZW50QgTiQQECElkKC2FjdGlvbl90eXBlGAYgASgOMj4udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5FZGl0RmF2b3JpdGVzQWN0aW9uVHlwZUIE4kEBAhIVCghncm91cF9pZBgHIAEoCUgAiAEBQgsKCV9ncm91cF9pZCJdCh5FZGl0RmF2b3JpdGVzUmVxdWVzdEluc3RydW1lbnQSFQoEZmlnaRgBIAEoCUICGAFIAIgBARIbCg1pbnN0cnVtZW50X2lkGAIgASgJQgTiQQECQgcKBV9maWdpIpQBChVFZGl0RmF2b3JpdGVzUmVzcG9uc2USVwoUZmF2b3JpdGVfaW5zdHJ1bWVudHMYASADKAsyOS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkZhdm9yaXRlSW5zdHJ1bWVudBIVCghncm91cF9pZBgCIAEoCUgAiAEBQgsKCV9ncm91cF9pZCJtChpDcmVhdGVGYXZvcml0ZUdyb3VwUmVxdWVzdBIYCgpncm91cF9uYW1lGAEgASgJQgTiQQECEhkKC2dyb3VwX2NvbG9yGAIgASgJQgTiQQECEhEKBG5vdGUYAyABKAlIAIgBAUIHCgVfbm90ZSJDChtDcmVhdGVGYXZvcml0ZUdyb3VwUmVzcG9uc2USEAoIZ3JvdXBfaWQYASABKAkSEgoKZ3JvdXBfbmFtZRgCIAEoCSI0ChpEZWxldGVGYXZvcml0ZUdyb3VwUmVxdWVzdBIWCghncm91cF9pZBgBIAEoCUIE4kEBAiIdChtEZWxldGVGYXZvcml0ZUdyb3VwUmVzcG9uc2UiTAoYR2V0RmF2b3JpdGVHcm91cHNSZXF1ZXN0EhUKDWluc3RydW1lbnRfaWQYASADKAkSGQoRZXhjbHVkZWRfZ3JvdXBfaWQYAiADKAkiogIKGUdldEZhdm9yaXRlR3JvdXBzUmVzcG9uc2USXgoGZ3JvdXBzGAEgAygLMk4udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRGYXZvcml0ZUdyb3Vwc1Jlc3BvbnNlLkZhdm9yaXRlR3JvdXAapAEKDUZhdm9yaXRlR3JvdXASFgoIZ3JvdXBfaWQYASABKAlCBOJBAQISGAoKZ3JvdXBfbmFtZRgCIAEoCUIE4kEBAhITCgVjb2xvchgDIAEoCUIE4kEBAhISCgRzaXplGAQgASgFQgTiQQECEiAKE2NvbnRhaW5zX2luc3RydW1lbnQYBSABKAhIAIgBAUIWChRfY29udGFpbnNfaW5zdHJ1bWVudCIVChNHZXRDb3VudHJpZXNSZXF1ZXN0ImEKFEdldENvdW50cmllc1Jlc3BvbnNlEkkKCWNvdW50cmllcxgBIAMoCzI2LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQ291bnRyeVJlc3BvbnNlIhQKEkluZGljYXRpdmVzUmVxdWVzdCJlChNJbmRpY2F0aXZlc1Jlc3BvbnNlEk4KC2luc3RydW1lbnRzGAEgAygLMjkudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbmRpY2F0aXZlUmVzcG9uc2UikAIKEkluZGljYXRpdmVSZXNwb25zZRIMCgRmaWdpGAEgASgJEg4KBnRpY2tlchgCIAEoCRISCgpjbGFzc19jb2RlGAMgASgJEhAKCGN1cnJlbmN5GAQgASgJEk4KD2luc3RydW1lbnRfa2luZBgKIAEoDjI1LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFR5cGUSDAoEbmFtZRgMIAEoCRIQCghleGNoYW5nZRgNIAEoCRILCgN1aWQYDiABKAkSGwoSYnV5X2F2YWlsYWJsZV9mbGFnGJQDIAEoCBIcChNzZWxsX2F2YWlsYWJsZV9mbGFnGJUDIAEoCCJZCg9Db3VudHJ5UmVzcG9uc2USEAoIYWxmYV90d28YASABKAkSEgoKYWxmYV90aHJlZRgCIAEoCRIMCgRuYW1lGAMgASgJEhIKCm5hbWVfYnJpZWYYBCABKAki2QEKFUZpbmRJbnN0cnVtZW50UmVxdWVzdBITCgVxdWVyeRgBIAEoCUIE4kEBAhJTCg9pbnN0cnVtZW50X2tpbmQYAiABKA4yNS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRUeXBlSACIAQESJQoYYXBpX3RyYWRlX2F2YWlsYWJsZV9mbGFnGAMgASgISAGIAQFCEgoQX2luc3RydW1lbnRfa2luZEIbChlfYXBpX3RyYWRlX2F2YWlsYWJsZV9mbGFnImUKFkZpbmRJbnN0cnVtZW50UmVzcG9uc2USSwoLaW5zdHJ1bWVudHMYASADKAsyNi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRTaG9ydCL4AwoPSW5zdHJ1bWVudFNob3J0EgwKBGlzaW4YASABKAkSDAoEZmlnaRgCIAEoCRIOCgZ0aWNrZXIYAyABKAkSEgoKY2xhc3NfY29kZRgEIAEoCRIXCg9pbnN0cnVtZW50X3R5cGUYBSABKAkSDAoEbmFtZRgGIAEoCRILCgN1aWQYByABKAkSFAoMcG9zaXRpb25fdWlkGAggASgJEk4KD2luc3RydW1lbnRfa2luZBgKIAEoDjI1LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFR5cGUSIAoYYXBpX3RyYWRlX2F2YWlsYWJsZV9mbGFnGAsgASgIEhQKDGZvcl9paXNfZmxhZxgMIAEoCBI6ChZmaXJzdF8xbWluX2NhbmRsZV9kYXRlGBogASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI6ChZmaXJzdF8xZGF5X2NhbmRsZV9kYXRlGBsgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIeChZmb3JfcXVhbF9pbnZlc3Rvcl9mbGFnGBwgASgIEhQKDHdlZWtlbmRfZmxhZxgdIAEoCBIYChBibG9ja2VkX3RjYV9mbGFnGB4gASgIEgsKA2xvdBgfIAEoBSJPChBHZXRCcmFuZHNSZXF1ZXN0EjsKBnBhZ2luZxgBIAEoCzIrLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUGFnZSIjCg9HZXRCcmFuZFJlcXVlc3QSEAoCaWQYASABKAlCBOJBAQIilgEKEUdldEJyYW5kc1Jlc3BvbnNlEjwKBmJyYW5kcxgBIAMoCzIsLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQnJhbmQSQwoGcGFnaW5nGAIgASgLMjMudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5QYWdlUmVzcG9uc2UiMwobR2V0QXNzZXRGdW5kYW1lbnRhbHNSZXF1ZXN0EhQKBmFzc2V0cxgBIAMoCUIE4kEBAiL9DgocR2V0QXNzZXRGdW5kYW1lbnRhbHNSZXNwb25zZRJrCgxmdW5kYW1lbnRhbHMYASADKAsyVS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEFzc2V0RnVuZGFtZW50YWxzUmVzcG9uc2UuU3RhdGlzdGljUmVzcG9uc2Ua7w0KEVN0YXRpc3RpY1Jlc3BvbnNlEhEKCWFzc2V0X3VpZBgBIAEoCRIQCghjdXJyZW5jeRgCIAEoCRIdChVtYXJrZXRfY2FwaXRhbGl6YXRpb24YAyABKAESIAoYaGlnaF9wcmljZV9sYXN0XzUyX3dlZWtzGAQgASgBEh8KF2xvd19wcmljZV9sYXN0XzUyX3dlZWtzGAUgASgBEikKIWF2ZXJhZ2VfZGFpbHlfdm9sdW1lX2xhc3RfMTBfZGF5cxgGIAEoARIpCiFhdmVyYWdlX2RhaWx5X3ZvbHVtZV9sYXN0XzRfd2Vla3MYByABKAESDAoEYmV0YRgIIAEoARISCgpmcmVlX2Zsb2F0GAkgASgBEiUKHWZvcndhcmRfYW5udWFsX2RpdmlkZW5kX3lpZWxkGAogASgBEhoKEnNoYXJlc19vdXRzdGFuZGluZxgLIAEoARITCgtyZXZlbnVlX3R0bRgMIAEoARISCgplYml0ZGFfdHRtGA0gASgBEhYKDm5ldF9pbmNvbWVfdHRtGA4gASgBEg8KB2Vwc190dG0YDyABKAESFwoPZGlsdXRlZF9lcHNfdHRtGBAgASgBEhoKEmZyZWVfY2FzaF9mbG93X3R0bRgRIAEoARIsCiRmaXZlX3llYXJfYW5udWFsX3JldmVudWVfZ3Jvd3RoX3JhdGUYEiABKAESLQoldGhyZWVfeWVhcl9hbm51YWxfcmV2ZW51ZV9ncm93dGhfcmF0ZRgTIAEoARIUCgxwZV9yYXRpb190dG0YFCABKAESGgoScHJpY2VfdG9fc2FsZXNfdHRtGBUgASgBEhkKEXByaWNlX3RvX2Jvb2tfdHRtGBYgASgBEiMKG3ByaWNlX3RvX2ZyZWVfY2FzaF9mbG93X3R0bRgXIAEoARIiChp0b3RhbF9lbnRlcnByaXNlX3ZhbHVlX21ycRgYIAEoARIYChBldl90b19lYml0ZGFfbXJxGBkgASgBEhYKDm5ldF9tYXJnaW5fbXJxGBogASgBEh8KF25ldF9pbnRlcmVzdF9tYXJnaW5fbXJxGBsgASgBEgsKA3JvZRgcIAEoARILCgNyb2EYHSABKAESDAoEcm9pYxgeIAEoARIWCg50b3RhbF9kZWJ0X21ycRgfIAEoARIgChh0b3RhbF9kZWJ0X3RvX2VxdWl0eV9tcnEYICABKAESIAoYdG90YWxfZGVidF90b19lYml0ZGFfbXJxGCEgASgBEh8KF2ZyZWVfY2FzaF9mbG93X3RvX3ByaWNlGCIgASgBEhoKEm5ldF9kZWJ0X3RvX2ViaXRkYRgjIAEoARIZChFjdXJyZW50X3JhdGlvX21ycRgkIAEoARImCh5maXhlZF9jaGFyZ2VfY292ZXJhZ2VfcmF0aW9fZnkYJSABKAESIAoYZGl2aWRlbmRfeWllbGRfZGFpbHlfdHRtGCYgASgBEhkKEWRpdmlkZW5kX3JhdGVfdHRtGCcgASgBEhsKE2RpdmlkZW5kc19wZXJfc2hhcmUYKCABKAESKQohZml2ZV95ZWFyc19hdmVyYWdlX2RpdmlkZW5kX3lpZWxkGCkgASgBEi0KJWZpdmVfeWVhcl9hbm51YWxfZGl2aWRlbmRfZ3Jvd3RoX3JhdGUYKiABKAESIAoYZGl2aWRlbmRfcGF5b3V0X3JhdGlvX2Z5GCsgASgBEhQKDGJ1eV9iYWNrX3R0bRgsIAEoARIrCiNvbmVfeWVhcl9hbm51YWxfcmV2ZW51ZV9ncm93dGhfcmF0ZRgtIAEoARIfChdkb21pY2lsZV9pbmRpY2F0b3JfY29kZRguIAEoCRIhChlhZHJfdG9fY29tbW9uX3NoYXJlX3JhdGlvGC8gASgBEhsKE251bWJlcl9vZl9lbXBsb3llZXMYMCABKAESNAoQZXhfZGl2aWRlbmRfZGF0ZRgxIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPAoYZmlzY2FsX3BlcmlvZF9zdGFydF9kYXRlGDIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI6ChZmaXNjYWxfcGVyaW9kX2VuZF9kYXRlGDMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIhChlyZXZlbnVlX2NoYW5nZV9maXZlX3llYXJzGDUgASgBEh0KFWVwc19jaGFuZ2VfZml2ZV95ZWFycxg2IAEoARIgChhlYml0ZGFfY2hhbmdlX2ZpdmVfeWVhcnMYNyABKAESJAocdG90YWxfZGVidF9jaGFuZ2VfZml2ZV95ZWFycxg4IAEoARITCgtldl90b19zYWxlcxg5IAEoASKhAQoWR2V0QXNzZXRSZXBvcnRzUmVxdWVzdBIbCg1pbnN0cnVtZW50X2lkGAEgASgJQgTiQQECEi0KBGZyb20YAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSACIAQESKwoCdG8YAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSAGIAQFCBwoFX2Zyb21CBQoDX3RvIqcEChdHZXRBc3NldFJlcG9ydHNSZXNwb25zZRJjCgZldmVudHMYASADKAsyUy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEFzc2V0UmVwb3J0c1Jlc3BvbnNlLkdldEFzc2V0UmVwb3J0c0V2ZW50GqICChRHZXRBc3NldFJlcG9ydHNFdmVudBIVCg1pbnN0cnVtZW50X2lkGAEgASgJEi8KC3JlcG9ydF9kYXRlGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBITCgtwZXJpb2RfeWVhchgDIAEoBRISCgpwZXJpb2RfbnVtGAQgASgFEmkKC3BlcmlvZF90eXBlGAUgASgOMlQudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRBc3NldFJlcG9ydHNSZXNwb25zZS5Bc3NldFJlcG9ydFBlcmlvZFR5cGUSLgoKY3JlYXRlZF9hdBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAigQEKFUFzc2V0UmVwb3J0UGVyaW9kVHlwZRIbChdQRVJJT0RfVFlQRV9VTlNQRUNJRklFRBAAEhcKE1BFUklPRF9UWVBFX1FVQVJURVIQARIaChZQRVJJT0RfVFlQRV9TRU1JQU5OVUFMEAISFgoSUEVSSU9EX1RZUEVfQU5OVUFMEAMiawocR2V0Q29uc2Vuc3VzRm9yZWNhc3RzUmVxdWVzdBJACgZwYWdpbmcYASABKAsyKy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlBhZ2VIAIgBAUIJCgdfcGFnaW5nIoYGCh1HZXRDb25zZW5zdXNGb3JlY2FzdHNSZXNwb25zZRJqCgVpdGVtcxgBIAMoCzJbLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0Q29uc2Vuc3VzRm9yZWNhc3RzUmVzcG9uc2UuQ29uc2Vuc3VzRm9yZWNhc3RzSXRlbRJBCgRwYWdlGAIgASgLMjMudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5QYWdlUmVzcG9uc2UatQQKFkNvbnNlbnN1c0ZvcmVjYXN0c0l0ZW0SCwoDdWlkGAEgASgJEhEKCWFzc2V0X3VpZBgCIAEoCRIuCgpjcmVhdGVkX2F0GAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJLChFiZXN0X3RhcmdldF9wcmljZRgEIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkkKD2Jlc3RfdGFyZ2V0X2xvdxgFIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkoKEGJlc3RfdGFyZ2V0X2hpZ2gYBiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhIbChN0b3RhbF9idXlfcmVjb21tZW5kGAcgASgFEhwKFHRvdGFsX2hvbGRfcmVjb21tZW5kGAggASgFEhwKFHRvdGFsX3NlbGxfcmVjb21tZW5kGAkgASgFEhAKCGN1cnJlbmN5GAogASgJEkgKCWNvbnNlbnN1cxgLIAEoDjI1LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUmVjb21tZW5kYXRpb24SMgoOcHJvZ25vc2lzX2RhdGUYDCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wIisKEkdldEZvcmVjYXN0UmVxdWVzdBIVCg1pbnN0cnVtZW50X2lkGAEgASgJIpcKChNHZXRGb3JlY2FzdFJlc3BvbnNlElYKB3RhcmdldHMYASADKAsyRS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEZvcmVjYXN0UmVzcG9uc2UuVGFyZ2V0SXRlbRJbCgljb25zZW5zdXMYAiABKAsySC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEZvcmVjYXN0UmVzcG9uc2UuQ29uc2Vuc3VzSXRlbRqMBAoKVGFyZ2V0SXRlbRILCgN1aWQYASABKAkSDgoGdGlja2VyGAIgASgJEg8KB2NvbXBhbnkYAyABKAkSTQoOcmVjb21tZW5kYXRpb24YBCABKA4yNS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlJlY29tbWVuZGF0aW9uEjcKE3JlY29tbWVuZGF0aW9uX2RhdGUYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhAKCGN1cnJlbmN5GAYgASgJEkcKDWN1cnJlbnRfcHJpY2UYByABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJGCgx0YXJnZXRfcHJpY2UYCCABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJGCgxwcmljZV9jaGFuZ2UYCSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJKChBwcmljZV9jaGFuZ2VfcmVsGAogASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SEQoJc2hvd19uYW1lGAsgASgJGrsECg1Db25zZW5zdXNJdGVtEgsKA3VpZBgBIAEoCRIOCgZ0aWNrZXIYAiABKAkSTQoOcmVjb21tZW5kYXRpb24YAyABKA4yNS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlJlY29tbWVuZGF0aW9uEhAKCGN1cnJlbmN5GAQgASgJEkcKDWN1cnJlbnRfcHJpY2UYBSABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJDCgljb25zZW5zdXMYBiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbhJECgptaW5fdGFyZ2V0GAcgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRAoKbWF4X3RhcmdldBgIIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkYKDHByaWNlX2NoYW5nZRgJIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkoKEHByaWNlX2NoYW5nZV9yZWwYCiABKAsyMC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlF1b3RhdGlvbiIpChBSaXNrUmF0ZXNSZXF1ZXN0EhUKDWluc3RydW1lbnRfaWQYASADKAkiywUKEVJpc2tSYXRlc1Jlc3BvbnNlEmYKFWluc3RydW1lbnRfcmlza19yYXRlcxgBIAMoCzJHLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUmlza1JhdGVzUmVzcG9uc2UuUmlza1JhdGVSZXN1bHQa5wMKDlJpc2tSYXRlUmVzdWx0EhYKDmluc3RydW1lbnRfdWlkGAEgASgJEl8KD3Nob3J0X3Jpc2tfcmF0ZRgCIAEoCzJBLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUmlza1JhdGVzUmVzcG9uc2UuUmlza1JhdGVIAIgBARJeCg5sb25nX3Jpc2tfcmF0ZRgDIAEoCzJBLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUmlza1JhdGVzUmVzcG9uc2UuUmlza1JhdGVIAYgBARJbChBzaG9ydF9yaXNrX3JhdGVzGAUgAygLMkEudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5SaXNrUmF0ZXNSZXNwb25zZS5SaXNrUmF0ZRJaCg9sb25nX3Jpc2tfcmF0ZXMYBiADKAsyQS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlJpc2tSYXRlc1Jlc3BvbnNlLlJpc2tSYXRlEhIKBWVycm9yGAkgASgJSAKIAQFCEgoQX3Nob3J0X3Jpc2tfcmF0ZUIRCg9fbG9uZ19yaXNrX3JhdGVCCAoGX2Vycm9yGmQKCFJpc2tSYXRlEhcKD3Jpc2tfbGV2ZWxfY29kZRgCIAEoCRI/CgV2YWx1ZRgFIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uIuABCg9UcmFkaW5nSW50ZXJ2YWwSDAoEdHlwZRgBIAEoCRJVCghpbnRlcnZhbBgCIAEoCzJDLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuVHJhZGluZ0ludGVydmFsLlRpbWVJbnRlcnZhbBpoCgxUaW1lSW50ZXJ2YWwSLAoIc3RhcnRfdHMYASABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEioKBmVuZF90cxgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAiaAoWR2V0SW5zaWRlckRlYWxzUmVxdWVzdBIVCg1pbnN0cnVtZW50X2lkGAEgASgJEg0KBWxpbWl0GAIgASgFEhgKC25leHRfY3Vyc29yGAMgASgJSACIAQFCDgoMX25leHRfY3Vyc29yIpwGChdHZXRJbnNpZGVyRGVhbHNSZXNwb25zZRJhCg1pbnNpZGVyX2RlYWxzGAEgAygLMkoudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRJbnNpZGVyRGVhbHNSZXNwb25zZS5JbnNpZGVyRGVhbBIYCgtuZXh0X2N1cnNvchgCIAEoCUgAiAEBGtADCgtJbnNpZGVyRGVhbBIQCgh0cmFkZV9pZBgBIAEoAxJgCglkaXJlY3Rpb24YAiABKA4yTS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEluc2lkZXJEZWFsc1Jlc3BvbnNlLlRyYWRlRGlyZWN0aW9uEhAKCGN1cnJlbmN5GAMgASgJEigKBGRhdGUYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhAKCHF1YW50aXR5GAUgASgDEj8KBXByaWNlGAYgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SFgoOaW5zdHJ1bWVudF91aWQYByABKAkSDgoGdGlja2VyGAggASgJEhUKDWludmVzdG9yX25hbWUYCSABKAkSGQoRaW52ZXN0b3JfcG9zaXRpb24YCiABKAkSEgoKcGVyY2VudGFnZRgLIAEoAhIbChNpc19vcHRpb25fZXhlY3V0aW9uGAwgASgIEjMKD2Rpc2Nsb3N1cmVfZGF0ZRgNIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAioAEKDlRyYWRlRGlyZWN0aW9uEh8KG1RSQURFX0RJUkVDVElPTl9VTlNQRUNJRklFRBAAEhcKE1RSQURFX0RJUkVDVElPTl9CVVkQARIYChRUUkFERV9ESVJFQ1RJT05fU0VMTBACEhwKGFRSQURFX0RJUkVDVElPTl9JTkNSRUFTRRADEhwKGFRSQURFX0RJUkVDVElPTl9ERUNSRUFTRRAEQg4KDF9uZXh0X2N1cnNvciINCgtEZmFzUmVxdWVzdCL6CQoLRGZhUmVzcG9uc2USCwoDdWlkGAEgASgJEg4KBnRpY2tlchgCIAEoCRIMCgRuYW1lGAMgASgJEhQKDHBvc2l0aW9uX3VpZBgEIAEoCRJNChNtaW5fcHJpY2VfaW5jcmVtZW50GAUgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SCwoDbG90GAYgASgFEkIKB25vbWluYWwYByABKAsyMS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLk1vbmV5VmFsdWUSEAoIY3VycmVuY3kYCCABKAkSMQoNbWF0dXJpdHlfZGF0ZRgJIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASGgoSc2hvcnRfZW5hYmxlZF9mbGFnGAogASgIEiAKGGFwaV90cmFkZV9hdmFpbGFibGVfZmxhZxgLIAEoCBIaChJidXlfYXZhaWxhYmxlX2ZsYWcYDCABKAgSGwoTc2VsbF9hdmFpbGFibGVfZmxhZxgNIAEoCBIiChpsaW1pdF9vcmRlcl9hdmFpbGFibGVfZmxhZxgOIAEoCBIjChttYXJrZXRfb3JkZXJfYXZhaWxhYmxlX2ZsYWcYDyABKAgSJgoeYmVzdHByaWNlX29yZGVyX2F2YWlsYWJsZV9mbGFnGBAgASgIEhQKDGZvcl9paXNfZmxhZxgRIAEoCBIeChZmb3JfcXVhbF9pbnZlc3Rvcl9mbGFnGBIgASgIEgwKBHR5cGUYEyABKAkSUwoMYmFzaWNfYXNzZXRzGBQgAygLMj0udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5EZmFSZXNwb25zZS5CYXNpY0Fzc2V0ElgKDmZvcmVjYXN0X3lpZWxkGBUgASgLMkAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5EZmFSZXNwb25zZS5Gb3JlY2FzdFlpZWxkEksKEXlpZWxkX3RvX21hdHVyaXR5GBYgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SRgoMY291cG9uX3ZhbHVlGBcgASgLMjAudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5RdW90YXRpb24SIAoYY291cG9uX3BheW1lbnRfZnJlcXVlbmN5GBggASgFEjcKE2NvdXBvbl9wYXltZW50X2RhdGUYGSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEkMKCWFjaV92YWx1ZRgaIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uGhkKCkJhc2ljQXNzZXQSCwoDdWlkGAEgASgJGpkBCg1Gb3JlY2FzdFlpZWxkEkMKCW1pbl92YWx1ZRgBIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uEkMKCW1heF92YWx1ZRgCIAEoCzIwLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuUXVvdGF0aW9uIlcKDERmYXNSZXNwb25zZRJHCgtpbnN0cnVtZW50cxgBIAMoCzIyLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRGZhUmVzcG9uc2Uq1wEKCkNvdXBvblR5cGUSGwoXQ09VUE9OX1RZUEVfVU5TUEVDSUZJRUQQABIYChRDT1VQT05fVFlQRV9DT05TVEFOVBABEhgKFENPVVBPTl9UWVBFX0ZMT0FUSU5HEAISGAoUQ09VUE9OX1RZUEVfRElTQ09VTlQQAxIYChRDT1VQT05fVFlQRV9NT1JUR0FHRRAEEhMKD0NPVVBPTl9UWVBFX0ZJWBAFEhgKFENPVVBPTl9UWVBFX1ZBUklBQkxFEAYSFQoRQ09VUE9OX1RZUEVfT1RIRVIQBypoCg9PcHRpb25EaXJlY3Rpb24SIAocT1BUSU9OX0RJUkVDVElPTl9VTlNQRUNJRklFRBAAEhgKFE9QVElPTl9ESVJFQ1RJT05fUFVUEAESGQoVT1BUSU9OX0RJUkVDVElPTl9DQUxMEAIqewoRT3B0aW9uUGF5bWVudFR5cGUSIwofT1BUSU9OX1BBWU1FTlRfVFlQRV9VTlNQRUNJRklFRBAAEh8KG09QVElPTl9QQVlNRU5UX1RZUEVfUFJFTUlVTRABEiAKHE9QVElPTl9QQVlNRU5UX1RZUEVfTUFSR0lOQUwQAiphCgtPcHRpb25TdHlsZRIcChhPUFRJT05fU1RZTEVfVU5TUEVDSUZJRUQQABIZChVPUFRJT05fU1RZTEVfQU1FUklDQU4QARIZChVPUFRJT05fU1RZTEVfRVVST1BFQU4QAiqVAQoUT3B0aW9uU2V0dGxlbWVudFR5cGUSJQohT1BUSU9OX0VYRUNVVElPTl9UWVBFX1VOU1BFQ0lGSUVEEAASKwonT1BUSU9OX0VYRUNVVElPTl9UWVBFX1BIWVNJQ0FMX0RFTElWRVJZEAESKQolT1BUSU9OX0VYRUNVVElPTl9UWVBFX0NBU0hfU0VUVExFTUVOVBACKskBChBJbnN0cnVtZW50SWRUeXBlEh0KGUlOU1RSVU1FTlRfSURfVU5TUEVDSUZJRUQQABIbChdJTlNUUlVNRU5UX0lEX1RZUEVfRklHSRABEh0KGUlOU1RSVU1FTlRfSURfVFlQRV9USUNLRVIQAhIaChZJTlNUUlVNRU5UX0lEX1RZUEVfVUlEEAMSIwofSU5TVFJVTUVOVF9JRF9UWVBFX1BPU0lUSU9OX1VJRBAEEhkKFUlOU1RSVU1FTlRfSURfVFlQRV9JRBAFKuUBCglTaGFyZVR5cGUSGgoWU0hBUkVfVFlQRV9VTlNQRUNJRklFRBAAEhUKEVNIQVJFX1RZUEVfQ09NTU9OEAESGAoUU0hBUkVfVFlQRV9QUkVGRVJSRUQQAhISCg5TSEFSRV9UWVBFX0FEUhADEhIKDlNIQVJFX1RZUEVfR0RSEAQSEgoOU0hBUkVfVFlQRV9NTFAQBRIaChZTSEFSRV9UWVBFX05ZX1JFR19TSFJTEAYSHgoaU0hBUkVfVFlQRV9DTE9TRURfRU5EX0ZVTkQQBxITCg9TSEFSRV9UWVBFX1JFSVQQCCqJAQoJQXNzZXRUeXBlEhoKFkFTU0VUX1RZUEVfVU5TUEVDSUZJRUQQABIXChNBU1NFVF9UWVBFX0NVUlJFTkNZEAESGAoUQVNTRVRfVFlQRV9DT01NT0RJVFkQAhIUChBBU1NFVF9UWVBFX0lOREVYEAMSFwoTQVNTRVRfVFlQRV9TRUNVUklUWRAEKmYKFVN0cnVjdHVyZWRQcm9kdWN0VHlwZRIXChNTUF9UWVBFX1VOU1BFQ0lGSUVEEAASFwoTU1BfVFlQRV9ERUxJVkVSQUJMRRABEhsKF1NQX1RZUEVfTk9OX0RFTElWRVJBQkxFEAIqjQEKF0VkaXRGYXZvcml0ZXNBY3Rpb25UeXBlEioKJkVESVRfRkFWT1JJVEVTX0FDVElPTl9UWVBFX1VOU1BFQ0lGSUVEEAASIgoeRURJVF9GQVZPUklURVNfQUNUSU9OX1RZUEVfQUREEAESIgoeRURJVF9GQVZPUklURVNfQUNUSU9OX1RZUEVfREVMEAIqegoOUmVjb21tZW5kYXRpb24SHgoaUkVDT01NRU5EQVRJT05fVU5TUEVDSUZJRUQQABIWChJSRUNPTU1FTkRBVElPTl9CVVkQARIXChNSRUNPTU1FTkRBVElPTl9IT0xEEAISFwoTUkVDT01NRU5EQVRJT05fU0VMTBADKmkKCVJpc2tMZXZlbBIaChZSSVNLX0xFVkVMX1VOU1BFQ0lGSUVEEAASEgoOUklTS19MRVZFTF9MT1cQARIXChNSSVNLX0xFVkVMX01PREVSQVRFEAISEwoPUklTS19MRVZFTF9ISUdIEAMqPQoIQm9uZFR5cGUSGQoVQk9ORF9UWVBFX1VOU1BFQ0lGSUVEEAASFgoSQk9ORF9UWVBFX1JFUExBQ0VEEAEqXQoWSW5zdHJ1bWVudEV4Y2hhbmdlVHlwZRIjCh9JTlNUUlVNRU5UX0VYQ0hBTkdFX1VOU1BFQ0lGSUVEEAASHgoaSU5TVFJVTUVOVF9FWENIQU5HRV9ERUFMRVIQATLiLAoSSW5zdHJ1bWVudHNTZXJ2aWNlEpMBChBUcmFkaW5nU2NoZWR1bGVzEj4udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5UcmFkaW5nU2NoZWR1bGVzUmVxdWVzdBo/LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuVHJhZGluZ1NjaGVkdWxlc1Jlc3BvbnNlEncKBkJvbmRCeRI4LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFJlcXVlc3QaMy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkJvbmRSZXNwb25zZRJ4CgVCb25kcxI5LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudHNSZXF1ZXN0GjQudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Cb25kc1Jlc3BvbnNlEo0BCg5HZXRCb25kQ291cG9ucxI8LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0Qm9uZENvdXBvbnNSZXF1ZXN0Gj0udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRCb25kQ291cG9uc1Jlc3BvbnNlEooBCg1HZXRCb25kRXZlbnRzEjsudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRCb25kRXZlbnRzUmVxdWVzdBo8LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0Qm9uZEV2ZW50c1Jlc3BvbnNlEn8KCkN1cnJlbmN5QnkSOC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRSZXF1ZXN0GjcudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5DdXJyZW5jeVJlc3BvbnNlEoIBCgpDdXJyZW5jaWVzEjkudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50c1JlcXVlc3QaOS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkN1cnJlbmNpZXNSZXNwb25zZRJ1CgVFdGZCeRI4LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFJlcXVlc3QaMi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkV0ZlJlc3BvbnNlEnYKBEV0ZnMSOS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRzUmVxdWVzdBozLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRXRmc1Jlc3BvbnNlEnsKCEZ1dHVyZUJ5EjgudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbnN0cnVtZW50UmVxdWVzdBo1LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRnV0dXJlUmVzcG9uc2USfAoHRnV0dXJlcxI5LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudHNSZXF1ZXN0GjYudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5GdXR1cmVzUmVzcG9uc2USewoIT3B0aW9uQnkSOC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRSZXF1ZXN0GjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5PcHRpb25SZXNwb25zZRKBAQoHT3B0aW9ucxI5LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudHNSZXF1ZXN0GjYudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5PcHRpb25zUmVzcG9uc2UiA4gCARKAAQoJT3B0aW9uc0J5EjsudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5GaWx0ZXJPcHRpb25zUmVxdWVzdBo2LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuT3B0aW9uc1Jlc3BvbnNlEnkKB1NoYXJlQnkSOC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRSZXF1ZXN0GjQudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TaGFyZVJlc3BvbnNlEnoKBlNoYXJlcxI5LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudHNSZXF1ZXN0GjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TaGFyZXNSZXNwb25zZRJ1CgVEZmFCeRI4LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFJlcXVlc3QaMi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkRmYVJlc3BvbnNlEm8KBERmYXMSMi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkRmYXNSZXF1ZXN0GjMudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5EZmFzUmVzcG9uc2UShAEKC0luZGljYXRpdmVzEjkudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5JbmRpY2F0aXZlc1JlcXVlc3QaOi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluZGljYXRpdmVzUmVzcG9uc2USnAEKE0dldEFjY3J1ZWRJbnRlcmVzdHMSQS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEFjY3J1ZWRJbnRlcmVzdHNSZXF1ZXN0GkIudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRBY2NydWVkSW50ZXJlc3RzUmVzcG9uc2USkwEKEEdldEZ1dHVyZXNNYXJnaW4SPi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEZ1dHVyZXNNYXJnaW5SZXF1ZXN0Gj8udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRGdXR1cmVzTWFyZ2luUmVzcG9uc2UShgEKD0dldEluc3RydW1lbnRCeRI4LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFJlcXVlc3QaOS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkluc3RydW1lbnRSZXNwb25zZRKHAQoMR2V0RGl2aWRlbmRzEjoudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXREaXZpZGVuZHNSZXF1ZXN0GjsudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXREaXZpZGVuZHNSZXNwb25zZRJ3CgpHZXRBc3NldEJ5EjMudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldFJlcXVlc3QaNC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkFzc2V0UmVzcG9uc2USeAoJR2V0QXNzZXRzEjQudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldHNSZXF1ZXN0GjUudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5Bc3NldHNSZXNwb25zZRKHAQoMR2V0RmF2b3JpdGVzEjoudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRGYXZvcml0ZXNSZXF1ZXN0GjsudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRGYXZvcml0ZXNSZXNwb25zZRKKAQoNRWRpdEZhdm9yaXRlcxI7LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRWRpdEZhdm9yaXRlc1JlcXVlc3QaPC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkVkaXRGYXZvcml0ZXNSZXNwb25zZRKcAQoTQ3JlYXRlRmF2b3JpdGVHcm91cBJBLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQ3JlYXRlRmF2b3JpdGVHcm91cFJlcXVlc3QaQi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkNyZWF0ZUZhdm9yaXRlR3JvdXBSZXNwb25zZRKcAQoTRGVsZXRlRmF2b3JpdGVHcm91cBJBLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRGVsZXRlRmF2b3JpdGVHcm91cFJlcXVlc3QaQi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkRlbGV0ZUZhdm9yaXRlR3JvdXBSZXNwb25zZRKWAQoRR2V0RmF2b3JpdGVHcm91cHMSPy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEZhdm9yaXRlR3JvdXBzUmVxdWVzdBpALnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0RmF2b3JpdGVHcm91cHNSZXNwb25zZRKHAQoMR2V0Q291bnRyaWVzEjoudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRDb3VudHJpZXNSZXF1ZXN0GjsudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRDb3VudHJpZXNSZXNwb25zZRKNAQoORmluZEluc3RydW1lbnQSPC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkZpbmRJbnN0cnVtZW50UmVxdWVzdBo9LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuRmluZEluc3RydW1lbnRSZXNwb25zZRJ+CglHZXRCcmFuZHMSNy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEJyYW5kc1JlcXVlc3QaOC50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEJyYW5kc1Jlc3BvbnNlEnIKCkdldEJyYW5kQnkSNi50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEJyYW5kUmVxdWVzdBosLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuQnJhbmQSnwEKFEdldEFzc2V0RnVuZGFtZW50YWxzEkIudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRBc3NldEZ1bmRhbWVudGFsc1JlcXVlc3QaQy50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEFzc2V0RnVuZGFtZW50YWxzUmVzcG9uc2USkAEKD0dldEFzc2V0UmVwb3J0cxI9LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0QXNzZXRSZXBvcnRzUmVxdWVzdBo+LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0QXNzZXRSZXBvcnRzUmVzcG9uc2USogEKFUdldENvbnNlbnN1c0ZvcmVjYXN0cxJDLnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0Q29uc2Vuc3VzRm9yZWNhc3RzUmVxdWVzdBpELnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0Q29uc2Vuc3VzRm9yZWNhc3RzUmVzcG9uc2UShgEKDUdldEZvcmVjYXN0QnkSOS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLkdldEZvcmVjYXN0UmVxdWVzdBo6LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuR2V0Rm9yZWNhc3RSZXNwb25zZRKBAQoMR2V0Umlza1JhdGVzEjcudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5SaXNrUmF0ZXNSZXF1ZXN0GjgudGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5SaXNrUmF0ZXNSZXNwb25zZRKQAQoPR2V0SW5zaWRlckRlYWxzEj0udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRJbnNpZGVyRGVhbHNSZXF1ZXN0Gj4udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5HZXRJbnNpZGVyRGVhbHNSZXNwb25zZRKLAQoQU3RydWN0dXJlZE5vdGVCeRI4LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudFJlcXVlc3QaPS50aW5rb2ZmLnB1YmxpYy5pbnZlc3QuYXBpLmNvbnRyYWN0LnYxLlN0cnVjdHVyZWROb3RlUmVzcG9uc2USjAEKD1N0cnVjdHVyZWROb3RlcxI5LnRpbmtvZmYucHVibGljLmludmVzdC5hcGkuY29udHJhY3QudjEuSW5zdHJ1bWVudHNSZXF1ZXN0Gj4udGlua29mZi5wdWJsaWMuaW52ZXN0LmFwaS5jb250cmFjdC52MS5TdHJ1Y3R1cmVkTm90ZXNSZXNwb25zZUJhChxydS50aW5rb2ZmLnBpYXBpLmNvbnRyYWN0LnYxUAFaDC4vO2ludmVzdGFwaaICBVRJQVBJqgIUVGlua29mZi5JbnZlc3RBcGkuVjHKAhFUaW5rb2ZmXEludmVzdFxWMWIGcHJvdG8z", [file_google_protobuf_timestamp, file_common, file_google_api_field_behavior]);
+var InstrumentsService = /* @__PURE__ */ serviceDesc(file_instruments, 0);
+
+// src/gen/marketdata_pb.ts
+var file_marketdata = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_common, file_google_api_field_behavior]);
+var MarketDataService = /* @__PURE__ */ serviceDesc(file_marketdata, 0);
+
+// src/gen/operations_pb.ts
+var file_operations = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_common, file_google_api_field_behavior]);
+var OperationsService = /* @__PURE__ */ serviceDesc(file_operations, 0);
+
+// src/gen/orders_pb.ts
+var file_orders = /* @__PURE__ */ fileDesc("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", [file_common, file_google_protobuf_timestamp, file_google_api_field_behavior]);
+var OrdersService = /* @__PURE__ */ serviceDesc(file_orders, 1);
+
+// src/gen/stoporders_pb.ts
+var file_stoporders = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_api_field_behavior, file_common]);
+var StopOrdersService = /* @__PURE__ */ serviceDesc(file_stoporders, 0);
+
+// src/gen/users_pb.ts
+var file_users = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_api_field_behavior, file_common]);
+var UsersService = /* @__PURE__ */ serviceDesc(file_users, 0);
+
+// src/gen/sandbox_pb.ts
+var file_sandbox = /* @__PURE__ */ fileDesc("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", [file_common, file_orders, file_operations, file_stoporders, file_users, file_google_api_field_behavior]);
+var SandboxService = /* @__PURE__ */ serviceDesc(file_sandbox, 0);
+
+// src/gen/signals_pb.ts
+var file_signals = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_api_field_behavior, file_common]);
+var SignalService = /* @__PURE__ */ serviceDesc(file_signals, 0);
+
+// src/client/index.ts
+var TInvestApi = class {
+  instruments;
+  marketData;
+  operations;
+  orders;
+  sandbox;
+  signals;
+  stopOrders;
+  users;
+  constructor(token, baseUrl = T_INVEST_PROD_URL) {
+    const baseInterceptor = (next) => (req) => {
+      req.header.set("Authorization", `Bearer ${token}`);
+      req.header.set("x-app-name", "grind-t.tinkoff-invest-api");
+      return next(req);
+    };
+    const transport = createGrpcTransport({
+      baseUrl,
+      interceptors: [baseInterceptor]
+    });
+    this.instruments = createClient(InstrumentsService, transport);
+    this.marketData = createClient(MarketDataService, transport);
+    this.operations = createClient(OperationsService, transport);
+    this.orders = createClient(OrdersService, transport);
+    this.sandbox = createClient(SandboxService, transport);
+    this.signals = createClient(SignalService, transport);
+    this.stopOrders = createClient(StopOrdersService, transport);
+    this.users = createClient(UsersService, transport);
+  }
+};
+export {
+  TInvestApi,
+  T_INVEST_PROD_URL,
+  T_INVEST_SANDBOX_URL
+};