R/cpp11.R

In openfhe.R: R Interface to the 'OpenFHE' Fully Homomorphic Encryption Library

# Generated by cpp11: do not edit by hand

BinFHEContext__new <- function() {
  .Call(`_openfhe_R_BinFHEContext__new`)
}

BinFHEContext__GenerateBinFHEContext <- function(ctx_xp, paramset, method) {
  invisible(.Call(`_openfhe_R_BinFHEContext__GenerateBinFHEContext`, ctx_xp, paramset, method))
}

BinFHEContext__GenerateBinFHEContextArbFunc <- function(ctx_xp, paramset, arb_func, log_q, n, method, time_optimization) {
  invisible(.Call(`_openfhe_R_BinFHEContext__GenerateBinFHEContextArbFunc`, ctx_xp, paramset, arb_func, log_q, n, method, time_optimization))
}

BinFHEContext__GetMaxPlaintextSpace <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__GetMaxPlaintextSpace`, ctx_xp)
}

BinFHEContext__KeyGen <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__KeyGen`, ctx_xp)
}

BinFHEContext__BTKeyGen <- function(ctx_xp, sk_xp, keygen_mode, internal32) {
  invisible(.Call(`_openfhe_R_BinFHEContext__BTKeyGen`, ctx_xp, sk_xp, keygen_mode, internal32))
}

BinFHEContext__Encrypt <- function(ctx_xp, sk_xp, message, output, p) {
  .Call(`_openfhe_R_BinFHEContext__Encrypt`, ctx_xp, sk_xp, message, output, p)
}

BinFHEContext__EncryptWithMod <- function(ctx_xp, sk_xp, message, output, p, mod) {
  .Call(`_openfhe_R_BinFHEContext__EncryptWithMod`, ctx_xp, sk_xp, message, output, p, mod)
}

BinFHEContext__Decrypt <- function(ctx_xp, sk_xp, ct_xp, p) {
  .Call(`_openfhe_R_BinFHEContext__Decrypt`, ctx_xp, sk_xp, ct_xp, p)
}

BinFHEContext__EvalBinGate <- function(ctx_xp, gate, ct1_xp, ct2_xp, extended) {
  .Call(`_openfhe_R_BinFHEContext__EvalBinGate`, ctx_xp, gate, ct1_xp, ct2_xp, extended)
}

BinFHEContext__EvalBinGate__vec <- function(ctx_xp, gate, ct_list, extended) {
  .Call(`_openfhe_R_BinFHEContext__EvalBinGate__vec`, ctx_xp, gate, ct_list, extended)
}

BinFHEContext__EvalNOT <- function(ctx_xp, ct_xp) {
  .Call(`_openfhe_R_BinFHEContext__EvalNOT`, ctx_xp, ct_xp)
}

LWECiphertext__GetLength <- function(ct_xp) {
  .Call(`_openfhe_R_LWECiphertext__GetLength`, ct_xp)
}

BinFHEContext__EvalSign <- function(ctx_xp, ct_xp, scheme_switch) {
  .Call(`_openfhe_R_BinFHEContext__EvalSign`, ctx_xp, ct_xp, scheme_switch)
}

BinFHEContext__EvalFloor <- function(ctx_xp, ct_xp, roundbits) {
  .Call(`_openfhe_R_BinFHEContext__EvalFloor`, ctx_xp, ct_xp, roundbits)
}

BinFHEContext__EvalFunc <- function(ctx_xp, ct_xp, plaintext_lut) {
  .Call(`_openfhe_R_BinFHEContext__EvalFunc`, ctx_xp, ct_xp, plaintext_lut)
}

BinFHEContext__KeyGenN <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__KeyGenN`, ctx_xp)
}

BinFHEContext__KeyGenPair <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__KeyGenPair`, ctx_xp)
}

BinFHEContext__PubKeyGen <- function(ctx_xp, sk_xp) {
  .Call(`_openfhe_R_BinFHEContext__PubKeyGen`, ctx_xp, sk_xp)
}

BinFHEContext__KeySwitchGen <- function(ctx_xp, sk_xp, skn_xp) {
  .Call(`_openfhe_R_BinFHEContext__KeySwitchGen`, ctx_xp, sk_xp, skn_xp)
}

BinFHEContext__EncryptPK <- function(ctx_xp, pk_xp, message, output, p, mod) {
  .Call(`_openfhe_R_BinFHEContext__EncryptPK`, ctx_xp, pk_xp, message, output, p, mod)
}

BinFHEContext__SwitchCTtoqn <- function(ctx_xp, ksk_xp, ct_xp) {
  .Call(`_openfhe_R_BinFHEContext__SwitchCTtoqn`, ctx_xp, ksk_xp, ct_xp)
}

BinFHEContext__Bootstrap <- function(ctx_xp, ct_xp, extended) {
  .Call(`_openfhe_R_BinFHEContext__Bootstrap`, ctx_xp, ct_xp, extended)
}

BinFHEContext__EvalConstant <- function(ctx_xp, value) {
  .Call(`_openfhe_R_BinFHEContext__EvalConstant`, ctx_xp, value)
}

BinFHEContext__EvalDecomp <- function(ctx_xp, ct_xp) {
  .Call(`_openfhe_R_BinFHEContext__EvalDecomp`, ctx_xp, ct_xp)
}

BinFHEContext__GetBTKey <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__GetBTKey`, ctx_xp)
}

BinFHEContext__GetBTKeyMap <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__GetBTKeyMap`, ctx_xp)
}

BinFHEContext__GetSwitchKey <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__GetSwitchKey`, ctx_xp)
}

BinFHEContext__GetPublicKey <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__GetPublicKey`, ctx_xp)
}

BinFHEContext__BTKeyLoad <- function(ctx_xp, key_xp, internal32) {
  invisible(.Call(`_openfhe_R_BinFHEContext__BTKeyLoad`, ctx_xp, key_xp, internal32))
}

BinFHEContext__BTKeyMapLoadSingleElement <- function(ctx_xp, base_g, key_xp) {
  invisible(.Call(`_openfhe_R_BinFHEContext__BTKeyMapLoadSingleElement`, ctx_xp, base_g, key_xp))
}

BinFHEContext__ClearBTKeys <- function(ctx_xp) {
  invisible(.Call(`_openfhe_R_BinFHEContext__ClearBTKeys`, ctx_xp))
}

BinFHEContext__HasInternal32Key <- function(ctx_xp, refresh) {
  .Call(`_openfhe_R_BinFHEContext__HasInternal32Key`, ctx_xp, refresh)
}

BinFHEContext__GetParam <- function(ctx_xp, which) {
  .Call(`_openfhe_R_BinFHEContext__GetParam`, ctx_xp, which)
}

BinFHEContext__SerializedObjectName <- function(ctx_xp) {
  .Call(`_openfhe_R_BinFHEContext__SerializedObjectName`, ctx_xp)
}

BinFHEContext__SerializedVersion <- function() {
  .Call(`_openfhe_R_BinFHEContext__SerializedVersion`)
}

LWE__GetLength <- function(xp, kind) {
  .Call(`_openfhe_R_LWE__GetLength`, xp, kind)
}

LWE__GetModulus <- function(xp, kind) {
  .Call(`_openfhe_R_LWE__GetModulus`, xp, kind)
}

LWE__equal <- function(a_xp, b_xp, kind) {
  .Call(`_openfhe_R_LWE__equal`, a_xp, b_xp, kind)
}

LWECiphertext__GetptModulus <- function(ct_xp) {
  .Call(`_openfhe_R_LWECiphertext__GetptModulus`, ct_xp)
}

LWECiphertext__SetModulus <- function(ct_xp, modulus) {
  invisible(.Call(`_openfhe_R_LWECiphertext__SetModulus`, ct_xp, modulus))
}

LWECiphertext__SetptModulus <- function(ct_xp, plaintext_modulus) {
  invisible(.Call(`_openfhe_R_LWECiphertext__SetptModulus`, ct_xp, plaintext_modulus))
}

BinFHE__SerializeToFile <- function(xp, kind, filename, binary) {
  .Call(`_openfhe_R_BinFHE__SerializeToFile`, xp, kind, filename, binary)
}

BinFHE__DeserializeFromFile <- function(filename, kind, binary) {
  .Call(`_openfhe_R_BinFHE__DeserializeFromFile`, filename, kind, binary)
}

openfhe_enum_values <- function() {
  .Call(`_openfhe_R_openfhe_enum_values`)
}

openfhe_set_num_threads <- function(n) {
  .Call(`_openfhe_R_openfhe_set_num_threads`, n)
}

openfhe_get_num_threads <- function() {
  .Call(`_openfhe_R_openfhe_get_num_threads`)
}

openfhe_native_int <- function() {
  .Call(`_openfhe_R_openfhe_native_int`)
}

selftest_bfv <- function() {
  .Call(`_openfhe_R_selftest_bfv`)
}

BFVParams__new <- function() {
  .Call(`_openfhe_R_BFVParams__new`)
}

BFVParams__SetPlaintextModulus <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetPlaintextModulus`, params_xp, value))
}

BFVParams__SetMultiplicativeDepth <- function(params_xp, depth) {
  invisible(.Call(`_openfhe_R_BFVParams__SetMultiplicativeDepth`, params_xp, depth))
}

BFVParams__SetSecurityLevel <- function(params_xp, level) {
  invisible(.Call(`_openfhe_R_BFVParams__SetSecurityLevel`, params_xp, level))
}

BFVParams__SetBatchSize <- function(params_xp, size) {
  invisible(.Call(`_openfhe_R_BFVParams__SetBatchSize`, params_xp, size))
}

BFVParams__SetRingDim <- function(params_xp, dim) {
  invisible(.Call(`_openfhe_R_BFVParams__SetRingDim`, params_xp, dim))
}

GenCryptoContext__BFV <- function(params_xp) {
  .Call(`_openfhe_R_GenCryptoContext__BFV`, params_xp)
}

CryptoContext__Enable <- function(cc_xp, feature) {
  invisible(.Call(`_openfhe_R_CryptoContext__Enable`, cc_xp, feature))
}

CryptoContext__GetRingDimension <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetRingDimension`, cc_xp)
}

CryptoContext__KeyGen <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__KeyGen`, cc_xp)
}

CryptoContext__EvalMultKeyGen <- function(cc_xp, sk_xp) {
  invisible(.Call(`_openfhe_R_CryptoContext__EvalMultKeyGen`, cc_xp, sk_xp))
}

CryptoContext__EvalRotateKeyGen <- function(cc_xp, sk_xp, indices) {
  invisible(.Call(`_openfhe_R_CryptoContext__EvalRotateKeyGen`, cc_xp, sk_xp, indices))
}

CryptoContext__EvalAtIndexKeyGen <- function(cc_xp, sk_xp, indices) {
  invisible(.Call(`_openfhe_R_CryptoContext__EvalAtIndexKeyGen`, cc_xp, sk_xp, indices))
}

CryptoContext__MakePackedPlaintext <- function(cc_xp, values, noise_scale_deg, level) {
  .Call(`_openfhe_R_CryptoContext__MakePackedPlaintext`, cc_xp, values, noise_scale_deg, level)
}

Plaintext__GetPackedValue <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetPackedValue`, pt_xp)
}

