@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.5476d83

package/src/crs/browser/cached_net_crs.ts

@@ -1,4 +1,4 @@
-import { NetCrs } from '../net_crs.js';
+import { NetCrs, NetGrumpkinCrs } from '../net_crs.js';
 import { get, set } from 'idb-keyval';
 
 /**
@@ -57,3 +57,43 @@ export class CachedNetCrs {
     return this.g2Data;
   }
 }
+
+/**
+ * Downloader for CRS from the web or local.
+ */
+export class CachedNetGrumpkinCrs {
+  private g1Data!: Uint8Array;
+
+  constructor(public readonly numPoints: number) {}
+
+  static async new(numPoints: number) {
+    const crs = new CachedNetGrumpkinCrs(numPoints);
+    await crs.init();
+    return crs;
+  }
+
+  /**
+   * Download the data.
+   */
+  async init() {
+    // Check if data is in IndexedDB
+    const g1Data = await get('grumpkinG1Data');
+    const netGrumpkinCrs = new NetGrumpkinCrs(this.numPoints);
+    const g1DataLength = this.numPoints * 64;
+
+    if (!g1Data || g1Data.length < g1DataLength) {
+      this.g1Data = await netGrumpkinCrs.downloadG1Data();
+      await set('grumpkinG1Data', this.g1Data);
+    } else {
+      this.g1Data = g1Data;
+    }
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return this.g1Data;
+  }
+}

package/src/crs/browser/index.ts

@@ -1 +1 @@
-export { CachedNetCrs as Crs } from './cached_net_crs.js';
+export { CachedNetCrs as Crs, CachedNetGrumpkinCrs as GrumpkinCrs } from './cached_net_crs.js';

package/src/crs/index.ts

@@ -1 +1 @@
-export { Crs } from './node/index.js';
+export { Crs, GrumpkinCrs } from './node/index.js';

package/src/crs/net_crs.ts

@@ -1,3 +1,4 @@
+import { retry, makeBackoff } from '../retry/index.js';
 /**
  * Downloader for CRS from the web or local.
  */
@@ -20,17 +21,24 @@ export class NetCrs {
     await this.downloadG2Data();
   }
 
-  async downloadG1Data() {
-    const g1Start = 28;
-    const g1End = g1Start + this.numPoints * 64 - 1;
+  /**
+   * Opens up a ReadableStream to the points data
+   */
+  async streamG1Data(): Promise<ReadableStream<Uint8Array>> {
+    const response = await this.fetchG1Data();
+    return response.body!;
+  }
 
-    const response = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/monomial/transcript00.dat', {
-      headers: {
-        Range: `bytes=${g1Start}-${g1End}`,
-      },
-      cache: 'force-cache',
-    });
+  /**
+   * Opens up a ReadableStream to the points data
+   */
+  async streamG2Data(): Promise<ReadableStream<Uint8Array>> {
+    const response = await this.fetchG2Data();
+    return response.body!;
+  }
 
+  async downloadG1Data() {
+    const response = await this.fetchG1Data();
     return (this.data = new Uint8Array(await response.arrayBuffer()));
   }
 
@@ -38,16 +46,7 @@ export class NetCrs {
    * Download the G2 points data.
    */
   async downloadG2Data() {
-    const g2Start = 28 + 5040000 * 64;
-    const g2End = g2Start + 128 - 1;
-
-    const response2 = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/sealed/transcript00.dat', {
-      headers: {
-        Range: `bytes=${g2Start}-${g2End}`,
-      },
-      cache: 'force-cache',
-    });
-
+    const response2 = await this.fetchG2Data();
     return (this.g2Data = new Uint8Array(await response2.arrayBuffer()));
   }
 
