Trait snarkvm_wasm::AllocGadget

pub trait AllocGadget<V, F> where
    F: Field,
    V: ?Sized, {
    fn alloc<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError>
    where
        Fn: FnOnce() -> Result<T, SynthesisError>,
        CS: ConstraintSystem<F>,
        T: Borrow<V>;
    fn alloc_input<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError>
    where
        Fn: FnOnce() -> Result<T, SynthesisError>,
        CS: ConstraintSystem<F>,
        T: Borrow<V>;

    fn alloc_constant<Fn, T, CS>(
        _cs: CS, 
        _f: Fn
    ) -> Result<Self, SynthesisError>
    where
        Fn: FnOnce() -> Result<T, SynthesisError>,
        CS: ConstraintSystem<F>,
        T: Borrow<V>,
    { ... }
    fn alloc_checked<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError>
    where
        Fn: FnOnce() -> Result<T, SynthesisError>,
        CS: ConstraintSystem<F>,
        T: Borrow<V>,
    { ... }
    fn alloc_input_checked<Fn, T, CS>(
        cs: CS, 
        f: Fn
    ) -> Result<Self, SynthesisError>
    where
        Fn: FnOnce() -> Result<T, SynthesisError>,
        CS: ConstraintSystem<F>,
        T: Borrow<V>,
    { ... }
}

Required methods

fn alloc<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

fn alloc_input<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

Provided methods

fn alloc_constant<Fn, T, CS>(_cs: CS, _f: Fn) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

fn alloc_checked<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

fn alloc_input_checked<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

Implementations on Foreign Types

impl<I, F, A> AllocGadget<[I], F> for Vec<A, Global> where
    A: AllocGadget<I, F>,
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, f: Fn) -> Result<Vec<A, Global>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[I]>, 

pub fn alloc_checked<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<Vec<A, Global>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[I]>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<Vec<A, Global>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[I]>, 

pub fn alloc_input_checked<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<Vec<A, Global>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[I]>, 

Implementors

impl<C, H, CGadget, HGadget, F> AllocGadget<CommitmentMerklePath<C, H>, F> for CommitmentMerklePathGadget<C, H, CGadget, HGadget, F> where
    C: CommitmentScheme,
    H: CRH,
    F: Field,
    CGadget: CommitmentGadget<C, F>,
    HGadget: CRHGadget<H, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<CommitmentMerklePathGadget<C, H, CGadget, HGadget, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<CommitmentMerklePath<C, H>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<CommitmentMerklePathGadget<C, H, CGadget, HGadget, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<CommitmentMerklePath<C, H>>, 

impl<F> AllocGadget<<Int8 as Integer>::IntegerType, F> for Int8 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<Int8, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int8 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Int8, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int8 as Integer>::IntegerType>, 

impl<F> AllocGadget<<Int16 as Integer>::IntegerType, F> for Int16 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<Int16, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int16 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Int16, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int16 as Integer>::IntegerType>, 

impl<F> AllocGadget<<Int32 as Integer>::IntegerType, F> for Int32 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<Int32, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int32 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Int32, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int32 as Integer>::IntegerType>, 

impl<F> AllocGadget<<Int64 as Integer>::IntegerType, F> for Int64 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<Int64, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int64 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Int64, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int64 as Integer>::IntegerType>, 

impl<F> AllocGadget<<Int128 as Integer>::IntegerType, F> for Int128 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<Int128, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int128 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Int128, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<Int128 as Integer>::IntegerType>, 

impl<F> AllocGadget<<UInt8 as Integer>::IntegerType, F> for UInt8 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<UInt8, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt8 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<UInt8, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt8 as Integer>::IntegerType>, 

impl<F> AllocGadget<<UInt16 as Integer>::IntegerType, F> for UInt16 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<UInt16, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt16 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<UInt16, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt16 as Integer>::IntegerType>, 

impl<F> AllocGadget<<UInt32 as Integer>::IntegerType, F> for UInt32 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<UInt32, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt32 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<UInt32, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt32 as Integer>::IntegerType>, 

impl<F> AllocGadget<<UInt64 as Integer>::IntegerType, F> for UInt64 where
    F: Field, 