Plaintext__SetLength <- function(pt_xp, len) {
  invisible(.Call(`_openfhe_R_Plaintext__SetLength`, pt_xp, len))
}

Plaintext__ToString <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__ToString`, pt_xp)
}

CryptoContext__Encrypt_PublicKey <- function(cc_xp, pk_xp, pt_xp) {
  .Call(`_openfhe_R_CryptoContext__Encrypt_PublicKey`, cc_xp, pk_xp, pt_xp)
}

CryptoContext__Decrypt <- function(cc_xp, sk_xp, ct_xp) {
  .Call(`_openfhe_R_CryptoContext__Decrypt`, cc_xp, sk_xp, ct_xp)
}

Ciphertext__GetCryptoContext <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetCryptoContext`, ct_xp)
}

EvalAdd__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalAdd__ct_ct`, ct1_xp, ct2_xp)
}

EvalAdd__ct_pt <- function(ct_xp, pt_xp) {
  .Call(`_openfhe_R_EvalAdd__ct_pt`, ct_xp, pt_xp)
}

EvalAdd__ct_scalar <- function(ct_xp, scalar) {
  .Call(`_openfhe_R_EvalAdd__ct_scalar`, ct_xp, scalar)
}

EvalAdd__ct_int <- function(ct_xp, scalar) {
  .Call(`_openfhe_R_EvalAdd__ct_int`, ct_xp, scalar)
}

EvalSub__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalSub__ct_ct`, ct1_xp, ct2_xp)
}

EvalSub__ct_scalar <- function(ct_xp, scalar) {
  .Call(`_openfhe_R_EvalSub__ct_scalar`, ct_xp, scalar)
}

EvalSub__ct_int <- function(ct_xp, scalar) {
  .Call(`_openfhe_R_EvalSub__ct_int`, ct_xp, scalar)
}

EvalSub__ct_pt <- function(ct_xp, pt_xp) {
  .Call(`_openfhe_R_EvalSub__ct_pt`, ct_xp, pt_xp)
}

EvalMult__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalMult__ct_ct`, ct1_xp, ct2_xp)
}

EvalMult__ct_scalar <- function(ct_xp, scalar) {
  .Call(`_openfhe_R_EvalMult__ct_scalar`, ct_xp, scalar)
}

EvalMult__ct_pt <- function(ct_xp, pt_xp) {
  .Call(`_openfhe_R_EvalMult__ct_pt`, ct_xp, pt_xp)
}

EvalMult__ct_int <- function(ct_xp, scalar) {
  .Call(`_openfhe_R_EvalMult__ct_int`, ct_xp, scalar)
}

EvalNegate <- function(ct_xp) {
  .Call(`_openfhe_R_EvalNegate`, ct_xp)
}

EvalSquare <- function(ct_xp) {
  .Call(`_openfhe_R_EvalSquare`, ct_xp)
}

EvalRotate <- function(ct_xp, index) {
  .Call(`_openfhe_R_EvalRotate`, ct_xp, index)
}

EvalSum <- function(ct_xp, batch_size) {
  .Call(`_openfhe_R_EvalSum`, ct_xp, batch_size)
}

Rescale <- function(ct_xp) {
  .Call(`_openfhe_R_Rescale`, ct_xp)
}

EvalFastRotationPrecompute <- function(ct_xp) {
  .Call(`_openfhe_R_EvalFastRotationPrecompute`, ct_xp)
}

EvalFastRotation <- function(ct_xp, index, m, precomp_xp) {
  .Call(`_openfhe_R_EvalFastRotation`, ct_xp, index, m, precomp_xp)
}

BGVParams__new <- function() {
  .Call(`_openfhe_R_BGVParams__new`)
}

BGVParams__SetPlaintextModulus <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetPlaintextModulus`, params_xp, value))
}

BGVParams__SetMultiplicativeDepth <- function(params_xp, depth) {
  invisible(.Call(`_openfhe_R_BGVParams__SetMultiplicativeDepth`, params_xp, depth))
}

GenCryptoContext__BGV <- function(params_xp) {
  .Call(`_openfhe_R_GenCryptoContext__BGV`, params_xp)
}

CKKSParams__new <- function() {
  .Call(`_openfhe_R_CKKSParams__new`)
}

CKKSParams__SetMultiplicativeDepth <- function(params_xp, depth) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetMultiplicativeDepth`, params_xp, depth))
}

CKKSParams__SetScalingModSize <- function(params_xp, size) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetScalingModSize`, params_xp, size))
}

CKKSParams__SetBatchSize <- function(params_xp, size) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetBatchSize`, params_xp, size))
}

CKKSParams__SetRingDim <- function(params_xp, dim) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetRingDim`, params_xp, dim))
}

CKKSParams__SetSecurityLevel <- function(params_xp, level) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetSecurityLevel`, params_xp, level))
}

CKKSParams__SetScalingTechnique <- function(params_xp, tech) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetScalingTechnique`, params_xp, tech))
}

CKKSParams__SetFirstModSize <- function(params_xp, size) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetFirstModSize`, params_xp, size))
}

CKKSParams__SetNumLargeDigits <- function(params_xp, dnum) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetNumLargeDigits`, params_xp, dnum))
}

CKKSParams__SetKeySwitchTechnique <- function(params_xp, tech) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetKeySwitchTechnique`, params_xp, tech))
}

CKKSParams__SetDigitSize <- function(params_xp, size) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetDigitSize`, params_xp, size))
}

GenCryptoContext__CKKS <- function(params_xp) {
  .Call(`_openfhe_R_GenCryptoContext__CKKS`, params_xp)
}

CryptoContext__MakeCKKSPackedPlaintext <- function(cc_xp, values, noise_scale_deg, level, params_xp, slots) {
  .Call(`_openfhe_R_CryptoContext__MakeCKKSPackedPlaintext`, cc_xp, values, noise_scale_deg, level, params_xp, slots)
}

CryptoContext__MakeCoefPackedPlaintext <- function(cc_xp, values, noise_scale_deg, level) {
  .Call(`_openfhe_R_CryptoContext__MakeCoefPackedPlaintext`, cc_xp, values, noise_scale_deg, level)
}

Plaintext__GetRealPackedValue <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetRealPackedValue`, pt_xp)
}

EvalSin_ <- function(ct_xp, a, b, degree) {
  .Call(`_openfhe_R_EvalSin_`, ct_xp, a, b, degree)
}

EvalCos_ <- function(ct_xp, a, b, degree) {
  .Call(`_openfhe_R_EvalCos_`, ct_xp, a, b, degree)
}

EvalLogistic_ <- function(ct_xp, a, b, degree) {
  .Call(`_openfhe_R_EvalLogistic_`, ct_xp, a, b, degree)
}

EvalDivide_ <- function(ct_xp, a, b, degree) {
  .Call(`_openfhe_R_EvalDivide_`, ct_xp, a, b, degree)
}

CryptoContext__EvalBootstrapSetup <- function(cc_xp, level_budget, dim1, slots, correction_factor, precompute, bt_slots_encoding) {
  invisible(.Call(`_openfhe_R_CryptoContext__EvalBootstrapSetup`, cc_xp, level_budget, dim1, slots, correction_factor, precompute, bt_slots_encoding))
}

CryptoContext__EvalBootstrapKeyGen <- function(cc_xp, sk_xp, slots) {
  invisible(.Call(`_openfhe_R_CryptoContext__EvalBootstrapKeyGen`, cc_xp, sk_xp, slots))
}

CryptoContext__EvalBootstrap <- function(ct_xp, num_iterations, precision) {
  .Call(`_openfhe_R_CryptoContext__EvalBootstrap`, ct_xp, num_iterations, precision)
}

FHECKKSRNS__GetBootstrapDepth <- function(level_budget, secret_key_dist) {
  .Call(`_openfhe_R_FHECKKSRNS__GetBootstrapDepth`, level_budget, secret_key_dist)
}

FHECKKSRNS__GetBootstrapDepth__approx <- function(approx_mod_depth, level_budget, secret_key_dist) {
  .Call(`_openfhe_R_FHECKKSRNS__GetBootstrapDepth__approx`, approx_mod_depth, level_budget, secret_key_dist)
}

CryptoContext__EvalSumKeyGen <- function(cc_xp, sk_xp) {
  invisible(.Call(`_openfhe_R_CryptoContext__EvalSumKeyGen`, cc_xp, sk_xp))
}

BFVParams__GetScheme <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetScheme`, params_xp)
}

BFVParams__GetPlaintextModulus <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetPlaintextModulus`, params_xp)
}

BFVParams__GetDigitSize <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetDigitSize`, params_xp)
}

BFVParams__GetStandardDeviation <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetStandardDeviation`, params_xp)
}

BFVParams__GetSecretKeyDist <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetSecretKeyDist`, params_xp)
}

BFVParams__GetMaxRelinSkDeg <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetMaxRelinSkDeg`, params_xp)
}

BFVParams__GetPREMode <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetPREMode`, params_xp)
}

BFVParams__GetMultipartyMode <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetMultipartyMode`, params_xp)
}

BFVParams__GetExecutionMode <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetExecutionMode`, params_xp)
}

BFVParams__GetDecryptionNoiseMode <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetDecryptionNoiseMode`, params_xp)
}

BFVParams__GetNoiseEstimate <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetNoiseEstimate`, params_xp)
}

BFVParams__GetDesiredPrecision <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetDesiredPrecision`, params_xp)
}

BFVParams__GetStatisticalSecurity <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetStatisticalSecurity`, params_xp)
}

BFVParams__GetNumAdversarialQueries <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetNumAdversarialQueries`, params_xp)
}

BFVParams__GetThresholdNumOfParties <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetThresholdNumOfParties`, params_xp)
}

BFVParams__GetKeySwitchTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetKeySwitchTechnique`, params_xp)
}

BFVParams__GetScalingTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetScalingTechnique`, params_xp)
}

BFVParams__GetBatchSize <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetBatchSize`, params_xp)
}

BFVParams__GetFirstModSize <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetFirstModSize`, params_xp)
}

BFVParams__GetNumLargeDigits <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetNumLargeDigits`, params_xp)
}

BFVParams__GetMultiplicativeDepth <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetMultiplicativeDepth`, params_xp)
}

BFVParams__GetScalingModSize <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetScalingModSize`, params_xp)
}

BFVParams__GetSecurityLevel <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetSecurityLevel`, params_xp)
}