@@ -66,4 +65,100 @@ export class NetCrs {
   getG2Data(): Uint8Array {
     return this.g2Data;
   }
+
+  /**
+   * Fetches the appropriate range of points from a remote source
+   */
+  private async fetchG1Data(): Promise<Response> {
+    // Skip the download if numPoints is 0 (would download the entire file due to bad range header otherwise)
+    if (this.numPoints === 0) {
+      return new Response(new Uint8Array([]));
+    }
+
+    const g1End = this.numPoints * 64 - 1;
+    return await retry(
+      () =>
+        fetch('https://crs.aztec.network/g1.dat', {
+          headers: {
+            Range: `bytes=0-${g1End}`,
+          },
+          cache: 'force-cache',
+        }),
+      makeBackoff([5, 5, 5]),
+    );
+  }
+
+  /**
+   * Fetches the appropriate range of points from a remote source
+   */
+  private async fetchG2Data(): Promise<Response> {
+    return await retry(
+      () =>
+        fetch('https://crs.aztec.network/g2.dat', {
+          cache: 'force-cache',
+        }),
+      makeBackoff([5, 5, 5]),
+    );
+  }
+}
+
+/**
+ * Downloader for CRS from the web or local.
+ */
+export class NetGrumpkinCrs {
+  private data!: Uint8Array;
+
+  constructor(
+    /**
+     * The number of circuit gates.
+     */
+    public readonly numPoints: number,
+  ) {}
+
+  /**
+   * Download the data.
+   */
+  async init() {
+    await this.downloadG1Data();
+  }
+
+  async downloadG1Data() {
+    const response = await this.fetchG1Data();
+    return (this.data = new Uint8Array(await response.arrayBuffer()));
+  }
+
+  /**
+   * Opens up a ReadableStream to the points data
+   */
+  async streamG1Data(): Promise<ReadableStream<Uint8Array>> {
+    const response = await this.fetchG1Data();
+    return response.body!;
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return this.data;
+  }
+
+  /**
+   * Fetches the appropriate range of points from a remote source
+   */
+  private async fetchG1Data(): Promise<Response> {
+    // Skip the download if numPoints is 0 (would download the entire file due to bad range header otherwise)
+    if (this.numPoints === 0) {
+      return new Response(new Uint8Array([]));
+    }
+
+    const g1End = this.numPoints * 64 - 1;
+
+    return await fetch('https://crs.aztec.network/grumpkin_g1.dat', {
+      headers: {
+        Range: `bytes=0-${g1End}`,
+      },
+      cache: 'force-cache',
+    });
+  }
 }

package/src/crs/node/index.ts

