tfhe 0.2.4 → 0.2.5

package/README.md

@@ -0,0 +1,188 @@
+<p align="center">
+<!-- product name logo -->
+  <img width=600 src="https://user-images.githubusercontent.com/5758427/231206749-8f146b97-3c5a-4201-8388-3ffa88580415.png">
+</p>
+<hr/>
+<p align="center">
+  <a href="https://docs.zama.ai/tfhe-rs"> 📒 Read documentation</a> | <a href="https://zama.ai/community"> 💛 Community support</a>
+</p>
+<p align="center">
+<!-- Version badge using shields.io -->
+  <a href="https://github.com/zama-ai/tfhe-rs/releases">
+    <img src="https://img.shields.io/github/v/release/zama-ai/tfhe-rs?style=flat-square">
+  </a>
+<!-- Zama Bounty Program -->
+  <a href="https://github.com/zama-ai/bounty-program">
+    <img src="https://img.shields.io/badge/Contribute-Zama%20Bounty%20Program-yellow?style=flat-square">
+  </a>
+</p>
+<hr/>
+
+
+**TFHE-rs** is a pure Rust implementation of TFHE for boolean and integer
+arithmetics over encrypted data. It includes:
+ - a **Rust** API
+ - a **C** API
+ - and a **client-side WASM** API
+
+**TFHE-rs** is meant for developers and researchers who want full control over
+what they can do with TFHE, while not having to worry about the low level
+implementation. The goal is to have a stable, simple, high-performance, and
+production-ready library for all the advanced features of TFHE.
+
+## Getting Started
+
+To use the latest version of `TFHE-rs` in your project, you first need to add it as a dependency in your `Cargo.toml`:
+
++ For x86_64-based machines running Unix-like OSes:
+
+```toml
+tfhe = { version = "*", features = ["boolean", "shortint", "integer", "x86_64-unix"] }
+```
+
++ For Apple Silicon or aarch64-based machines running Unix-like OSes:
+
+```toml
+tfhe = { version = "*", features = ["boolean", "shortint", "integer", "aarch64-unix"] }
+```
+Note: users with ARM devices must use `TFHE-rs` by compiling using the `nightly` toolchain.
+
+
++ For x86_64-based machines with the [`rdseed instruction`](https://en.wikipedia.org/wiki/RDRAND) 
+running Windows:
+
+```toml
+tfhe = { version = "*", features = ["boolean", "shortint", "integer", "x86_64"] }
+```
+
+Note: aarch64-based machines are not yet supported for Windows as it's currently missing an entropy source to be able to seed the [CSPRNGs](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator) used in TFHE-rs
+
+Note that when running code that uses `tfhe-rs`, it is highly recommended
+to run in release mode with cargo's `--release` flag to have the best performances possible,
+eg: `cargo run --release`.
+
+Here is a full example evaluating a Boolean circuit:
+
+```rust
+use tfhe::boolean::prelude::*;
+
+fn main() {
+    // We generate a set of client/server keys, using the default parameters:
+    let (mut client_key, mut server_key) = gen_keys();
+
+    // We use the client secret key to encrypt two messages:
+    let ct_1 = client_key.encrypt(true);
+    let ct_2 = client_key.encrypt(false);
+
+    // We use the server public key to execute a boolean circuit:
+    // if ((NOT ct_2) NAND (ct_1 AND ct_2)) then (NOT ct_2) else (ct_1 AND ct_2)
+    let ct_3 = server_key.not(&ct_2);
+    let ct_4 = server_key.and(&ct_1, &ct_2);
+    let ct_5 = server_key.nand(&ct_3, &ct_4);
+    let ct_6 = server_key.mux(&ct_5, &ct_3, &ct_4);
+
+    // We use the client key to decrypt the output of the circuit:
+    let output = client_key.decrypt(&ct_6);
+    assert_eq!(output, true);
+}
+```
+
+Another example of how the library can be used with shortints:
+
+```rust
+use tfhe::shortint::prelude::*;
+
+fn main() {
+    // Generate a set of client/server keys
+    // with 2 bits of message and 2 bits of carry
+    let (client_key, server_key) = gen_keys(PARAM_MESSAGE_2_CARRY_2);
+
+    let msg1 = 3;
+    let msg2 = 2;
+
+    // Encrypt two messages using the (private) client key:
+    let ct_1 = client_key.encrypt(msg1);
+    let ct_2 = client_key.encrypt(msg2);
+
+    // Homomorphically compute an addition
+    let ct_add = server_key.unchecked_add(&ct_1, &ct_2);
+
+    // Define the Hamming weight function
+    // f: x -> sum of the bits of x
+    let f = |x:u64| x.count_ones() as u64;
+
+    // Generate the accumulator for the function
+    let acc = server_key.generate_accumulator(f);
+
+    // Compute the function over the ciphertext using the PBS
+    let ct_res = server_key.apply_lookup_table(&ct_add, &acc);
+
+    // Decrypt the ciphertext using the (private) client key
+    let output = client_key.decrypt(&ct_res);
+    assert_eq!(output, f(msg1 + msg2));
+}
+```
+
+An example using integer:
+
+```rust
+use tfhe::integer::gen_keys_radix;
+use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2;
+
+fn main() {
+    // We create keys to create 16 bits integers
+    // using 8 blocks of 2 bits
+    let (cks, sks) = gen_keys_radix(&PARAM_MESSAGE_2_CARRY_2, 8);
+
+    let clear_a = 2382u16;
+    let clear_b = 29374u16;
+
+    let mut a = cks.encrypt(clear_a as u64);
+    let mut b = cks.encrypt(clear_b as u64);
+
+    let encrypted_max = sks.smart_max_parallelized(&mut a, &mut b);
+    let decrypted_max: u64 = cks.decrypt(&encrypted_max);
+
+    assert_eq!(decrypted_max as u16, clear_a.max(clear_b))
+}
+```
+
+## Contributing
+
+There are two ways to contribute to TFHE-rs:
+
+- you can open issues to report bugs or typos, or to suggest new ideas
+- you can ask to become an official contributor by emailing [hello@zama.ai](mailto:hello@zama.ai).
+(becoming an approved contributor involves signing our Contributor License Agreement (CLA))
+
+Only approved contributors can send pull requests, so please make sure to get in touch before you do!
+
+## Credits
+
+This library uses several dependencies and we would like to thank the contributors of those
+libraries.
+
+## Need support?
+<a target="_blank" href="https://community.zama.ai">
+  <img src="https://user-images.githubusercontent.com/5758427/231115030-21195b55-2629-4c01-9809-be5059243999.png">
+</a>
+
+## License
+
+This software is distributed under the BSD-3-Clause-Clear license. If you have any questions,
+please contact us at `hello@zama.ai`.
+
+## Disclaimers
+
+### Security Estimation
+
+Security estimations are done using the
+[Lattice Estimator](https://github.com/malb/lattice-estimator)
+with `red_cost_model = reduction.RC.BDGL16`.
+
+When a new update is published in the Lattice Estimator, we update parameters accordingly.
+
+### Side-Channel Attacks
+
+Mitigation for side channel attacks have not yet been implemented in TFHE-rs,
+and will be released in upcoming versions.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tfhe",
   "description": "TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "license": "BSD-3-Clause-Clear",
   "repository": {
     "type": "git",

package/tfhe.d.ts

@@ -387,6 +387,35 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_booleanciphertext_free: (a: number) => void;
+  readonly __wbg_booleancompressedciphertext_free: (a: number) => void;
+  readonly __wbg_booleanclientkey_free: (a: number) => void;
+  readonly __wbg_booleanpublickey_free: (a: number) => void;
+  readonly __wbg_booleancompressedserverkey_free: (a: number) => void;
+  readonly __wbg_booleanparameters_free: (a: number) => void;
+  readonly boolean_get_parameters: (a: number, b: number) => void;
+  readonly boolean_new_parameters: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+  readonly boolean_new_client_key_from_seed_and_parameters: (a: number, b: number, c: number) => number;
+  readonly boolean_new_client_key: (a: number) => number;
+  readonly boolean_new_public_key: (a: number) => number;
+  readonly boolean_new_compressed_server_key: (a: number) => number;
+  readonly boolean_encrypt: (a: number, b: number) => number;
+  readonly boolean_encrypt_compressed: (a: number, b: number) => number;
+  readonly boolean_decompress_ciphertext: (a: number) => number;
+  readonly boolean_encrypt_with_public_key: (a: number, b: number) => number;
+  readonly boolean_trivial_encrypt: (a: number, b: number) => number;
+  readonly boolean_decrypt: (a: number, b: number) => number;
+  readonly boolean_serialize_ciphertext: (a: number, b: number) => void;
+  readonly boolean_deserialize_ciphertext: (a: number, b: number, c: number) => void;
+  readonly boolean_serialize_compressed_ciphertext: (a: number, b: number) => void;
+  readonly boolean_deserialize_compressed_ciphertext: (a: number, b: number, c: number) => void;
+  readonly boolean_serialize_client_key: (a: number, b: number) => void;
+  readonly boolean_deserialize_client_key: (a: number, b: number, c: number) => void;
+  readonly boolean_serialize_public_key: (a: number, b: number) => void;
+  readonly boolean_deserialize_public_key: (a: number, b: number, c: number) => void;
+  readonly boolean_serialize_compressed_server_key: (a: number, b: number) => void;
+  readonly boolean_deserialize_compressed_server_key: (a: number, b: number, c: number) => void;
+  readonly __wbg_boolean_free: (a: number) => void;
   readonly __wbg_shortintciphertext_free: (a: number) => void;
   readonly __wbg_shortintcompressedciphertext_free: (a: number) => void;
   readonly __wbg_shortintclientkey_free: (a: number) => void;
@@ -425,39 +454,10 @@ export interface InitOutput {
   readonly shortint_serialize_compressed_server_key: (a: number, b: number) => void;
   readonly shortint_deserialize_compressed_server_key: (a: number, b: number, c: number) => void;
   readonly __wbg_shortint_free: (a: number) => void;
-  readonly __wbg_booleanciphertext_free: (a: number) => void;
-  readonly __wbg_booleancompressedciphertext_free: (a: number) => void;
-  readonly __wbg_booleanclientkey_free: (a: number) => void;
-  readonly __wbg_booleanpublickey_free: (a: number) => void;
-  readonly __wbg_booleancompressedserverkey_free: (a: number) => void;
-  readonly __wbg_booleanparameters_free: (a: number) => void;
-  readonly boolean_get_parameters: (a: number, b: number) => void;
-  readonly boolean_new_parameters: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
-  readonly boolean_new_client_key_from_seed_and_parameters: (a: number, b: number, c: number) => number;
-  readonly boolean_new_client_key: (a: number) => number;
-  readonly boolean_new_public_key: (a: number) => number;
-  readonly boolean_new_compressed_server_key: (a: number) => number;
-  readonly boolean_encrypt: (a: number, b: number) => number;
-  readonly boolean_encrypt_compressed: (a: number, b: number) => number;
-  readonly boolean_decompress_ciphertext: (a: number) => number;
-  readonly boolean_encrypt_with_public_key: (a: number, b: number) => number;
-  readonly boolean_trivial_encrypt: (a: number, b: number) => number;
-  readonly boolean_decrypt: (a: number, b: number) => number;
-  readonly boolean_serialize_ciphertext: (a: number, b: number) => void;
-  readonly boolean_deserialize_ciphertext: (a: number, b: number, c: number) => void;
-  readonly boolean_serialize_compressed_ciphertext: (a: number, b: number) => void;
-  readonly boolean_deserialize_compressed_ciphertext: (a: number, b: number, c: number) => void;
-  readonly boolean_serialize_client_key: (a: number, b: number) => void;
-  readonly boolean_deserialize_client_key: (a: number, b: number, c: number) => void;
-  readonly boolean_serialize_public_key: (a: number, b: number) => void;
-  readonly boolean_deserialize_public_key: (a: number, b: number, c: number) => void;
-  readonly boolean_serialize_compressed_server_key: (a: number, b: number) => void;
-  readonly boolean_deserialize_compressed_server_key: (a: number, b: number, c: number) => void;
-  readonly __wbg_boolean_free: (a: number) => void;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
-  readonly __wbindgen_free: (a: number, b: number) => void;
-  readonly __wbindgen_malloc: (a: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;
 }
 
@@ -480,4 +480,4 @@ export function initSync(module: SyncInitInput): InitOutput;
 *
 * @returns {Promise<InitOutput>}
 */
-export default function init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
+export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;

package/tfhe.js

@@ -1,8 +1,8 @@
 let wasm;
 
-const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
-cachedTextDecoder.decode();
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
 
 let cachedUint8Memory0 = null;
 
@@ -14,6 +14,7 @@ function getUint8Memory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
     return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 
@@ -63,19 +64,20 @@ function _assertClass(instance, klass) {
 }
 
 function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
 let WASM_VECTOR_LEN = 0;
 
 function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8Memory0().set(arg, ptr / 1);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
 
-const cachedTextEncoder = new TextEncoder('utf-8');
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
@@ -94,14 +96,14 @@ function passStringToWasm0(arg, malloc, realloc) {
 
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length);
+        const ptr = malloc(buf.length, 1) >>> 0;
         getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
 
     let len = arg.length;
-    let ptr = malloc(len);
+    let ptr = malloc(len, 1) >>> 0;
 
     const mem = getUint8Memory0();
 
@@ -117,7 +119,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         if (offset !== 0) {
             arg = arg.slice(offset);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
         const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
         const ret = encodeString(arg, view);
 
@@ -143,8 +145,8 @@ export const BooleanParameterSet = Object.freeze({ Default:0,"0":"Default",TfheL
 export class Boolean {
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -196,7 +198,7 @@ export class Boolean {
     */
     static new_client_key_from_seed_and_parameters(seed_high_bytes, seed_low_bytes, parameters) {
         _assertClass(parameters, BooleanParameters);
-        const ret = wasm.boolean_new_client_key_from_seed_and_parameters(seed_high_bytes, seed_low_bytes, parameters.ptr);
+        const ret = wasm.boolean_new_client_key_from_seed_and_parameters(seed_high_bytes, seed_low_bytes, parameters.__wbg_ptr);
         return BooleanClientKey.__wrap(ret);
     }
     /**
@@ -205,7 +207,7 @@ export class Boolean {
     */
     static new_client_key(parameters) {
         _assertClass(parameters, BooleanParameters);
-        const ret = wasm.boolean_new_client_key(parameters.ptr);
+        const ret = wasm.boolean_new_client_key(parameters.__wbg_ptr);
         return BooleanClientKey.__wrap(ret);
     }
     /**
@@ -214,7 +216,7 @@ export class Boolean {
     */
     static new_public_key(client_key) {
         _assertClass(client_key, BooleanClientKey);
-        const ret = wasm.boolean_new_public_key(client_key.ptr);
+        const ret = wasm.boolean_new_public_key(client_key.__wbg_ptr);
         return BooleanPublicKey.__wrap(ret);
     }
     /**
@@ -223,7 +225,7 @@ export class Boolean {
     */
     static new_compressed_server_key(client_key) {
         _assertClass(client_key, BooleanClientKey);
-        const ret = wasm.boolean_new_compressed_server_key(client_key.ptr);
+        const ret = wasm.boolean_new_compressed_server_key(client_key.__wbg_ptr);
         return BooleanCompressedServerKey.__wrap(ret);
     }
     /**
@@ -233,7 +235,7 @@ export class Boolean {
     */
     static encrypt(client_key, message) {
         _assertClass(client_key, BooleanClientKey);
-        const ret = wasm.boolean_encrypt(client_key.ptr, message);
+        const ret = wasm.boolean_encrypt(client_key.__wbg_ptr, message);
         return BooleanCiphertext.__wrap(ret);
     }
     /**
@@ -243,7 +245,7 @@ export class Boolean {
     */
     static encrypt_compressed(client_key, message) {
         _assertClass(client_key, BooleanClientKey);
-        const ret = wasm.boolean_encrypt_compressed(client_key.ptr, message);
+        const ret = wasm.boolean_encrypt_compressed(client_key.__wbg_ptr, message);
         return BooleanCompressedCiphertext.__wrap(ret);
     }
     /**
@@ -252,7 +254,7 @@ export class Boolean {
     */
     static decompress_ciphertext(compressed_ciphertext) {
         _assertClass(compressed_ciphertext, BooleanCompressedCiphertext);
-        const ret = wasm.boolean_decompress_ciphertext(compressed_ciphertext.ptr);
+        const ret = wasm.boolean_decompress_ciphertext(compressed_ciphertext.__wbg_ptr);
         return BooleanCiphertext.__wrap(ret);
     }
     /**
@@ -262,7 +264,7 @@ export class Boolean {
     */
     static encrypt_with_public_key(public_key, message) {
         _assertClass(public_key, BooleanPublicKey);
-        const ret = wasm.boolean_encrypt_with_public_key(public_key.ptr, message);
+        const ret = wasm.boolean_encrypt_with_public_key(public_key.__wbg_ptr, message);
         return BooleanCiphertext.__wrap(ret);
     }
     /**
@@ -270,7 +272,7 @@ export class Boolean {
     * @returns {BooleanCiphertext}
     */
     trivial_encrypt(message) {
-        const ret = wasm.boolean_trivial_encrypt(this.ptr, message);
+        const ret = wasm.boolean_trivial_encrypt(this.__wbg_ptr, message);
         return BooleanCiphertext.__wrap(ret);
     }
     /**
@@ -281,7 +283,7 @@ export class Boolean {
     static decrypt(client_key, ct) {
         _assertClass(client_key, BooleanClientKey);
         _assertClass(ct, BooleanCiphertext);
-        const ret = wasm.boolean_decrypt(client_key.ptr, ct.ptr);
+        const ret = wasm.boolean_decrypt(client_key.__wbg_ptr, ct.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -292,7 +294,7 @@ export class Boolean {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(ciphertext, BooleanCiphertext);
-            wasm.boolean_serialize_ciphertext(retptr, ciphertext.ptr);
+            wasm.boolean_serialize_ciphertext(retptr, ciphertext.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -300,9 +302,9 @@ export class Boolean {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -336,7 +338,7 @@ export class Boolean {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(ciphertext, BooleanCompressedCiphertext);
-            wasm.boolean_serialize_compressed_ciphertext(retptr, ciphertext.ptr);
+            wasm.boolean_serialize_compressed_ciphertext(retptr, ciphertext.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -344,9 +346,9 @@ export class Boolean {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -380,7 +382,7 @@ export class Boolean {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(client_key, BooleanClientKey);
-            wasm.boolean_serialize_client_key(retptr, client_key.ptr);
+            wasm.boolean_serialize_client_key(retptr, client_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -388,9 +390,9 @@ export class Boolean {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -424,7 +426,7 @@ export class Boolean {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(public_key, BooleanPublicKey);
-            wasm.boolean_serialize_public_key(retptr, public_key.ptr);
+            wasm.boolean_serialize_public_key(retptr, public_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -432,9 +434,9 @@ export class Boolean {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -468,7 +470,7 @@ export class Boolean {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(server_key, BooleanCompressedServerKey);
-            wasm.boolean_serialize_compressed_server_key(retptr, server_key.ptr);
+            wasm.boolean_serialize_compressed_server_key(retptr, server_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -476,9 +478,9 @@ export class Boolean {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -510,15 +512,16 @@ export class Boolean {
 export class BooleanCiphertext {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(BooleanCiphertext.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -533,15 +536,16 @@ export class BooleanCiphertext {
 export class BooleanClientKey {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(BooleanClientKey.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -556,15 +560,16 @@ export class BooleanClientKey {
 export class BooleanCompressedCiphertext {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(BooleanCompressedCiphertext.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -579,15 +584,16 @@ export class BooleanCompressedCiphertext {
 export class BooleanCompressedServerKey {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(BooleanCompressedServerKey.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -602,15 +608,16 @@ export class BooleanCompressedServerKey {
 export class BooleanParameters {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(BooleanParameters.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -625,15 +632,16 @@ export class BooleanParameters {
 export class BooleanPublicKey {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(BooleanPublicKey.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -648,8 +656,8 @@ export class BooleanPublicKey {
 export class Shortint {
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -732,7 +740,7 @@ export class Shortint {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(parameters, ShortintParameters);
-            wasm.shortint_new_client_key_from_seed_and_parameters(retptr, seed_high_bytes, seed_low_bytes, parameters.ptr);
+            wasm.shortint_new_client_key_from_seed_and_parameters(retptr, seed_high_bytes, seed_low_bytes, parameters.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -750,7 +758,7 @@ export class Shortint {
     */
     static new_client_key(parameters) {
         _assertClass(parameters, ShortintParameters);
-        const ret = wasm.shortint_new_client_key(parameters.ptr);
+        const ret = wasm.shortint_new_client_key(parameters.__wbg_ptr);
         return ShortintClientKey.__wrap(ret);
     }
     /**
@@ -759,7 +767,7 @@ export class Shortint {
     */
     static new_public_key(client_key) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_new_public_key(client_key.ptr);
+        const ret = wasm.shortint_new_public_key(client_key.__wbg_ptr);
         return ShortintPublicKey.__wrap(ret);
     }
     /**
@@ -768,7 +776,7 @@ export class Shortint {
     */
     static new_public_key_small(client_key) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_new_public_key_small(client_key.ptr);
+        const ret = wasm.shortint_new_public_key_small(client_key.__wbg_ptr);
         return ShortintPublicKey.__wrap(ret);
     }
     /**
@@ -777,7 +785,7 @@ export class Shortint {
     */
     static new_compressed_public_key(client_key) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_new_compressed_public_key(client_key.ptr);
+        const ret = wasm.shortint_new_compressed_public_key(client_key.__wbg_ptr);
         return ShortintCompressedPublicKey.__wrap(ret);
     }
     /**
@@ -786,7 +794,7 @@ export class Shortint {
     */
     static new_compressed_public_key_small(client_key) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_new_compressed_public_key_small(client_key.ptr);
+        const ret = wasm.shortint_new_compressed_public_key_small(client_key.__wbg_ptr);
         return ShortintCompressedPublicKey.__wrap(ret);
     }
     /**
@@ -795,7 +803,7 @@ export class Shortint {
     */
     static new_compressed_server_key(client_key) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_new_compressed_server_key(client_key.ptr);
+        const ret = wasm.shortint_new_compressed_server_key(client_key.__wbg_ptr);
         return ShortintCompressedServerKey.__wrap(ret);
     }
     /**
@@ -805,7 +813,7 @@ export class Shortint {
     */
     static encrypt(client_key, message) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_encrypt(client_key.ptr, message);
+        const ret = wasm.shortint_encrypt(client_key.__wbg_ptr, message);
         return ShortintCiphertext.__wrap(ret);
     }
     /**
@@ -815,7 +823,7 @@ export class Shortint {
     */
     static encrypt_small(client_key, message) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_encrypt_small(client_key.ptr, message);
+        const ret = wasm.shortint_encrypt_small(client_key.__wbg_ptr, message);
         return ShortintCiphertext.__wrap(ret);
     }
     /**
@@ -825,7 +833,7 @@ export class Shortint {
     */
     static encrypt_compressed(client_key, message) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_encrypt_compressed(client_key.ptr, message);
+        const ret = wasm.shortint_encrypt_compressed(client_key.__wbg_ptr, message);
         return ShortintCompressedCiphertext.__wrap(ret);
     }
     /**
@@ -835,7 +843,7 @@ export class Shortint {
     */
     static encrypt_compressed_small(client_key, message) {
         _assertClass(client_key, ShortintClientKey);
-        const ret = wasm.shortint_encrypt_compressed_small(client_key.ptr, message);
+        const ret = wasm.shortint_encrypt_compressed_small(client_key.__wbg_ptr, message);
         return ShortintCompressedCiphertext.__wrap(ret);
     }
     /**
@@ -844,7 +852,7 @@ export class Shortint {
     */
     static decompress_ciphertext(compressed_ciphertext) {
         _assertClass(compressed_ciphertext, ShortintCompressedCiphertext);
-        const ret = wasm.shortint_decompress_ciphertext(compressed_ciphertext.ptr);
+        const ret = wasm.shortint_decompress_ciphertext(compressed_ciphertext.__wbg_ptr);
         return ShortintCiphertext.__wrap(ret);
     }
     /**
@@ -854,7 +862,7 @@ export class Shortint {
     */
     static encrypt_with_public_key(public_key, message) {
         _assertClass(public_key, ShortintPublicKey);
-        const ret = wasm.shortint_encrypt_with_public_key(public_key.ptr, message);
+        const ret = wasm.shortint_encrypt_with_public_key(public_key.__wbg_ptr, message);
         return ShortintCiphertext.__wrap(ret);
     }
     /**
@@ -864,7 +872,7 @@ export class Shortint {
     */
     static encrypt_with_compressed_public_key(public_key, message) {
         _assertClass(public_key, ShortintCompressedPublicKey);
-        const ret = wasm.shortint_encrypt_with_compressed_public_key(public_key.ptr, message);
+        const ret = wasm.shortint_encrypt_with_compressed_public_key(public_key.__wbg_ptr, message);
         return ShortintCiphertext.__wrap(ret);
     }
     /**
@@ -875,7 +883,7 @@ export class Shortint {
     static decrypt(client_key, ct) {
         _assertClass(client_key, ShortintClientKey);
         _assertClass(ct, ShortintCiphertext);
-        const ret = wasm.shortint_decrypt(client_key.ptr, ct.ptr);
+        const ret = wasm.shortint_decrypt(client_key.__wbg_ptr, ct.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -886,7 +894,7 @@ export class Shortint {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(ciphertext, ShortintCiphertext);
-            wasm.shortint_serialize_ciphertext(retptr, ciphertext.ptr);
+            wasm.shortint_serialize_ciphertext(retptr, ciphertext.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -894,9 +902,9 @@ export class Shortint {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -930,7 +938,7 @@ export class Shortint {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(ciphertext, ShortintCompressedCiphertext);
-            wasm.shortint_serialize_compressed_ciphertext(retptr, ciphertext.ptr);
+            wasm.shortint_serialize_compressed_ciphertext(retptr, ciphertext.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -938,9 +946,9 @@ export class Shortint {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -974,7 +982,7 @@ export class Shortint {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(client_key, ShortintClientKey);
-            wasm.shortint_serialize_client_key(retptr, client_key.ptr);
+            wasm.shortint_serialize_client_key(retptr, client_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -982,9 +990,9 @@ export class Shortint {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1018,7 +1026,7 @@ export class Shortint {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(public_key, ShortintPublicKey);
-            wasm.shortint_serialize_public_key(retptr, public_key.ptr);
+            wasm.shortint_serialize_public_key(retptr, public_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1026,9 +1034,9 @@ export class Shortint {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1062,7 +1070,7 @@ export class Shortint {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(public_key, ShortintCompressedPublicKey);
-            wasm.shortint_serialize_compressed_public_key(retptr, public_key.ptr);
+            wasm.shortint_serialize_compressed_public_key(retptr, public_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1070,9 +1078,9 @@ export class Shortint {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1106,7 +1114,7 @@ export class Shortint {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(server_key, ShortintCompressedServerKey);
-            wasm.shortint_serialize_compressed_server_key(retptr, server_key.ptr);
+            wasm.shortint_serialize_compressed_server_key(retptr, server_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1114,9 +1122,9 @@ export class Shortint {
             if (r3) {
                 throw takeObject(r2);
             }
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1148,15 +1156,16 @@ export class Shortint {
 export class ShortintCiphertext {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ShortintCiphertext.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -1171,15 +1180,16 @@ export class ShortintCiphertext {
 export class ShortintClientKey {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ShortintClientKey.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -1194,15 +1204,16 @@ export class ShortintClientKey {
 export class ShortintCompressedCiphertext {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ShortintCompressedCiphertext.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -1217,15 +1228,16 @@ export class ShortintCompressedCiphertext {
 export class ShortintCompressedPublicKey {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ShortintCompressedPublicKey.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -1240,15 +1252,16 @@ export class ShortintCompressedPublicKey {
 export class ShortintCompressedServerKey {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ShortintCompressedServerKey.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -1263,15 +1276,16 @@ export class ShortintCompressedServerKey {
 export class ShortintParameters {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ShortintParameters.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -1286,15 +1300,16 @@ export class ShortintParameters {
 export class ShortintPublicKey {
 
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ShortintPublicKey.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
 
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -1305,7 +1320,7 @@ export class ShortintPublicKey {
     }
 }
 
-async function load(module, imports) {
+async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
@@ -1336,7 +1351,7 @@ async function load(module, imports) {
     }
 }
 
-function getImports() {
+function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
     imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
@@ -1349,22 +1364,26 @@ function getImports() {
     };
     imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
-        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
     imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
         try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
             console.error(getStringFromWasm0(arg0, arg1));
         } finally {
-            wasm.__wbindgen_free(arg0, arg1);
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_crypto_70a96de3b6b73dac = function(arg0) {
+    imports.wbg.__wbg_crypto_c48a774b022d20ac = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
     };
@@ -1373,15 +1392,15 @@ function getImports() {
         const ret = typeof(val) === 'object' && val !== null;
         return ret;
     };
-    imports.wbg.__wbg_process_dd1577445152112e = function(arg0) {
+    imports.wbg.__wbg_process_298734cf255a885d = function(arg0) {
         const ret = getObject(arg0).process;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_versions_58036bec3add9e6f = function(arg0) {
+    imports.wbg.__wbg_versions_e2e78e134e3e5d01 = function(arg0) {
         const ret = getObject(arg0).versions;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_node_6a9d28205ed5b0d8 = function(arg0) {
+    imports.wbg.__wbg_node_1cd7a5d853dbea79 = function(arg0) {
         const ret = getObject(arg0).node;
         return addHeapObject(ret);
     };
@@ -1389,11 +1408,11 @@ function getImports() {
         const ret = typeof(getObject(arg0)) === 'string';
         return ret;
     };
-    imports.wbg.__wbg_msCrypto_adbc770ec9eca9c7 = function(arg0) {
+    imports.wbg.__wbg_msCrypto_bcb970640f50a1e8 = function(arg0) {
         const ret = getObject(arg0).msCrypto;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_require_f05d779769764e82 = function() { return handleError(function () {
+    imports.wbg.__wbg_require_8f08ceecec0f4fee = function() { return handleError(function () {
         const ret = module.require;
         return addHeapObject(ret);
     }, arguments) };
@@ -1405,17 +1424,17 @@ function getImports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_getRandomValues_3774744e221a22ad = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_getRandomValues_37fa2ca9e4e07fab = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).getRandomValues(getObject(arg1));
     }, arguments) };
-    imports.wbg.__wbg_randomFillSync_e950366c42764a07 = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_randomFillSync_dc1e9a60c158336d = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).randomFillSync(takeObject(arg1));
     }, arguments) };
-    imports.wbg.__wbg_newnoargs_2b8b6bd7753c76ba = function(arg0, arg1) {
+    imports.wbg.__wbg_newnoargs_581967eacc0e2604 = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_95d1ea488d03e4e8 = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_call_cb65541d95d71282 = function() { return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).call(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
@@ -1423,19 +1442,19 @@ function getImports() {
         const ret = getObject(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_self_e7c1f827057f6584 = function() { return handleError(function () {
+    imports.wbg.__wbg_self_1ff1d729e9aae938 = function() { return handleError(function () {
         const ret = self.self;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_window_a09ec664e14b1b81 = function() { return handleError(function () {
+    imports.wbg.__wbg_window_5f4faef6c12b79ec = function() { return handleError(function () {
         const ret = window.window;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_globalThis_87cbb8506fecf3a9 = function() { return handleError(function () {
+    imports.wbg.__wbg_globalThis_1d39714405582d3c = function() { return handleError(function () {
         const ret = globalThis.globalThis;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_global_c85a9259e621f3db = function() { return handleError(function () {
+    imports.wbg.__wbg_global_651f05c6a0944d1c = function() { return handleError(function () {
         const ret = global.global;
         return addHeapObject(ret);
     }, arguments) };
@@ -1443,30 +1462,30 @@ function getImports() {
         const ret = getObject(arg0) === undefined;
         return ret;
     };
-    imports.wbg.__wbg_call_9495de66fdbe016b = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_call_01734de55d61e11d = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_buffer_cf65c07de34b9a08 = function(arg0) {
+    imports.wbg.__wbg_buffer_085ec1f694018c4f = function(arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_newwithbyteoffsetandlength_6da8e527659b86aa = function(arg0, arg1, arg2) {
         const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_537b7341ce90bb31 = function(arg0) {
+    imports.wbg.__wbg_new_8125e318e6245eed = function(arg0) {
         const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_17499e8aa4003ebd = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_5cf90238115182c3 = function(arg0, arg1, arg2) {
         getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     };
-    imports.wbg.__wbg_newwithlength_b56c882b57805732 = function(arg0) {
+    imports.wbg.__wbg_newwithlength_e5d69174d6984cd7 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_subarray_7526649b91a252a6 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_subarray_13db269f57aa838d = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
@@ -1481,13 +1500,13 @@ function getImports() {
     return imports;
 }
 
-function initMemory(imports, maybe_memory) {
+function __wbg_init_memory(imports, maybe_memory) {
 
 }
 
-function finalizeInit(instance, module) {
+function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
-    init.__wbindgen_wasm_module = module;
+    __wbg_init.__wbindgen_wasm_module = module;
     cachedInt32Memory0 = null;
     cachedUint8Memory0 = null;
 
@@ -1496,9 +1515,11 @@ function finalizeInit(instance, module) {
 }
 
 function initSync(module) {
-    const imports = getImports();
+    if (wasm !== undefined) return wasm;
 
-    initMemory(imports);
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
 
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
@@ -1506,25 +1527,27 @@ function initSync(module) {
 
     const instance = new WebAssembly.Instance(module, imports);
 
-    return finalizeInit(instance, module);
+    return __wbg_finalize_init(instance, module);
 }
 
-async function init(input) {
+async function __wbg_init(input) {
+    if (wasm !== undefined) return wasm;
+
     if (typeof input === 'undefined') {
         input = new URL('tfhe_bg.wasm', import.meta.url);
     }
-    const imports = getImports();
+    const imports = __wbg_get_imports();
 
     if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
         input = fetch(input);
     }
 
-    initMemory(imports);
+    __wbg_init_memory(imports);
 
-    const { instance, module } = await load(await input, imports);
+    const { instance, module } = await __wbg_load(await input, imports);
 
-    return finalizeInit(instance, module);
+    return __wbg_finalize_init(instance, module);
 }
 
 export { initSync }
-export default init;
+export default __wbg_init;