BFVParams__GetRingDim <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetRingDim`, params_xp)
}

BFVParams__GetEvalAddCount <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetEvalAddCount`, params_xp)
}

BFVParams__GetKeySwitchCount <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetKeySwitchCount`, params_xp)
}

BFVParams__GetEncryptionTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetEncryptionTechnique`, params_xp)
}

BFVParams__GetMultiplicationTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetMultiplicationTechnique`, params_xp)
}

BFVParams__GetPRENumHops <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetPRENumHops`, params_xp)
}

BFVParams__GetInteractiveBootCompressionLevel <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetInteractiveBootCompressionLevel`, params_xp)
}

BFVParams__GetCompositeDegree <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetCompositeDegree`, params_xp)
}

BFVParams__GetRegisterWordSize <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetRegisterWordSize`, params_xp)
}

BFVParams__GetCKKSDataType <- function(params_xp) {
  .Call(`_openfhe_R_BFVParams__GetCKKSDataType`, params_xp)
}

BGVParams__GetScheme <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetScheme`, params_xp)
}

BGVParams__GetPlaintextModulus <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetPlaintextModulus`, params_xp)
}

BGVParams__GetDigitSize <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetDigitSize`, params_xp)
}

BGVParams__GetStandardDeviation <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetStandardDeviation`, params_xp)
}

BGVParams__GetSecretKeyDist <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetSecretKeyDist`, params_xp)
}

BGVParams__GetMaxRelinSkDeg <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetMaxRelinSkDeg`, params_xp)
}

BGVParams__GetPREMode <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetPREMode`, params_xp)
}

BGVParams__GetMultipartyMode <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetMultipartyMode`, params_xp)
}

BGVParams__GetExecutionMode <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetExecutionMode`, params_xp)
}

BGVParams__GetDecryptionNoiseMode <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetDecryptionNoiseMode`, params_xp)
}

BGVParams__GetNoiseEstimate <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetNoiseEstimate`, params_xp)
}

BGVParams__GetDesiredPrecision <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetDesiredPrecision`, params_xp)
}

BGVParams__GetStatisticalSecurity <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetStatisticalSecurity`, params_xp)
}

BGVParams__GetNumAdversarialQueries <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetNumAdversarialQueries`, params_xp)
}

BGVParams__GetThresholdNumOfParties <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetThresholdNumOfParties`, params_xp)
}

BGVParams__GetKeySwitchTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetKeySwitchTechnique`, params_xp)
}

BGVParams__GetScalingTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetScalingTechnique`, params_xp)
}

BGVParams__GetBatchSize <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetBatchSize`, params_xp)
}

BGVParams__GetFirstModSize <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetFirstModSize`, params_xp)
}

BGVParams__GetNumLargeDigits <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetNumLargeDigits`, params_xp)
}

BGVParams__GetMultiplicativeDepth <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetMultiplicativeDepth`, params_xp)
}

BGVParams__GetScalingModSize <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetScalingModSize`, params_xp)
}

BGVParams__GetSecurityLevel <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetSecurityLevel`, params_xp)
}

BGVParams__GetRingDim <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetRingDim`, params_xp)
}

BGVParams__GetEvalAddCount <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetEvalAddCount`, params_xp)
}

BGVParams__GetKeySwitchCount <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetKeySwitchCount`, params_xp)
}

BGVParams__GetEncryptionTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetEncryptionTechnique`, params_xp)
}

BGVParams__GetMultiplicationTechnique <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetMultiplicationTechnique`, params_xp)
}

BGVParams__GetPRENumHops <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetPRENumHops`, params_xp)
}

BGVParams__GetInteractiveBootCompressionLevel <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetInteractiveBootCompressionLevel`, params_xp)
}

BGVParams__GetCompositeDegree <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetCompositeDegree`, params_xp)
}

BGVParams__GetRegisterWordSize <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetRegisterWordSize`, params_xp)
}

BGVParams__GetCKKSDataType <- function(params_xp) {
  .Call(`_openfhe_R_BGVParams__GetCKKSDataType`, params_xp)
}

CKKSParams__GetScheme <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetScheme`, params_xp)
}

CKKSParams__GetPlaintextModulus <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetPlaintextModulus`, params_xp)
}

CKKSParams__GetDigitSize <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetDigitSize`, params_xp)
}

CKKSParams__GetStandardDeviation <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetStandardDeviation`, params_xp)
}

CKKSParams__GetSecretKeyDist <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetSecretKeyDist`, params_xp)
}

CKKSParams__GetMaxRelinSkDeg <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetMaxRelinSkDeg`, params_xp)
}

CKKSParams__GetPREMode <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetPREMode`, params_xp)
}

CKKSParams__GetMultipartyMode <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetMultipartyMode`, params_xp)
}

CKKSParams__GetExecutionMode <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetExecutionMode`, params_xp)
}

CKKSParams__GetDecryptionNoiseMode <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetDecryptionNoiseMode`, params_xp)
}

CKKSParams__GetNoiseEstimate <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetNoiseEstimate`, params_xp)
}

CKKSParams__GetDesiredPrecision <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetDesiredPrecision`, params_xp)
}

CKKSParams__GetStatisticalSecurity <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetStatisticalSecurity`, params_xp)
}

CKKSParams__GetNumAdversarialQueries <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetNumAdversarialQueries`, params_xp)
}

CKKSParams__GetThresholdNumOfParties <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetThresholdNumOfParties`, params_xp)
}

CKKSParams__GetKeySwitchTechnique <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetKeySwitchTechnique`, params_xp)
}

CKKSParams__GetScalingTechnique <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetScalingTechnique`, params_xp)
}

CKKSParams__GetBatchSize <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetBatchSize`, params_xp)
}

CKKSParams__GetFirstModSize <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetFirstModSize`, params_xp)
}

CKKSParams__GetNumLargeDigits <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetNumLargeDigits`, params_xp)
}

CKKSParams__GetMultiplicativeDepth <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetMultiplicativeDepth`, params_xp)
}

CKKSParams__GetScalingModSize <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetScalingModSize`, params_xp)
}

CKKSParams__GetSecurityLevel <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetSecurityLevel`, params_xp)
}

CKKSParams__GetRingDim <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetRingDim`, params_xp)
}

CKKSParams__GetEvalAddCount <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetEvalAddCount`, params_xp)
}

CKKSParams__GetKeySwitchCount <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetKeySwitchCount`, params_xp)
}

CKKSParams__GetEncryptionTechnique <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetEncryptionTechnique`, params_xp)
}

CKKSParams__GetMultiplicationTechnique <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetMultiplicationTechnique`, params_xp)
}

CKKSParams__GetPRENumHops <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetPRENumHops`, params_xp)
}

CKKSParams__GetInteractiveBootCompressionLevel <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetInteractiveBootCompressionLevel`, params_xp)
}

CKKSParams__GetCompositeDegree <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetCompositeDegree`, params_xp)
}

CKKSParams__GetRegisterWordSize <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetRegisterWordSize`, params_xp)
}

CKKSParams__GetCKKSDataType <- function(params_xp) {
  .Call(`_openfhe_R_CKKSParams__GetCKKSDataType`, params_xp)
}

CCParams__Set <- function(params_xp, field, value) {
  invisible(.Call(`_openfhe_R_CCParams__Set`, params_xp, field, value))
}

CCParams__ToString <- function(params_xp) {
  .Call(`_openfhe_R_CCParams__ToString`, params_xp)
}

BFVParams__SetDigitSize <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetDigitSize`, params_xp, value))
}

BFVParams__SetStandardDeviation <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetStandardDeviation`, params_xp, value))
}

BFVParams__SetSecretKeyDist <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetSecretKeyDist`, params_xp, value))
}

BFVParams__SetMaxRelinSkDeg <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetMaxRelinSkDeg`, params_xp, value))
}

BFVParams__SetPREMode <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetPREMode`, params_xp, value))
}

BFVParams__SetMultipartyMode <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetMultipartyMode`, params_xp, value))
}

BFVParams__SetThresholdNumOfParties <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetThresholdNumOfParties`, params_xp, value))
}

BFVParams__SetKeySwitchTechnique <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetKeySwitchTechnique`, params_xp, value))
}

BFVParams__SetNumLargeDigits <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetNumLargeDigits`, params_xp, value))
}

BFVParams__SetScalingModSize <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetScalingModSize`, params_xp, value))
}

BFVParams__SetEvalAddCount <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetEvalAddCount`, params_xp, value))
}

BFVParams__SetKeySwitchCount <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetKeySwitchCount`, params_xp, value))
}

BFVParams__SetEncryptionTechnique <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetEncryptionTechnique`, params_xp, value))
}

BFVParams__SetMultiplicationTechnique <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BFVParams__SetMultiplicationTechnique`, params_xp, value))
}

BGVParams__SetDigitSize <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetDigitSize`, params_xp, value))
}

BGVParams__SetStandardDeviation <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetStandardDeviation`, params_xp, value))
}

BGVParams__SetSecretKeyDist <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetSecretKeyDist`, params_xp, value))
}

BGVParams__SetMaxRelinSkDeg <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetMaxRelinSkDeg`, params_xp, value))
}

BGVParams__SetPREMode <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetPREMode`, params_xp, value))
}

BGVParams__SetMultipartyMode <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetMultipartyMode`, params_xp, value))
}

BGVParams__SetStatisticalSecurity <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetStatisticalSecurity`, params_xp, value))
}

BGVParams__SetNumAdversarialQueries <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetNumAdversarialQueries`, params_xp, value))
}

BGVParams__SetThresholdNumOfParties <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetThresholdNumOfParties`, params_xp, value))
}

BGVParams__SetKeySwitchTechnique <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetKeySwitchTechnique`, params_xp, value))
}

BGVParams__SetScalingTechnique <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetScalingTechnique`, params_xp, value))
}

BGVParams__SetBatchSize <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetBatchSize`, params_xp, value))
}

BGVParams__SetFirstModSize <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetFirstModSize`, params_xp, value))
}

BGVParams__SetNumLargeDigits <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetNumLargeDigits`, params_xp, value))
}

BGVParams__SetScalingModSize <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetScalingModSize`, params_xp, value))
}

BGVParams__SetSecurityLevel <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetSecurityLevel`, params_xp, value))
}

BGVParams__SetRingDim <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetRingDim`, params_xp, value))
}

BGVParams__SetEvalAddCount <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetEvalAddCount`, params_xp, value))
}

BGVParams__SetKeySwitchCount <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetKeySwitchCount`, params_xp, value))
}

BGVParams__SetPRENumHops <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_BGVParams__SetPRENumHops`, params_xp, value))
}

CKKSParams__SetStandardDeviation <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetStandardDeviation`, params_xp, value))
}

