shamir | Shamir Secret Sharing Scheme in single page | Frontend Framework library

This is exactly what the expect_before and expect_after commands do. In this case it doesn't matter which one you use:

If your k is not too large you can keep adding random values to a set until it reaches size k:

This should do the trick (or at least be a start):

Rebuild the (static) library for x64.

The symbol in your library is called _hello and not hello as one would expect for a x64-build (your extension is built for 64bit as can be seen in the logs).

On x64, MSVC doesn't mangle names when compiling as C-code so the resulting symbol is simple - hello, but it does mangle C-names on x86 (here documentation, here an example on godbolt.org):

• __cdecl-calling convention (default for x86 if no special compile-flags are used) adds prefix _ to the name which would lead to the symbol being called _hello.
• __stdcall-calling convention (if compiled with /Gz or the calling convention is explicitly specified, i.e. void __stdcall hello(char *)) adds prefix _ to the name and suffix @ with the number of bytes in the parameter list, i.e. it would lead to _hello@4.

Thus, it becomes clear, that your library is built in 32bit and thus cannot be linked to a 64bit-dll.

Were the library a dll, the symbol's names would be slightly different. Calling

Why does validate1 work though? Why does using previous state cause it to work?

This is a limitation in how de-structured rest objects are types. For a long type TS did not even allow de-structuring of generic type parameters. In version 3.2 the ability to use rest variables with generic type parameters was added (PR) but the rest variable is typed as Pick>, or equivalently Omit. The use of the conditional type Exclude will work fine for the consumers of this function if T is fully resolved (ie not a generic type parameter) but inside the function, typescript can't really reason about the type that contains the Exclude. This is just a limitation of how conditional types work. You are excluding from T, but since T is not known, ts will defer the evaluation of the conditional type. This means that T will not be assignable to Pick>

We can use a type assertion as you have, and this is what I have recommended in the past. Type assertions should be avoided, but they are there to help out when you (ie the developer) have more information than the compiler. This is one of those cases.

For a better workaround we could use a trick. While Omit is not assignable to T it is assignable to itself. So we can type the component props as Props | Omit. Since Props and Omit are essentially the same type, this will not matter much, but it will let the compiler assign the rest object to the component props.

IMPORTANT:

I made another version with some improvements: Version 2

I made my own Class to make more dynamic the interaction with Object/Dynamic/ExpandoObjects using C# Net Core

CHECK THE CODE HERE

Here is the full code:

As you may know, Python's built-in int type can handle arbitrarily large integers, but the float type which has limited precision. The only part of your code which deals with numbers that aren't ints seems to be this function:

Note that I want all (2,3,4 and 5) keys need to decrypt.
found Shamir's Secret Sharing I believe it could solve my problem

Shamir's Secret Sharing could as well solve your problem, but it can do more (recover the decryption key having only a subset of the keys). It's doing that in expense of complexity and performance. If you consider any future option to use the shares (subsets), imho the link from Kelalaka is maybe the best you can get for your case.

If you need all the keys for decryption, you can simplify your code to derive the encryption key from N random keys (faster and simpler) using any secure operation (XOR, hash, remainterless addition, ..). I'd prefer using simple XOR as it is a commutative operation, fast and supported out of box

example:

• generate N random decryption keys
• XOR all the decryption keys to get the encryption key

Note. Your first link (encryption/decryption with multiple keys) is using GPG to encrypt a single encryption key for multiple recipients (public keys) separately, so any of the recipients would be able to recover the encryption key