pub fn alloc<Fn, T, CS>(cs: CS, value_gen: Fn) -> Result<UInt64, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt64 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<UInt64, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt64 as Integer>::IntegerType>, 

impl<F> AllocGadget<<UInt128 as Integer>::IntegerType, F> for UInt128 where
    F: Field, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<UInt128, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt128 as Integer>::IntegerType>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<UInt128, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<UInt128 as Integer>::IntegerType>, 

impl<F> AllocGadget<[u8; 32], F> for Blake2sRandomnessGadget where
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Blake2sRandomnessGadget, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[u8; 32]>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Blake2sRandomnessGadget, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[u8; 32]>, 

impl<F> AllocGadget<[u8; 32], F> for Blake2sOutputGadget where
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Blake2sOutputGadget, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[u8; 32]>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Blake2sOutputGadget, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<[u8; 32]>, 

impl<F> AllocGadget<bool, F> for Boolean where
    F: Field, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Boolean, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<bool>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Boolean, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<bool>, 

impl<F> AllocGadget<bool, F> for AllocatedBit where
    F: Field, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AllocatedBit, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<bool>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AllocatedBit, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<bool>, 

impl<F> AllocGadget<(), F> for Blake2sParametersGadget where
    F: Field, 

pub fn alloc<Fn, T, CS>(
    CS,
    Fn
) -> Result<Blake2sParametersGadget, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<()>, 

pub fn alloc_input<Fn, T, CS>(
    CS,
    Fn
) -> Result<Blake2sParametersGadget, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<()>, 

impl<F> AllocGadget<F, F> for FpGadget<F> where
    F: PrimeField, 

pub fn alloc_constant<FN, T, CS>(
    _cs: CS,
    value_gen: FN
) -> Result<FpGadget<F>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<F>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<FpGadget<F>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<F>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<FpGadget<F>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<F>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

impl<F> AllocGadget<F, F> for AllocatedFp<F> where
    F: PrimeField, 

pub fn alloc_constant<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AllocatedFp<F>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<F>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AllocatedFp<F>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<F>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AllocatedFp<F>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<F>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

impl<F, CF> AllocGadget<Vec<F, Global>, CF> for NonNativeFieldInputVar<F, CF> where
    F: PrimeField,
    CF: PrimeField, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<NonNativeFieldInputVar<F, CF>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<CF>,
    T: Borrow<Vec<F, Global>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<NonNativeFieldInputVar<F, CF>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<CF>,
    T: Borrow<Vec<F, Global>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<NonNativeFieldInputVar<F, CF>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<CF>,
    T: Borrow<Vec<F, Global>>, 

impl<F, CF> AllocGadget<Vec<F, Global>, CF> for BooleanInputGadget<F, CF> where
    F: PrimeField,
    CF: PrimeField, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<BooleanInputGadget<F, CF>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<CF>,
    T: Borrow<Vec<F, Global>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<BooleanInputGadget<F, CF>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<CF>,
    T: Borrow<Vec<F, Global>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<BooleanInputGadget<F, CF>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<CF>,
    T: Borrow<Vec<F, Global>>, 

impl<G, F> AllocGadget<<G as Group>::ScalarField, F> for PedersenRandomnessGadget<G> where
    G: Group,
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PedersenRandomnessGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<G as Group>::ScalarField>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PedersenRandomnessGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<G as Group>::ScalarField>, 

impl<G, F> AllocGadget<<G as Group>::ScalarField, F> for GroupEncryptionPrivateKeyGadget<G> where
    G: Group,
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionPrivateKeyGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<G as Group>::ScalarField>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionPrivateKeyGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<G as Group>::ScalarField>, 

impl<G, F> AllocGadget<<G as Group>::ScalarField, F> for GroupEncryptionRandomnessGadget<G> where
    G: Group,
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionRandomnessGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<G as Group>::ScalarField>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionRandomnessGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<G as Group>::ScalarField>, 