CKKSParams__SetSecretKeyDist <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetSecretKeyDist`, params_xp, value))
}

CKKSParams__SetMaxRelinSkDeg <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetMaxRelinSkDeg`, params_xp, value))
}

CKKSParams__SetPREMode <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetPREMode`, params_xp, value))
}

CKKSParams__SetExecutionMode <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetExecutionMode`, params_xp, value))
}

CKKSParams__SetDecryptionNoiseMode <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetDecryptionNoiseMode`, params_xp, value))
}

CKKSParams__SetNoiseEstimate <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetNoiseEstimate`, params_xp, value))
}

CKKSParams__SetDesiredPrecision <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetDesiredPrecision`, params_xp, value))
}

CKKSParams__SetStatisticalSecurity <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetStatisticalSecurity`, params_xp, value))
}

CKKSParams__SetNumAdversarialQueries <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetNumAdversarialQueries`, params_xp, value))
}

CKKSParams__SetInteractiveBootCompressionLevel <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetInteractiveBootCompressionLevel`, params_xp, value))
}

CKKSParams__SetCompositeDegree <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetCompositeDegree`, params_xp, value))
}

CKKSParams__SetRegisterWordSize <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetRegisterWordSize`, params_xp, value))
}

CKKSParams__SetCKKSDataType <- function(params_xp, value) {
  invisible(.Call(`_openfhe_R_CKKSParams__SetCKKSDataType`, params_xp, value))
}

Ciphertext__GetLevel <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetLevel`, ct_xp)
}

Ciphertext__SetLevel <- function(ct_xp, level) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetLevel`, ct_xp, level))
}

Ciphertext__GetSlots <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetSlots`, ct_xp)
}

Ciphertext__SetSlots <- function(ct_xp, slots) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetSlots`, ct_xp, slots))
}

Ciphertext__GetNoiseScaleDeg <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetNoiseScaleDeg`, ct_xp)
}

Ciphertext__SetNoiseScaleDeg <- function(ct_xp, d) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetNoiseScaleDeg`, ct_xp, d))
}

Ciphertext__GetScalingFactor <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetScalingFactor`, ct_xp)
}

Ciphertext__SetScalingFactor <- function(ct_xp, sf) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetScalingFactor`, ct_xp, sf))
}

Ciphertext__GetScalingFactorInt <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetScalingFactorInt`, ct_xp)
}

Ciphertext__SetScalingFactorInt <- function(ct_xp, sf) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetScalingFactorInt`, ct_xp, sf))
}

Ciphertext__GetEncodingType <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetEncodingType`, ct_xp)
}

Ciphertext__GetKeyTag <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetKeyTag`, ct_xp)
}

Ciphertext__SetKeyTag <- function(ct_xp, tag) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetKeyTag`, ct_xp, tag))
}

CryptoContext__GetScalingFactorReal <- function(cc_xp, level) {
  .Call(`_openfhe_R_CryptoContext__GetScalingFactorReal`, cc_xp, level)
}

MakeCKKSPackedPlaintext__complex <- function(cc_xp, values_complex, noise_scale_deg, level, params_xp, slots) {
  .Call(`_openfhe_R_MakeCKKSPackedPlaintext__complex`, cc_xp, values_complex, noise_scale_deg, level, params_xp, slots)
}

Plaintext__GetCKKSPackedValue <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetCKKSPackedValue`, pt_xp)
}

CryptoContext__FindAutomorphismIndex <- function(cc_xp, idx) {
  .Call(`_openfhe_R_CryptoContext__FindAutomorphismIndex`, cc_xp, idx)
}

CryptoContext__FindAutomorphismIndices <- function(cc_xp, idx_list) {
  .Call(`_openfhe_R_CryptoContext__FindAutomorphismIndices`, cc_xp, idx_list)
}

CryptoContext__EvalAutomorphismKeyGen <- function(cc_xp, sk_xp, idx_list) {
  .Call(`_openfhe_R_CryptoContext__EvalAutomorphismKeyGen`, cc_xp, sk_xp, idx_list)
}

EvalAutomorphism__ <- function(ct_xp, idx, map_xp) {
  .Call(`_openfhe_R_EvalAutomorphism__`, ct_xp, idx, map_xp)
}

EvalSeriesPowers__ <- function(ct_xp, chebyshev, coefficients, a, b) {
  .Call(`_openfhe_R_EvalSeriesPowers__`, ct_xp, chebyshev, coefficients, a, b)
}

EvalSeriesWithPrecomp__ <- function(powers_xp, chebyshev, coefficients) {
  .Call(`_openfhe_R_EvalSeriesWithPrecomp__`, powers_xp, chebyshev, coefficients)
}

SeriesPowers__info <- function(powers_xp) {
  .Call(`_openfhe_R_SeriesPowers__info`, powers_xp)
}

EvalBootstrapPrecompute__ <- function(cc_xp, slots) {
  invisible(.Call(`_openfhe_R_EvalBootstrapPrecompute__`, cc_xp, slots))
}

EvalBootstrapStCFirst__ <- function(ct_xp, num_iterations, precision) {
  .Call(`_openfhe_R_EvalBootstrapStCFirst__`, ct_xp, num_iterations, precision)
}

EvalSeries__ <- function(ct_xp, which, coefficients, a, b) {
  .Call(`_openfhe_R_EvalSeries__`, ct_xp, which, coefficients, a, b)
}

CryptoContext__GetCKKSBootCorrectionFactor <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetCKKSBootCorrectionFactor`, cc_xp)
}

CryptoContext__SetCKKSBootCorrectionFactor <- function(cc_xp, cf) {
  invisible(.Call(`_openfhe_R_CryptoContext__SetCKKSBootCorrectionFactor`, cc_xp, cf))
}

EvalFastRotationExt__ <- function(ct_xp, index, precomp_xp, add_first) {
  .Call(`_openfhe_R_EvalFastRotationExt__`, ct_xp, index, precomp_xp, add_first)
}

EvalFastRotation__3arg <- function(ct_xp, index, precomp_xp) {
  .Call(`_openfhe_R_EvalFastRotation__3arg`, ct_xp, index, precomp_xp)
}

KeySwitchDown__ <- function(ct_xp) {
  .Call(`_openfhe_R_KeySwitchDown__`, ct_xp)
}

IntBootDecrypt__ <- function(sk_xp, ct_xp) {
  .Call(`_openfhe_R_IntBootDecrypt__`, sk_xp, ct_xp)
}

IntBootEncrypt__ <- function(pk_xp, ct_xp) {
  .Call(`_openfhe_R_IntBootEncrypt__`, pk_xp, ct_xp)
}

IntBootAdd__ <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_IntBootAdd__`, ct1_xp, ct2_xp)
}

IntBootAdjustScale__ <- function(ct_xp) {
  .Call(`_openfhe_R_IntBootAdjustScale__`, ct_xp)
}

IntMPBootAdjustScale__ <- function(ct_xp) {
  .Call(`_openfhe_R_IntMPBootAdjustScale__`, ct_xp)
}

IntMPBootRandomElementGen__pk <- function(cc_xp, pk_xp) {
  .Call(`_openfhe_R_IntMPBootRandomElementGen__pk`, cc_xp, pk_xp)
}

IntMPBootRandomElementGen__ct <- function(ct_xp) {
  .Call(`_openfhe_R_IntMPBootRandomElementGen__ct`, ct_xp)
}

IntMPBootDecrypt__ <- function(sk_xp, ct_xp, a_xp) {
  .Call(`_openfhe_R_IntMPBootDecrypt__`, sk_xp, ct_xp, a_xp)
}

IntMPBootAdd__ <- function(cc_xp, shares_pair_list) {
  .Call(`_openfhe_R_IntMPBootAdd__`, cc_xp, shares_pair_list)
}

IntMPBootEncrypt__ <- function(pk_xp, shares_pair_list, a_xp, ct_xp) {
  .Call(`_openfhe_R_IntMPBootEncrypt__`, pk_xp, shares_pair_list, a_xp, ct_xp)
}

CryptoContext__Encrypt_PrivateKey <- function(cc_xp, sk_xp, pt_xp) {
  .Call(`_openfhe_R_CryptoContext__Encrypt_PrivateKey`, cc_xp, sk_xp, pt_xp)
}

CryptoContext__Enable_Mask <- function(cc_xp, mask) {
  invisible(.Call(`_openfhe_R_CryptoContext__Enable_Mask`, cc_xp, mask))
}

CryptoContext__GetSchemeId <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetSchemeId`, cc_xp)
}

CryptoContext__ClearStaticMapsAndVectors <- function() {
  invisible(.Call(`_openfhe_R_CryptoContext__ClearStaticMapsAndVectors`))
}

PublicKey__GetKeyTag <- function(key_xp) {
  .Call(`_openfhe_R_PublicKey__GetKeyTag`, key_xp)
}

PublicKey__SetKeyTag <- function(key_xp, tag) {
  invisible(.Call(`_openfhe_R_PublicKey__SetKeyTag`, key_xp, tag))
}

PrivateKey__GetKeyTag <- function(key_xp) {
  .Call(`_openfhe_R_PrivateKey__GetKeyTag`, key_xp)
}

PrivateKey__SetKeyTag <- function(key_xp, tag) {
  invisible(.Call(`_openfhe_R_PrivateKey__SetKeyTag`, key_xp, tag))
}

CryptoContext__GetCryptoParameters <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetCryptoParameters`, cc_xp)
}

CryptoContext__GetKeyGenLevel <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetKeyGenLevel`, cc_xp)
}

CryptoContext__SetKeyGenLevel <- function(cc_xp, level) {
  invisible(.Call(`_openfhe_R_CryptoContext__SetKeyGenLevel`, cc_xp, level))
}

CryptoContext__GetElementParams <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetElementParams`, cc_xp)
}

CryptoContext__GetEncodingParams <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetEncodingParams`, cc_xp)
}

CryptoContext__GetCyclotomicOrder <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetCyclotomicOrder`, cc_xp)
}

CryptoContext__GetCKKSDataType <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetCKKSDataType`, cc_xp)
}

CryptoContext__GetPlaintextModulus <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetPlaintextModulus`, cc_xp)
}

CryptoContext__GetBatchSize <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetBatchSize`, cc_xp)
}

CryptoContext__GetScalingTechnique <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetScalingTechnique`, cc_xp)
}

CryptoContext__GetDigitSize <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetDigitSize`, cc_xp)
}

CryptoContext__GetNoiseEstimate <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetNoiseEstimate`, cc_xp)
}

CryptoContext__GetMultiplicativeDepth <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetMultiplicativeDepth`, cc_xp)
}

CryptoContext__GetEvalAddCount <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetEvalAddCount`, cc_xp)
}