@@ -1,41 +1,54 @@
-import { NetCrs } from '../net_crs.js';
-import { IgnitionFilesCrs } from './ignition_files_crs.js';
-import { mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { readFile } from 'fs/promises';
-import createDebug from 'debug';
-
-const debug = createDebug('bb.js:crs');
+import { NetCrs, NetGrumpkinCrs } from '../net_crs.js';
+import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync, createWriteStream } from 'fs';
+import { stat } from 'fs/promises';
+import { Readable } from 'stream';
+import { homedir } from 'os';
+import { finished } from 'stream/promises';
+import { join } from 'path';
 
 /**
  * Generic CRS finder utility class.
  */
 export class Crs {
-  constructor(public readonly numPoints: number, public readonly path: string) {}
+  constructor(
+    public readonly numPoints: number,
+    public readonly path: string,
+    private readonly logger: (msg: string) => void = () => {},
+  ) {}
 
-  static async new(numPoints: number) {
-    const crs = new Crs(numPoints, './crs');
+  static async new(
+    numPoints: number,
+    crsPath = process.env.CRS_PATH ?? join(homedir(), '.bb-crs'),
+    logger: (msg: string) => void = () => {},
+  ) {
+    const crs = new Crs(numPoints, crsPath, logger);
     await crs.init();
     return crs;
   }
 
-  async init() {
+  async init(): Promise<void> {
     mkdirSync(this.path, { recursive: true });
-    const size = await readFile(this.path + '/size', 'ascii').catch(() => undefined);
-    if (size && +size >= this.numPoints) {
-      debug(`using cached crs of size: ${size}`);
+
+    const g1FileSize = await stat(this.path + '/bn254_g1.dat')
+      .then(stats => stats.size)
+      .catch(() => 0);
+    const g2FileSize = await stat(this.path + '/bn254_g2.dat')
+      .then(stats => stats.size)
+      .catch(() => 0);
+
+    if (g1FileSize >= this.numPoints * 64 && g1FileSize % 64 == 0 && g2FileSize == 128) {
+      this.logger(`Using cached CRS of size ${g1FileSize / 64}`);
       return;
     }
 
-    const crs = IgnitionFilesCrs.defaultExists() ? new IgnitionFilesCrs(this.numPoints) : new NetCrs(this.numPoints);
-    if (crs instanceof NetCrs) {
-      debug(`downloading crs of size: ${this.numPoints}`);
-    } else {
-      debug(`loading igntion file crs of size: ${this.numPoints}`);
-    }
-    await crs.init();
-    writeFileSync(this.path + '/size', this.numPoints.toString());
-    writeFileSync(this.path + '/g1.dat', crs.getG1Data());
-    writeFileSync(this.path + '/g2.dat', crs.getG2Data());
+    this.logger(`Downloading CRS of size ${this.numPoints} into ${this.path}`);
+    const crs = new NetCrs(this.numPoints);
+    const [g1, g2] = await Promise.all([crs.streamG1Data(), crs.streamG2Data()]);
+
+    await Promise.all([
+      finished(Readable.fromWeb(g1 as any).pipe(createWriteStream(this.path + '/bn254_g1.dat'))),
+      finished(Readable.fromWeb(g2 as any).pipe(createWriteStream(this.path + '/bn254_g2.dat'))),
+    ]);
   }
 
   /**
@@ -43,7 +56,14 @@ export class Crs {
    * @returns The points data.
    */
   getG1Data(): Uint8Array {
-    return readFileSync(this.path + '/g1.dat');
+    // Ensure length > 0, otherwise we might read a huge file.
+    // This is a backup.
+    const length = Math.max(this.numPoints, 1) * 64;
+    const fd = openSync(this.path + '/bn254_g1.dat', 'r');
+    const buffer = new Uint8Array(length);
+    readSync(fd, buffer, 0, length, 0);
+    closeSync(fd);
+    return buffer;
   }
 
   /**
@@ -51,6 +71,55 @@ export class Crs {
    * @returns The points data.
    */
   getG2Data(): Uint8Array {
-    return readFileSync(this.path + '/g2.dat');
+    return readFileSync(this.path + '/bn254_g2.dat');
+  }
+}
+
+/**
+ * Generic Grumpkin CRS finder utility class.
+ */
+export class GrumpkinCrs {
+  constructor(
+    public readonly numPoints: number,
+    public readonly path: string,
+    private readonly logger: (msg: string) => void = () => {},
+  ) {}
+
+  static async new(
+    numPoints: number,
+    crsPath = process.env.CRS_PATH ?? join(homedir(), '.bb-crs'),
+    logger: (msg: string) => void = () => {},
+  ) {
+    const crs = new GrumpkinCrs(numPoints, crsPath, logger);
+    await crs.init();
+    return crs;
+  }
+
+  async init(): Promise<void> {
+    mkdirSync(this.path, { recursive: true });
+
+    const g1FileSize = await stat(this.path + '/grumpkin_g1.flat.dat')
+      .then(stats => stats.size)
+      .catch(() => 0);
+
+    if (g1FileSize >= this.numPoints * 64 && g1FileSize % 64 == 0) {
+      this.logger(`Using cached Grumpkin CRS of size ${g1FileSize / 64}`);
+      return;
+    }
+
+    this.logger(`Downloading Grumpkin CRS of size ${this.numPoints} into ${this.path}`);
+    const crs = new NetGrumpkinCrs(this.numPoints);
+    const stream = await crs.streamG1Data();
+
+    await finished(Readable.fromWeb(stream as any).pipe(createWriteStream(this.path + '/grumpkin_g1.flat.dat')));
+    writeFileSync(this.path + '/grumpkin_size', String(crs.numPoints));
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return readFileSync(this.path + '/grumpkin_g1.flat.dat');
   }
 }

package/src/index.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html>
   <head>
     <title>My App</title>

package/src/index.ts

@@ -1,5 +1,43 @@
-export * from './crs/index.js';
-export * from './barretenberg_wasm/index.js';
-export * from './barretenberg_api/index.js';
-export * from './factory/index.js';
-export { RawBuffer } from './types/index.js';
+export { Crs, GrumpkinCrs } from './crs/index.js';
+export {
+  type BackendOptions,
+  BackendType,
+  Barretenberg,
+  BarretenbergSync,
+  UltraHonkVerifierBackend,
+  UltraHonkBackend,
+  AztecClientBackend,
+} from './barretenberg/index.js';
+
+export { randomBytes } from './random/index.js';
+export { splitHonkProof, reconstructHonkProof, deflattenFields, type ProofData } from './proof/index.js';
+export { BBApiException } from './bbapi_exception.js';
+
+// Export Point types for use in foundation and other packages
+export type {
+  Bn254G1Point,
+  Bn254G2Point,
+  GrumpkinPoint,
+  Secp256k1Point,
+  Secp256r1Point,
+  Field2,
+} from './cbind/generated/api_types.js';
+
+// Export curve constants for use in foundation
+export {
+  BN254_FQ_MODULUS,
+  BN254_FR_MODULUS,
+  BN254_G1_GENERATOR,
+  BN254_G2_GENERATOR,
+  GRUMPKIN_FR_MODULUS,
+  GRUMPKIN_FQ_MODULUS,
+  GRUMPKIN_G1_GENERATOR,
+  SECP256K1_FR_MODULUS,
+  SECP256K1_FQ_MODULUS,
+  SECP256K1_G1_GENERATOR,
+  SECP256R1_FR_MODULUS,
+  SECP256R1_FQ_MODULUS,
+  SECP256R1_G1_GENERATOR,
+} from './cbind/generated/curve_constants.js';
+
+export { findNapiBinary } from './bb_backends/node/platform.js';

package/src/proof/index.ts

@@ -0,0 +1,94 @@
+/**
+ * @description
+ * The representation of a proof
+ * */
+export type ProofData = {
+  /** @description Public inputs of a proof */
+  publicInputs: string[];
+  /** @description An byte array representing the proof */
+  proof: Uint8Array;
+};
+
+export const PAIRING_POINTS_SIZE = 16;
+
+// Fields are 32 bytes
+const fieldByteSize = 32;
+
+export function splitHonkProof(
+  proofWithPublicInputs: Uint8Array,
+  numPublicInputs: number,
+): { publicInputs: Uint8Array; proof: Uint8Array } {
+  const publicInputs = proofWithPublicInputs.slice(0, numPublicInputs * fieldByteSize);
+  const proof = proofWithPublicInputs.slice(numPublicInputs * fieldByteSize);
+
+  return {
+    proof,
+    publicInputs,
+  };
+}
+
+export function reconstructHonkProof(publicInputs: Uint8Array, proof: Uint8Array): Uint8Array {
+  const proofWithPublicInputs = Uint8Array.from([...publicInputs, ...proof]);
+  return proofWithPublicInputs;
+}
+
+export function deflattenFields(flattenedFields: Uint8Array): string[] {
+  const publicInputSize = 32;
+  const chunkedFlattenedPublicInputs: Uint8Array[] = [];
+
+  for (let i = 0; i < flattenedFields.length; i += publicInputSize) {
+    const publicInput = flattenedFields.slice(i, i + publicInputSize);
+    chunkedFlattenedPublicInputs.push(publicInput);
+  }
+
+  return chunkedFlattenedPublicInputs.map(uint8ArrayToHex);
+}
+
+export function flattenFieldsAsArray(fields: string[]): Uint8Array {
+  const flattenedPublicInputs = fields.map(hexToUint8Array);
+  return flattenUint8Arrays(flattenedPublicInputs);
+}
+
+function flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {
+  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);
+  const result = new Uint8Array(totalLength);
+
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+
+  return result;
+}
+
+export function uint8ArrayToHex(buffer: Uint8Array): string {
+  const hex: string[] = [];
+
+  buffer.forEach(function (i) {
+    let h = i.toString(16);
+    if (h.length % 2) {
+      h = '0' + h;
+    }
+    hex.push(h);
+  });
+
+  return '0x' + hex.join('');
+}
+
+export function hexToUint8Array(hex: string): Uint8Array {
+  const sanitizedHex = BigInt(hex).toString(16).padStart(64, '0');
+
+  const len = sanitizedHex.length / 2;
+  const u8 = new Uint8Array(len);
+
+  let i = 0;
+  let j = 0;
+  while (i < len) {
+    u8[i] = parseInt(sanitizedHex.slice(j, j + 2), 16);
+    i += 1;
+    j += 2;
+  }
+
+  return u8;
+}

package/src/random/browser/index.ts

@@ -1,7 +1,7 @@
 export const randomBytes = (len: number) => {
   const getWebCrypto = () => {
     if (typeof window !== 'undefined' && window.crypto) return window.crypto;
-    if (typeof self !== 'undefined' && self.crypto) return self.crypto;
+    if (typeof globalThis !== 'undefined' && globalThis.crypto) return globalThis.crypto;
     return undefined;
   };
 

package/src/retry/index.ts

@@ -0,0 +1,50 @@
+/**
+ * Generates a backoff sequence for retrying operations with an increasing delay.
+ * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
+ * This generator can be used in combination with the `retry` function to perform
+ * retries with exponential backoff and capped at 64 seconds between attempts.
+ *
+ * @returns A generator that yields the next backoff value in seconds as an integer.
+ */
+export function* backoffGenerator() {
+  const v = [1, 1, 1, 2, 4, 8, 16, 32, 64];
+  let i = 0;
+  while (true) {
+    yield v[Math.min(i++, v.length - 1)];
+  }
+}
+
+/**
+ * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
+ * @param retries - Intervals to retry (in seconds).
+ * @returns A generator sequence.
+ */
+export function* makeBackoff(retries: number[]) {
+  for (const retry of retries) {
+    yield retry;
+  }
+}
+
+/**
+ * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
+ * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
+ *
+ * @param fn - The asynchronous function to be retried.
+ * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
+ * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
+ * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
+ */
+export async function retry<Result>(fn: () => Promise<Result>, backoff = backoffGenerator()) {
+  while (true) {
+    try {
+      return await fn();
+    } catch (err: any) {
+      const s = backoff.next().value;
+      if (s === undefined) {
+        throw err;
+      }
+      await new Promise(resolve => setTimeout(resolve, s * 1000));
+      continue;
+    }
+  }
+}

package/dest/async_map/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async_map/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAMhG"}

package/dest/barretenberg_api/blake2s.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=blake2s.test.d.ts.map

package/dest/barretenberg_api/blake2s.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blake2s.test.d.ts","sourceRoot":"","sources":["../../src/barretenberg_api/blake2s.test.ts"],"names":[],"mappings":""}

package/dest/barretenberg_api/blake2s.test.js

@@ -1,30 +0,0 @@
-import { newBarretenbergApiSync } from '../factory/index.js';
-import { Buffer32, Fr } from '../types/index.js';
-describe('blake2s', () => {
-    let api;
-    beforeAll(async () => {
-        api = await newBarretenbergApiSync();
-    });
-    afterAll(async () => {
-        await api.destroy();
-    });
-    it('blake2s', () => {
-        const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
-        const expected = Buffer32.fromBuffer(new Uint8Array([
-            0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
-            0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
-        ]));
-        const result = api.blake2s(input);
-        expect(result).toEqual(expected);
-    });
-    it('blake2sToField', () => {
-        const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
-        const expected = Fr.fromBufferReduce(new Uint8Array([
-            0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
-            0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
-        ]));
-        const result = api.blake2sToField(input);
-        expect(result).toEqual(expected);
-    });
-});
-//# sourceMappingURL=data:application/json;base64,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

package/dest/barretenberg_api/common.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=common.test.d.ts.map

package/dest/barretenberg_api/common.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.test.d.ts","sourceRoot":"","sources":["../../src/barretenberg_api/common.test.ts"],"names":[],"mappings":""}

package/dest/barretenberg_api/common.test.js

@@ -1,18 +0,0 @@
-import { newBarretenbergApiAsync } from '../factory/index.js';
-describe('env', () => {
-    let api;
-    beforeAll(async () => {
-        api = await newBarretenbergApiAsync(3);
-    });
-    afterAll(async () => {
-        await api.destroy();
-    });
-    it('thread test', async () => {
-        // Main thread doesn't do anything in this test, so -1.
-        const threads = (await api.getNumThreads()) - 1;
-        const iterations = 100000;
-        const result = await api.testThreads(threads, iterations);
-        expect(result).toBe(iterations);
-    });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmFycmV0ZW5iZXJnX2FwaS9jb21tb24udGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXdCLHVCQUF1QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFcEYsUUFBUSxDQUFDLEtBQUssRUFBRSxHQUFHLEVBQUU7SUFDbkIsSUFBSSxHQUF5QixDQUFDO0lBRTlCLFNBQVMsQ0FBQyxLQUFLLElBQUksRUFBRTtRQUNuQixHQUFHLEdBQUcsTUFBTSx1QkFBdUIsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN6QyxDQUFDLENBQUMsQ0FBQztJQUVILFFBQVEsQ0FBQyxLQUFLLElBQUksRUFBRTtRQUNsQixNQUFNLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUN0QixDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyxhQUFhLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDM0IsdURBQXVEO1FBQ3ZELE1BQU0sT0FBTyxHQUFHLENBQUMsTUFBTSxHQUFHLENBQUMsYUFBYSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDaEQsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDO1FBQzFCLE1BQU0sTUFBTSxHQUFHLE1BQU0sR0FBRyxDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDMUQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNsQyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIn0=