impl<G, F> AllocGadget<Vec<<G as Group>::ScalarField, Global>, F> for GroupEncryptionBlindingExponentsGadget<G> where
    G: Group,
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionBlindingExponentsGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Vec<<G as Group>::ScalarField, Global>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionBlindingExponentsGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Vec<<G as Group>::ScalarField, Global>>, 

impl<G, F> AllocGadget<GroupEncryptionParameters<G>, F> for GroupEncryptionParametersGadget<G> where
    G: Group + ProjectiveCurve,
    F: Field, 

pub fn alloc<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionParametersGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupEncryptionParameters<G>>, 

pub fn alloc_input<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<GroupEncryptionParametersGadget<G>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupEncryptionParameters<G>>, 

impl<G, F, D> AllocGadget<SchnorrParameters<G, D>, F> for SchnorrParametersGadget<G, F, D> where
    G: Group,
    D: Digest,
    F: Field, 

pub fn alloc<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<SchnorrParametersGadget<G, F, D>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<SchnorrParameters<G, D>>, 

pub fn alloc_input<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<SchnorrParametersGadget<G, F, D>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<SchnorrParameters<G, D>>, 

impl<G, F, GG> AllocGadget<Vec<G, Global>, F> for GroupEncryptionCiphertextGadget<G, F, GG> where
    G: Group + ProjectiveCurve,
    F: Field,
    GG: CompressedGroupGadget<G, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<GroupEncryptionCiphertextGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Vec<G, Global>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<GroupEncryptionCiphertextGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Vec<G, Global>>, 

impl<G, F, GG> AllocGadget<Vec<G, Global>, F> for GroupEncryptionPlaintextGadget<G, F, GG> where
    G: Group + ProjectiveCurve,
    F: Field,
    GG: GroupGadget<G, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<GroupEncryptionPlaintextGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Vec<G, Global>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<GroupEncryptionPlaintextGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Vec<G, Global>>, 

impl<G, F, GG> AllocGadget<GroupEncryptionPublicKey<G>, F> for GroupEncryptionPublicKeyGadget<G, F, GG> where
    G: Group + ProjectiveCurve,
    F: Field,
    GG: GroupGadget<G, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<GroupEncryptionPublicKeyGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupEncryptionPublicKey<G>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<GroupEncryptionPublicKeyGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupEncryptionPublicKey<G>>, 

impl<G, F, GG> AllocGadget<SchnorrPublicKey<G>, F> for SchnorrPublicKeyGadget<G, F, GG> where
    G: Group + CanonicalSerialize + CanonicalDeserialize,
    F: Field,
    GG: GroupGadget<G, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<SchnorrPublicKeyGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<SchnorrPublicKey<G>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<SchnorrPublicKeyGadget<G, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<SchnorrPublicKey<G>>, 

impl<G, S, F> AllocGadget<PedersenCommitmentParameters<G, S>, F> for PedersenCommitmentParametersGadget<G, S, F> where
    G: Group,
    S: PedersenSize,
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<PedersenCommitmentParametersGadget<G, S, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<PedersenCommitmentParameters<G, S>>, 

pub fn alloc_input<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<PedersenCommitmentParametersGadget<G, S, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<PedersenCommitmentParameters<G, S>>, 

impl<G, S, F, GG> AllocGadget<PedersenCRHParameters<G, S>, F> for PedersenCRHParametersGadget<G, S, F, GG> where
    G: Group,
    S: PedersenSize,
    F: Field,
    GG: GroupGadget<G, F>, 

pub fn alloc<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<PedersenCRHParametersGadget<G, S, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<PedersenCRHParameters<G, S>>, 

pub fn alloc_input<Fn, T, CS>(
    _cs: CS,
    value_gen: Fn
) -> Result<PedersenCRHParametersGadget<G, S, F, GG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<PedersenCRHParameters<G, S>>, 

impl<P> AllocGadget<G2Prepared<P>, <P as Bls12Parameters>::Fp> for G2PreparedGadget<P> where
    P: Bls12Parameters, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<G2PreparedGadget<P>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<P as Bls12Parameters>::Fp>,
    T: Borrow<G2Prepared<P>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<G2PreparedGadget<P>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<P as Bls12Parameters>::Fp>,
    T: Borrow<G2Prepared<P>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<G2PreparedGadget<P>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<P as Bls12Parameters>::Fp>,
    T: Borrow<G2Prepared<P>>, 