CryptoContext__GetKeySwitchCount <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetKeySwitchCount`, cc_xp)
}

CryptoContext__GetPRENumHops <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetPRENumHops`, cc_xp)
}

CryptoContext__GetRegisterWordSize <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetRegisterWordSize`, cc_xp)
}

CryptoContext__GetCompositeDegree <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetCompositeDegree`, cc_xp)
}

CryptoContext__GetKeySwitchTechnique <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetKeySwitchTechnique`, cc_xp)
}

EvalAddInPlace__ct_ct <- function(ct1_xp, ct2_xp) {
  invisible(.Call(`_openfhe_R_EvalAddInPlace__ct_ct`, ct1_xp, ct2_xp))
}

EvalAddInPlace__ct_pt <- function(ct_xp, pt_xp) {
  invisible(.Call(`_openfhe_R_EvalAddInPlace__ct_pt`, ct_xp, pt_xp))
}

EvalSubInPlace__ct_ct <- function(ct1_xp, ct2_xp) {
  invisible(.Call(`_openfhe_R_EvalSubInPlace__ct_ct`, ct1_xp, ct2_xp))
}

EvalSubInPlace__ct_pt <- function(ct_xp, pt_xp) {
  invisible(.Call(`_openfhe_R_EvalSubInPlace__ct_pt`, ct_xp, pt_xp))
}

EvalNegateInPlace__ct <- function(ct_xp) {
  invisible(.Call(`_openfhe_R_EvalNegateInPlace__ct`, ct_xp))
}

EvalAddMutable__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalAddMutable__ct_ct`, ct1_xp, ct2_xp)
}

EvalSubMutable__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalSubMutable__ct_ct`, ct1_xp, ct2_xp)
}

EvalMultMutable__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalMultMutable__ct_ct`, ct1_xp, ct2_xp)
}

EvalSquareMutable__ct <- function(ct_xp) {
  .Call(`_openfhe_R_EvalSquareMutable__ct`, ct_xp)
}

EvalMultNoRelin__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalMultNoRelin__ct_ct`, ct1_xp, ct2_xp)
}

Relinearize__ct <- function(ct_xp) {
  .Call(`_openfhe_R_Relinearize__ct`, ct_xp)
}

EvalMultAndRelinearize__ct_ct <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalMultAndRelinearize__ct_ct`, ct1_xp, ct2_xp)
}

ModReduce__ct <- function(ct_xp) {
  .Call(`_openfhe_R_ModReduce__ct`, ct_xp)
}

ModReduceInPlace__ct <- function(ct_xp) {
  invisible(.Call(`_openfhe_R_ModReduceInPlace__ct`, ct_xp))
}

LevelReduce__ct <- function(ct_xp, eval_key_xp, levels) {
  .Call(`_openfhe_R_LevelReduce__ct`, ct_xp, eval_key_xp, levels)
}

LevelReduceInPlace__ct <- function(ct_xp, eval_key_xp, levels) {
  invisible(.Call(`_openfhe_R_LevelReduceInPlace__ct`, ct_xp, eval_key_xp, levels))
}

Compress__ct <- function(ct_xp, towers_left, noise_scale_deg) {
  .Call(`_openfhe_R_Compress__ct`, ct_xp, towers_left, noise_scale_deg)
}

EvalArith__real <- function(op, ct_xp, scalar, scalar_first) {
  .Call(`_openfhe_R_EvalArith__real`, op, ct_xp, scalar, scalar_first)
}

EvalArith__complex <- function(op, ct_xp, re, im, scalar_first) {
  .Call(`_openfhe_R_EvalArith__complex`, op, ct_xp, re, im, scalar_first)
}

EvalArithInPlace__real <- function(op, ct_xp, scalar, scalar_first) {
  invisible(.Call(`_openfhe_R_EvalArithInPlace__real`, op, ct_xp, scalar, scalar_first))
}

EvalArithInPlace__complex <- function(op, ct_xp, re, im, scalar_first) {
  invisible(.Call(`_openfhe_R_EvalArithInPlace__complex`, op, ct_xp, re, im, scalar_first))
}

EvalArith__pt_ct <- function(op, pt_xp, ct_xp) {
  .Call(`_openfhe_R_EvalArith__pt_ct`, op, pt_xp, ct_xp)
}

EvalArithInPlace__pt_ct <- function(op, pt_xp, ct_xp) {
  invisible(.Call(`_openfhe_R_EvalArithInPlace__pt_ct`, op, pt_xp, ct_xp))
}

EvalArithMutable__pt <- function(op, ct_xp, pt_xp, pt_first) {
  .Call(`_openfhe_R_EvalArithMutable__pt`, op, ct_xp, pt_xp, pt_first)
}

EvalAddMany__ <- function(cts) {
  .Call(`_openfhe_R_EvalAddMany__`, cts)
}

EvalAddManyInPlace__ <- function(cts) {
  .Call(`_openfhe_R_EvalAddManyInPlace__`, cts)
}

EvalMultMany__ <- function(cts) {
  .Call(`_openfhe_R_EvalMultMany__`, cts)
}

EvalMerge__ <- function(cts) {
  .Call(`_openfhe_R_EvalMerge__`, cts)
}

EvalLinearWSum__ <- function(cts, constants) {
  .Call(`_openfhe_R_EvalLinearWSum__`, cts, constants)
}

EvalLinearWSumMutable__ <- function(constants, cts) {
  .Call(`_openfhe_R_EvalLinearWSumMutable__`, constants, cts)
}

EvalInnerProduct__ct_ct <- function(ct1_xp, ct2_xp, batch_size) {
  .Call(`_openfhe_R_EvalInnerProduct__ct_ct`, ct1_xp, ct2_xp, batch_size)
}

EvalInnerProduct__ct_pt <- function(ct_xp, pt_xp, batch_size) {
  .Call(`_openfhe_R_EvalInnerProduct__ct_pt`, ct_xp, pt_xp, batch_size)
}

EvalSumRowsKeyGen__ <- function(cc_xp, sk_xp, pk_xp, row_size, subring_dim) {
  .Call(`_openfhe_R_EvalSumRowsKeyGen__`, cc_xp, sk_xp, pk_xp, row_size, subring_dim)
}

EvalSumColsKeyGen__ <- function(cc_xp, sk_xp) {
  .Call(`_openfhe_R_EvalSumColsKeyGen__`, cc_xp, sk_xp)
}

EvalSumRows__ <- function(ct_xp, num_rows, map_xp, subring_dim) {
  .Call(`_openfhe_R_EvalSumRows__`, ct_xp, num_rows, map_xp, subring_dim)
}

EvalSumCols__ <- function(ct_xp, num_cols, map_xp) {
  .Call(`_openfhe_R_EvalSumCols__`, ct_xp, num_cols, map_xp)
}

EvalAtIndex__ <- function(ct_xp, index) {
  .Call(`_openfhe_R_EvalAtIndex__`, ct_xp, index)
}

ReKeyGen__ <- function(cc_xp, old_sk_xp, new_pk_xp) {
  .Call(`_openfhe_R_ReKeyGen__`, cc_xp, old_sk_xp, new_pk_xp)
}

ReEncrypt__ <- function(ct_xp, ek_xp, pk_xp) {
  .Call(`_openfhe_R_ReEncrypt__`, ct_xp, ek_xp, pk_xp)
}

MakeStringPlaintext__ <- function(cc_xp, str) {
  .Call(`_openfhe_R_MakeStringPlaintext__`, cc_xp, str)
}

EvalUnaryInPlace__ <- function(ct_xp, which) {
  invisible(.Call(`_openfhe_R_EvalUnaryInPlace__`, ct_xp, which))
}

EvalMutableInPlace__ <- function(op, ct1_xp, ct2_xp) {
  invisible(.Call(`_openfhe_R_EvalMutableInPlace__`, op, ct1_xp, ct2_xp))
}

EvalAddInPlaceNoCheck__ <- function(ct1_xp, ct2_xp) {
  invisible(.Call(`_openfhe_R_EvalAddInPlaceNoCheck__`, ct1_xp, ct2_xp))
}

EvalMultNoCheck__ <- function(ct_xp, scalar) {
  .Call(`_openfhe_R_EvalMultNoCheck__`, ct_xp, scalar)
}

EvalMultNoRelinNoCheck__ <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_EvalMultNoRelinNoCheck__`, ct1_xp, ct2_xp)
}

ComposedEvalMult__ <- function(ct1_xp, ct2_xp) {
  .Call(`_openfhe_R_ComposedEvalMult__`, ct1_xp, ct2_xp)
}

EvalMultKeysGen__ <- function(cc_xp, sk_xp) {
  invisible(.Call(`_openfhe_R_EvalMultKeysGen__`, cc_xp, sk_xp))
}

GetFBTDepth__ <- function(level_budget, coefficients, p_input, order, skd, first_mod_size) {
  .Call(`_openfhe_R_GetFBTDepth__`, level_budget, coefficients, p_input, order, skd, first_mod_size)
}

GetFEFBTDepth__ <- function(level_budget, coefficients, skd, first_mod_size) {
  .Call(`_openfhe_R_GetFEFBTDepth__`, level_budget, coefficients, skd, first_mod_size)
}

EvalFBTSetup__ <- function(cc_xp, coeffs, num_slots, p_in, p_out, big_q, pk_xp, dim1, level_budget, lvls_after_boot, depth_leveled_computation, order) {
  invisible(.Call(`_openfhe_R_EvalFBTSetup__`, cc_xp, coeffs, num_slots, p_in, p_out, big_q, pk_xp, dim1, level_budget, lvls_after_boot, depth_leveled_computation, order))
}

EvalFBT__ <- function(ct_xp, coeffs, digit_bit_size, initial_scaling, post_scaling, level_to_reduce, order) {
  .Call(`_openfhe_R_EvalFBT__`, ct_xp, coeffs, digit_bit_size, initial_scaling, post_scaling, level_to_reduce, order)
}

EvalFBTNoDecoding__ <- function(ct_xp, coeffs, digit_bit_size, initial_scaling, order) {
  .Call(`_openfhe_R_EvalFBTNoDecoding__`, ct_xp, coeffs, digit_bit_size, initial_scaling, order)
}

EvalHomDecoding__ <- function(ct_xp, post_scaling, level_to_reduce) {
  .Call(`_openfhe_R_EvalHomDecoding__`, ct_xp, post_scaling, level_to_reduce)
}

EvalMVBPrecompute__ <- function(ct_xp, coeffs, digit_bit_size, initial_scaling, order) {
  .Call(`_openfhe_R_EvalMVBPrecompute__`, ct_xp, coeffs, digit_bit_size, initial_scaling, order)
}

EvalMVB__ <- function(powers_xp, coeffs, digit_bit_size, post_scaling, level_to_reduce, order) {
  .Call(`_openfhe_R_EvalMVB__`, powers_xp, coeffs, digit_bit_size, post_scaling, level_to_reduce, order)
}

EvalMVBNoDecoding__ <- function(powers_xp, coeffs, digit_bit_size, order) {
  .Call(`_openfhe_R_EvalMVBNoDecoding__`, powers_xp, coeffs, digit_bit_size, order)
}

EvalHermiteTrigSeries__ <- function(ct_xp, coefficients_cheb, a, b, coefficients_herm, precomp) {
  .Call(`_openfhe_R_EvalHermiteTrigSeries__`, ct_xp, coefficients_cheb, a, b, coefficients_herm, precomp)
}

EvalFEFuncBootstrapSetup__ <- function(cc_xp, level_budget, dim1, slots) {
  invisible(.Call(`_openfhe_R_EvalFEFuncBootstrapSetup__`, cc_xp, level_budget, dim1, slots))
}

EvalFEFuncBootstrap__ <- function(ct_xp, coefficients) {
  .Call(`_openfhe_R_EvalFEFuncBootstrap__`, ct_xp, coefficients)
}

EvalFEFuncBootstrapPrecompute__ <- function(ct_xp, coefficients) {
  .Call(`_openfhe_R_EvalFEFuncBootstrapPrecompute__`, ct_xp, coefficients)
}

EvalFEFuncBootstrapWithPrecomp__ <- function(powers_xp, coefficients) {
  .Call(`_openfhe_R_EvalFEFuncBootstrapWithPrecomp__`, powers_xp, coefficients)
}

GetHermiteTrigCoefficients__ <- function(func, p, order, scale) {
  .Call(`_openfhe_R_GetHermiteTrigCoefficients__`, func, p, order, scale)
}

CryptoContext__GetAllEvalMultKeys <- function() {
  .Call(`_openfhe_R_CryptoContext__GetAllEvalMultKeys`)
}

CryptoContext__GetEvalMultKeyVector <- function(key_tag) {
  .Call(`_openfhe_R_CryptoContext__GetEvalMultKeyVector`, key_tag)
}

CryptoContext__GetAllEvalAutomorphismKeys <- function() {
  .Call(`_openfhe_R_CryptoContext__GetAllEvalAutomorphismKeys`)
}

CryptoContext__GetAllEvalSumKeys <- function() {
  .Call(`_openfhe_R_CryptoContext__GetAllEvalSumKeys`)
}

CryptoContext__InsertEvalMultKey <- function(eval_key_list, key_tag) {
  invisible(.Call(`_openfhe_R_CryptoContext__InsertEvalMultKey`, eval_key_list, key_tag))
}

CryptoContext__ClearEvalMultKeys__tag <- function(key_tag) {
  invisible(.Call(`_openfhe_R_CryptoContext__ClearEvalMultKeys__tag`, key_tag))
}

CryptoContext__ClearEvalAutomorphismKeys__tag <- function(key_tag) {
  invisible(.Call(`_openfhe_R_CryptoContext__ClearEvalAutomorphismKeys__tag`, key_tag))
}

KeySwitchGen__ <- function(cc_xp, old_sk_xp, new_sk_xp) {
  .Call(`_openfhe_R_KeySwitchGen__`, cc_xp, old_sk_xp, new_sk_xp)
}

KeySwitch__ <- function(ct_xp, ek_xp) {
  .Call(`_openfhe_R_KeySwitch__`, ct_xp, ek_xp)
}

KeySwitchInPlace__ <- function(ct_xp, ek_xp) {
  invisible(.Call(`_openfhe_R_KeySwitchInPlace__`, ct_xp, ek_xp))
}

KeySwitchExt__ <- function(ct_xp, add_first) {
  .Call(`_openfhe_R_KeySwitchExt__`, ct_xp, add_first)
}

KeySwitchDownFirstElement__ <- function(ct_xp) {
  .Call(`_openfhe_R_KeySwitchDownFirstElement__`, ct_xp)
}

SparseKeyGen__ <- function(cc_xp) {
  .Call(`_openfhe_R_SparseKeyGen__`, cc_xp)
}

MultiMultEvalKey__ <- function(cc_xp, sk_xp, ek_xp, key_tag) {
  .Call(`_openfhe_R_MultiMultEvalKey__`, cc_xp, sk_xp, ek_xp, key_tag)
}

ClearEvalSumKeys__ <- function() {
  invisible(.Call(`_openfhe_R_ClearEvalSumKeys__`))
}

ClearEvalSumKeys__tag <- function(key_tag) {
  invisible(.Call(`_openfhe_R_ClearEvalSumKeys__tag`, key_tag))
}

GetAllContexts__ <- function() {
  .Call(`_openfhe_R_GetAllContexts__`)
}

PrecomputeCRTTablesAfterDeserializaton__set <- function(enable) {
  invisible(.Call(`_openfhe_R_PrecomputeCRTTablesAfterDeserializaton__set`, enable))
}

PrecomputeCRTTablesAfterDeserializaton__get <- function() {
  .Call(`_openfhe_R_PrecomputeCRTTablesAfterDeserializaton__get`)
}

EvalChebyshevFunctionPtxt__ <- function(func, ptxt, a, b, degree) {
  .Call(`_openfhe_R_EvalChebyshevFunctionPtxt__`, func, ptxt, a, b, degree)
}

GetMultiplicativeDepthByCoeffVector__ <- function(n_coefficients, is_normalized) {
  .Call(`_openfhe_R_GetMultiplicativeDepthByCoeffVector__`, n_coefficients, is_normalized)
}

MultiEvalAutomorphismKeyGen__ <- function(cc_xp, sk_xp, map_xp, index_list, key_tag) {
  .Call(`_openfhe_R_MultiEvalAutomorphismKeyGen__`, cc_xp, sk_xp, map_xp, index_list, key_tag)
}

MultiEvalAtIndexKeyGen__ <- function(cc_xp, sk_xp, map_xp, index_list, key_tag) {
  .Call(`_openfhe_R_MultiEvalAtIndexKeyGen__`, cc_xp, sk_xp, map_xp, index_list, key_tag)
}

MultiEvalSumKeyGen__ <- function(cc_xp, sk_xp, map_xp, key_tag) {
  .Call(`_openfhe_R_MultiEvalSumKeyGen__`, cc_xp, sk_xp, map_xp, key_tag)
}

MultiAddEvalSumKeys__ <- function(cc_xp, map1_xp, map2_xp, key_tag) {
  .Call(`_openfhe_R_MultiAddEvalSumKeys__`, cc_xp, map1_xp, map2_xp, key_tag)
}

MultiAddEvalAutomorphismKeys__ <- function(cc_xp, map1_xp, map2_xp, key_tag) {
  .Call(`_openfhe_R_MultiAddEvalAutomorphismKeys__`, cc_xp, map1_xp, map2_xp, key_tag)
}

CryptoContext__GetEvalSumKeyMap <- function(key_tag) {
  .Call(`_openfhe_R_CryptoContext__GetEvalSumKeyMap`, key_tag)
}

CryptoContext__GetEvalAutomorphismKeyMapPtr <- function(key_tag) {
  .Call(`_openfhe_R_CryptoContext__GetEvalAutomorphismKeyMapPtr`, key_tag)
}

CryptoContext__InsertEvalSumKey <- function(map_xp, key_tag) {
  invisible(.Call(`_openfhe_R_CryptoContext__InsertEvalSumKey`, map_xp, key_tag))
}

CryptoContext__InsertEvalAutomorphismKey <- function(map_xp, key_tag) {
  invisible(.Call(`_openfhe_R_CryptoContext__InsertEvalAutomorphismKey`, map_xp, key_tag))
}

MultipartyKeyGen <- function(cc_xp, pk_xp, make_sparse, fresh) {
  .Call(`_openfhe_R_MultipartyKeyGen`, cc_xp, pk_xp, make_sparse, fresh)
}

MultipartyKeyGen__sk_vec <- function(cc_xp, sk_list) {
  .Call(`_openfhe_R_MultipartyKeyGen__sk_vec`, cc_xp, sk_list)
}

MultiAddPubKeys <- function(cc_xp, pk1_xp, pk2_xp, key_tag) {
  .Call(`_openfhe_R_MultiAddPubKeys`, cc_xp, pk1_xp, pk2_xp, key_tag)
}

MultiAddEvalKeys <- function(cc_xp, ek1_xp, ek2_xp, key_tag) {
  .Call(`_openfhe_R_MultiAddEvalKeys`, cc_xp, ek1_xp, ek2_xp, key_tag)
}

MultiAddEvalMultKeys <- function(cc_xp, ek1_xp, ek2_xp, key_tag) {
  .Call(`_openfhe_R_MultiAddEvalMultKeys`, cc_xp, ek1_xp, ek2_xp, key_tag)
}

MultiKeySwitchGen <- function(cc_xp, sk_orig_xp, sk_new_xp, ek_xp) {
  .Call(`_openfhe_R_MultiKeySwitchGen`, cc_xp, sk_orig_xp, sk_new_xp, ek_xp)
}

MultipartyDecryptLead <- function(cc_xp, sk_xp, ct_xp) {
  .Call(`_openfhe_R_MultipartyDecryptLead`, cc_xp, sk_xp, ct_xp)
}

MultipartyDecryptMain <- function(cc_xp, sk_xp, ct_xp) {
  .Call(`_openfhe_R_MultipartyDecryptMain`, cc_xp, sk_xp, ct_xp)
}

MultipartyDecryptFusion <- function(cc_xp, partials_list) {
  .Call(`_openfhe_R_MultipartyDecryptFusion`, cc_xp, partials_list)
}

ElementParams__GetCyclotomicOrder <- function(ep_xp) {
  .Call(`_openfhe_R_ElementParams__GetCyclotomicOrder`, ep_xp)
}

ElementParams__GetRingDimension <- function(ep_xp) {
  .Call(`_openfhe_R_ElementParams__GetRingDimension`, ep_xp)
}

ElementParams__GetModulus <- function(ep_xp) {
  .Call(`_openfhe_R_ElementParams__GetModulus`, ep_xp)
}

EncodingParams__GetBatchSize <- function(ep_xp) {
  .Call(`_openfhe_R_EncodingParams__GetBatchSize`, ep_xp)
}

EncodingParams__GetPlaintextModulus <- function(ep_xp) {
  .Call(`_openfhe_R_EncodingParams__GetPlaintextModulus`, ep_xp)
}

EncodingParams__GetPlaintextGenerator <- function(ep_xp) {
  .Call(`_openfhe_R_EncodingParams__GetPlaintextGenerator`, ep_xp)
}

CryptoContext__GetModulus <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetModulus`, cc_xp)
}

CryptoContext__GetModulusCKKS <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetModulusCKKS`, cc_xp)
}

CryptoContext__GetRootOfUnity <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetRootOfUnity`, cc_xp)
}