impl<P, F> AllocGadget<<P as ModelParameters>::BaseField, F> for Elligator2FieldGadget<P, F> where
    P: MontgomeryModelParameters,
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Elligator2FieldGadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<P as ModelParameters>::BaseField>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Elligator2FieldGadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<<P as ModelParameters>::BaseField>, 

impl<P, F> AllocGadget<Fp6<P>, F> for Fp6Gadget<P, F> where
    P: Fp6Parameters,
    F: PrimeField,
    <P as Fp6Parameters>::Fp2Params: Fp2Parameters,
    <<P as Fp6Parameters>::Fp2Params as Fp2Parameters>::Fp == F, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Fp6Gadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Fp6<P>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Fp6Gadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Fp6<P>>, 

impl<P, F> AllocGadget<Fp2<P>, F> for Fp2Gadget<P, F> where
    P: Fp2Parameters<Fp = F>,
    F: PrimeField, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Fp2Gadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Fp2<P>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Fp2Gadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Fp2<P>>, 

impl<P, F> AllocGadget<Fp12<P>, F> for Fp12Gadget<P, F> where
    P: Fp12Parameters,
    F: PrimeField,
    <<P as Fp12Parameters>::Fp6Params as Fp6Parameters>::Fp2Params: Fp2Parameters,
    <<<P as Fp12Parameters>::Fp6Params as Fp6Parameters>::Fp2Params as Fp2Parameters>::Fp == F, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Fp12Gadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Fp12<P>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Fp12Gadget<P, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Fp12<P>>, 

impl<P, F, FG> AllocGadget<GroupProjective<P>, F> for snarkvm_wasm::curves::templates::bls12::AffineGadget<P, F, FG> where
    P: SWModelParameters,
    F: PrimeField,
    FG: FieldGadget<<P as ModelParameters>::BaseField, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupProjective<P>>, 

pub fn alloc_checked<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupProjective<P>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupProjective<P>>, 

impl<P, F, FG> AllocGadget<GroupAffine<P>, F> for snarkvm_wasm::curves::templates::twisted_edwards::AffineGadget<P, F, FG> where
    P: TEModelParameters,
    F: Field,
    FG: FieldGadget<<P as ModelParameters>::BaseField, F>,
    AffineGadget<P, F, FG>: GroupGadget<GroupAffine<P>, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupAffine<P>>, 

pub fn alloc_checked<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupAffine<P>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<GroupAffine<P>>, 

impl<P, F, FG> AllocGadget<GroupProjective<P>, F> for snarkvm_wasm::curves::templates::twisted_edwards::AffineGadget<P, F, FG> where
    P: TEModelParameters,
    F: Field,
    FG: FieldGadget<<P as ModelParameters>::BaseField, F>,
    AffineGadget<P, F, FG>: GroupGadget<GroupProjective<P>, F>, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<GroupProjective<P>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_checked<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<GroupProjective<P>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AffineGadget<P, F, FG>, SynthesisError> where
    CS: ConstraintSystem<F>,
    T: Borrow<GroupProjective<P>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

impl<P, HGadget, F> AllocGadget<MerklePath<P>, F> for MerklePathGadget<P, HGadget, F> where
    P: MerkleParameters,
    F: Field,
    HGadget: CRHGadget<<P as MerkleParameters>::H, F>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<MerklePathGadget<P, HGadget, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<MerklePath<P>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<MerklePathGadget<P, HGadget, F>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<MerklePath<P>>, 

impl<Pairing, F, P> AllocGadget<Proof<Pairing>, F> for GM17ProofGadget<Pairing, F, P> where
    P: PairingGadget<Pairing, F>,
    F: Field,
    Pairing: PairingEngine, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GM17ProofGadget<Pairing, F, P>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Proof<Pairing>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GM17ProofGadget<Pairing, F, P>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<Proof<Pairing>>, 