CryptoContext__GetScheme <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__GetScheme`, cc_xp)
}

CryptoContext__setSchemeId <- function(cc_xp, scheme_tag) {
  invisible(.Call(`_openfhe_R_CryptoContext__setSchemeId`, cc_xp, scheme_tag))
}

CryptoContext__SerializedObjectName <- function(cc_xp) {
  .Call(`_openfhe_R_CryptoContext__SerializedObjectName`, cc_xp)
}

CryptoContext__SerializedVersion <- function() {
  .Call(`_openfhe_R_CryptoContext__SerializedVersion`)
}

CryptoContext__ClearCaches <- function(cc_xp, which) {
  invisible(.Call(`_openfhe_R_CryptoContext__ClearCaches`, cc_xp, which))
}

CryptoContext__SetRNS <- function(cc_xp, field, value) {
  invisible(.Call(`_openfhe_R_CryptoContext__SetRNS`, cc_xp, field, value))
}

CryptoContext__GetPlaintextForDecrypt <- function(encoding_type, ep_xp, encp_xp, ckks_data_type) {
  .Call(`_openfhe_R_CryptoContext__GetPlaintextForDecrypt`, encoding_type, ep_xp, encp_xp, ckks_data_type)
}

CryptoContext__GetUniqueValues <- function(old_values, new_values) {
  .Call(`_openfhe_R_CryptoContext__GetUniqueValues`, old_values, new_values)
}

CryptoContext__GetExistingEvalAutomorphismKeyIndices <- function(key_tag) {
  .Call(`_openfhe_R_CryptoContext__GetExistingEvalAutomorphismKeyIndices`, key_tag)
}

CryptoContext__GetEvalAutomorphismNoKeyIndices <- function(key_tag, indices) {
  .Call(`_openfhe_R_CryptoContext__GetEvalAutomorphismNoKeyIndices`, key_tag, indices)
}

EvalKey__GetKeyTag <- function(ek_xp) {
  .Call(`_openfhe_R_EvalKey__GetKeyTag`, ek_xp)
}

EvalKey__SetKeyTag <- function(ek_xp, tag) {
  invisible(.Call(`_openfhe_R_EvalKey__SetKeyTag`, ek_xp, tag))
}

PublicKey__GetCryptoContext <- function(pk_xp) {
  .Call(`_openfhe_R_PublicKey__GetCryptoContext`, pk_xp)
}

PrivateKey__GetCryptoContext <- function(sk_xp) {
  .Call(`_openfhe_R_PrivateKey__GetCryptoContext`, sk_xp)
}

Ciphertext__Clone <- function(ct_xp, empty) {
  .Call(`_openfhe_R_Ciphertext__Clone`, ct_xp, empty)
}

Ciphertext__NumberCiphertextElements <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__NumberCiphertextElements`, ct_xp)
}

Ciphertext__RemoveElement <- function(ct_xp, index) {
  invisible(.Call(`_openfhe_R_Ciphertext__RemoveElement`, ct_xp, index))
}

Ciphertext__GetHopLevel <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetHopLevel`, ct_xp)
}

Ciphertext__SetHopLevel <- function(ct_xp, hop_level) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetHopLevel`, ct_xp, hop_level))
}

Ciphertext__SetEncodingType <- function(ct_xp, encoding_type) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetEncodingType`, ct_xp, encoding_type))
}

Ciphertext__GetElements <- function(ct_xp) {
  .Call(`_openfhe_R_Ciphertext__GetElements`, ct_xp)
}

Ciphertext__SetElements <- function(ct_xp, elements) {
  invisible(.Call(`_openfhe_R_Ciphertext__SetElements`, ct_xp, elements))
}

Plaintext__Encode <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__Encode`, pt_xp)
}

Plaintext__Decode <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__Decode`, pt_xp)
}

Plaintext__Decode__ckks <- function(pt_xp, depth, scaling_factor, scal_tech, execution_mode) {
  .Call(`_openfhe_R_Plaintext__Decode__ckks`, pt_xp, depth, scaling_factor, scal_tech, execution_mode)
}

Plaintext__GetElementModulus <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetElementModulus`, pt_xp)
}

Plaintext__GetEncodingParams <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetEncodingParams`, pt_xp)
}

Plaintext__SetFormat <- function(pt_xp, format) {
  invisible(.Call(`_openfhe_R_Plaintext__SetFormat`, pt_xp, format))
}

Plaintext__GetEncodingType <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetEncodingType`, pt_xp)
}

Plaintext__GetScalingFactor <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetScalingFactor`, pt_xp)
}

Plaintext__GetScalingFactorInt <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetScalingFactorInt`, pt_xp)
}

Plaintext__GetSchemeID <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetSchemeID`, pt_xp)
}

Plaintext__IsEncoded <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__IsEncoded`, pt_xp)
}

Plaintext__GetCKKSDataType <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetCKKSDataType`, pt_xp)
}

Plaintext__GetLength <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetLength`, pt_xp)
}

Plaintext__LowBound <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__LowBound`, pt_xp)
}

Plaintext__HighBound <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__HighBound`, pt_xp)
}

Plaintext__GetNoiseScaleDeg <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetNoiseScaleDeg`, pt_xp)
}

Plaintext__GetLevel <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetLevel`, pt_xp)
}

Plaintext__GetSlots <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetSlots`, pt_xp)
}

Plaintext__GetLogError <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetLogError`, pt_xp)
}

Plaintext__GetLogPrecision <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetLogPrecision`, pt_xp)
}

Plaintext__GetFormattedValues <- function(pt_xp, precision) {
  .Call(`_openfhe_R_Plaintext__GetFormattedValues`, pt_xp, precision)
}

Plaintext__GetCoefPackedValue <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetCoefPackedValue`, pt_xp)
}