impl<Pairing, F, P> AllocGadget<VerifyingKey<Pairing>, F> for GM17VerifyingKeyGadget<Pairing, F, P> where
    P: PairingGadget<Pairing, F>,
    F: Field,
    Pairing: PairingEngine, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GM17VerifyingKeyGadget<Pairing, F, P>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<VerifyingKey<Pairing>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<GM17VerifyingKeyGadget<Pairing, F, P>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<VerifyingKey<Pairing>>, 

impl<PairingE, ConstraintF, P> AllocGadget<Proof<PairingE>, ConstraintF> for ProofGadget<PairingE, ConstraintF, P> where
    P: PairingGadget<PairingE, ConstraintF>,
    PairingE: PairingEngine,
    ConstraintF: Field, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<ProofGadget<PairingE, ConstraintF, P>, SynthesisError> where
    CS: ConstraintSystem<ConstraintF>,
    T: Borrow<Proof<PairingE>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<ProofGadget<PairingE, ConstraintF, P>, SynthesisError> where
    CS: ConstraintSystem<ConstraintF>,
    T: Borrow<Proof<PairingE>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

impl<PairingE, ConstraintF, P> AllocGadget<VerifyingKey<PairingE>, ConstraintF> for VerifyingKeyGadget<PairingE, ConstraintF, P> where
    P: PairingGadget<PairingE, ConstraintF>,
    PairingE: PairingEngine,
    ConstraintF: Field, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<VerifyingKeyGadget<PairingE, ConstraintF, P>, SynthesisError> where
    CS: ConstraintSystem<ConstraintF>,
    T: Borrow<VerifyingKey<PairingE>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<VerifyingKeyGadget<PairingE, ConstraintF, P>, SynthesisError> where
    CS: ConstraintSystem<ConstraintF>,
    T: Borrow<VerifyingKey<PairingE>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

impl<TargetCurve, BaseCurve, PG> AllocGadget<Proof<TargetCurve>, <BaseCurve as PairingEngine>::Fr> for ProofVar<TargetCurve, BaseCurve, PG> where
    TargetCurve: PairingEngine,
    BaseCurve: PairingEngine,
    PG: PairingGadget<TargetCurve, <BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G1Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G2Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<ProofVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<Proof<TargetCurve>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<ProofVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<Proof<TargetCurve>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<ProofVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<Proof<TargetCurve>>, 

impl<TargetCurve, BaseCurve, PG> AllocGadget<Commitment<TargetCurve>, <BaseCurve as PairingEngine>::Fr> for CommitmentVar<TargetCurve, BaseCurve, PG> where
    TargetCurve: PairingEngine,
    BaseCurve: PairingEngine,
    PG: PairingGadget<TargetCurve, <BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G1Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G2Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<CommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<Commitment<TargetCurve>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<CommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<Commitment<TargetCurve>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<CommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<Commitment<TargetCurve>>, 

impl<TargetCurve, BaseCurve, PG> AllocGadget<PreparedCommitment<TargetCurve>, <BaseCurve as PairingEngine>::Fr> for PreparedCommitmentVar<TargetCurve, BaseCurve, PG> where
    TargetCurve: PairingEngine,
    BaseCurve: PairingEngine,
    PG: PairingGadget<TargetCurve, <BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G1Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G2Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PreparedCommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<PreparedCommitment<TargetCurve>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PreparedCommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<PreparedCommitment<TargetCurve>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PreparedCommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<PreparedCommitment<TargetCurve>>, 

impl<TargetCurve, BaseCurve, PG> AllocGadget<PreparedVerifierKey<TargetCurve>, <BaseCurve as PairingEngine>::Fr> for PreparedVerifierKeyVar<TargetCurve, BaseCurve, PG> where
    TargetCurve: PairingEngine,
    BaseCurve: PairingEngine,
    PG: PairingGadget<TargetCurve, <BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G1Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G2Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PreparedVerifierKeyVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<PreparedVerifierKey<TargetCurve>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PreparedVerifierKeyVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<PreparedVerifierKey<TargetCurve>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<PreparedVerifierKeyVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<PreparedVerifierKey<TargetCurve>>, 