Plaintext__GetStringValue <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetStringValue`, pt_xp)
}

Plaintext__GetElementRingDimension <- function(pt_xp) {
  .Call(`_openfhe_R_Plaintext__GetElementRingDimension`, pt_xp)
}

Plaintext__SetScalingFactor <- function(pt_xp, sf) {
  invisible(.Call(`_openfhe_R_Plaintext__SetScalingFactor`, pt_xp, sf))
}

Plaintext__SetScalingFactorInt <- function(pt_xp, sf) {
  invisible(.Call(`_openfhe_R_Plaintext__SetScalingFactorInt`, pt_xp, sf))
}

Plaintext__SetCKKSDataType <- function(pt_xp, cdt) {
  invisible(.Call(`_openfhe_R_Plaintext__SetCKKSDataType`, pt_xp, cdt))
}

Plaintext__SetNoiseScaleDeg <- function(pt_xp, d) {
  invisible(.Call(`_openfhe_R_Plaintext__SetNoiseScaleDeg`, pt_xp, d))
}

Plaintext__SetLevel <- function(pt_xp, level) {
  invisible(.Call(`_openfhe_R_Plaintext__SetLevel`, pt_xp, level))
}

Plaintext__SetSlots <- function(pt_xp, slots) {
  invisible(.Call(`_openfhe_R_Plaintext__SetSlots`, pt_xp, slots))
}

Plaintext__SetStringValue <- function(pt_xp, value) {
  invisible(.Call(`_openfhe_R_Plaintext__SetStringValue`, pt_xp, value))
}

Plaintext__SetIntVectorValue <- function(pt_xp, value) {
  invisible(.Call(`_openfhe_R_Plaintext__SetIntVectorValue`, pt_xp, value))
}

SchSwchParams__new <- function() {
  .Call(`_openfhe_R_SchSwchParams__new`)
}

SchSwchParams__Set <- function(xp, field, value) {
  invisible(.Call(`_openfhe_R_SchSwchParams__Set`, xp, field, value))
}

SchSwchParams__Get <- function(xp, field) {
  .Call(`_openfhe_R_SchSwchParams__Get`, xp, field)
}

SchSwchParams__SetInitialCKKSModulus <- function(xp, modulus) {
  invisible(.Call(`_openfhe_R_SchSwchParams__SetInitialCKKSModulus`, xp, modulus))
}

SchSwchParams__GetInitialCKKSModulus <- function(xp) {
  .Call(`_openfhe_R_SchSwchParams__GetInitialCKKSModulus`, xp)
}

SchSwchParams__SetParamsFromCKKSCryptocontextCalled <- function(xp) {
  invisible(.Call(`_openfhe_R_SchSwchParams__SetParamsFromCKKSCryptocontextCalled`, xp))
}

SchSwchParams__str <- function(xp) {
  .Call(`_openfhe_R_SchSwchParams__str`, xp)
}

SetParamsFromCKKSCryptocontext__ <- function(cc_xp, params_xp) {
  invisible(.Call(`_openfhe_R_SetParamsFromCKKSCryptocontext__`, cc_xp, params_xp))
}

GetBinCCForSchemeSwitch__ <- function(cc_xp) {
  .Call(`_openfhe_R_GetBinCCForSchemeSwitch__`, cc_xp)
}

SetBinCCForSchemeSwitch__ <- function(cc_xp, bin_xp) {
  invisible(.Call(`_openfhe_R_SetBinCCForSchemeSwitch__`, cc_xp, bin_xp))
}

GetSwkFC__ <- function(cc_xp) {
  .Call(`_openfhe_R_GetSwkFC__`, cc_xp)
}

SetSwkFC__ <- function(cc_xp, ct_xp) {
  invisible(.Call(`_openfhe_R_SetSwkFC__`, cc_xp, ct_xp))
}

SchemeSwitchSetup__ <- function(cc_xp, params_xp, both) {
  .Call(`_openfhe_R_SchemeSwitchSetup__`, cc_xp, params_xp, both)
}

EvalCkksToFhewKeyGen__ <- function(cc_xp, pk_xp, sk_xp, lwesk_xp) {
  invisible(.Call(`_openfhe_R_EvalCkksToFhewKeyGen__`, cc_xp, pk_xp, sk_xp, lwesk_xp))
}

EvalSchemeSwitchingKeyGen__ <- function(cc_xp, pk_xp, sk_xp, lwesk_xp) {
  invisible(.Call(`_openfhe_R_EvalSchemeSwitchingKeyGen__`, cc_xp, pk_xp, sk_xp, lwesk_xp))
}

EvalCKKStoFHEWPrecompute__ <- function(cc_xp, scale) {
  invisible(.Call(`_openfhe_R_EvalCKKStoFHEWPrecompute__`, cc_xp, scale))
}

EvalCKKStoFHEW__ <- function(ct_xp, num_ctxts) {
  .Call(`_openfhe_R_EvalCKKStoFHEW__`, ct_xp, num_ctxts)
}

EvalFHEWtoCKKSSetup__ <- function(cc_xp, bin_xp, num_slots_ckks, log_q) {
  invisible(.Call(`_openfhe_R_EvalFHEWtoCKKSSetup__`, cc_xp, bin_xp, num_slots_ckks, log_q))
}

EvalFhewToCkksKeyGen__ <- function(cc_xp, pk_xp, sk_xp, lwesk_xp, num_slots, num_ctxts, dim1, l) {
  invisible(.Call(`_openfhe_R_EvalFhewToCkksKeyGen__`, cc_xp, pk_xp, sk_xp, lwesk_xp, num_slots, num_ctxts, dim1, l))
}

EvalFHEWtoCKKS__ <- function(cc_xp, lwe_ciphertexts, num_ctxts, num_slots, p, pmin, pmax, dim1) {
  .Call(`_openfhe_R_EvalFHEWtoCKKS__`, cc_xp, lwe_ciphertexts, num_ctxts, num_slots, p, pmin, pmax, dim1)
}

EvalCompareSwitchPrecompute__ <- function(cc_xp, p_lwe, scale_sign, unit) {
  invisible(.Call(`_openfhe_R_EvalCompareSwitchPrecompute__`, cc_xp, p_lwe, scale_sign, unit))
}

EvalCompareSchemeSwitching__ <- function(ct1_xp, ct2_xp, num_ctxts, num_slots, p_lwe, scale_sign, unit) {
  .Call(`_openfhe_R_EvalCompareSchemeSwitching__`, ct1_xp, ct2_xp, num_ctxts, num_slots, p_lwe, scale_sign, unit)
}

EvalMinMaxSchemeSwitching__ <- function(ct_xp, pk_xp, which, num_values, num_slots, p_lwe, scale_sign) {
  .Call(`_openfhe_R_EvalMinMaxSchemeSwitching__`, ct_xp, pk_xp, which, num_values, num_slots, p_lwe, scale_sign)
}

PolyVector__new <- function() {
  .Call(`_openfhe_R_PolyVector__new`)
}

PolyVector__length <- function(xp) {
  .Call(`_openfhe_R_PolyVector__length`, xp)
}

PolyVector__clone <- function(xp) {
  .Call(`_openfhe_R_PolyVector__clone`, xp)
}

PolyVector__SwitchModulus <- function(xp, modulus) {
  invisible(.Call(`_openfhe_R_PolyVector__SwitchModulus`, xp, modulus))
}

PolyVector__sub <- function(a_xp, b_xp) {
  .Call(`_openfhe_R_PolyVector__sub`, a_xp, b_xp)
}

Schemelet__GetElementParams <- function(sk_xp, level) {
  .Call(`_openfhe_R_Schemelet__GetElementParams`, sk_xp, level)
}

Schemelet__EncryptCoeff <- function(input, q, p, sk_xp, ep_xp, bit_reverse) {
  .Call(`_openfhe_R_Schemelet__EncryptCoeff`, input, q, p, sk_xp, ep_xp, bit_reverse)
}

Schemelet__DecryptCoeff <- function(input_xp, q, p, sk_xp, ep_xp, num_slots, length, bit_reverse) {
  .Call(`_openfhe_R_Schemelet__DecryptCoeff`, input_xp, q, p, sk_xp, ep_xp, num_slots, length, bit_reverse)
}

Schemelet__ModSwitch <- function(input_xp, q1, q2) {
  invisible(.Call(`_openfhe_R_Schemelet__ModSwitch`, input_xp, q1, q2))
}

Schemelet__ConvertRLWEToCKKS <- function(cc_xp, coeffs_xp, pk_xp, big_q, slots, level) {
  .Call(`_openfhe_R_Schemelet__ConvertRLWEToCKKS`, cc_xp, coeffs_xp, pk_xp, big_q, slots, level)
}

Schemelet__ConvertCKKSToRLWE <- function(ct_xp, q) {
  .Call(`_openfhe_R_Schemelet__ConvertCKKSToRLWE`, ct_xp, q)
}

Schemelet__GetQPrime <- function(pk_xp, lvls) {
  .Call(`_openfhe_R_Schemelet__GetQPrime`, pk_xp, lvls)
}

SchSwchSerializer__new <- function(cc_xp, pk_xp, ct_xp) {
  .Call(`_openfhe_R_SchSwchSerializer__new`, cc_xp, pk_xp, ct_xp)
}

SchSwchDeserializer__new <- function() {
  .Call(`_openfhe_R_SchSwchDeserializer__new`)
}

SchSwchSerializer__SetDataDirectory <- function(xp, dir) {
  invisible(.Call(`_openfhe_R_SchSwchSerializer__SetDataDirectory`, xp, dir))
}

SchSwchDeserializer__SetDataDirectory <- function(xp, dir) {
  invisible(.Call(`_openfhe_R_SchSwchDeserializer__SetDataDirectory`, xp, dir))
}

SchSwchSerializer__Serialize <- function(xp) {
  invisible(.Call(`_openfhe_R_SchSwchSerializer__Serialize`, xp))
}

SchSwchDeserializer__Deserialize <- function(xp) {
  invisible(.Call(`_openfhe_R_SchSwchDeserializer__Deserialize`, xp))
}

SchSwchDeserializer__get <- function(xp, which) {
  .Call(`_openfhe_R_SchSwchDeserializer__get`, xp, which)
}

MultipartyDecryptLead__ct_vec <- function(cc_xp, sk_xp, ct_list) {
  .Call(`_openfhe_R_MultipartyDecryptLead__ct_vec`, cc_xp, sk_xp, ct_list)
}

MultipartyDecryptMain__ct_vec <- function(cc_xp, sk_xp, ct_list) {
  .Call(`_openfhe_R_MultipartyDecryptMain__ct_vec`, cc_xp, sk_xp, ct_list)
}

CryptoContext__ShareKeys <- function(cc_xp, sk_xp, n_parties, threshold, index, sharing_scheme) {
  .Call(`_openfhe_R_CryptoContext__ShareKeys`, cc_xp, sk_xp, n_parties, threshold, index, sharing_scheme)
}

SecretShareMap__length <- function(share_map_xp) {
  .Call(`_openfhe_R_SecretShareMap__length`, share_map_xp)
}

CryptoContext__RecoverSharedKey <- function(cc_xp, share_map_xp, n_parties, threshold, sharing_scheme) {
  .Call(`_openfhe_R_CryptoContext__RecoverSharedKey`, cc_xp, share_map_xp, n_parties, threshold, sharing_scheme)
}

Serialize__CryptoContext <- function(cc_xp, filename, binary) {
  .Call(`_openfhe_R_Serialize__CryptoContext`, cc_xp, filename, binary)
}

Serialize__PublicKey <- function(pk_xp, filename, binary) {
  .Call(`_openfhe_R_Serialize__PublicKey`, pk_xp, filename, binary)
}

Serialize__PrivateKey <- function(sk_xp, filename, binary) {
  .Call(`_openfhe_R_Serialize__PrivateKey`, sk_xp, filename, binary)
}

Serialize__Ciphertext <- function(ct_xp, filename, binary) {
  .Call(`_openfhe_R_Serialize__Ciphertext`, ct_xp, filename, binary)
}

Deserialize__CryptoContext <- function(filename, binary) {
  .Call(`_openfhe_R_Deserialize__CryptoContext`, filename, binary)
}

Deserialize__PublicKey <- function(filename, binary) {
  .Call(`_openfhe_R_Deserialize__PublicKey`, filename, binary)
}

Deserialize__PrivateKey <- function(filename, binary) {
  .Call(`_openfhe_R_Deserialize__PrivateKey`, filename, binary)
}

Deserialize__Ciphertext <- function(filename, binary) {
  .Call(`_openfhe_R_Deserialize__Ciphertext`, filename, binary)
}

Serialize__EvalMultKey <- function(filename, binary, key_tag) {
  .Call(`_openfhe_R_Serialize__EvalMultKey`, filename, binary, key_tag)
}

Deserialize__EvalMultKey <- function(filename, binary) {
  .Call(`_openfhe_R_Deserialize__EvalMultKey`, filename, binary)
}

Serialize__EvalAutomorphismKey <- function(filename, binary, key_tag) {
  .Call(`_openfhe_R_Serialize__EvalAutomorphismKey`, filename, binary, key_tag)
}

Deserialize__EvalAutomorphismKey <- function(filename, binary) {
  .Call(`_openfhe_R_Deserialize__EvalAutomorphismKey`, filename, binary)
}

ClearEvalMultKeys <- function() {
  invisible(.Call(`_openfhe_R_ClearEvalMultKeys`))
}

ClearEvalAutomorphismKeys <- function() {
  invisible(.Call(`_openfhe_R_ClearEvalAutomorphismKeys`))
}

ReleaseAllContexts <- function() {
  invisible(.Call(`_openfhe_R_ReleaseAllContexts`))
}

SerializeMem__ <- function(xp, kind, binary) {
  .Call(`_openfhe_R_SerializeMem__`, xp, kind, binary)
}

SerializeMem__EvalKeyVector <- function(eks, binary) {
  .Call(`_openfhe_R_SerializeMem__EvalKeyVector`, eks, binary)
}

DeserializeMem__ <- function(data, kind, binary) {
  .Call(`_openfhe_R_DeserializeMem__`, data, kind, binary)
}

SerializeFile__ <- function(xp, kind, filename, binary) {
  .Call(`_openfhe_R_SerializeFile__`, xp, kind, filename, binary)
}

DeserializeFile__ <- function(filename, kind, binary) {
  .Call(`_openfhe_R_DeserializeFile__`, filename, kind, binary)
}

SerializeEvalKeys__ <- function(which, filename, binary, key_tag, cc_xp) {
  .Call(`_openfhe_R_SerializeEvalKeys__`, which, filename, binary, key_tag, cc_xp)
}

DeserializeEvalKeysMem__ <- function(data, which, binary) {
  .Call(`_openfhe_R_DeserializeEvalKeysMem__`, data, which, binary)
}

SerializeEvalBootstrapKey__ <- function(filename, binary, cc_xp, key_tag, slots) {
  .Call(`_openfhe_R_SerializeEvalBootstrapKey__`, filename, binary, cc_xp, key_tag, slots)
}

DeserializeEvalBootstrapKey__ <- function(filename, binary, cc_xp, key_tag, slots, index_list) {
  .Call(`_openfhe_R_DeserializeEvalBootstrapKey__`, filename, binary, cc_xp, key_tag, slots, index_list)
}

Serialize__EvalSumKey <- function(filename, binary, key_tag) {
  .Call(`_openfhe_R_Serialize__EvalSumKey`, filename, binary, key_tag)
}

Deserialize__EvalSumKey <- function(filename, binary) {
  .Call(`_openfhe_R_Deserialize__EvalSumKey`, filename, binary)
}

xptr_type <- function(xp) {
  .Call(`_openfhe_R_xptr_type`, xp)
}