impl<TargetCurve, BaseCurve, PG> AllocGadget<VerifierKey<TargetCurve>, <BaseCurve as PairingEngine>::Fr> for VerifierKeyVar<TargetCurve, BaseCurve, PG> where
    TargetCurve: PairingEngine,
    BaseCurve: PairingEngine,
    PG: PairingGadget<TargetCurve, <BaseCurve as PairingEngine>::Fr>, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<VerifierKeyVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<VerifierKey<TargetCurve>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<VerifierKeyVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<VerifierKey<TargetCurve>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<VerifierKeyVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<VerifierKey<TargetCurve>>, 

impl<TargetCurve, BaseCurve, PG> AllocGadget<BatchLCProof<<TargetCurve as PairingEngine>::Fr, MarlinKZG10<TargetCurve>>, <BaseCurve as PairingEngine>::Fr> for BatchLCProofVar<TargetCurve, BaseCurve, PG> where
    TargetCurve: PairingEngine,
    BaseCurve: PairingEngine,
    PG: PairingGadget<TargetCurve, <BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G1Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G2Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<BatchLCProofVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<BatchLCProof<<TargetCurve as PairingEngine>::Fr, MarlinKZG10<TargetCurve>>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<BatchLCProofVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<BatchLCProof<<TargetCurve as PairingEngine>::Fr, MarlinKZG10<TargetCurve>>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<BatchLCProofVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<BatchLCProof<<TargetCurve as PairingEngine>::Fr, MarlinKZG10<TargetCurve>>>, 

impl<TargetCurve, BaseCurve, PG> AllocGadget<LabeledCommitment<Commitment<TargetCurve>>, <BaseCurve as PairingEngine>::Fr> for LabeledCommitmentVar<TargetCurve, BaseCurve, PG> where
    TargetCurve: PairingEngine,
    BaseCurve: PairingEngine,
    PG: PairingGadget<TargetCurve, <BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G1Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>,
    <TargetCurve as PairingEngine>::G2Affine: ToConstraintField<<BaseCurve as PairingEngine>::Fr>, 

pub fn alloc_constant<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<LabeledCommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<LabeledCommitment<Commitment<TargetCurve>>>, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<LabeledCommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<LabeledCommitment<Commitment<TargetCurve>>>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<LabeledCommitmentVar<TargetCurve, BaseCurve, PG>, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<<BaseCurve as PairingEngine>::Fr>,
    T: Borrow<LabeledCommitment<Commitment<TargetCurve>>>, 

impl<TargetField, BaseField> AllocGadget<LinearCombination<TargetField>, BaseField> for LinearCombinationVar<TargetField, BaseField> where
    BaseField: PrimeField,
    TargetField: PrimeField, 

pub fn alloc_constant<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<LinearCombinationVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<LinearCombination<TargetField>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<LinearCombinationVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<LinearCombination<TargetField>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<LinearCombinationVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<LinearCombination<TargetField>>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

impl<TargetField, BaseField> AllocGadget<TargetField, BaseField> for NonNativeFieldVar<TargetField, BaseField> where
    BaseField: PrimeField,
    TargetField: PrimeField, 

pub fn alloc_constant<FN, T, CS>(
    _cs: CS,
    value_gen: FN
) -> Result<NonNativeFieldVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<TargetField>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<NonNativeFieldVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<TargetField>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<NonNativeFieldVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<TargetField>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

impl<TargetField, BaseField> AllocGadget<TargetField, BaseField> for AllocatedNonNativeFieldVar<TargetField, BaseField> where
    BaseField: PrimeField,
    TargetField: PrimeField, 

pub fn alloc_constant<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AllocatedNonNativeFieldVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<TargetField>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AllocatedNonNativeFieldVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<TargetField>,
    FN: FnOnce() -> Result<T, SynthesisError>, 

pub fn alloc_input<FN, T, CS>(
    cs: CS,
    value_gen: FN
) -> Result<AllocatedNonNativeFieldVar<TargetField, BaseField>, SynthesisError> where
    CS: ConstraintSystem<BaseField>,
    T: Borrow<TargetField>,
    FN: FnOnce() -> Result<T, SynthesisError>,