SYMBOL INDEX (1673 symbols across 47 files)

FILE: bindings/blst.h
  type __SIZE_TYPE__ (line 10) | typedef __SIZE_TYPE__ size_t;
  type __UINT8_TYPE__ (line 17) | typedef __UINT8_TYPE__  uint8_t;
  type __UINT32_TYPE__ (line 18) | typedef __UINT32_TYPE__ uint32_t;
  type __UINT64_TYPE__ (line 19) | typedef __UINT64_TYPE__ uint64_t;
  type _Bool (line 28) | typedef _Bool bool;
  type BLST_ERROR (line 47) | typedef enum {
  type byte (line 58) | typedef uint8_t byte;
  type limb_t (line 59) | typedef uint64_t limb_t;
  type blst_scalar (line 61) | typedef struct { byte b[256/8]; } blst_scalar;
  type blst_fr (line 62) | typedef struct { limb_t l[256/8/sizeof(limb_t)]; } blst_fr;
  type blst_fp (line 63) | typedef struct { limb_t l[384/8/sizeof(limb_t)]; } blst_fp;
  type blst_fp2 (line 65) | typedef struct { blst_fp fp[2]; } blst_fp2;
  type blst_fp6 (line 66) | typedef struct { blst_fp2 fp2[3]; } blst_fp6;
  type blst_fp12 (line 67) | typedef struct { blst_fp6 fp6[2]; } blst_fp12;
  type blst_p1 (line 169) | typedef struct { blst_fp x, y, z; } blst_p1;
  type blst_p1_affine (line 170) | typedef struct { blst_fp x, y; } blst_p1_affine;
  type blst_p2 (line 196) | typedef struct { blst_fp2 x, y, z; } blst_p2;
  type blst_p2_affine (line 197) | typedef struct { blst_fp2 x, y; } blst_p2_affine;
  type limb_t (line 356) | typedef limb_t blst_pairing;
  type blst_pairing (line 358) | typedef struct {} blst_pairing;
  type blst_pairing (line 360) | typedef struct blst_opaque blst_pairing;

FILE: bindings/blst.hpp
  type blst (line 19) | namespace blst {
    type bytes_t (line 32) | struct bytes_t {
      method bytes_t (line 36) | bytes_t() = default;
      method bytes_t (line 37) | bytes_t(const byte* p, size_t l) : ptr{p}, len{l} {}
      method bytes_t (line 39) | bytes_t(const C<T>& c)
      method bytes_t (line 46) | bytes_t(const C<T, N>& c)
    class P1_Affine (line 54) | class P1_Affine
      method P1_Affine (line 192) | P1_Affine(const blst_p1_affine *cptr) { point = *cptr; }
      method P1_Affine (line 194) | P1_Affine() { memset(&point, 0, sizeof(point)); }
      method P1_Affine (line 196) | P1_Affine(const byte *in)
      method P1_Affine (line 202) | P1_Affine(const byte *in, size_t len)
      method P1_Affine (line 211) | P1_Affine dup() const { return *this; }
      method serialize (line 213) | void serialize(byte out[96]) const
      method compress (line 215) | void compress(byte out[48]) const
      method on_curve (line 217) | bool on_curve() const { return blst_p1_affine_on_curve(&point); }
      method in_group (line 218) | bool in_group() const { return blst_p1_affine_in_g1(&point);    }
      method is_inf (line 219) | bool is_inf() const   { return blst_p1_affine_is_inf(&point);   }
      method is_equal (line 220) | bool is_equal(const P1_Affine& p) const
      method BLST_ERROR (line 228) | BLST_ERROR core_verify(const P2_Affine& pk, bool hash_or_encode,
      method P1_Affine (line 234) | static P1_Affine generator()
    class P1 (line 55) | class P1
      method P1 (line 251) | P1(const blst_p1 *cptr) { point = *cptr; }
      method P1 (line 253) | P1() { memset(&point, 0, sizeof(point)); }
      method P1 (line 254) | P1(const SecretKey& sk) { blst_sk_to_pk_in_g1(&point, &sk.key); }
      method P1 (line 256) | P1(const byte *in)
      method P1 (line 264) | P1(const byte *in, size_t len)
      method P1 (line 273) | P1(const P1_Affine& affine) { blst_p1_from_affine(&point, affine); }
      method P1 (line 275) | P1 dup() const                      { return *this; }
      method P1_Affine (line 276) | P1_Affine to_affine() const         { return P1_Affine(*this);      ...
      method serialize (line 277) | void serialize(byte out[96]) const  { blst_p1_serialize(out, &point)...
      method compress (line 278) | void compress(byte out[48]) const   { blst_p1_compress(out, &point);...
      method on_curve (line 279) | bool on_curve() const               { return blst_p1_on_curve(&point...
      method in_group (line 280) | bool in_group() const               { return blst_p1_in_g1(&point); ...
      method is_inf (line 281) | bool is_inf() const                 { return blst_p1_is_inf(&point);...
      method is_equal (line 282) | bool is_equal(const P1& p) const
      method aggregate (line 284) | void aggregate(const P1_Affine& in)
      method P1 (line 290) | P1* sign_with(const SecretKey& sk)
      method P1 (line 292) | P1* sign_with(const Scalar& scalar)
      method P1 (line 294) | P1* hash_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 300) | P1* encode_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 307) | P1* hash_to(const byte* msg, size_t msg_len,
      method P1 (line 314) | P1* encode_to(const byte* msg, size_t msg_len,
      method P1 (line 322) | P1* mult(const byte* scalar, size_t nbits)
      method P1 (line 324) | P1* mult(const Scalar& scalar)
      method P1 (line 326) | P1* cneg(bool flag)
      method P1 (line 328) | P1* neg()
      method P1 (line 330) | P1* add(const P1& a)
      method P1 (line 332) | P1* add(const P1_Affine &a)
      method P1 (line 334) | P1* dbl()
      method P1 (line 337) | static P1 add(const P1& a, const P1& b)
      method P1 (line 339) | static P1 add(const P1& a, const P1_Affine& b)
      method P1 (line 341) | static P1 dbl(const P1& a)
      method P1 (line 344) | static P1 generator()
    class P2_Affine (line 56) | class P2_Affine
      method P2_Affine (line 494) | P2_Affine(const blst_p2_affine *cptr) { point = *cptr; }
      method P2_Affine (line 496) | P2_Affine() { memset(&point, 0, sizeof(point)); }
      method P2_Affine (line 498) | P2_Affine(const byte *in)
      method P2_Affine (line 504) | P2_Affine(const byte *in, size_t len)
      method P2_Affine (line 513) | P2_Affine dup() const { return *this; }
      method serialize (line 515) | void serialize(byte out[192]) const
      method compress (line 517) | void compress(byte out[96]) const
      method on_curve (line 519) | bool on_curve() const { return blst_p2_affine_on_curve(&point); }
      method in_group (line 520) | bool in_group() const { return blst_p2_affine_in_g2(&point);    }
      method is_inf (line 521) | bool is_inf() const   { return blst_p2_affine_is_inf(&point);   }
      method is_equal (line 522) | bool is_equal(const P2_Affine& p) const
      method BLST_ERROR (line 530) | BLST_ERROR core_verify(const P1_Affine& pk, bool hash_or_encode,
      method P2_Affine (line 536) | static P2_Affine generator()
    class P2 (line 57) | class P2
      method P2 (line 553) | P2(const blst_p2 *cptr) { point = *cptr; }
      method P2 (line 555) | P2() { memset(&point, 0, sizeof(point)); }
      method P2 (line 556) | P2(const SecretKey& sk) { blst_sk_to_pk_in_g2(&point, &sk.key); }
      method P2 (line 558) | P2(const byte *in)
      method P2 (line 566) | P2(const byte *in, size_t len)
      method P2 (line 575) | P2(const P2_Affine& affine) { blst_p2_from_affine(&point, affine); }
      method P2 (line 577) | P2 dup() const                      { return *this; }
      method P2_Affine (line 578) | P2_Affine to_affine() const         { return P2_Affine(*this);      ...
      method serialize (line 579) | void serialize(byte out[192]) const { blst_p2_serialize(out, &point)...
      method compress (line 580) | void compress(byte out[96]) const   { blst_p2_compress(out, &point);...
      method on_curve (line 581) | bool on_curve() const               { return blst_p2_on_curve(&point...
      method in_group (line 582) | bool in_group() const               { return blst_p2_in_g2(&point); ...
      method is_inf (line 583) | bool is_inf() const                 { return blst_p2_is_inf(&point);...
      method is_equal (line 584) | bool is_equal(const P2& p) const
      method aggregate (line 586) | void aggregate(const P2_Affine& in)
      method P2 (line 592) | P2* sign_with(const SecretKey& sk)
      method P2 (line 594) | P2* sign_with(const Scalar& scalar)
      method P2 (line 596) | P2* hash_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 602) | P2* encode_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 609) | P2* hash_to(const byte* msg, size_t msg_len,
      method P2 (line 616) | P2* encode_to(const byte* msg, size_t msg_len,
      method P2 (line 625) | P2* mult(const byte* scalar, size_t nbits)
      method P2 (line 627) | P2* mult(const Scalar& scalar)
      method P2 (line 629) | P2* cneg(bool flag)
      method P2 (line 631) | P2* neg()
      method P2 (line 633) | P2* add(const P2& a)
      method P2 (line 635) | P2* add(const P2_Affine &a)
      method P2 (line 637) | P2* dbl()
      method P2 (line 640) | static P2 add(const P2& a, const P2& b)
      method P2 (line 642) | static P2 add(const P2& a, const P2_Affine& b)
      method P2 (line 644) | static P2 dbl(const P2& a)
      method P2 (line 647) | static P2 generator()
    class Pairing (line 58) | class Pairing
      method init (line 869) | void init(bool hash_or_encode, const byte* DST, size_t DST_len)
      method Pairing (line 883) | Pairing(bool hash_or_encode, const std::string& DST)
      method Pairing (line 887) | Pairing(bool hash_or_encode, const byte* DST, size_t DST_len)
      method BLST_ERROR (line 892) | BLST_ERROR aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 897) | BLST_ERROR aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method BLST_ERROR (line 902) | BLST_ERROR mul_n_aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 908) | BLST_ERROR mul_n_aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method BLST_ERROR (line 915) | BLST_ERROR aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 921) | BLST_ERROR aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method BLST_ERROR (line 927) | BLST_ERROR mul_n_aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 934) | BLST_ERROR mul_n_aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method commit (line 942) | void commit()
      method BLST_ERROR (line 944) | BLST_ERROR merge(const Pairing* ctx)
      method finalverify (line 946) | bool finalverify(const PT* sig = nullptr) const
      method raw_aggregate (line 950) | void raw_aggregate(const P2_Affine* q, const P1_Affine* p)
      method PT (line 952) | PT as_fp12()
    function byte (line 60) | inline const byte *C_bytes(const void *ptr)
    type SecretKey (line 72) | struct SecretKey {
      method keygen (line 82) | void keygen(const byte* IKM, size_t IKM_len,
      method keygen_v3 (line 85) | void keygen_v3(const byte* IKM, size_t IKM_len,
      method keygen_v4_5 (line 88) | void keygen_v4_5(const byte* IKM, size_t IKM_len,
      method keygen_v5 (line 94) | void keygen_v5(const byte* IKM, size_t IKM_len,
      method keygen (line 101) | void keygen(bytes_t IKM, const std::string& info = "")
      method keygen_v3 (line 103) | void keygen_v3(bytes_t IKM, const std::string& info = "")
      method keygen_v4_5 (line 105) | void keygen_v4_5(bytes_t IKM, bytes_t salt, const std::string& info ...
      method keygen_v5 (line 107) | void keygen_v5(bytes_t IKM, bytes_t salt, const std::string& info = "")
      method derive_master_eip2333 (line 109) | void derive_master_eip2333(const byte* IKM, size_t IKM_len)
      method derive_child_eip2333 (line 111) | void derive_child_eip2333(const SecretKey& SK, unsigned int child_in...
      method from_bendian (line 114) | void from_bendian(const byte in[32]) { blst_scalar_from_bendian(&key...
      method from_lendian (line 115) | void from_lendian(const byte in[32]) { blst_scalar_from_lendian(&key...
      method to_bendian (line 117) | void to_bendian(byte out[32]) const
      method to_lendian (line 119) | void to_lendian(byte out[32]) const
    class Scalar (line 123) | class Scalar {
      method Scalar (line 128) | Scalar() { memset(&val, 0, sizeof(val)); }
      method Scalar (line 129) | Scalar(const byte* scalar, size_t nbits)
      method Scalar (line 132) | Scalar(const byte *msg, size_t msg_len, const std::string& DST)
      method Scalar (line 135) | Scalar* hash_to(const byte *msg, size_t msg_len, const std::string& ...
      method Scalar (line 143) | Scalar(bytes_t msg, const std::string& DST)
      method Scalar (line 145) | Scalar* hash_to(bytes_t msg, const std::string& DST = "")
      method Scalar (line 148) | Scalar dup() const { return *this; }
      method Scalar (line 149) | Scalar* from_bendian(const byte *msg, size_t msg_len)
      method Scalar (line 151) | Scalar* from_lendian(const byte *msg, size_t msg_len)
      method to_bendian (line 153) | void to_bendian(byte out[32]) const
      method to_lendian (line 155) | void to_lendian(byte out[32]) const
      method Scalar (line 158) | Scalar* add(const Scalar& a)
      method Scalar (line 163) | Scalar* add(const SecretKey& a)
      method Scalar (line 168) | Scalar* sub(const Scalar& a)
      method Scalar (line 173) | Scalar* mul(const Scalar& a)
      method Scalar (line 178) | Scalar* inverse()
    class P1_Affine (line 188) | class P1_Affine {
      method P1_Affine (line 192) | P1_Affine(const blst_p1_affine *cptr) { point = *cptr; }
      method P1_Affine (line 194) | P1_Affine() { memset(&point, 0, sizeof(point)); }
      method P1_Affine (line 196) | P1_Affine(const byte *in)
      method P1_Affine (line 202) | P1_Affine(const byte *in, size_t len)
      method P1_Affine (line 211) | P1_Affine dup() const { return *this; }
      method serialize (line 213) | void serialize(byte out[96]) const
      method compress (line 215) | void compress(byte out[48]) const
      method on_curve (line 217) | bool on_curve() const { return blst_p1_affine_on_curve(&point); }
      method in_group (line 218) | bool in_group() const { return blst_p1_affine_in_g1(&point);    }
      method is_inf (line 219) | bool is_inf() const   { return blst_p1_affine_is_inf(&point);   }
      method is_equal (line 220) | bool is_equal(const P1_Affine& p) const
      method BLST_ERROR (line 228) | BLST_ERROR core_verify(const P2_Affine& pk, bool hash_or_encode,
      method P1_Affine (line 234) | static P1_Affine generator()
    class P1 (line 247) | class P1 {
      method P1 (line 251) | P1(const blst_p1 *cptr) { point = *cptr; }
      method P1 (line 253) | P1() { memset(&point, 0, sizeof(point)); }
      method P1 (line 254) | P1(const SecretKey& sk) { blst_sk_to_pk_in_g1(&point, &sk.key); }
      method P1 (line 256) | P1(const byte *in)
      method P1 (line 264) | P1(const byte *in, size_t len)
      method P1 (line 273) | P1(const P1_Affine& affine) { blst_p1_from_affine(&point, affine); }
      method P1 (line 275) | P1 dup() const                      { return *this; }
      method P1_Affine (line 276) | P1_Affine to_affine() const         { return P1_Affine(*this);      ...
      method serialize (line 277) | void serialize(byte out[96]) const  { blst_p1_serialize(out, &point)...
      method compress (line 278) | void compress(byte out[48]) const   { blst_p1_compress(out, &point);...
      method on_curve (line 279) | bool on_curve() const               { return blst_p1_on_curve(&point...
      method in_group (line 280) | bool in_group() const               { return blst_p1_in_g1(&point); ...
      method is_inf (line 281) | bool is_inf() const                 { return blst_p1_is_inf(&point);...
      method is_equal (line 282) | bool is_equal(const P1& p) const
      method aggregate (line 284) | void aggregate(const P1_Affine& in)
      method P1 (line 290) | P1* sign_with(const SecretKey& sk)
      method P1 (line 292) | P1* sign_with(const Scalar& scalar)
      method P1 (line 294) | P1* hash_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 300) | P1* encode_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 307) | P1* hash_to(const byte* msg, size_t msg_len,
      method P1 (line 314) | P1* encode_to(const byte* msg, size_t msg_len,
      method P1 (line 322) | P1* mult(const byte* scalar, size_t nbits)
      method P1 (line 324) | P1* mult(const Scalar& scalar)
      method P1 (line 326) | P1* cneg(bool flag)
      method P1 (line 328) | P1* neg()
      method P1 (line 330) | P1* add(const P1& a)
      method P1 (line 332) | P1* add(const P1_Affine &a)
      method P1 (line 334) | P1* dbl()
      method P1 (line 337) | static P1 add(const P1& a, const P1& b)
      method P1 (line 339) | static P1 add(const P1& a, const P1_Affine& b)
      method P1 (line 341) | static P1 dbl(const P1& a)
      method P1 (line 344) | static P1 generator()
    class P1_Affines (line 354) | class P1_Affines {
      type p1_affine_no_init (line 356) | struct p1_affine_no_init {
        method p1_affine_no_init (line 358) | p1_affine_no_init() { }
      method P1_Affines (line 368) | P1_Affines() {}
      method P1_Affines (line 369) | P1_Affines(size_t wbits, const P1_Affine* const points[], size_t npo...
      method P1_Affines (line 377) | P1_Affines(size_t wbits, const P1_Affine points[], size_t npoints)
      method P1_Affines (line 381) | P1_Affines(size_t wbits, const std::vector<P1_Affine>& points)
      method P1_Affines (line 384) | P1_Affines(size_t wbits, const P1* const points[], size_t npoints)
      method P1_Affines (line 396) | P1_Affines(size_t wbits, const P1 points[], size_t npoints)
      method P1_Affines (line 400) | P1_Affines(size_t wbits, const std::vector<P1>& points)
      method P1_Affines (line 403) | P1_Affines(const P1* const points[], size_t npoints)
      method P1_Affines (line 411) | P1_Affines(const P1 points[], size_t npoints)
      method P1_Affines (line 415) | P1_Affines(const std::vector<P1>& points)
      method P1 (line 418) | P1 mult(const byte* const scalars[], size_t nbits) const
      method from (line 436) | static std::vector<P1_Affine> from(const P1* const points[], size_t ...
      method from (line 444) | static std::vector<P1_Affine> from(const P1 points[], size_t npoints)
      method from (line 448) | static std::vector<P1_Affine> from(const std::vector<P1>& points)
      method P1 (line 452) | static P1 mult_pippenger(const P1_Affine* const points[], size_t npo...
      method P1 (line 463) | static P1 mult_pippenger(const P1_Affine points[], size_t npoints,
      method P1 (line 468) | static P1 mult_pippenger(const std::vector<P1_Affine>& points,
      method P1 (line 473) | static P1 add(const P1_Affine* const points[], size_t npoints)
      method P1 (line 481) | static P1 add(const P1_Affine points[], size_t npoints)
      method P1 (line 485) | static P1 add(const std::vector<P1_Affine>& points)
    class P2_Affine (line 490) | class P2_Affine {
      method P2_Affine (line 494) | P2_Affine(const blst_p2_affine *cptr) { point = *cptr; }
      method P2_Affine (line 496) | P2_Affine() { memset(&point, 0, sizeof(point)); }
      method P2_Affine (line 498) | P2_Affine(const byte *in)
      method P2_Affine (line 504) | P2_Affine(const byte *in, size_t len)
      method P2_Affine (line 513) | P2_Affine dup() const { return *this; }
      method serialize (line 515) | void serialize(byte out[192]) const
      method compress (line 517) | void compress(byte out[96]) const
      method on_curve (line 519) | bool on_curve() const { return blst_p2_affine_on_curve(&point); }
      method in_group (line 520) | bool in_group() const { return blst_p2_affine_in_g2(&point);    }
      method is_inf (line 521) | bool is_inf() const   { return blst_p2_affine_is_inf(&point);   }
      method is_equal (line 522) | bool is_equal(const P2_Affine& p) const
      method BLST_ERROR (line 530) | BLST_ERROR core_verify(const P1_Affine& pk, bool hash_or_encode,
      method P2_Affine (line 536) | static P2_Affine generator()
    class P2 (line 549) | class P2 {
      method P2 (line 553) | P2(const blst_p2 *cptr) { point = *cptr; }
      method P2 (line 555) | P2() { memset(&point, 0, sizeof(point)); }
      method P2 (line 556) | P2(const SecretKey& sk) { blst_sk_to_pk_in_g2(&point, &sk.key); }
      method P2 (line 558) | P2(const byte *in)
      method P2 (line 566) | P2(const byte *in, size_t len)
      method P2 (line 575) | P2(const P2_Affine& affine) { blst_p2_from_affine(&point, affine); }
      method P2 (line 577) | P2 dup() const                      { return *this; }
      method P2_Affine (line 578) | P2_Affine to_affine() const         { return P2_Affine(*this);      ...
      method serialize (line 579) | void serialize(byte out[192]) const { blst_p2_serialize(out, &point)...
      method compress (line 580) | void compress(byte out[96]) const   { blst_p2_compress(out, &point);...
      method on_curve (line 581) | bool on_curve() const               { return blst_p2_on_curve(&point...
      method in_group (line 582) | bool in_group() const               { return blst_p2_in_g2(&point); ...
      method is_inf (line 583) | bool is_inf() const                 { return blst_p2_is_inf(&point);...
      method is_equal (line 584) | bool is_equal(const P2& p) const
      method aggregate (line 586) | void aggregate(const P2_Affine& in)
      method P2 (line 592) | P2* sign_with(const SecretKey& sk)
      method P2 (line 594) | P2* sign_with(const Scalar& scalar)
      method P2 (line 596) | P2* hash_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 602) | P2* encode_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 609) | P2* hash_to(const byte* msg, size_t msg_len,
      method P2 (line 616) | P2* encode_to(const byte* msg, size_t msg_len,
      method P2 (line 625) | P2* mult(const byte* scalar, size_t nbits)
      method P2 (line 627) | P2* mult(const Scalar& scalar)
      method P2 (line 629) | P2* cneg(bool flag)
      method P2 (line 631) | P2* neg()
      method P2 (line 633) | P2* add(const P2& a)
      method P2 (line 635) | P2* add(const P2_Affine &a)
      method P2 (line 637) | P2* dbl()
      method P2 (line 640) | static P2 add(const P2& a, const P2& b)
      method P2 (line 642) | static P2 add(const P2& a, const P2_Affine& b)
      method P2 (line 644) | static P2 dbl(const P2& a)
      method P2 (line 647) | static P2 generator()
    class P2_Affines (line 657) | class P2_Affines {
      type p2_affine_no_init (line 659) | struct p2_affine_no_init {
        method p2_affine_no_init (line 661) | p2_affine_no_init() { }
      method P2_Affines (line 671) | P2_Affines() {}
      method P2_Affines (line 672) | P2_Affines(size_t wbits, const P2_Affine* const points[], size_t npo...
      method P2_Affines (line 680) | P2_Affines(size_t wbits, const P2_Affine points[], size_t npoints)
      method P2_Affines (line 684) | P2_Affines(size_t wbits, const std::vector<P2_Affine>& points)
      method P2_Affines (line 687) | P2_Affines(size_t wbits, const P2* const points[], size_t npoints)
      method P2_Affines (line 699) | P2_Affines(size_t wbits, const P2 points[], size_t npoints)
      method P2_Affines (line 703) | P2_Affines(size_t wbits, const std::vector<P2>& points)
      method P2_Affines (line 706) | P2_Affines(const P2* const points[], size_t npoints)
      method P2_Affines (line 714) | P2_Affines(const P2 points[], size_t npoints)
      method P2_Affines (line 718) | P2_Affines(const std::vector<P2>& points)
      method P2 (line 721) | P2 mult(const byte* const scalars[], size_t nbits) const
      method from (line 739) | static std::vector<P2_Affine> from(const P2* const points[], size_t ...
      method from (line 747) | static std::vector<P2_Affine> from(const P2 points[], size_t npoints)
      method from (line 751) | static std::vector<P2_Affine> from(const std::vector<P2>& points)
      method P2 (line 755) | static P2 mult_pippenger(const P2_Affine* const points[], size_t npo...
      method P2 (line 766) | static P2 mult_pippenger(const P2_Affine points[], size_t npoints,
      method P2 (line 771) | static P2 mult_pippenger(const std::vector<P2_Affine>& points,
      method P2 (line 776) | static P2 add(const P2_Affine* const points[], size_t npoints)
      method P2 (line 784) | static P2 add(const P2_Affine points[], size_t npoints)
      method P2 (line 788) | static P2 add(const std::vector<P2_Affine>& points)
    function P1 (line 798) | inline P1 P1_Affine::to_jacobian() const { P1 ret(*this); return ret; }
      method P1 (line 251) | P1(const blst_p1 *cptr) { point = *cptr; }
      method P1 (line 253) | P1() { memset(&point, 0, sizeof(point)); }
      method P1 (line 254) | P1(const SecretKey& sk) { blst_sk_to_pk_in_g1(&point, &sk.key); }
      method P1 (line 256) | P1(const byte *in)
      method P1 (line 264) | P1(const byte *in, size_t len)
      method P1 (line 273) | P1(const P1_Affine& affine) { blst_p1_from_affine(&point, affine); }
      method P1 (line 275) | P1 dup() const                      { return *this; }
      method P1_Affine (line 276) | P1_Affine to_affine() const         { return P1_Affine(*this);      ...
      method serialize (line 277) | void serialize(byte out[96]) const  { blst_p1_serialize(out, &point)...
      method compress (line 278) | void compress(byte out[48]) const   { blst_p1_compress(out, &point);...
      method on_curve (line 279) | bool on_curve() const               { return blst_p1_on_curve(&point...
      method in_group (line 280) | bool in_group() const               { return blst_p1_in_g1(&point); ...
      method is_inf (line 281) | bool is_inf() const                 { return blst_p1_is_inf(&point);...
      method is_equal (line 282) | bool is_equal(const P1& p) const
      method aggregate (line 284) | void aggregate(const P1_Affine& in)
      method P1 (line 290) | P1* sign_with(const SecretKey& sk)
      method P1 (line 292) | P1* sign_with(const Scalar& scalar)
      method P1 (line 294) | P1* hash_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 300) | P1* encode_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 307) | P1* hash_to(const byte* msg, size_t msg_len,
      method P1 (line 314) | P1* encode_to(const byte* msg, size_t msg_len,
      method P1 (line 322) | P1* mult(const byte* scalar, size_t nbits)
      method P1 (line 324) | P1* mult(const Scalar& scalar)
      method P1 (line 326) | P1* cneg(bool flag)
      method P1 (line 328) | P1* neg()
      method P1 (line 330) | P1* add(const P1& a)
      method P1 (line 332) | P1* add(const P1_Affine &a)
      method P1 (line 334) | P1* dbl()
      method P1 (line 337) | static P1 add(const P1& a, const P1& b)
      method P1 (line 339) | static P1 add(const P1& a, const P1_Affine& b)
      method P1 (line 341) | static P1 dbl(const P1& a)
      method P1 (line 344) | static P1 generator()
    function P2 (line 799) | inline P2 P2_Affine::to_jacobian() const { P2 ret(*this); return ret; }
      method P2 (line 553) | P2(const blst_p2 *cptr) { point = *cptr; }
      method P2 (line 555) | P2() { memset(&point, 0, sizeof(point)); }
      method P2 (line 556) | P2(const SecretKey& sk) { blst_sk_to_pk_in_g2(&point, &sk.key); }
      method P2 (line 558) | P2(const byte *in)
      method P2 (line 566) | P2(const byte *in, size_t len)
      method P2 (line 575) | P2(const P2_Affine& affine) { blst_p2_from_affine(&point, affine); }
      method P2 (line 577) | P2 dup() const                      { return *this; }
      method P2_Affine (line 578) | P2_Affine to_affine() const         { return P2_Affine(*this);      ...
      method serialize (line 579) | void serialize(byte out[192]) const { blst_p2_serialize(out, &point)...
      method compress (line 580) | void compress(byte out[96]) const   { blst_p2_compress(out, &point);...
      method on_curve (line 581) | bool on_curve() const               { return blst_p2_on_curve(&point...
      method in_group (line 582) | bool in_group() const               { return blst_p2_in_g2(&point); ...
      method is_inf (line 583) | bool is_inf() const                 { return blst_p2_is_inf(&point);...
      method is_equal (line 584) | bool is_equal(const P2& p) const
      method aggregate (line 586) | void aggregate(const P2_Affine& in)
      method P2 (line 592) | P2* sign_with(const SecretKey& sk)
      method P2 (line 594) | P2* sign_with(const Scalar& scalar)
      method P2 (line 596) | P2* hash_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 602) | P2* encode_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 609) | P2* hash_to(const byte* msg, size_t msg_len,
      method P2 (line 616) | P2* encode_to(const byte* msg, size_t msg_len,
      method P2 (line 625) | P2* mult(const byte* scalar, size_t nbits)
      method P2 (line 627) | P2* mult(const Scalar& scalar)
      method P2 (line 629) | P2* cneg(bool flag)
      method P2 (line 631) | P2* neg()
      method P2 (line 633) | P2* add(const P2& a)
      method P2 (line 635) | P2* add(const P2_Affine &a)
      method P2 (line 637) | P2* dbl()
      method P2 (line 640) | static P2 add(const P2& a, const P2& b)
      method P2 (line 642) | static P2 add(const P2& a, const P2_Affine& b)
      method P2 (line 644) | static P2 dbl(const P2& a)
      method P2 (line 647) | static P2 generator()
    function P1 (line 801) | inline P1 G1() { return P1::generator();  }
      method P1 (line 251) | P1(const blst_p1 *cptr) { point = *cptr; }
      method P1 (line 253) | P1() { memset(&point, 0, sizeof(point)); }
      method P1 (line 254) | P1(const SecretKey& sk) { blst_sk_to_pk_in_g1(&point, &sk.key); }
      method P1 (line 256) | P1(const byte *in)
      method P1 (line 264) | P1(const byte *in, size_t len)
      method P1 (line 273) | P1(const P1_Affine& affine) { blst_p1_from_affine(&point, affine); }
      method P1 (line 275) | P1 dup() const                      { return *this; }
      method P1_Affine (line 276) | P1_Affine to_affine() const         { return P1_Affine(*this);      ...
      method serialize (line 277) | void serialize(byte out[96]) const  { blst_p1_serialize(out, &point)...
      method compress (line 278) | void compress(byte out[48]) const   { blst_p1_compress(out, &point);...
      method on_curve (line 279) | bool on_curve() const               { return blst_p1_on_curve(&point...
      method in_group (line 280) | bool in_group() const               { return blst_p1_in_g1(&point); ...
      method is_inf (line 281) | bool is_inf() const                 { return blst_p1_is_inf(&point);...
      method is_equal (line 282) | bool is_equal(const P1& p) const
      method aggregate (line 284) | void aggregate(const P1_Affine& in)
      method P1 (line 290) | P1* sign_with(const SecretKey& sk)
      method P1 (line 292) | P1* sign_with(const Scalar& scalar)
      method P1 (line 294) | P1* hash_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 300) | P1* encode_to(bytes_t msg, const std::string& DST = "",
      method P1 (line 307) | P1* hash_to(const byte* msg, size_t msg_len,
      method P1 (line 314) | P1* encode_to(const byte* msg, size_t msg_len,
      method P1 (line 322) | P1* mult(const byte* scalar, size_t nbits)
      method P1 (line 324) | P1* mult(const Scalar& scalar)
      method P1 (line 326) | P1* cneg(bool flag)
      method P1 (line 328) | P1* neg()
      method P1 (line 330) | P1* add(const P1& a)
      method P1 (line 332) | P1* add(const P1_Affine &a)
      method P1 (line 334) | P1* dbl()
      method P1 (line 337) | static P1 add(const P1& a, const P1& b)
      method P1 (line 339) | static P1 add(const P1& a, const P1_Affine& b)
      method P1 (line 341) | static P1 dbl(const P1& a)
      method P1 (line 344) | static P1 generator()
    function P2 (line 802) | inline P2 G2() { return P2::generator();  }
      method P2 (line 553) | P2(const blst_p2 *cptr) { point = *cptr; }
      method P2 (line 555) | P2() { memset(&point, 0, sizeof(point)); }
      method P2 (line 556) | P2(const SecretKey& sk) { blst_sk_to_pk_in_g2(&point, &sk.key); }
      method P2 (line 558) | P2(const byte *in)
      method P2 (line 566) | P2(const byte *in, size_t len)
      method P2 (line 575) | P2(const P2_Affine& affine) { blst_p2_from_affine(&point, affine); }
      method P2 (line 577) | P2 dup() const                      { return *this; }
      method P2_Affine (line 578) | P2_Affine to_affine() const         { return P2_Affine(*this);      ...
      method serialize (line 579) | void serialize(byte out[192]) const { blst_p2_serialize(out, &point)...
      method compress (line 580) | void compress(byte out[96]) const   { blst_p2_compress(out, &point);...
      method on_curve (line 581) | bool on_curve() const               { return blst_p2_on_curve(&point...
      method in_group (line 582) | bool in_group() const               { return blst_p2_in_g2(&point); ...
      method is_inf (line 583) | bool is_inf() const                 { return blst_p2_is_inf(&point);...
      method is_equal (line 584) | bool is_equal(const P2& p) const
      method aggregate (line 586) | void aggregate(const P2_Affine& in)
      method P2 (line 592) | P2* sign_with(const SecretKey& sk)
      method P2 (line 594) | P2* sign_with(const Scalar& scalar)
      method P2 (line 596) | P2* hash_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 602) | P2* encode_to(bytes_t msg, const std::string& DST = "",
      method P2 (line 609) | P2* hash_to(const byte* msg, size_t msg_len,
      method P2 (line 616) | P2* encode_to(const byte* msg, size_t msg_len,
      method P2 (line 625) | P2* mult(const byte* scalar, size_t nbits)
      method P2 (line 627) | P2* mult(const Scalar& scalar)
      method P2 (line 629) | P2* cneg(bool flag)
      method P2 (line 631) | P2* neg()
      method P2 (line 633) | P2* add(const P2& a)
      method P2 (line 635) | P2* add(const P2_Affine &a)
      method P2 (line 637) | P2* dbl()
      method P2 (line 640) | static P2 add(const P2& a, const P2& b)
      method P2 (line 642) | static P2 add(const P2& a, const P2_Affine& b)
      method P2 (line 644) | static P2 dbl(const P2& a)
      method P2 (line 647) | static P2 generator()
    function BLST_ERROR (line 805) | inline BLST_ERROR P1_Affine::core_verify(const P2_Affine& pk,
    function BLST_ERROR (line 815) | inline BLST_ERROR P2_Affine::core_verify(const P1_Affine& pk,
    class PT (line 827) | class PT {
      method PT (line 831) | PT(const blst_fp12 *v)  { value = *v; }
      method PT (line 833) | PT(const P1_Affine& p)  { blst_aggregated_in_g1(&value, p); }
      method PT (line 834) | PT(const P2_Affine& q)  { blst_aggregated_in_g2(&value, q); }
      method PT (line 835) | PT(const P2_Affine& q, const P1_Affine& p)
      method PT (line 837) | PT(const P1_Affine& p, const P2_Affine& q) : PT(q, p) {}
      method PT (line 838) | PT(const P2& q, const P1& p)
      method PT (line 840) | PT(const P1& p, const P2& q) : PT(q, p) {}
      method PT (line 842) | PT dup() const          { return *this; }
      method is_one (line 843) | bool is_one() const     { return blst_fp12_is_one(&value); }
      method is_equal (line 844) | bool is_equal(const PT& p) const
      method PT (line 846) | PT* sqr()               { blst_fp12_sqr(&value, &value);    return t...
      method PT (line 847) | PT* mul(const PT& p)    { blst_fp12_mul(&value, &value, p); return t...
      method PT (line 848) | PT* final_exp()         { blst_final_exp(&value, &value);   return t...
      method in_group (line 849) | bool in_group() const   { return blst_fp12_in_group(&value); }
      method to_bendian (line 850) | void to_bendian(byte out[48*12]) const
      method finalverify (line 853) | static bool finalverify(const PT& gt1, const PT& gt2)
      method PT (line 855) | static PT one() { return PT(blst_fp12_one()); }
    class Pairing (line 862) | class Pairing {
      method init (line 869) | void init(bool hash_or_encode, const byte* DST, size_t DST_len)
      method Pairing (line 883) | Pairing(bool hash_or_encode, const std::string& DST)
      method Pairing (line 887) | Pairing(bool hash_or_encode, const byte* DST, size_t DST_len)
      method BLST_ERROR (line 892) | BLST_ERROR aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 897) | BLST_ERROR aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method BLST_ERROR (line 902) | BLST_ERROR mul_n_aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 908) | BLST_ERROR mul_n_aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method BLST_ERROR (line 915) | BLST_ERROR aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 921) | BLST_ERROR aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method BLST_ERROR (line 927) | BLST_ERROR mul_n_aggregate(const P1_Affine* pk, const P2_Affine* sig,
      method BLST_ERROR (line 934) | BLST_ERROR mul_n_aggregate(const P2_Affine* pk, const P1_Affine* sig,
      method commit (line 942) | void commit()
      method BLST_ERROR (line 944) | BLST_ERROR merge(const Pairing* ctx)
      method finalverify (line 946) | bool finalverify(const PT* sig = nullptr) const
      method raw_aggregate (line 950) | void raw_aggregate(const P2_Affine* q, const P1_Affine* p)
      method PT (line 952) | PT as_fp12()

FILE: bindings/blst_aux.h
  type blst_uniq (line 60) | typedef struct {} blst_uniq;
  type blst_uniq (line 62) | typedef struct blst_opaque blst_uniq;

FILE: bindings/c#/poc.cs
  class PoC (line 5) | class PoC {
    method Main (line 6) | private static void Main(string[] args)
    method fromHexChar (line 58) | private static int fromHexChar(char c)
    method fromHexString (line 66) | private static byte[] fromHexString(string str)

FILE: bindings/c#/supranational.blst.cs
  class blst (line 21) | public static class blst {
    method blst (line 26) | static blst()
    type ERROR (line 71) | public enum ERROR {
    class Exception (line 82) | public class Exception : ApplicationException {
      method Exception (line 85) | public Exception(ERROR err) { code = err; }
    type ByteOrder (line 102) | public enum ByteOrder {
    method blst_keygen (line 107) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_keygen_v3 (line 111) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_keygen_v4_5 (line 115) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_keygen_v5 (line 120) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_derive_master_eip2333 (line 125) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_derive_child_eip2333 (line 128) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_scalar_from_bendian (line 132) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_bendian_from_scalar (line 134) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sk_check (line 136) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_scalar_from_lendian (line 139) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_lendian_from_scalar (line 141) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type SecretKey (line 144) | public struct SecretKey {
      method SecretKey (line 148) | public SecretKey(byte[] IKM, string info)
      method SecretKey (line 150) | public SecretKey(byte[] inp, ByteOrder order=ByteOrder.BigEndian)
      method keygen (line 158) | public void keygen(byte[] IKM, string info="")
      method keygen_v3 (line 164) | public void keygen_v3(byte[] IKM, string info="")
      method keygen_v4_5 (line 170) | public void keygen_v4_5(byte[] IKM, string salt, string info="")
      method keygen_v5 (line 178) | public void keygen_v5(byte[] IKM, byte[] salt, string info="")
      method keygen_v5 (line 185) | public void keygen_v5(byte[] IKM, string salt, string info="")
      method derive_master_eip2333 (line 187) | public void derive_master_eip2333(byte[] IKM)
      method SecretKey (line 191) | public SecretKey(SecretKey master, uint child_index)
      method from_bendian (line 196) | public void from_bendian(byte[] inp)
      method from_lendian (line 204) | public void from_lendian(byte[] inp)
      method to_bendian (line 213) | public byte[] to_bendian()
      method to_lendian (line 218) | public byte[] to_lendian()
    method blst_scalar_from_be_bytes (line 225) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_scalar_from_le_bytes (line 228) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sk_add_n_check (line 231) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sk_sub_n_check (line 234) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sk_mul_n_check (line 237) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sk_inverse (line 240) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type Scalar (line 243) | public struct Scalar {
      method Scalar (line 247) | public Scalar(byte[] inp, ByteOrder order=ByteOrder.BigEndian)
      method Scalar (line 254) | private Scalar(bool _)      { val = new byte[32];               }
      method Scalar (line 255) | private Scalar(Scalar orig) { val = (byte[])orig.val.Clone();   }
      method dup (line 257) | public Scalar dup()         { return new Scalar(this);          }
      method from_bendian (line 259) | public void from_bendian(byte[] inp)
      method from_lendian (line 263) | public void from_lendian(byte[] inp)
      method to_bendian (line 268) | public byte[] to_bendian()
      method to_lendian (line 273) | public byte[] to_lendian()
      method add (line 279) | public Scalar add(SecretKey a)
      method add (line 284) | public Scalar add(Scalar a)
      method sub (line 289) | public Scalar sub(Scalar a)
      method mul (line 294) | public Scalar mul(Scalar a)
      method inverse (line 299) | public Scalar inverse()
    method blst_p1_affine_sizeof (line 316) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_deserialize (line 319) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_affine_serialize (line 321) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_affine_compress (line 323) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_to_affine (line 326) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_affine_on_curve (line 328) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_affine_in_g1 (line 330) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_affine_is_inf (line 332) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_affine_is_equal (line 334) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_generator (line 337) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_core_verify_pk_in_g2 (line 340) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type P1_Affine (line 347) | public struct P1_Affine {
      method P1_Affine (line 353) | private P1_Affine(bool _)       { point = new long[sz]; }
      method P1_Affine (line 354) | private P1_Affine(P1_Affine p)  { point = (long[])p.point.Clone(); }
      method P1_Affine (line 356) | public P1_Affine(byte[] inp) : this(true)
      method P1_Affine (line 365) | public P1_Affine(P1 jacobian) : this(true)
      method dup (line 368) | public P1_Affine dup()      { return new P1_Affine(this);   }
      method to_jacobian (line 369) | public P1 to_jacobian()     { return new P1(this);          }
      method serialize (line 370) | public byte[] serialize()
      method compress (line 375) | public byte[] compress()
      method on_curve (line 381) | public bool on_curve()      { return blst_p1_affine_on_curve(point);...
      method in_group (line 382) | public bool in_group()      { return blst_p1_affine_in_g1(point);   ...
      method is_inf (line 383) | public bool is_inf()        { return blst_p1_affine_is_inf(point);  ...
      method is_equal (line 384) | public bool is_equal(P1_Affine p)
      method core_verify (line 387) | ERROR core_verify(P2_Affine pk, bool hash_or_encode,
      method generator (line 397) | public static P1_Affine generator()
    method blst_p1_sizeof (line 404) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_serialize (line 406) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_compress (line 408) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_from_affine (line 410) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_on_curve (line 413) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_in_g1 (line 415) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_is_inf (line 417) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_is_equal (line 419) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sk_to_pk_in_g1 (line 422) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_encode_to_g1 (line 424) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_hash_to_g1 (line 429) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sign_pk_in_g2 (line 434) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_mult (line 438) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_cneg (line 442) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_add_or_double (line 444) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_add_or_double_affine (line 447) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p1_double (line 451) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type P1 (line 454) | public struct P1 {
      method P1 (line 460) | private P1(bool _)      { point = new long[sz]; }
      method P1 (line 461) | private P1(P1 p)        { point = (long[])p.point.Clone(); }
      method self (line 462) | private long[] self()
      method P1 (line 465) | public P1(SecretKey sk) : this(true)
      method P1 (line 467) | public P1(byte[] inp) : this(true)
      method P1 (line 477) | public P1(P1_Affine affine) : this(true)
      method dup (line 480) | public P1 dup()                 { return new P1(this);              ...
      method to_affine (line 481) | public P1_Affine to_affine()    { return new P1_Affine(this);       ...
      method serialize (line 482) | public byte[] serialize()
      method compress (line 487) | public byte[] compress()
      method on_curve (line 493) | public bool on_curve()      { return blst_p1_on_curve(point);       ...
      method in_group (line 494) | public bool in_group()      { return blst_p1_in_g1(point);          ...
      method is_inf (line 495) | public bool is_inf()        { return blst_p1_is_inf(point);         ...
      method is_equal (line 496) | public bool is_equal(P1 p)  { return blst_p1_is_equal(point, p.point...
      method hash_to (line 498) | public P1 hash_to(byte[] msg, string DST="", byte[] aug=null)
      method encode_to (line 505) | public P1 encode_to(byte[] msg, string DST="", byte[] aug=null)
      method sign_with (line 513) | public P1 sign_with(SecretKey sk)
      method sign_with (line 515) | public P1 sign_with(Scalar scalar)
      method aggregate (line 518) | public void aggregate(P1_Affine inp)
      method mult (line 525) | public P1 mult(byte[] scalar)
      method mult (line 529) | public P1 mult(Scalar scalar)
      method mult (line 533) | public P1 mult(BigInteger scalar)
      method cneg (line 546) | public P1 cneg(bool flag)   { blst_p1_cneg(point, flag); return this...
      method neg (line 547) | public P1 neg()             { blst_p1_cneg(point, true); return this...
      method add (line 548) | public P1 add(P1 a)
      method add (line 550) | public P1 add(P1_Affine a)
      method dbl (line 552) | public P1 dbl()
      method generator (line 555) | public static P1 generator()
    method G1 (line 562) | public static P1 G1() { return P1.generator(); }
    method blst_aggregated_in_g1 (line 564) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_aggregate_pk_in_g1 (line 566) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_mul_n_aggregate_pk_in_g1 (line 571) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_affine_sizeof (line 579) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_deserialize (line 582) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_affine_serialize (line 584) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_affine_compress (line 586) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_to_affine (line 589) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_affine_on_curve (line 591) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_affine_in_g2 (line 593) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_affine_is_inf (line 595) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_affine_is_equal (line 597) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_generator (line 600) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_core_verify_pk_in_g1 (line 603) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type P2_Affine (line 610) | public struct P2_Affine {
      method P2_Affine (line 616) | private P2_Affine(bool _)       { point = new long[sz]; }
      method P2_Affine (line 617) | private P2_Affine(P2_Affine p)  { point = (long[])p.point.Clone(); }
      method P2_Affine (line 619) | public P2_Affine(byte[] inp) : this(true)
      method P2_Affine (line 628) | public P2_Affine(P2 jacobian) : this(true)
      method dup (line 631) | public P2_Affine dup()      { return new P2_Affine(this);   }
      method to_jacobian (line 632) | public P2 to_jacobian()     { return new P2(this);          }
      method serialize (line 633) | public byte[] serialize()
      method compress (line 638) | public byte[] compress()
      method on_curve (line 644) | public bool on_curve()      { return blst_p2_affine_on_curve(point);...
      method in_group (line 645) | public bool in_group()      { return blst_p2_affine_in_g2(point);   ...
      method is_inf (line 646) | public bool is_inf()        { return blst_p2_affine_is_inf(point);  ...
      method is_equal (line 647) | public bool is_equal(P2_Affine p)
      method core_verify (line 650) | ERROR core_verify(P1_Affine pk, bool hash_or_encode,
      method generator (line 660) | public static P2_Affine generator()
    method blst_p2_sizeof (line 667) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_serialize (line 669) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_compress (line 671) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_from_affine (line 673) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_on_curve (line 676) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_in_g2 (line 678) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_is_inf (line 680) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_is_equal (line 682) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sk_to_pk_in_g2 (line 685) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_encode_to_g2 (line 687) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_hash_to_g2 (line 692) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_sign_pk_in_g1 (line 697) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_mult (line 701) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_cneg (line 705) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_add_or_double (line 707) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_add_or_double_affine (line 710) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_p2_double (line 714) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type P2 (line 717) | public struct P2 {
      method P2 (line 723) | private P2(bool _)      { point = new long[sz]; }
      method P2 (line 724) | private P2(P2 p)        { point = (long[])p.point.Clone(); }
      method self (line 725) | private long[] self()
      method P2 (line 728) | public P2(SecretKey sk) : this(true)
      method P2 (line 730) | public P2(byte[] inp) : this(true)
      method P2 (line 740) | public P2(P2_Affine affine) : this(true)
      method dup (line 743) | public P2 dup()                 { return new P2(this);              ...
      method to_affine (line 744) | public P2_Affine to_affine()    { return new P2_Affine(this);       ...
      method serialize (line 745) | public byte[] serialize()
      method compress (line 750) | public byte[] compress()
      method on_curve (line 756) | public bool on_curve()      { return blst_p2_on_curve(point);       ...
      method in_group (line 757) | public bool in_group()      { return blst_p2_in_g2(point);          ...
      method is_inf (line 758) | public bool is_inf()        { return blst_p2_is_inf(point);         ...
      method is_equal (line 759) | public bool is_equal(P2 p)  { return blst_p2_is_equal(point, p.point...
      method hash_to (line 761) | public P2 hash_to(byte[] msg, string DST="", byte[] aug=null)
      method encode_to (line 768) | public P2 encode_to(byte[] msg, string DST="", byte[] aug=null)
      method sign_with (line 776) | public P2 sign_with(SecretKey sk)
      method sign_with (line 778) | public P2 sign_with(Scalar scalar)
      method aggregate (line 781) | public void aggregate(P2_Affine inp)
      method mult (line 788) | public P2 mult(byte[] scalar)
      method mult (line 792) | public P2 mult(Scalar scalar)
      method mult (line 796) | public P2 mult(BigInteger scalar)
      method cneg (line 809) | public P2 cneg(bool flag)   { blst_p2_cneg(point, flag); return this...
      method neg (line 810) | public P2 neg()             { blst_p2_cneg(point, true); return this...
      method add (line 811) | public P2 add(P2 a)
      method add (line 813) | public P2 add(P2_Affine a)
      method dbl (line 815) | public P2 dbl()
      method generator (line 818) | public static P2 generator()
    method G2 (line 825) | public static P2 G2() { return P2.generator(); }
    method blst_aggregated_in_g2 (line 827) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_aggregate_pk_in_g2 (line 829) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_mul_n_aggregate_pk_in_g2 (line 834) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_sizeof (line 842) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_miller_loop (line 844) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_is_one (line 847) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_is_equal (line 849) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_sqr (line 851) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_mul (line 853) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_final_exp (line 856) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_finalverify (line 858) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_one (line 860) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_fp12_in_group (line 862) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_bendian_from_fp12 (line 864) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type PT (line 867) | public struct PT {
      method PT (line 872) | internal PT(bool _)     { fp12 = new long[sz]; }
      method PT (line 873) | private PT(PT orig)     { fp12 = (long[])orig.fp12.Clone(); }
      method PT (line 875) | public PT(P1_Affine p) : this(true)
      method PT (line 877) | public PT(P1 p) : this(true)
      method PT (line 879) | public PT(P2_Affine q) : this(true)
      method PT (line 881) | public PT(P2 q) : this(true)
      method PT (line 883) | public PT(P2_Affine q, P1_Affine p) : this(true)
      method PT (line 885) | public PT(P1_Affine p, P2_Affine q) : this(q, p) {}
      method PT (line 886) | public PT(P2 q, P1 p) : this(true)
      method PT (line 890) | public PT(P1 p, P2 q) : this(q, p) {}
      method dup (line 892) | public PT dup()         { return new PT(this); }
      method is_one (line 893) | public bool is_one()    { return blst_fp12_is_one(fp12); }
      method is_equal (line 894) | public bool is_equal(PT p)
      method sqr (line 896) | public PT sqr()         { blst_fp12_sqr(fp12, fp12);         return ...
      method mul (line 897) | public PT mul(PT p)     { blst_fp12_mul(fp12, fp12, p.fp12); return ...
      method final_exp (line 898) | public PT final_exp()   { blst_final_exp(fp12, fp12);        return ...
      method in_group (line 899) | public bool in_group()  { return blst_fp12_in_group(fp12); }
      method to_bendian (line 900) | public byte[] to_bendian()
      method finalverify (line 906) | public static bool finalverify(PT gt1, PT gt2)
      method one (line 909) | public static PT one()
    method blst_pairing_sizeof (line 916) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_init (line 918) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_commit (line 922) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_merge (line 924) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_finalverify (line 926) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_raw_aggregate (line 928) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    method blst_pairing_as_fp12 (line 932) | [DllImport("blst.dll", CallingConvention = CallingConvention.Cdecl)]
    type Pairing (line 935) | public struct Pairing {
      method Pairing (line 940) | public Pairing(bool hash_or_encode=false, string DST="")
      method aggregate (line 957) | public ERROR aggregate(P1_Affine pk, Nullable<P2_Affine> sig,
      method aggregate (line 964) | public ERROR aggregate(P2_Affine pk, Nullable<P1_Affine> sig,
      method mul_n_aggregate (line 971) | public ERROR mul_n_aggregate(P2_Affine pk, P1_Affine sig,
      method mul_n_aggregate (line 979) | public ERROR mul_n_aggregate(P1_Affine pk, P2_Affine sig,
      method commit (line 988) | public void commit()    { blst_pairing_commit(ctx); }
      method merge (line 989) | public void merge(Pairing a)
      method finalverify (line 994) | public bool finalverify(PT sig=new PT())
      method raw_aggregate (line 997) | public void raw_aggregate(P2_Affine q, P1_Affine p)
      method raw_aggregate (line 999) | public void raw_aggregate(P1_Affine p, P2_Affine q)
      method raw_aggregate (line 1001) | public void raw_aggregate(P2 q, P1 p)
      method raw_aggregate (line 1005) | public void raw_aggregate(P1 p, P2 q)
      method as_fp12 (line 1007) | public PT as_fp12()

FILE: bindings/go/blst.go
  constant BLST_SCALAR_BYTES (line 165) | BLST_SCALAR_BYTES = 256 / 8
  constant BLST_FP_BYTES (line 166) | BLST_FP_BYTES = 384 / 8
  constant BLST_P1_COMPRESS_BYTES (line 167) | BLST_P1_COMPRESS_BYTES = BLST_FP_BYTES
  constant BLST_P1_SERIALIZE_BYTES (line 168) | BLST_P1_SERIALIZE_BYTES = BLST_FP_BYTES * 2
  constant BLST_P2_COMPRESS_BYTES (line 169) | BLST_P2_COMPRESS_BYTES = BLST_FP_BYTES * 2
  constant BLST_P2_SERIALIZE_BYTES (line 170) | BLST_P2_SERIALIZE_BYTES = BLST_FP_BYTES * 4
  type Scalar (line 172) | type Scalar struct
    method MulAssign (line 3336) | func (a *Scalar) MulAssign(b *Scalar) (*Scalar, bool) {
    method Mul (line 3340) | func (a *Scalar) Mul(b *Scalar) (*Scalar, bool) {
    method AddAssign (line 3345) | func (a *Scalar) AddAssign(b *Scalar) (*Scalar, bool) {
    method Add (line 3349) | func (a *Scalar) Add(b *Scalar) (*Scalar, bool) {
    method SubAssign (line 3354) | func (a *Scalar) SubAssign(b *Scalar) (*Scalar, bool) {
    method Sub (line 3358) | func (a *Scalar) Sub(b *Scalar) (*Scalar, bool) {
    method Inverse (line 3363) | func (a *Scalar) Inverse() *Scalar {
    method Serialize (line 3374) | func (s *Scalar) Serialize() []byte {
    method Deserialize (line 3380) | func (s *Scalar) Deserialize(in []byte) *Scalar {
    method Valid (line 3388) | func (s *Scalar) Valid() bool {
    method HashTo (line 3392) | func (s *Scalar) HashTo(msg []byte, dst []byte) bool {
    method ToLEndian (line 3416) | func (fr *Scalar) ToLEndian() []byte {
    method FromLEndian (line 3428) | func (fr *Scalar) FromLEndian(arr []byte) *Scalar {
    method ToBEndian (line 3449) | func (fr *Scalar) ToBEndian() []byte {
    method FromBEndian (line 3461) | func (fr *Scalar) FromBEndian(arr []byte) *Scalar {
    method Print (line 3486) | func (s *Scalar) Print(name string) {
    method Equals (line 3534) | func (s1 *Scalar) Equals(s2 *Scalar) bool {
  type Fp (line 173) | type Fp struct
    method ToLEndian (line 3422) | func (fp *Fp) ToLEndian() []byte {
    method FromLEndian (line 3437) | func (fp *Fp) FromLEndian(arr []byte) *Fp {
    method ToBEndian (line 3455) | func (fp *Fp) ToBEndian() []byte {
    method FromBEndian (line 3470) | func (fp *Fp) FromBEndian(arr []byte) *Fp {
    method Equals (line 3538) | func (e1 *Fp) Equals(e2 *Fp) bool {
  type Fp2 (line 174) | type Fp2 struct
    method Print (line 3507) | func (f *Fp2) Print(name string) {
    method Equals (line 3542) | func (e1 *Fp2) Equals(e2 *Fp2) bool {
  type Fp12 (line 176) | type Fp12 struct
    method MulAssign (line 449) | func (pt *Fp12) MulAssign(p *Fp12) {
    method FinalExp (line 453) | func (pt *Fp12) FinalExp() {
    method InGroup (line 457) | func (pt *Fp12) InGroup() bool {
    method ToBendian (line 461) | func (pt *Fp12) ToBendian() []byte {
    method Equals (line 467) | func (pt1 *Fp12) Equals(pt2 *Fp12) bool {
    method asPtr (line 471) | func (pt *Fp12) asPtr() *C.blst_fp12 {
  type P1 (line 177) | type P1 struct
    method Serialize (line 1814) | func (p1 *P1) Serialize() []byte {
    method Compress (line 1819) | func (p1 *P1) Compress() []byte {
    method MultAssign (line 1825) | func (p1 *P1) MultAssign(scalarIf interface{}, optional ...int) *P1 {
    method Mult (line 1845) | func (p1 *P1) Mult(scalarIf interface{}, optional ...int) *P1 {
    method AddAssign (line 1850) | func (p1 *P1) AddAssign(pointIf interface{}) *P1 {
    method Add (line 1862) | func (p1 *P1) Add(pointIf interface{}) *P1 {
    method SubAssign (line 1867) | func (p1 *P1) SubAssign(pointIf interface{}) *P1 {
    method Sub (line 1884) | func (p1 *P1) Sub(pointIf interface{}) *P1 {
    method MultNAccumulate (line 1896) | func (acc *P1) MultNAccumulate(pointIf interface{}, scalarIf interface{},
    method ToAffine (line 1935) | func (p *P1) ToAffine() *P1Affine {
    method FromAffine (line 1941) | func (p *P1) FromAffine(pa *P1Affine) {
    method Print (line 3501) | func (p *P1) Print(name string) {
    method Equals (line 3558) | func (e1 *P1) Equals(e2 *P1) bool {
  type P2 (line 178) | type P2 struct
    method Serialize (line 2627) | func (p2 *P2) Serialize() []byte {
    method Compress (line 2632) | func (p2 *P2) Compress() []byte {
    method MultAssign (line 2638) | func (p2 *P2) MultAssign(scalarIf interface{}, optional ...int) *P2 {
    method Mult (line 2658) | func (p2 *P2) Mult(scalarIf interface{}, optional ...int) *P2 {
    method AddAssign (line 2663) | func (p2 *P2) AddAssign(pointIf interface{}) *P2 {
    method Add (line 2675) | func (p2 *P2) Add(pointIf interface{}) *P2 {
    method SubAssign (line 2680) | func (p2 *P2) SubAssign(pointIf interface{}) *P2 {
    method Sub (line 2697) | func (p2 *P2) Sub(pointIf interface{}) *P2 {
    method MultNAccumulate (line 2709) | func (acc *P2) MultNAccumulate(pointIf interface{}, scalarIf interface{},
    method ToAffine (line 2748) | func (p *P2) ToAffine() *P2Affine {
    method FromAffine (line 2754) | func (p *P2) FromAffine(pa *P2Affine) {
    method Print (line 3524) | func (p *P2) Print(name string) {
    method Equals (line 3574) | func (e1 *P2) Equals(e2 *P2) bool {
  type P1Affine (line 179) | type P1Affine struct
    method From (line 495) | func (pk *P1Affine) From(s *Scalar) *P1Affine {
    method KeyValidate (line 500) | func (pk *P1Affine) KeyValidate() bool {
    method SigValidate (line 1108) | func (sig *P1Affine) SigValidate(sigInfcheck bool) bool {
    method Sign (line 1116) | func (sig *P1Affine) Sign(sk *SecretKey, msg []byte, dst []byte,
    method Verify (line 1143) | func (sig *P1Affine) Verify(sigGroupcheck bool, pk *P2Affine, pkValida...
    method VerifyCompressed (line 1157) | func (dummy *P1Affine) VerifyCompressed(sig []byte, sigGroupcheck bool,
    method AggregateVerify (line 1171) | func (sig *P1Affine) AggregateVerify(sigGroupcheck bool,
    method AggregateVerifyCompressed (line 1203) | func (*P1Affine) AggregateVerifyCompressed(sig []byte, sigGroupcheck b...
    method FastAggregateVerify (line 1389) | func (sig *P1Affine) FastAggregateVerify(sigGroupcheck bool,
    method MultipleAggregateVerify (line 1409) | func (*P1Affine) MultipleAggregateVerify(sigs []*P1Affine,
    method Serialize (line 1727) | func (p1 *P1Affine) Serialize() []byte {
    method Deserialize (line 1733) | func (p1 *P1Affine) Deserialize(in []byte) *P1Affine {
    method Compress (line 1742) | func (p1 *P1Affine) Compress() []byte {
    method Uncompress (line 1748) | func (p1 *P1Affine) Uncompress(in []byte) *P1Affine {
    method InG1 (line 1758) | func (p1 *P1Affine) InG1() bool {
    method BatchUncompress (line 1762) | func (*P1Affine) BatchUncompress(in [][]byte) []*P1Affine {
    method Print (line 3491) | func (p *P1Affine) Print(name string) {
    method Equals (line 3546) | func (e1 *P1Affine) Equals(e2 *P1Affine) bool {
    method asPtr (line 3550) | func (pt *P1Affine) asPtr() *C.blst_p1_affine {
  type P2Affine (line 180) | type P2Affine struct
    method SigValidate (line 508) | func (sig *P2Affine) SigValidate(sigInfcheck bool) bool {
    method Sign (line 516) | func (sig *P2Affine) Sign(sk *SecretKey, msg []byte, dst []byte,
    method Verify (line 543) | func (sig *P2Affine) Verify(sigGroupcheck bool, pk *P1Affine, pkValida...
    method VerifyCompressed (line 557) | func (dummy *P2Affine) VerifyCompressed(sig []byte, sigGroupcheck bool,
    method AggregateVerify (line 571) | func (sig *P2Affine) AggregateVerify(sigGroupcheck bool,
    method AggregateVerifyCompressed (line 603) | func (*P2Affine) AggregateVerifyCompressed(sig []byte, sigGroupcheck b...
    method FastAggregateVerify (line 789) | func (sig *P2Affine) FastAggregateVerify(sigGroupcheck bool,
    method MultipleAggregateVerify (line 809) | func (*P2Affine) MultipleAggregateVerify(sigs []*P2Affine,
    method From (line 1095) | func (pk *P2Affine) From(s *Scalar) *P2Affine {
    method KeyValidate (line 1100) | func (pk *P2Affine) KeyValidate() bool {
    method Serialize (line 2540) | func (p2 *P2Affine) Serialize() []byte {
    method Deserialize (line 2546) | func (p2 *P2Affine) Deserialize(in []byte) *P2Affine {
    method Compress (line 2555) | func (p2 *P2Affine) Compress() []byte {
    method Uncompress (line 2561) | func (p2 *P2Affine) Uncompress(in []byte) *P2Affine {
    method InG2 (line 2571) | func (p2 *P2Affine) InG2() bool {
    method BatchUncompress (line 2575) | func (*P2Affine) BatchUncompress(in [][]byte) []*P2Affine {
    method Print (line 3516) | func (p *P2Affine) Print(name string) {
    method Equals (line 3562) | func (e1 *P2Affine) Equals(e2 *P2Affine) bool {
    method asPtr (line 3566) | func (pt *P2Affine) asPtr() *C.blst_p2_affine {
  type P1s (line 184) | type P1s
    method ToAffine (line 1994) | func (points P1s) ToAffine(optional ...P1Affines) P1Affines {
    method Add (line 2088) | func (points P1s) Add() *P1 {
    method Mult (line 2408) | func (points P1s) Mult(scalarsIf interface{}, nbits int) *P1 {
  type P2s (line 185) | type P2s
    method ToAffine (line 2807) | func (points P2s) ToAffine(optional ...P2Affines) P2Affines {
    method Add (line 2901) | func (points P2s) Add() *P2 {
    method Mult (line 3221) | func (points P2s) Mult(scalarsIf interface{}, nbits int) *P2 {
  type P1Affines (line 186) | type P1Affines
    method Add (line 2053) | func (points P1Affines) Add() *P1 {
    method Mult (line 2404) | func (points P1Affines) Mult(scalarsIf interface{}, nbits int) *P1 {
    method Validate (line 2496) | func (points P1Affines) Validate() bool {
  type P2Affines (line 187) | type P2Affines
    method Add (line 2866) | func (points P2Affines) Add() *P2 {
    method Mult (line 3217) | func (points P2Affines) Mult(scalarsIf interface{}, nbits int) *P2 {
    method Validate (line 3309) | func (points P2Affines) Validate() bool {
  function initMaxProcs (line 195) | func initMaxProcs() int {
  function SetMaxProcs (line 209) | func SetMaxProcs(procs int) {
  function numThreads (line 216) | func numThreads(maxThreads int) int {
  method Zeroize (line 238) | func (sk *SecretKey) Zeroize() {
  function KeyGen (line 243) | func KeyGen(ikm []byte, optional ...[]byte) *SecretKey {
  function KeyGenV3 (line 260) | func KeyGenV3(ikm []byte, optional ...[]byte) *SecretKey {
  function KeyGenV45 (line 277) | func KeyGenV45(ikm []byte, salt []byte, optional ...[]byte) *SecretKey {
  function KeyGenV5 (line 295) | func KeyGenV5(ikm []byte, salt []byte, optional ...[]byte) *SecretKey {
  function DeriveMasterEip2333 (line 317) | func DeriveMasterEip2333(ikm []byte) *SecretKey {
  method DeriveChildEip2333 (line 329) | func (master *SecretKey) DeriveChildEip2333(child_index uint32) *SecretK...
  function pairingSizeOf (line 339) | func pairingSizeOf(DST_len C.size_t) int {
  function PairingCtx (line 343) | func PairingCtx(hash_or_encode bool, DST []byte) Pairing {
  function PairingCommit (line 350) | func PairingCommit(ctx Pairing) {
  function PairingMerge (line 354) | func PairingMerge(ctx Pairing, ctx1 Pairing) int {
  function PairingFinalVerify (line 359) | func PairingFinalVerify(ctx Pairing, optional ...*Fp12) bool {
  function PairingRawAggregate (line 367) | func PairingRawAggregate(ctx Pairing, q *P2Affine, p *P1Affine) {
  function PairingAsFp12 (line 371) | func PairingAsFp12(ctx Pairing) *Fp12 {
  function Fp12One (line 377) | func Fp12One() Fp12 {
  function Fp12FinalVerify (line 381) | func Fp12FinalVerify(pt1 *Fp12, pt2 *Fp12) bool {
  function Fp12MillerLoop (line 385) | func Fp12MillerLoop(q *P2Affine, p *P1Affine) *Fp12 {
  function Fp12MillerLoopN (line 391) | func Fp12MillerLoopN(qs []P2Affine, ps []P1Affine) *Fp12 {
  function ptrOrNil (line 479) | func ptrOrNil(bytes []byte) *C.byte {
  type sigGetterP2 (line 539) | type sigGetterP2
  type pkGetterP1 (line 540) | type pkGetterP1
  function coreAggregateVerifyPkInG1 (line 650) | func coreAggregateVerifyPkInG1(sigFn sigGetterP2, sigGroupcheck bool,
  function CoreVerifyPkInG1 (line 759) | func CoreVerifyPkInG1(pk *P1Affine, sig *P2Affine, hash_or_encode bool,
  type mulAggGetterPkInG1 (line 840) | type mulAggGetterPkInG1
  function multipleAggregateVerifyPkInG1 (line 843) | func multipleAggregateVerifyPkInG1(paramsFn mulAggGetterPkInG1,
  type aggGetterP2 (line 929) | type aggGetterP2
  type P2Aggregate (line 930) | type P2Aggregate struct
    method Aggregate (line 935) | func (agg *P2Aggregate) Aggregate(elmts []*P2Affine,
    method AggregateWithRandomness (line 944) | func (agg *P2Aggregate) AggregateWithRandomness(pointsIf interface{},
    method AggregateCompressed (line 954) | func (agg *P2Aggregate) AggregateCompressed(elmts [][]byte,
    method AddAggregate (line 969) | func (agg *P2Aggregate) AddAggregate(other *P2Aggregate) {
    method Add (line 979) | func (agg *P2Aggregate) Add(elmt *P2Affine, groupcheck bool) bool {
    method ToAffine (line 992) | func (agg *P2Aggregate) ToAffine() *P2Affine {
    method coreAggregate (line 999) | func (agg *P2Aggregate) coreAggregate(getter aggGetterP2, groupcheck b...
  type sigGetterP1 (line 1139) | type sigGetterP1
  type pkGetterP2 (line 1140) | type pkGetterP2
  function coreAggregateVerifyPkInG2 (line 1250) | func coreAggregateVerifyPkInG2(sigFn sigGetterP1, sigGroupcheck bool,
  function CoreVerifyPkInG2 (line 1359) | func CoreVerifyPkInG2(pk *P2Affine, sig *P1Affine, hash_or_encode bool,
  type mulAggGetterPkInG2 (line 1440) | type mulAggGetterPkInG2
  function multipleAggregateVerifyPkInG2 (line 1443) | func multipleAggregateVerifyPkInG2(paramsFn mulAggGetterPkInG2,
  type aggGetterP1 (line 1529) | type aggGetterP1
  type P1Aggregate (line 1530) | type P1Aggregate struct
    method Aggregate (line 1535) | func (agg *P1Aggregate) Aggregate(elmts []*P1Affine,
    method AggregateWithRandomness (line 1544) | func (agg *P1Aggregate) AggregateWithRandomness(pointsIf interface{},
    method AggregateCompressed (line 1554) | func (agg *P1Aggregate) AggregateCompressed(elmts [][]byte,
    method AddAggregate (line 1569) | func (agg *P1Aggregate) AddAggregate(other *P1Aggregate) {
    method Add (line 1579) | func (agg *P1Aggregate) Add(elmt *P1Affine, groupcheck bool) bool {
    method ToAffine (line 1592) | func (agg *P1Aggregate) ToAffine() *P1Affine {
    method coreAggregate (line 1599) | func (agg *P1Aggregate) coreAggregate(getter aggGetterP1, groupcheck b...
  function PairingAggregatePkInG1 (line 1686) | func PairingAggregatePkInG1(ctx Pairing, PK *P1Affine, pkValidate bool,
  function PairingMulNAggregatePkInG1 (line 1703) | func PairingMulNAggregatePkInG1(ctx Pairing, PK *P1Affine, pkValidate bool,
  function P1Generator (line 1889) | func P1Generator() *P1 {
  function HashToG1 (line 1946) | func HashToG1(msg []byte, dst []byte,
  function EncodeToG1 (line 1961) | func EncodeToG1(msg []byte, dst []byte,
  function P1sToAffine (line 1980) | func P1sToAffine(points []*P1, optional ...int) P1Affines {
  function P1AffinesAdd (line 2039) | func P1AffinesAdd(points []*P1Affine, optional ...int) *P1 {
  function P1AffinesMult (line 2096) | func P1AffinesMult(pointsIf interface{}, scalarsIf interface{}, nbits in...
  function P1AffinesValidate (line 2416) | func P1AffinesValidate(pointsIf interface{}) bool {
  function PairingAggregatePkInG2 (line 2499) | func PairingAggregatePkInG2(ctx Pairing, PK *P2Affine, pkValidate bool,
  function PairingMulNAggregatePkInG2 (line 2516) | func PairingMulNAggregatePkInG2(ctx Pairing, PK *P2Affine, pkValidate bool,
  function P2Generator (line 2702) | func P2Generator() *P2 {
  function HashToG2 (line 2759) | func HashToG2(msg []byte, dst []byte,
  function EncodeToG2 (line 2774) | func EncodeToG2(msg []byte, dst []byte,
  function P2sToAffine (line 2793) | func P2sToAffine(points []*P2, optional ...int) P2Affines {
  function P2AffinesAdd (line 2852) | func P2AffinesAdd(points []*P2Affine, optional ...int) *P2 {
  function P2AffinesMult (line 2909) | func P2AffinesMult(pointsIf interface{}, scalarsIf interface{}, nbits in...
  function P2AffinesValidate (line 3229) | func P2AffinesValidate(pointsIf interface{}) bool {
  function parseOpts (line 3314) | func parseOpts(optional ...interface{}) (augSingle []byte, aug [][]byte,
  function HashToScalar (line 3401) | func HashToScalar(msg []byte, dst []byte) *Scalar {
  function PrintBytes (line 3482) | func PrintBytes(val []byte, name string) {
  function expandMessageXmd (line 3580) | func expandMessageXmd(msg []byte, dst []byte, len_in_bytes int) []byte {
  function breakdown (line 3589) | func breakdown(nbits, window, ncpus int) (nx int, ny int, wnd int) {
  function pippenger_window_size (line 3620) | func pippenger_window_size(npoints int) int {

FILE: bindings/go/blst_htoc_test.go
  function decodeP1 (line 20) | func decodeP1(m map[string]interface{}) *P1Affine {
  function readAll (line 36) | func readAll(file *os.File) ([]byte, error) {
  function jsonG1HashToCurve (line 57) | func jsonG1HashToCurve(t *testing.T, fname string) {
  function TestG1HashToCurve (line 103) | func TestG1HashToCurve(t *testing.T) {
  function decodeP2 (line 109) | func decodeP2(m map[string]interface{}) *P2Affine {
  function jsonG2HashToCurve (line 137) | func jsonG2HashToCurve(t *testing.T, fname string) {
  function TestG2HashToCurve (line 183) | func TestG2HashToCurve(t *testing.T) {
  function jsonExpandMessageXmd (line 189) | func jsonExpandMessageXmd(t *testing.T, fname string) {
  function TestExpandMessageXmd (line 236) | func TestExpandMessageXmd(t *testing.T) {

FILE: bindings/go/blst_miller_loop_test.go
  function TestMillerLoopN (line 8) | func TestMillerLoopN(t *testing.T) {

FILE: bindings/go/blst_minpk_test.go
  function init (line 26) | func init() {
  function TestInfinityMinPk (line 31) | func TestInfinityMinPk(t *testing.T) {
  function TestSerdesMinPk (line 38) | func TestSerdesMinPk(t *testing.T) {
  function TestSignVerifyMinPk (line 84) | func TestSignVerifyMinPk(t *testing.T) {
  function TestSignVerifyAugMinPk (line 159) | func TestSignVerifyAugMinPk(t *testing.T) {
  function TestSignVerifyEncodeMinPk (line 179) | func TestSignVerifyEncodeMinPk(t *testing.T) {
  function TestSignVerifyAggregateMinPk (line 196) | func TestSignVerifyAggregateMinPk(t *testing.T) {
  function TestSignMultipleVerifyAggregateMinPk (line 250) | func TestSignMultipleVerifyAggregateMinPk(t *testing.T) {
  function TestBatchUncompressMinPk (line 330) | func TestBatchUncompressMinPk(t *testing.T) {
  function BenchmarkCoreSignMinPk (line 353) | func BenchmarkCoreSignMinPk(b *testing.B) {
  function BenchmarkCoreVerifyMinPk (line 368) | func BenchmarkCoreVerifyMinPk(b *testing.B) {
  function BenchmarkCoreVerifyAggregateMinPk (line 389) | func BenchmarkCoreVerifyAggregateMinPk(b *testing.B) {
  function BenchmarkVerifyAggregateUncompressedMinPk (line 417) | func BenchmarkVerifyAggregateUncompressedMinPk(b *testing.B) {
  function BenchmarkCoreAggregateMinPk (line 444) | func BenchmarkCoreAggregateMinPk(b *testing.B) {
  function genRandomKeyMinPk (line 469) | func genRandomKeyMinPk() *SecretKey {
  function generateBatchTestDataMinPk (line 480) | func generateBatchTestDataMinPk(size int) (msgs []Message,
  function generateBatchTestDataUncompressedMinPk (line 507) | func generateBatchTestDataUncompressedMinPk(size int) (sks []*SecretKey,
  function BenchmarkBatchUncompressMinPk (line 529) | func BenchmarkBatchUncompressMinPk(b *testing.B) {
  function TestSignVerifyAggregateValidatesInfinitePubkeyMinPk (line 562) | func TestSignVerifyAggregateValidatesInfinitePubkeyMinPk(t *testing.T) {
  function TestEmptyMessageMinPk (line 608) | func TestEmptyMessageMinPk(t *testing.T) {
  function TestEmptySignatureMinPk (line 623) | func TestEmptySignatureMinPk(t *testing.T) {
  function TestMultiScalarP1 (line 637) | func TestMultiScalarP1(t *testing.T) {
  function BenchmarkMultiScalarP1 (line 667) | func BenchmarkMultiScalarP1(b *testing.B) {
  function BenchmarkToP1Affines (line 694) | func BenchmarkToP1Affines(b *testing.B) {

FILE: bindings/go/blst_minsig_test.go
  function init (line 30) | func init() {
  function TestInfinityMinSig (line 35) | func TestInfinityMinSig(t *testing.T) {
  function TestSerdesMinSig (line 42) | func TestSerdesMinSig(t *testing.T) {
  function TestSignVerifyMinSig (line 88) | func TestSignVerifyMinSig(t *testing.T) {
  function TestSignVerifyAugMinSig (line 163) | func TestSignVerifyAugMinSig(t *testing.T) {
  function TestSignVerifyEncodeMinSig (line 183) | func TestSignVerifyEncodeMinSig(t *testing.T) {
  function TestSignVerifyAggregateMinSig (line 200) | func TestSignVerifyAggregateMinSig(t *testing.T) {
  function TestSignMultipleVerifyAggregateMinSig (line 254) | func TestSignMultipleVerifyAggregateMinSig(t *testing.T) {
  function TestBatchUncompressMinSig (line 334) | func TestBatchUncompressMinSig(t *testing.T) {
  function BenchmarkCoreSignMinSig (line 357) | func BenchmarkCoreSignMinSig(b *testing.B) {
  function BenchmarkCoreVerifyMinSig (line 372) | func BenchmarkCoreVerifyMinSig(b *testing.B) {
  function BenchmarkCoreVerifyAggregateMinSig (line 393) | func BenchmarkCoreVerifyAggregateMinSig(b *testing.B) {
  function BenchmarkVerifyAggregateUncompressedMinSig (line 421) | func BenchmarkVerifyAggregateUncompressedMinSig(b *testing.B) {
  function BenchmarkCoreAggregateMinSig (line 448) | func BenchmarkCoreAggregateMinSig(b *testing.B) {
  function genRandomKeyMinSig (line 473) | func genRandomKeyMinSig() *SecretKey {
  function generateBatchTestDataMinSig (line 484) | func generateBatchTestDataMinSig(size int) (msgs []Message,
  function generateBatchTestDataUncompressedMinSig (line 511) | func generateBatchTestDataUncompressedMinSig(size int) (sks []*SecretKey,
  function BenchmarkBatchUncompressMinSig (line 533) | func BenchmarkBatchUncompressMinSig(b *testing.B) {
  function TestSignVerifyAggregateValidatesInfinitePubkeyMinSig (line 566) | func TestSignVerifyAggregateValidatesInfinitePubkeyMinSig(t *testing.T) {
  function TestEmptyMessageMinSig (line 612) | func TestEmptyMessageMinSig(t *testing.T) {
  function TestEmptySignatureMinSig (line 627) | func TestEmptySignatureMinSig(t *testing.T) {
  function TestMultiScalarP2 (line 641) | func TestMultiScalarP2(t *testing.T) {
  function BenchmarkMultiScalarP2 (line 671) | func BenchmarkMultiScalarP2(b *testing.B) {
  function BenchmarkToP2Affines (line 698) | func BenchmarkToP2Affines(b *testing.B) {

FILE: bindings/go/generate.py
  function concatFile (line 34) | def concatFile(fout, fin, removeImports):
  function remap (line 43) | def remap(fout, fin, mapping, dont_touch, removeImports):

FILE: bindings/go/rb_tree.go
  constant red (line 21) | red, black bool = true, false
  type node (line 23) | type node struct
  type rbTree (line 29) | type rbTree struct
    method insert (line 35) | func (tree *rbTree) insert(data *[]byte) bool {
  function Uniq (line 134) | func Uniq(msgs []Message) bool {

FILE: bindings/rust/benches/blst_benches.rs
  type BenchData (line 14) | struct BenchData {
  function gen_bench_data (line 22) | fn gen_bench_data(rng: &mut rand_chacha::ChaCha20Rng) -> BenchData {
  function gen_bench_data_for_msg (line 30) | fn gen_bench_data_for_msg(
  function bench_verify_multi_aggregate (line 55) | fn bench_verify_multi_aggregate(c: &mut Criterion) {
  function bench_fast_aggregate_verify (line 150) | fn bench_fast_aggregate_verify(c: &mut Criterion) {
  function bench_aggregate_verify (line 221) | fn bench_aggregate_verify(c: &mut Criterion) {
  function bench_aggregate (line 275) | fn bench_aggregate(c: &mut Criterion) {
  function bench_single_message (line 318) | fn bench_single_message(c: &mut Criterion) {
  function bench_serdes (line 336) | fn bench_serdes(c: &mut Criterion) {
  function bench_keys (line 442) | fn bench_keys(c: &mut Criterion) {

FILE: bindings/rust/build.rs
  function assembly (line 8) | fn assembly(
  function main (line 33) | fn main() {

FILE: bindings/rust/src/bindings.rs
  type BLST_ERROR (line 5) | pub enum BLST_ERROR {
  type byte (line 15) | pub type byte = u8;
  type limb_t (line 16) | pub type limb_t = u64;
  type blst_scalar (line 20) | pub struct blst_scalar {
  function bindgen_test_layout_blst_scalar (line 24) | fn bindgen_test_layout_blst_scalar() {
  type blst_fr (line 50) | pub struct blst_fr {
  function bindgen_test_layout_blst_fr (line 54) | fn bindgen_test_layout_blst_fr() {
  type blst_fp (line 80) | pub struct blst_fp {
  function bindgen_test_layout_blst_fp (line 84) | fn bindgen_test_layout_blst_fp() {
  type blst_fp2 (line 110) | pub struct blst_fp2 {
  function bindgen_test_layout_blst_fp2 (line 114) | fn bindgen_test_layout_blst_fp2() {
  type blst_fp6 (line 140) | pub struct blst_fp6 {
  function bindgen_test_layout_blst_fp6 (line 144) | fn bindgen_test_layout_blst_fp6() {
  type blst_fp12 (line 170) | pub struct blst_fp12 {
  function bindgen_test_layout_blst_fp12 (line 174) | fn bindgen_test_layout_blst_fp12() {
  function blst_scalar_from_uint32 (line 199) | pub fn blst_scalar_from_uint32(out: *mut blst_scalar, a: *const u32);
  function blst_uint32_from_scalar (line 202) | pub fn blst_uint32_from_scalar(out: *mut u32, a: *const blst_scalar);
  function blst_scalar_from_uint64 (line 205) | pub fn blst_scalar_from_uint64(out: *mut blst_scalar, a: *const u64);
  function blst_uint64_from_scalar (line 208) | pub fn blst_uint64_from_scalar(out: *mut u64, a: *const blst_scalar);
  function blst_scalar_from_bendian (line 211) | pub fn blst_scalar_from_bendian(out: *mut blst_scalar, a: *const byte);
  function blst_bendian_from_scalar (line 214) | pub fn blst_bendian_from_scalar(out: *mut byte, a: *const blst_scalar);
  function blst_scalar_from_lendian (line 217) | pub fn blst_scalar_from_lendian(out: *mut blst_scalar, a: *const byte);
  function blst_lendian_from_scalar (line 220) | pub fn blst_lendian_from_scalar(out: *mut byte, a: *const blst_scalar);
  function blst_scalar_fr_check (line 223) | pub fn blst_scalar_fr_check(a: *const blst_scalar) -> bool;
  function blst_sk_check (line 226) | pub fn blst_sk_check(a: *const blst_scalar) -> bool;
  function blst_sk_add_n_check (line 229) | pub fn blst_sk_add_n_check(
  function blst_sk_sub_n_check (line 236) | pub fn blst_sk_sub_n_check(
  function blst_sk_mul_n_check (line 243) | pub fn blst_sk_mul_n_check(
  function blst_sk_inverse (line 250) | pub fn blst_sk_inverse(out: *mut blst_scalar, a: *const blst_scalar);
  function blst_scalar_from_le_bytes (line 253) | pub fn blst_scalar_from_le_bytes(out: *mut blst_scalar, in_: *const byte...
  function blst_scalar_from_be_bytes (line 256) | pub fn blst_scalar_from_be_bytes(out: *mut blst_scalar, in_: *const byte...
  function blst_fr_add (line 259) | pub fn blst_fr_add(ret: *mut blst_fr, a: *const blst_fr, b: *const blst_...
  function blst_fr_sub (line 262) | pub fn blst_fr_sub(ret: *mut blst_fr, a: *const blst_fr, b: *const blst_...
  function blst_fr_mul_by_3 (line 265) | pub fn blst_fr_mul_by_3(ret: *mut blst_fr, a: *const blst_fr);
  function blst_fr_lshift (line 268) | pub fn blst_fr_lshift(ret: *mut blst_fr, a: *const blst_fr, count: usize);
  function blst_fr_rshift (line 271) | pub fn blst_fr_rshift(ret: *mut blst_fr, a: *const blst_fr, count: usize);
  function blst_fr_mul (line 274) | pub fn blst_fr_mul(ret: *mut blst_fr, a: *const blst_fr, b: *const blst_...
  function blst_fr_sqr (line 277) | pub fn blst_fr_sqr(ret: *mut blst_fr, a: *const blst_fr);
  function blst_fr_cneg (line 280) | pub fn blst_fr_cneg(ret: *mut blst_fr, a: *const blst_fr, flag: bool);
  function blst_fr_eucl_inverse (line 283) | pub fn blst_fr_eucl_inverse(ret: *mut blst_fr, a: *const blst_fr);
  function blst_fr_inverse (line 286) | pub fn blst_fr_inverse(ret: *mut blst_fr, a: *const blst_fr);
  function blst_fr_from_uint64 (line 289) | pub fn blst_fr_from_uint64(ret: *mut blst_fr, a: *const u64);
  function blst_uint64_from_fr (line 292) | pub fn blst_uint64_from_fr(ret: *mut u64, a: *const blst_fr);
  function blst_fr_from_scalar (line 295) | pub fn blst_fr_from_scalar(ret: *mut blst_fr, a: *const blst_scalar);
  function blst_scalar_from_fr (line 298) | pub fn blst_scalar_from_fr(ret: *mut blst_scalar, a: *const blst_fr);
  function blst_fp_add (line 301) | pub fn blst_fp_add(ret: *mut blst_fp, a: *const blst_fp, b: *const blst_...
  function blst_fp_sub (line 304) | pub fn blst_fp_sub(ret: *mut blst_fp, a: *const blst_fp, b: *const blst_...
  function blst_fp_mul_by_3 (line 307) | pub fn blst_fp_mul_by_3(ret: *mut blst_fp, a: *const blst_fp);
  function blst_fp_mul_by_8 (line 310) | pub fn blst_fp_mul_by_8(ret: *mut blst_fp, a: *const blst_fp);
  function blst_fp_lshift (line 313) | pub fn blst_fp_lshift(ret: *mut blst_fp, a: *const blst_fp, count: usize);
  function blst_fp_mul (line 316) | pub fn blst_fp_mul(ret: *mut blst_fp, a: *const blst_fp, b: *const blst_...
  function blst_fp_sqr (line 319) | pub fn blst_fp_sqr(ret: *mut blst_fp, a: *const blst_fp);
  function blst_fp_cneg (line 322) | pub fn blst_fp_cneg(ret: *mut blst_fp, a: *const blst_fp, flag: bool);
  function blst_fp_eucl_inverse (line 325) | pub fn blst_fp_eucl_inverse(ret: *mut blst_fp, a: *const blst_fp);
  function blst_fp_inverse (line 328) | pub fn blst_fp_inverse(ret: *mut blst_fp, a: *const blst_fp);
  function blst_fp_sqrt (line 331) | pub fn blst_fp_sqrt(ret: *mut blst_fp, a: *const blst_fp) -> bool;
  function blst_fp_from_uint32 (line 334) | pub fn blst_fp_from_uint32(ret: *mut blst_fp, a: *const u32);
  function blst_uint32_from_fp (line 337) | pub fn blst_uint32_from_fp(ret: *mut u32, a: *const blst_fp);
  function blst_fp_from_uint64 (line 340) | pub fn blst_fp_from_uint64(ret: *mut blst_fp, a: *const u64);
  function blst_uint64_from_fp (line 343) | pub fn blst_uint64_from_fp(ret: *mut u64, a: *const blst_fp);
  function blst_fp_from_bendian (line 346) | pub fn blst_fp_from_bendian(ret: *mut blst_fp, a: *const byte);
  function blst_bendian_from_fp (line 349) | pub fn blst_bendian_from_fp(ret: *mut byte, a: *const blst_fp);
  function blst_fp_from_lendian (line 352) | pub fn blst_fp_from_lendian(ret: *mut blst_fp, a: *const byte);
  function blst_lendian_from_fp (line 355) | pub fn blst_lendian_from_fp(ret: *mut byte, a: *const blst_fp);
  function blst_fp2_add (line 358) | pub fn blst_fp2_add(ret: *mut blst_fp2, a: *const blst_fp2, b: *const bl...
  function blst_fp2_sub (line 361) | pub fn blst_fp2_sub(ret: *mut blst_fp2, a: *const blst_fp2, b: *const bl...
  function blst_fp2_mul_by_3 (line 364) | pub fn blst_fp2_mul_by_3(ret: *mut blst_fp2, a: *const blst_fp2);
  function blst_fp2_mul_by_8 (line 367) | pub fn blst_fp2_mul_by_8(ret: *mut blst_fp2, a: *const blst_fp2);
  function blst_fp2_lshift (line 370) | pub fn blst_fp2_lshift(ret: *mut blst_fp2, a: *const blst_fp2, count: us...
  function blst_fp2_mul (line 373) | pub fn blst_fp2_mul(ret: *mut blst_fp2, a: *const blst_fp2, b: *const bl...
  function blst_fp2_sqr (line 376) | pub fn blst_fp2_sqr(ret: *mut blst_fp2, a: *const blst_fp2);
  function blst_fp2_cneg (line 379) | pub fn blst_fp2_cneg(ret: *mut blst_fp2, a: *const blst_fp2, flag: bool);
  function blst_fp2_eucl_inverse (line 382) | pub fn blst_fp2_eucl_inverse(ret: *mut blst_fp2, a: *const blst_fp2);
  function blst_fp2_inverse (line 385) | pub fn blst_fp2_inverse(ret: *mut blst_fp2, a: *const blst_fp2);
  function blst_fp2_sqrt (line 388) | pub fn blst_fp2_sqrt(ret: *mut blst_fp2, a: *const blst_fp2) -> bool;
  function blst_fp12_sqr (line 391) | pub fn blst_fp12_sqr(ret: *mut blst_fp12, a: *const blst_fp12);
  function blst_fp12_cyclotomic_sqr (line 394) | pub fn blst_fp12_cyclotomic_sqr(ret: *mut blst_fp12, a: *const blst_fp12);
  function blst_fp12_mul (line 397) | pub fn blst_fp12_mul(ret: *mut blst_fp12, a: *const blst_fp12, b: *const...
  function blst_fp12_mul_by_xy00z0 (line 400) | pub fn blst_fp12_mul_by_xy00z0(
  function blst_fp12_conjugate (line 407) | pub fn blst_fp12_conjugate(a: *mut blst_fp12);
  function blst_fp12_inverse (line 410) | pub fn blst_fp12_inverse(ret: *mut blst_fp12, a: *const blst_fp12);
  function blst_fp12_frobenius_map (line 413) | pub fn blst_fp12_frobenius_map(ret: *mut blst_fp12, a: *const blst_fp12,...
  function blst_fp12_is_equal (line 416) | pub fn blst_fp12_is_equal(a: *const blst_fp12, b: *const blst_fp12) -> b...
  function blst_fp12_is_one (line 419) | pub fn blst_fp12_is_one(a: *const blst_fp12) -> bool;
  function blst_fp12_in_group (line 422) | pub fn blst_fp12_in_group(a: *const blst_fp12) -> bool;
  function blst_fp12_one (line 425) | pub fn blst_fp12_one() -> *const blst_fp12;
  type blst_p1 (line 429) | pub struct blst_p1 {
  function bindgen_test_layout_blst_p1 (line 435) | fn bindgen_test_layout_blst_p1() {
  type blst_p1_affine (line 481) | pub struct blst_p1_affine {
  function bindgen_test_layout_blst_p1_affine (line 486) | fn bindgen_test_layout_blst_p1_affine() {
  function blst_p1_add (line 521) | pub fn blst_p1_add(out: *mut blst_p1, a: *const blst_p1, b: *const blst_...
  function blst_p1_add_or_double (line 524) | pub fn blst_p1_add_or_double(out: *mut blst_p1, a: *const blst_p1, b: *c...
  function blst_p1_add_affine (line 527) | pub fn blst_p1_add_affine(out: *mut blst_p1, a: *const blst_p1, b: *cons...
  function blst_p1_add_or_double_affine (line 530) | pub fn blst_p1_add_or_double_affine(
  function blst_p1_double (line 537) | pub fn blst_p1_double(out: *mut blst_p1, a: *const blst_p1);
  function blst_p1_mult (line 540) | pub fn blst_p1_mult(out: *mut blst_p1, p: *const blst_p1, scalar: *const...
  function blst_p1_cneg (line 543) | pub fn blst_p1_cneg(p: *mut blst_p1, cbit: bool);
  function blst_p1_to_affine (line 546) | pub fn blst_p1_to_affine(out: *mut blst_p1_affine, in_: *const blst_p1);
  function blst_p1_from_affine (line 549) | pub fn blst_p1_from_affine(out: *mut blst_p1, in_: *const blst_p1_affine);
  function blst_p1_on_curve (line 552) | pub fn blst_p1_on_curve(p: *const blst_p1) -> bool;
  function blst_p1_in_g1 (line 555) | pub fn blst_p1_in_g1(p: *const blst_p1) -> bool;
  function blst_p1_is_equal (line 558) | pub fn blst_p1_is_equal(a: *const blst_p1, b: *const blst_p1) -> bool;
  function blst_p1_is_inf (line 561) | pub fn blst_p1_is_inf(a: *const blst_p1) -> bool;
  function blst_p1_generator (line 564) | pub fn blst_p1_generator() -> *const blst_p1;
  function blst_p1_affine_on_curve (line 567) | pub fn blst_p1_affine_on_curve(p: *const blst_p1_affine) -> bool;
  function blst_p1_affine_in_g1 (line 570) | pub fn blst_p1_affine_in_g1(p: *const blst_p1_affine) -> bool;
  function blst_p1_affine_is_equal (line 573) | pub fn blst_p1_affine_is_equal(a: *const blst_p1_affine, b: *const blst_...
  function blst_p1_affine_is_inf (line 576) | pub fn blst_p1_affine_is_inf(a: *const blst_p1_affine) -> bool;
  function blst_p1_affine_generator (line 579) | pub fn blst_p1_affine_generator() -> *const blst_p1_affine;
  type blst_p2 (line 583) | pub struct blst_p2 {
  function bindgen_test_layout_blst_p2 (line 589) | fn bindgen_test_layout_blst_p2() {
  type blst_p2_affine (line 635) | pub struct blst_p2_affine {
  function bindgen_test_layout_blst_p2_affine (line 640) | fn bindgen_test_layout_blst_p2_affine() {
  function blst_p2_add (line 675) | pub fn blst_p2_add(out: *mut blst_p2, a: *const blst_p2, b: *const blst_...
  function blst_p2_add_or_double (line 678) | pub fn blst_p2_add_or_double(out: *mut blst_p2, a: *const blst_p2, b: *c...
  function blst_p2_add_affine (line 681) | pub fn blst_p2_add_affine(out: *mut blst_p2, a: *const blst_p2, b: *cons...
  function blst_p2_add_or_double_affine (line 684) | pub fn blst_p2_add_or_double_affine(
  function blst_p2_double (line 691) | pub fn blst_p2_double(out: *mut blst_p2, a: *const blst_p2);
  function blst_p2_mult (line 694) | pub fn blst_p2_mult(out: *mut blst_p2, p: *const blst_p2, scalar: *const...
  function blst_p2_cneg (line 697) | pub fn blst_p2_cneg(p: *mut blst_p2, cbit: bool);
  function blst_p2_to_affine (line 700) | pub fn blst_p2_to_affine(out: *mut blst_p2_affine, in_: *const blst_p2);
  function blst_p2_from_affine (line 703) | pub fn blst_p2_from_affine(out: *mut blst_p2, in_: *const blst_p2_affine);
  function blst_p2_on_curve (line 706) | pub fn blst_p2_on_curve(p: *const blst_p2) -> bool;
  function blst_p2_in_g2 (line 709) | pub fn blst_p2_in_g2(p: *const blst_p2) -> bool;
  function blst_p2_is_equal (line 712) | pub fn blst_p2_is_equal(a: *const blst_p2, b: *const blst_p2) -> bool;
  function blst_p2_is_inf (line 715) | pub fn blst_p2_is_inf(a: *const blst_p2) -> bool;
  function blst_p2_generator (line 718) | pub fn blst_p2_generator() -> *const blst_p2;
  function blst_p2_affine_on_curve (line 721) | pub fn blst_p2_affine_on_curve(p: *const blst_p2_affine) -> bool;
  function blst_p2_affine_in_g2 (line 724) | pub fn blst_p2_affine_in_g2(p: *const blst_p2_affine) -> bool;
  function blst_p2_affine_is_equal (line 727) | pub fn blst_p2_affine_is_equal(a: *const blst_p2_affine, b: *const blst_...
  function blst_p2_affine_is_inf (line 730) | pub fn blst_p2_affine_is_inf(a: *const blst_p2_affine) -> bool;
  function blst_p2_affine_generator (line 733) | pub fn blst_p2_affine_generator() -> *const blst_p2_affine;
  function blst_p1s_to_affine (line 736) | pub fn blst_p1s_to_affine(
  function blst_p1s_add (line 743) | pub fn blst_p1s_add(ret: *mut blst_p1, points: *const *const blst_p1_aff...
  function blst_p1s_mult_wbits_precompute_sizeof (line 746) | pub fn blst_p1s_mult_wbits_precompute_sizeof(wbits: usize, npoints: usiz...
  function blst_p1s_mult_wbits_precompute (line 749) | pub fn blst_p1s_mult_wbits_precompute(
  function blst_p1s_mult_wbits_scratch_sizeof (line 757) | pub fn blst_p1s_mult_wbits_scratch_sizeof(npoints: usize) -> usize;
  function blst_p1s_mult_wbits (line 760) | pub fn blst_p1s_mult_wbits(
  function blst_p1s_mult_pippenger_scratch_sizeof (line 771) | pub fn blst_p1s_mult_pippenger_scratch_sizeof(npoints: usize) -> usize;
  function blst_p1s_mult_pippenger (line 774) | pub fn blst_p1s_mult_pippenger(
  function blst_p1s_tile_pippenger (line 784) | pub fn blst_p1s_tile_pippenger(
  function blst_p2s_to_affine (line 796) | pub fn blst_p2s_to_affine(
  function blst_p2s_add (line 803) | pub fn blst_p2s_add(ret: *mut blst_p2, points: *const *const blst_p2_aff...
  function blst_p2s_mult_wbits_precompute_sizeof (line 806) | pub fn blst_p2s_mult_wbits_precompute_sizeof(wbits: usize, npoints: usiz...
  function blst_p2s_mult_wbits_precompute (line 809) | pub fn blst_p2s_mult_wbits_precompute(
  function blst_p2s_mult_wbits_scratch_sizeof (line 817) | pub fn blst_p2s_mult_wbits_scratch_sizeof(npoints: usize) -> usize;
  function blst_p2s_mult_wbits (line 820) | pub fn blst_p2s_mult_wbits(
  function blst_p2s_mult_pippenger_scratch_sizeof (line 831) | pub fn blst_p2s_mult_pippenger_scratch_sizeof(npoints: usize) -> usize;
  function blst_p2s_mult_pippenger (line 834) | pub fn blst_p2s_mult_pippenger(
  function blst_p2s_tile_pippenger (line 844) | pub fn blst_p2s_tile_pippenger(
  function blst_map_to_g1 (line 856) | pub fn blst_map_to_g1(out: *mut blst_p1, u: *const blst_fp, v: *const bl...
  function blst_map_to_g2 (line 859) | pub fn blst_map_to_g2(out: *mut blst_p2, u: *const blst_fp2, v: *const b...
  function blst_encode_to_g1 (line 862) | pub fn blst_encode_to_g1(
  function blst_hash_to_g1 (line 873) | pub fn blst_hash_to_g1(
  function blst_encode_to_g2 (line 884) | pub fn blst_encode_to_g2(
  function blst_hash_to_g2 (line 895) | pub fn blst_hash_to_g2(
  function blst_p1_serialize (line 906) | pub fn blst_p1_serialize(out: *mut byte, in_: *const blst_p1);
  function blst_p1_compress (line 909) | pub fn blst_p1_compress(out: *mut byte, in_: *const blst_p1);
  function blst_p1_affine_serialize (line 912) | pub fn blst_p1_affine_serialize(out: *mut byte, in_: *const blst_p1_affi...
  function blst_p1_affine_compress (line 915) | pub fn blst_p1_affine_compress(out: *mut byte, in_: *const blst_p1_affine);
  function blst_p1_uncompress (line 918) | pub fn blst_p1_uncompress(out: *mut blst_p1_affine, in_: *const byte) ->...
  function blst_p1_deserialize (line 921) | pub fn blst_p1_deserialize(out: *mut blst_p1_affine, in_: *const byte) -...
  function blst_p2_serialize (line 924) | pub fn blst_p2_serialize(out: *mut byte, in_: *const blst_p2);
  function blst_p2_compress (line 927) | pub fn blst_p2_compress(out: *mut byte, in_: *const blst_p2);
  function blst_p2_affine_serialize (line 930) | pub fn blst_p2_affine_serialize(out: *mut byte, in_: *const blst_p2_affi...
  function blst_p2_affine_compress (line 933) | pub fn blst_p2_affine_compress(out: *mut byte, in_: *const blst_p2_affine);
  function blst_p2_uncompress (line 936) | pub fn blst_p2_uncompress(out: *mut blst_p2_affine, in_: *const byte) ->...
  function blst_p2_deserialize (line 939) | pub fn blst_p2_deserialize(out: *mut blst_p2_affine, in_: *const byte) -...
  function blst_keygen (line 942) | pub fn blst_keygen(
  function blst_sk_to_pk_in_g1 (line 951) | pub fn blst_sk_to_pk_in_g1(out_pk: *mut blst_p1, SK: *const blst_scalar);
  function blst_sign_pk_in_g1 (line 954) | pub fn blst_sign_pk_in_g1(out_sig: *mut blst_p2, hash: *const blst_p2, S...
  function blst_sk_to_pk_in_g2 (line 957) | pub fn blst_sk_to_pk_in_g2(out_pk: *mut blst_p2, SK: *const blst_scalar);
  function blst_sign_pk_in_g2 (line 960) | pub fn blst_sign_pk_in_g2(out_sig: *mut blst_p1, hash: *const blst_p1, S...
  function blst_miller_loop (line 963) | pub fn blst_miller_loop(
  function blst_miller_loop_n (line 970) | pub fn blst_miller_loop_n(
  function blst_final_exp (line 978) | pub fn blst_final_exp(ret: *mut blst_fp12, f: *const blst_fp12);
  function blst_precompute_lines (line 981) | pub fn blst_precompute_lines(Qlines: *mut blst_fp6, Q: *const blst_p2_af...
  function blst_miller_loop_lines (line 984) | pub fn blst_miller_loop_lines(
  function blst_fp12_finalverify (line 991) | pub fn blst_fp12_finalverify(gt1: *const blst_fp12, gt2: *const blst_fp1...
  type blst_pairing (line 996) | pub struct blst_pairing {
  function bindgen_test_layout_blst_pairing (line 1000) | fn bindgen_test_layout_blst_pairing() {
  function blst_pairing_sizeof (line 1013) | pub fn blst_pairing_sizeof() -> usize;
  function blst_pairing_init (line 1016) | pub fn blst_pairing_init(
  function blst_pairing_get_dst (line 1024) | pub fn blst_pairing_get_dst(ctx: *const blst_pairing) -> *const byte;
  function blst_pairing_commit (line 1027) | pub fn blst_pairing_commit(ctx: *mut blst_pairing);
  function blst_pairing_aggregate_pk_in_g2 (line 1030) | pub fn blst_pairing_aggregate_pk_in_g2(
  function blst_pairing_chk_n_aggr_pk_in_g2 (line 1041) | pub fn blst_pairing_chk_n_aggr_pk_in_g2(
  function blst_pairing_mul_n_aggregate_pk_in_g2 (line 1054) | pub fn blst_pairing_mul_n_aggregate_pk_in_g2(
  function blst_pairing_chk_n_mul_n_aggr_pk_in_g2 (line 1067) | pub fn blst_pairing_chk_n_mul_n_aggr_pk_in_g2(
  function blst_pairing_aggregate_pk_in_g1 (line 1082) | pub fn blst_pairing_aggregate_pk_in_g1(
  function blst_pairing_chk_n_aggr_pk_in_g1 (line 1093) | pub fn blst_pairing_chk_n_aggr_pk_in_g1(
  function blst_pairing_mul_n_aggregate_pk_in_g1 (line 1106) | pub fn blst_pairing_mul_n_aggregate_pk_in_g1(
  function blst_pairing_chk_n_mul_n_aggr_pk_in_g1 (line 1119) | pub fn blst_pairing_chk_n_mul_n_aggr_pk_in_g1(
  function blst_pairing_merge (line 1134) | pub fn blst_pairing_merge(ctx: *mut blst_pairing, ctx1: *const blst_pair...
  function blst_pairing_finalverify (line 1137) | pub fn blst_pairing_finalverify(ctx: *const blst_pairing, gtsig: *const ...
  function blst_aggregate_in_g1 (line 1140) | pub fn blst_aggregate_in_g1(
  function blst_aggregate_in_g2 (line 1147) | pub fn blst_aggregate_in_g2(
  function blst_aggregated_in_g1 (line 1154) | pub fn blst_aggregated_in_g1(out: *mut blst_fp12, signature: *const blst...
  function blst_aggregated_in_g2 (line 1157) | pub fn blst_aggregated_in_g2(out: *mut blst_fp12, signature: *const blst...
  function blst_core_verify_pk_in_g1 (line 1160) | pub fn blst_core_verify_pk_in_g1(
  function blst_core_verify_pk_in_g2 (line 1173) | pub fn blst_core_verify_pk_in_g2(
  function blst_fr_ct_bfly (line 1198) | pub fn blst_fr_ct_bfly(x0: *mut blst_fr, x1: *mut blst_fr, twiddle: *con...
  function blst_fr_gs_bfly (line 1201) | pub fn blst_fr_gs_bfly(x0: *mut blst_fr, x1: *mut blst_fr, twiddle: *con...
  function blst_fr_to (line 1204) | pub fn blst_fr_to(ret: *mut blst_fr, a: *const blst_fr);
  function blst_fr_from (line 1207) | pub fn blst_fr_from(ret: *mut blst_fr, a: *const blst_fr);
  function blst_fp_to (line 1210) | pub fn blst_fp_to(ret: *mut blst_fp, a: *const blst_fp);
  function blst_fp_from (line 1213) | pub fn blst_fp_from(ret: *mut blst_fp, a: *const blst_fp);
  function blst_fp_is_square (line 1216) | pub fn blst_fp_is_square(a: *const blst_fp) -> bool;
  function blst_fp2_is_square (line 1219) | pub fn blst_fp2_is_square(a: *const blst_fp2) -> bool;
  function blst_p1_from_jacobian (line 1222) | pub fn blst_p1_from_jacobian(out: *mut blst_p1, in_: *const blst_p1);
  function blst_p2_from_jacobian (line 1225) | pub fn blst_p2_from_jacobian(out: *mut blst_p2, in_: *const blst_p2);
  function blst_sk_to_pk2_in_g1 (line 1228) | pub fn blst_sk_to_pk2_in_g1(
  function blst_sign_pk2_in_g1 (line 1235) | pub fn blst_sign_pk2_in_g1(
  function blst_sk_to_pk2_in_g2 (line 1243) | pub fn blst_sk_to_pk2_in_g2(
  function blst_sign_pk2_in_g2 (line 1250) | pub fn blst_sign_pk2_in_g2(
  type blst_uniq (line 1260) | pub struct blst_uniq {
  function bindgen_test_layout_blst_uniq (line 1264) | fn bindgen_test_layout_blst_uniq() {
  function blst_uniq_sizeof (line 1277) | pub fn blst_uniq_sizeof(n_nodes: usize) -> usize;
  function blst_uniq_init (line 1280) | pub fn blst_uniq_init(tree: *mut blst_uniq);
  function blst_uniq_test (line 1283) | pub fn blst_uniq_test(tree: *mut blst_uniq, msg: *const byte, len: usize...
  function blst_expand_message_xmd (line 1286) | pub fn blst_expand_message_xmd(
  function blst_p1_unchecked_mult (line 1296) | pub fn blst_p1_unchecked_mult(
  function blst_p2_unchecked_mult (line 1304) | pub fn blst_p2_unchecked_mult(
  function blst_pairing_raw_aggregate (line 1312) | pub fn blst_pairing_raw_aggregate(
  function blst_pairing_as_fp12 (line 1319) | pub fn blst_pairing_as_fp12(ctx: *mut blst_pairing) -> *mut blst_fp12;
  function blst_bendian_from_fp12 (line 1322) | pub fn blst_bendian_from_fp12(out: *mut byte, a: *const blst_fp12);
  function blst_keygen_v3 (line 1325) | pub fn blst_keygen_v3(
  function blst_keygen_v4_5 (line 1334) | pub fn blst_keygen_v4_5(
  function blst_keygen_v5 (line 1345) | pub fn blst_keygen_v5(
  function blst_derive_master_eip2333 (line 1356) | pub fn blst_derive_master_eip2333(out_SK: *mut blst_scalar, IKM: *const ...
  function blst_derive_child_eip2333 (line 1359) | pub fn blst_derive_child_eip2333(
  function blst_scalar_from_hexascii (line 1366) | pub fn blst_scalar_from_hexascii(out: *mut blst_scalar, hex: *const byte);
  function blst_fr_from_hexascii (line 1369) | pub fn blst_fr_from_hexascii(ret: *mut blst_fr, hex: *const byte);
  function blst_fp_from_hexascii (line 1372) | pub fn blst_fp_from_hexascii(ret: *mut blst_fp, hex: *const byte);
  function blst_p1_sizeof (line 1375) | pub fn blst_p1_sizeof() -> usize;
  function blst_p1_affine_sizeof (line 1378) | pub fn blst_p1_affine_sizeof() -> usize;
  function blst_p2_sizeof (line 1381) | pub fn blst_p2_sizeof() -> usize;
  function blst_p2_affine_sizeof (line 1384) | pub fn blst_p2_affine_sizeof() -> usize;
  function blst_fp12_sizeof (line 1387) | pub fn blst_fp12_sizeof() -> usize;
  function blst_fp_from_le_bytes (line 1390) | pub fn blst_fp_from_le_bytes(ret: *mut blst_fp, in_: *const byte, len: u...
  function blst_fp_from_be_bytes (line 1393) | pub fn blst_fp_from_be_bytes(ret: *mut blst_fp, in_: *const byte, len: u...
  function blst_sha256 (line 1396) | pub fn blst_sha256(out: *mut byte, msg: *const byte, msg_len: usize);
  function bindgen_test_normal_types (line 1399) | fn bindgen_test_normal_types() {

FILE: bindings/rust/src/lib.rs
  type ThreadPoolExt (line 28) | trait ThreadPoolExt {
    method joined_execute (line 29) | fn joined_execute<'any, F>(&self, job: F)
    method joined_execute (line 54) | fn joined_execute<'scope, F>(&self, job: F)
    method joined_execute (line 84) | fn joined_execute<'scope, F>(&self, job: F)
  function da_pool (line 40) | pub fn da_pool() -> ThreadPool {
  type Thunk (line 51) | type Thunk<'any> = Box<dyn FnOnce() + Send + 'any>;
  type EmptyPool (line 71) | pub struct EmptyPool {}
    method max_count (line 78) | pub fn max_count(&self) -> usize {
  function da_pool (line 73) | pub fn da_pool() -> EmptyPool {
  method eq (line 96) | fn eq(&self, other: &Self) -> bool {
  method eq (line 102) | fn eq(&self, other: &Self) -> bool {
  method eq (line 108) | fn eq(&self, other: &Self) -> bool {
  method eq (line 114) | fn eq(&self, other: &Self) -> bool {
  method default (line 120) | fn default() -> Self {
  method eq (line 126) | fn eq(&self, other: &Self) -> bool {
  type Output (line 132) | type Output = Self;
  method mul (line 134) | fn mul(self, other: Self) -> Self {
  method mul_assign (line 144) | fn mul_assign(&mut self, other: Self) {
  method miller_loop (line 150) | pub fn miller_loop(q: &blst_p2_affine, p: &blst_p1_affine) -> Self {
  method miller_loop_n (line 159) | pub fn miller_loop_n(q: &[blst_p2_affine], p: &[blst_p1_affine]) -> Self {
  method miller_loop_n (line 174) | pub fn miller_loop_n(q: &[blst_p2_affine], p: &[blst_p1_affine]) -> Self {
  method final_exp (line 233) | pub fn final_exp(&self) -> Self {
  method in_group (line 241) | pub fn in_group(&self) -> bool {
  method finalverify (line 245) | pub fn finalverify(a: &Self, b: &Self) -> bool {
  method to_bendian (line 249) | pub fn to_bendian(&self) -> [u8; 48 * 12] {
  method hash_to (line 259) | pub fn hash_to(msg: &[u8], dst: &[u8]) -> Option<Self> {
  type Pairing (line 281) | pub struct Pairing {
    method new (line 286) | pub fn new(hash_or_encode: bool, dst: &[u8]) -> Self {
    method init (line 295) | pub fn init(&mut self, hash_or_encode: bool, dst: &[u8]) {
    method ctx (line 305) | fn ctx(&mut self) -> *mut blst_pairing {
    method const_ctx (line 308) | fn const_ctx(&self) -> *const blst_pairing {
    method aggregate (line 312) | pub fn aggregate(
    method mul_n_aggregate (line 367) | pub fn mul_n_aggregate(
    method aggregated (line 427) | pub fn aggregated(gtsig: &mut blst_fp12, sig: &dyn Any) {
    method commit (line 447) | pub fn commit(&mut self) {
    method merge (line 451) | pub fn merge(&mut self, ctx1: &Self) -> BLST_ERROR {
    method finalverify (line 455) | pub fn finalverify(&self, gtsig: Option<&blst_fp12>) -> bool {
    method raw_aggregate (line 467) | pub fn raw_aggregate(&mut self, q: &blst_p2_affine, p: &blst_p1_affine) {
    method as_fp12 (line 471) | pub fn as_fp12(&mut self) -> blst_fp12 {
  function uniq (line 476) | pub fn uniq(msgs: &[&[u8]]) -> bool {
  function print_bytes (line 500) | pub fn print_bytes(bytes: &[u8], name: &str) {
  type MultiPoint (line 2286) | pub trait MultiPoint {
    method mult (line 2289) | fn mult(&self, scalars: &[u8], nbits: usize) -> Self::Output;
    method add (line 2290) | fn add(&self) -> Self::Output;
    method validate (line 2291) | fn validate(&self) -> Result<(), BLST_ERROR> {
  function miller_loop_n (line 2309) | fn miller_loop_n() {
  function inverse (line 2362) | fn inverse() {

FILE: bindings/rust/src/pippenger.rs
  type tile (line 10) | struct tile {
  type Cell (line 21) | struct Cell<T: ?Sized> {
  function as_ptr (line 26) | pub fn as_ptr(&self) -> *mut T {
  function num_bits (line 497) | fn num_bits(l: usize) -> usize {
  function breakdown (line 501) | fn breakdown(
  function pippenger_window_size (line 538) | fn pippenger_window_size(npoints: usize) -> usize {

FILE: bindings/zig/generate.py
  function xchg_1vs2 (line 396) | def xchg_1vs2(matchobj):
  function newer (line 414) | def newer(*files):

FILE: build/srcroot.go
  function init (line 10) | func init() {

FILE: build/win64/dll.c
  function BOOL (line 31) | BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReser...

FILE: src/aggregate.c
  type AggregatedSignature (line 43) | typedef union { POINTonE1 e1; POINTonE2 e2; } AggregatedSignature;
  type PAIRING (line 44) | typedef struct {
  function blst_pairing_sizeof (line 65) | size_t blst_pairing_sizeof(void)
  function blst_pairing_init (line 68) | void blst_pairing_init(PAIRING *ctx, int hash_or_encode,
  function BLST_ERROR (line 98) | static BLST_ERROR PAIRING_Aggregate_PK_in_G2(PAIRING *ctx,
  function BLST_ERROR (line 192) | BLST_ERROR blst_pairing_aggregate_pk_in_g2(PAIRING *ctx,
  function BLST_ERROR (line 201) | BLST_ERROR blst_pairing_mul_n_aggregate_pk_in_g2(PAIRING *ctx,
  function BLST_ERROR (line 214) | BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g2(PAIRING *ctx,
  function BLST_ERROR (line 225) | BLST_ERROR blst_pairing_chk_n_mul_n_aggr_pk_in_g2(PAIRING *ctx,
  function BLST_ERROR (line 241) | static BLST_ERROR PAIRING_Aggregate_PK_in_G1(PAIRING *ctx,
  function BLST_ERROR (line 341) | BLST_ERROR blst_pairing_aggregate_pk_in_g1(PAIRING *ctx,
  function BLST_ERROR (line 350) | BLST_ERROR blst_pairing_mul_n_aggregate_pk_in_g1(PAIRING *ctx,
  function BLST_ERROR (line 363) | BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g1(PAIRING *ctx,
  function BLST_ERROR (line 374) | BLST_ERROR blst_pairing_chk_n_mul_n_aggr_pk_in_g1(PAIRING *ctx,
  function PAIRING_Commit (line 390) | static void PAIRING_Commit(PAIRING *ctx)
  function blst_pairing_commit (line 407) | void blst_pairing_commit(PAIRING *ctx)
  function BLST_ERROR (line 410) | BLST_ERROR blst_pairing_merge(PAIRING *ctx, const PAIRING *ctx1)
  function bool_t (line 460) | static bool_t PAIRING_FinalVerify(const PAIRING *ctx, const vec384fp12 G...
  function blst_pairing_finalverify (line 503) | int blst_pairing_finalverify(const PAIRING *ctx, const vec384fp12 GTsig)
  function blst_fp12_finalverify (line 506) | int blst_fp12_finalverify(const vec384fp12 GT1, const vec384fp12 GT2)
  function blst_pairing_raw_aggregate (line 520) | void blst_pairing_raw_aggregate(PAIRING *ctx, const POINTonE2_affine *q,
  function vec384fp12 (line 545) | vec384fp12 *blst_pairing_as_fp12(PAIRING *ctx)
  function BLST_ERROR (line 559) | BLST_ERROR blst_aggregate_in_g1(POINTonE1 *out, const POINTonE1 *in,
  function BLST_ERROR (line 589) | BLST_ERROR blst_aggregate_in_g2(POINTonE2 *out, const POINTonE2 *in,
  function blst_aggregated_in_g1 (line 619) | void blst_aggregated_in_g1(vec384fp12 ret, const POINTonE1_affine *sig)
  function blst_aggregated_in_g2 (line 622) | void blst_aggregated_in_g2(vec384fp12 ret, const POINTonE2_affine *sig)
  function BLST_ERROR (line 625) | BLST_ERROR blst_core_verify_pk_in_g1(const POINTonE1_affine *pk,
  function BLST_ERROR (line 650) | BLST_ERROR blst_core_verify_pk_in_g2(const POINTonE2_affine *pk,

FILE: src/blst_t.hpp
  function vec_left_align (line 33) | static inline void vec_left_align(limb_t *out, const limb_t *inp, size_t N)
  class blst_384_t (line 56) | class blst_384_t {
    method limb_t (line 62) | inline limb_t& operator[](size_t i)             { return val[i]; }
    method limb_t (line 63) | inline const limb_t& operator[](size_t i) const { return val[i]; }
    method bit_length (line 68) | static constexpr size_t bit_length() { return N; }
    method blst_384_t (line 73) | inline blst_384_t() {}
    method blst_384_t (line 74) | inline blst_384_t(const vec384 p, bool align = false)
    method blst_384_t (line 81) | inline blst_384_t(uint64_t a)
    method blst_384_t (line 87) | inline blst_384_t(int a) : blst_384_t((uint64_t)a) {}
    method blst_384_t (line 94) | constexpr blst_384_t(limb_t a0, Ts... arr)
    method blst_384_t (line 116) | constexpr blst_384_t(limb_t a0, Ts... arr) : val{a0, arr...} {}
    method to_scalar (line 119) | inline void to_scalar(pow_t& scalar) const
    method blst_384_t (line 136) | static inline const blst_384_t& one()
    method blst_384_t (line 139) | static inline blst_384_t one(bool or_zero)
    method blst_384_t (line 148) | inline blst_384_t& to()
    method blst_384_t (line 150) | inline blst_384_t& from()
    method store (line 153) | inline void store(limb_t *p) const
    method blst_384_t (line 156) | inline blst_384_t& operator+=(const blst_384_t& b)
    method blst_384_t (line 158) | inline blst_384_t operator+(const blst_384_t& a, const blst_384_t& b)
    method blst_384_t (line 165) | inline blst_384_t& operator<<=(unsigned l)
    method blst_384_t (line 167) | inline blst_384_t operator<<(const blst_384_t& a, unsigned l)
    method blst_384_t (line 174) | inline blst_384_t& operator>>=(unsigned r)
    method blst_384_t (line 176) | inline blst_384_t operator>>(const blst_384_t& a, unsigned r)
    method blst_384_t (line 183) | inline blst_384_t& operator-=(const blst_384_t& b)
    method blst_384_t (line 185) | inline blst_384_t operator-(const blst_384_t& a, const blst_384_t& b)
    method blst_384_t (line 192) | inline blst_384_t& cneg(bool flag)
    method blst_384_t (line 194) | inline blst_384_t cneg(const blst_384_t& a, bool flag)
    method blst_384_t (line 200) | inline blst_384_t operator-(const blst_384_t& a)
    method blst_384_t (line 207) | inline blst_384_t& operator*=(const blst_384_t& a)
    method blst_384_t (line 213) | inline blst_384_t operator*(const blst_384_t& a, const blst_384_t& b)
    method blst_384_t (line 222) | inline blst_384_t operator^(const blst_384_t& a, unsigned p)
    method blst_384_t (line 247) | inline blst_384_t& operator^=(unsigned p)
    method blst_384_t (line 257) | inline blst_384_t operator()(unsigned p)
    method blst_384_t (line 259) | inline blst_384_t sqr(const blst_384_t& a)
    method is_one (line 262) | inline bool is_one() const
    method is_zero (line 265) | inline int is_zero() const
    method zero (line 268) | inline void zero()
    method blst_384_t (line 271) | inline blst_384_t czero(const blst_384_t& a, int set_z)
    method blst_384_t (line 278) | static inline blst_384_t csel(const blst_384_t& a, const blst_384_t& b,
    method blst_384_t (line 285) | blst_384_t reciprocal() const
    method blst_384_t (line 296) | inline blst_384_t operator/(unsigned one, const blst_384_t& a)
    method blst_384_t (line 302) | inline blst_384_t operator/(const blst_384_t& a, const blst_384_t& b)
    method blst_384_t (line 304) | inline blst_384_t& operator/=(const blst_384_t& a)
    method blst_384_t (line 307) | inline blst_384_t(const char *hexascii)
    method OStream (line 316) | OStream& operator<<(OStream& os, const blst_384_t& obj)
  class blst_256_t (line 334) | class blst_256_t {
    method limb_t (line 339) | inline limb_t& operator[](size_t i)             { return val[i]; }
    method limb_t (line 340) | inline const limb_t& operator[](size_t i) const { return val[i]; }
    method bit_length (line 345) | static constexpr size_t bit_length() { return N; }
    method blst_256_t (line 350) | inline blst_256_t() {}
    method blst_256_t (line 351) | inline blst_256_t(const vec256 p, bool align = false)
    method blst_256_t (line 358) | inline blst_256_t(uint64_t a)
    method blst_256_t (line 364) | inline blst_256_t(int a) : blst_256_t((uint64_t)a) {}
    method blst_256_t (line 371) | constexpr blst_256_t(limb_t a0, Ts... arr)
    method blst_256_t (line 389) | constexpr blst_256_t(limb_t a0, Ts... arr) : val{a0, arr...} {}
    method to_scalar (line 392) | inline void to_scalar(pow_t& scalar) const
    method blst_256_t (line 409) | static inline const blst_256_t& one()
    method blst_256_t (line 412) | static inline blst_256_t one(bool or_zero)
    method blst_256_t (line 421) | inline blst_256_t& to()
    method blst_256_t (line 423) | inline blst_256_t& to(const uint64_t a[2*n])
    method blst_256_t (line 431) | blst_256_t& to(const unsigned char* bytes, size_t n, bool le = false)
    method blst_256_t (line 464) | inline blst_256_t& from()
    method blst_256_t (line 466) | inline blst_256_t& from(const uint64_t a[2*n])
    method blst_256_t (line 473) | inline blst_256_t& from(const unsigned char *bytes, size_t n, bool le ...
    method store (line 494) | inline void store(limb_t *p) const
    method blst_256_t (line 497) | inline blst_256_t& operator+=(const blst_256_t& b)
    method blst_256_t (line 499) | inline blst_256_t operator+(const blst_256_t& a, const blst_256_t& b)
    method blst_256_t (line 506) | inline blst_256_t& operator<<=(unsigned l)
    method blst_256_t (line 508) | inline blst_256_t operator<<(const blst_256_t& a, unsigned l)
    method blst_256_t (line 515) | inline blst_256_t& operator>>=(unsigned r)
    method blst_256_t (line 517) | inline blst_256_t operator>>(const blst_256_t& a, unsigned r)
    method blst_256_t (line 524) | inline blst_256_t& operator-=(const blst_256_t& b)
    method blst_256_t (line 526) | inline blst_256_t operator-(const blst_256_t& a, const blst_256_t& b)
    method blst_256_t (line 533) | inline blst_256_t& cneg(bool flag)
    method blst_256_t (line 535) | inline blst_256_t cneg(const blst_256_t& a, bool flag)
    method blst_256_t (line 541) | inline blst_256_t operator-(const blst_256_t& a)
    method blst_256_t (line 548) | inline blst_256_t& operator*=(const blst_256_t& a)
    method blst_256_t (line 554) | inline blst_256_t operator*(const blst_256_t& a, const blst_256_t& b)
    method blst_256_t (line 563) | inline blst_256_t operator^(const blst_256_t& a, unsigned p)
    method blst_256_t (line 588) | inline blst_256_t& operator^=(unsigned p)
    method blst_256_t (line 598) | inline blst_256_t operator()(unsigned p)
    method blst_256_t (line 600) | inline blst_256_t sqr(const blst_256_t& a)
    method is_one (line 603) | inline bool is_one() const
    method is_zero (line 606) | inline int is_zero() const
    method zero (line 609) | inline void zero()
    method blst_256_t (line 612) | inline blst_256_t czero(const blst_256_t& a, int set_z)
    method blst_256_t (line 619) | static inline blst_256_t csel(const blst_256_t& a, const blst_256_t& b,
    method blst_256_t (line 626) | blst_256_t reciprocal() const
    method blst_256_t (line 637) | inline blst_256_t operator/(int one, const blst_256_t& a)
    method blst_256_t (line 643) | inline blst_256_t operator/(const blst_256_t& a, const blst_256_t& b)
    method blst_256_t (line 645) | inline blst_256_t& operator/=(const blst_256_t& a)
    method blst_256_t (line 648) | inline blst_256_t(const char *hexascii)
    method OStream (line 657) | OStream& operator<<(OStream& os, const blst_256_t& obj)

FILE: src/bytes.h
  function bytes_zero (line 9) | static inline void bytes_zero(unsigned char *a, size_t num)
  function limbs_from_be_bytes (line 17) | static inline void limbs_from_be_bytes(limb_t *restrict ret,
  function be_bytes_from_limbs (line 35) | static inline void be_bytes_from_limbs(unsigned char *out, const limb_t ...
  function limbs_from_le_bytes (line 46) | static inline void limbs_from_le_bytes(limb_t *restrict ret,
  function le_bytes_from_limbs (line 64) | static inline void le_bytes_from_limbs(unsigned char *out, const limb_t ...
  function hex_from_nibble (line 90) | static inline char hex_from_nibble(unsigned char nibble)
  function nibble_from_hex (line 96) | static unsigned char nibble_from_hex(char c)
  function bytes_from_hexascii (line 112) | static void bytes_from_hexascii(unsigned char *ret, size_t sz, const cha...
  function limbs_from_hexascii (line 132) | static void limbs_from_hexascii(limb_t *ret, size_t sz, const char *hex)

FILE: src/consts.h
  type radix384 (line 13) | typedef union { vec384 p12[12]; vec384x p2; vec384 p; } radix384;

FILE: src/cpuid.c
  function __cpuidex (line 15) | static void __cpuidex(int info[4], int func, int sub)
  function __blst_cpuid (line 32) | __attribute__((constructor))
  function __blst_cpuid (line 62) | __attribute__((constructor))
  function __blst_cpuid (line 77) | __attribute__((constructor))
  function __blst_cpuid (line 85) | __attribute__((constructor))
  function __blst_cpuid (line 99) | __attribute__((constructor))
  function BOOL (line 121) | BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpvReserved)

FILE: src/e1.c
  function mul_by_b_onE1 (line 48) | static inline void mul_by_b_onE1(vec384 out, const vec384 in)
  function mul_by_4b_onE1 (line 51) | static inline void mul_by_4b_onE1(vec384 out, const vec384 in)
  function POINTonE1_cneg (line 54) | static void POINTonE1_cneg(POINTonE1 *p, bool_t cbit)
  function blst_p1_cneg (line 57) | void blst_p1_cneg(POINTonE1 *a, int cbit)
  function POINTonE1_from_Jacobian (line 60) | static void POINTonE1_from_Jacobian(POINTonE1 *out, const POINTonE1 *in)
  function blst_p1_from_jacobian (line 77) | void blst_p1_from_jacobian(POINTonE1 *out, const POINTonE1 *a)
  function POINTonE1_to_affine (line 80) | static void POINTonE1_to_affine(POINTonE1_affine *out, const POINTonE1 *in)
  function blst_p1_to_affine (line 91) | void blst_p1_to_affine(POINTonE1_affine *out, const POINTonE1 *a)
  function blst_p1_from_affine (line 94) | void blst_p1_from_affine(POINTonE1 *out, const POINTonE1_affine *a)
  function bool_t (line 101) | static bool_t POINTonE1_affine_on_curve(const POINTonE1_affine *p)
  function blst_p1_affine_on_curve (line 114) | int blst_p1_affine_on_curve(const POINTonE1_affine *p)
  function bool_t (line 117) | static bool_t POINTonE1_on_curve(const POINTonE1 *p)
  function blst_p1_on_curve (line 136) | int blst_p1_on_curve(const POINTonE1 *p)
  function limb_t (line 139) | static limb_t POINTonE1_affine_Serialize_BE(unsigned char out[96],
  function blst_p1_affine_serialize (line 153) | void blst_p1_affine_serialize(unsigned char out[96],
  function limb_t (line 164) | static limb_t POINTonE1_Serialize_BE(unsigned char out[96],
  function POINTonE1_Serialize (line 177) | static void POINTonE1_Serialize(unsigned char out[96], const POINTonE1 *in)
  function blst_p1_serialize (line 187) | void blst_p1_serialize(unsigned char out[96], const POINTonE1 *in)
  function limb_t (line 190) | static limb_t POINTonE1_affine_Compress_BE(unsigned char out[48],
  function blst_p1_affine_compress (line 201) | void blst_p1_affine_compress(unsigned char out[48], const POINTonE1_affi...
  function limb_t (line 212) | static limb_t POINTonE1_Compress_BE(unsigned char out[48],
  function blst_p1_compress (line 225) | void blst_p1_compress(unsigned char out[48], const POINTonE1 *in)
  function limb_t (line 236) | static limb_t POINTonE1_Uncompress_BE(POINTonE1_affine *out,
  function BLST_ERROR (line 261) | static BLST_ERROR POINTonE1_Uncompress_Z(POINTonE1_affine *out,
  function BLST_ERROR (line 293) | BLST_ERROR blst_p1_uncompress(POINTonE1_affine *out, const unsigned char...
  function BLST_ERROR (line 296) | static BLST_ERROR POINTonE1_Deserialize_BE(POINTonE1_affine *out,
  function BLST_ERROR (line 328) | static BLST_ERROR POINTonE1_Deserialize_Z(POINTonE1_affine *out,
  function BLST_ERROR (line 349) | BLST_ERROR blst_p1_deserialize(POINTonE1_affine *out,
  function blst_p1_add (line 361) | void blst_p1_add(POINTonE1 *out, const POINTonE1 *a, const POINTonE1 *b)
  function blst_p1_add_or_double (line 364) | void blst_p1_add_or_double(POINTonE1 *out, const POINTonE1 *a,
  function blst_p1_add_affine (line 368) | void blst_p1_add_affine(POINTonE1 *out, const POINTonE1 *a,
  function blst_p1_add_or_double_affine (line 372) | void blst_p1_add_or_double_affine(POINTonE1 *out, const POINTonE1 *a,
  function blst_p1_double (line 376) | void blst_p1_double(POINTonE1 *out, const POINTonE1 *a)
  function blst_p1_is_equal (line 379) | int blst_p1_is_equal(const POINTonE1 *a, const POINTonE1 *b)
  function sigma (line 405) | static void sigma(POINTonE1 *out, const POINTonE1 *in)
  function POINTonE1_mult_glv (line 412) | static void POINTonE1_mult_glv(POINTonE1 *out, const POINTonE1 *in,
  function POINTonE1_sign (line 444) | static void POINTonE1_sign(POINTonE1 *out, const POINTonE1 *in, const po...
  function blst_sk_to_pk_in_g1 (line 469) | void blst_sk_to_pk_in_g1(POINTonE1 *out, const pow256 SK)
  function blst_sign_pk_in_g2 (line 472) | void blst_sign_pk_in_g2(POINTonE1 *out, const POINTonE1 *msg, const pow2...
  function blst_sk_to_pk2_in_g1 (line 475) | void blst_sk_to_pk2_in_g1(unsigned char out[96], POINTonE1_affine *PK,
  function blst_sign_pk2_in_g2 (line 490) | void blst_sign_pk2_in_g2(unsigned char out[96], POINTonE1_affine *sig,
  function blst_p1_mult (line 505) | void blst_p1_mult(POINTonE1 *out, const POINTonE1 *a,
  function blst_p1_unchecked_mult (line 535) | void blst_p1_unchecked_mult(POINTonE1 *out, const POINTonE1 *a,
  function blst_p1_affine_is_equal (line 544) | int blst_p1_affine_is_equal(const POINTonE1_affine *a,
  function blst_p1_is_inf (line 548) | int blst_p1_is_inf(const POINTonE1 *p)
  function POINTonE1 (line 551) | const POINTonE1 *blst_p1_generator(void)
  function blst_p1_affine_is_inf (line 554) | int blst_p1_affine_is_inf(const POINTonE1_affine *p)
  function POINTonE1_affine (line 557) | const POINTonE1_affine *blst_p1_affine_generator(void)
  function blst_p1_sizeof (line 560) | size_t blst_p1_sizeof(void)
  function blst_p1_affine_sizeof (line 563) | size_t blst_p1_affine_sizeof(void)

FILE: src/e2.c
  function mul_by_b_onE2 (line 75) | static void mul_by_b_onE2(vec384x out, const vec384x in)
  function mul_by_4b_onE2 (line 83) | static void mul_by_4b_onE2(vec384x out, const vec384x in)
  function POINTonE2_cneg (line 91) | static void POINTonE2_cneg(POINTonE2 *p, bool_t cbit)
  function blst_p2_cneg (line 94) | void blst_p2_cneg(POINTonE2 *a, int cbit)
  function POINTonE2_from_Jacobian (line 97) | static void POINTonE2_from_Jacobian(POINTonE2 *out, const POINTonE2 *in)
  function blst_p2_from_jacobian (line 114) | void blst_p2_from_jacobian(POINTonE2 *out, const POINTonE2 *a)
  function POINTonE2_to_affine (line 117) | static void POINTonE2_to_affine(POINTonE2_affine *out, const POINTonE2 *in)
  function blst_p2_to_affine (line 128) | void blst_p2_to_affine(POINTonE2_affine *out, const POINTonE2 *a)
  function blst_p2_from_affine (line 131) | void blst_p2_from_affine(POINTonE2 *out, const POINTonE2_affine *a)
  function bool_t (line 138) | static bool_t POINTonE2_affine_on_curve(const POINTonE2_affine *p)
  function blst_p2_affine_on_curve (line 151) | int blst_p2_affine_on_curve(const POINTonE2_affine *p)
  function bool_t (line 154) | static bool_t POINTonE2_on_curve(const POINTonE2 *p)
  function blst_p2_on_curve (line 173) | int blst_p2_on_curve(const POINTonE2 *p)
  function limb_t (line 176) | static limb_t POINTonE2_affine_Serialize_BE(unsigned char out[192],
  function blst_p2_affine_serialize (line 194) | void blst_p2_affine_serialize(unsigned char out[192],
  function limb_t (line 205) | static limb_t POINTonE2_Serialize_BE(unsigned char out[192],
  function POINTonE2_Serialize (line 218) | static void POINTonE2_Serialize(unsigned char out[192], const POINTonE2 ...
  function blst_p2_serialize (line 228) | void blst_p2_serialize(unsigned char out[192], const POINTonE2 *in)
  function limb_t (line 231) | static limb_t POINTonE2_affine_Compress_BE(unsigned char out[96],
  function blst_p2_affine_compress (line 244) | void blst_p2_affine_compress(unsigned char out[96], const POINTonE2_affi...
  function limb_t (line 255) | static limb_t POINTonE2_Compress_BE(unsigned char out[96],
  function blst_p2_compress (line 268) | void blst_p2_compress(unsigned char out[96], const POINTonE2 *in)
  function limb_t (line 279) | static limb_t POINTonE2_Uncompress_BE(POINTonE2_affine *out,
  function BLST_ERROR (line 312) | static BLST_ERROR POINTonE2_Uncompress_Z(POINTonE2_affine *out,
  function BLST_ERROR (line 342) | BLST_ERROR blst_p2_uncompress(POINTonE2_affine *out, const unsigned char...
  function BLST_ERROR (line 345) | static BLST_ERROR POINTonE2_Deserialize_BE(POINTonE2_affine *out,
  function BLST_ERROR (line 387) | static BLST_ERROR POINTonE2_Deserialize_Z(POINTonE2_affine *out,
  function BLST_ERROR (line 408) | BLST_ERROR blst_p2_deserialize(POINTonE2_affine *out,
  function blst_p2_add (line 420) | void blst_p2_add(POINTonE2 *out, const POINTonE2 *a, const POINTonE2 *b)
  function blst_p2_add_or_double (line 423) | void blst_p2_add_or_double(POINTonE2 *out, const POINTonE2 *a,
  function blst_p2_add_affine (line 427) | void blst_p2_add_affine(POINTonE2 *out, const POINTonE2 *a,
  function blst_p2_add_or_double_affine (line 431) | void blst_p2_add_or_double_affine(POINTonE2 *out, const POINTonE2 *a,
  function blst_p2_double (line 435) | void blst_p2_double(POINTonE2 *out, const POINTonE2 *a)
  function blst_p2_is_equal (line 438) | int blst_p2_is_equal(const POINTonE2 *a, const POINTonE2 *b)
  function DECLARE_PRIVATE_POINTXZ (line 446) | POINT_AFFINE_MULT_SCALAR_IMPL(POINTonE2)
  function POINTonE2_sign (line 518) | static void POINTonE2_sign(POINTonE2 *out, const POINTonE2 *in, const po...
  function blst_sk_to_pk_in_g2 (line 543) | void blst_sk_to_pk_in_g2(POINTonE2 *out, const pow256 SK)
  function blst_sign_pk_in_g1 (line 546) | void blst_sign_pk_in_g1(POINTonE2 *out, const POINTonE2 *msg, const pow2...
  function blst_sk_to_pk2_in_g2 (line 549) | void blst_sk_to_pk2_in_g2(unsigned char out[192], POINTonE2_affine *PK,
  function blst_sign_pk2_in_g1 (line 564) | void blst_sign_pk2_in_g1(unsigned char out[192], POINTonE2_affine *sig,
  function blst_p2_mult (line 579) | void blst_p2_mult(POINTonE2 *out, const POINTonE2 *a,
  function blst_p2_unchecked_mult (line 609) | void blst_p2_unchecked_mult(POINTonE2 *out, const POINTonE2 *a,
  function blst_p2_affine_is_equal (line 618) | int blst_p2_affine_is_equal(const POINTonE2_affine *a,
  function blst_p2_is_inf (line 622) | int blst_p2_is_inf(const POINTonE2 *p)
  function POINTonE2 (line 625) | const POINTonE2 *blst_p2_generator(void)
  function blst_p2_affine_is_inf (line 628) | int blst_p2_affine_is_inf(const POINTonE2_affine *p)
  function POINTonE2_affine (line 631) | const POINTonE2_affine *blst_p2_affine_generator(void)
  function blst_p2_sizeof (line 634) | size_t blst_p2_sizeof(void)
  function blst_p2_affine_sizeof (line 637) | size_t blst_p2_affine_sizeof(void)

FILE: src/ec_mult.h
  function limb_t (line 12) | static limb_t get_wval(const byte *d, size_t off, size_t bits)
  function limb_t (line 23) | static limb_t get_wval_limb(const byte *d, size_t off, size_t bits)
  function limb_t (line 46) | static limb_t booth_encode(limb_t wval, size_t sz)

FILE: src/errors.h
  type BLST_ERROR (line 9) | typedef enum {

FILE: src/exp.c
  function exp_mont_384 (line 12) | static void exp_mont_384(vec384 out, const vec384 inp, const byte *pow,
  function exp_mont_384x (line 42) | static void exp_mont_384x(vec384x out, const vec384x inp, const byte *pow,

FILE: src/exports.c
  function blst_fr_add (line 24) | void blst_fr_add(vec256 ret, const vec256 a, const vec256 b)
  function blst_fr_sub (line 27) | void blst_fr_sub(vec256 ret, const vec256 a, const vec256 b)
  function blst_fr_mul_by_3 (line 30) | void blst_fr_mul_by_3(vec256 ret, const vec256 a)
  function blst_fr_lshift (line 33) | void blst_fr_lshift(vec256 ret, const vec256 a, size_t count)
  function blst_fr_rshift (line 36) | void blst_fr_rshift(vec256 ret, const vec256 a, size_t count)
  function blst_fr_mul (line 39) | void blst_fr_mul(vec256 ret, const vec256 a, const vec256 b)
  function blst_fr_ct_bfly (line 42) | void blst_fr_ct_bfly(vec256 x0, vec256 x1, const vec256 twiddle)
  function blst_fr_gs_bfly (line 51) | void blst_fr_gs_bfly(vec256 x0, vec256 x1, const vec256 twiddle)
  function blst_fr_sqr (line 60) | void blst_fr_sqr(vec256 ret, const vec256 a)
  function blst_fr_cneg (line 63) | void blst_fr_cneg(vec256 ret, const vec256 a, int flag)
  function blst_fr_to (line 66) | void blst_fr_to(vec256 ret, const vec256 a)
  function blst_fr_from (line 69) | void blst_fr_from(vec256 ret, const vec256 a)
  function blst_fr_from_scalar (line 72) | void blst_fr_from_scalar(vec256 ret, const pow256 a)
  function blst_scalar_from_fr (line 90) | void blst_scalar_from_fr(pow256 ret, const vec256 a)
  function blst_scalar_fr_check (line 107) | int blst_scalar_fr_check(const pow256 a)
  function blst_sk_check (line 112) | int blst_sk_check(const pow256 a)
  function blst_sk_add_n_check (line 115) | int blst_sk_add_n_check(pow256 ret, const pow256 a, const pow256 b)
  function blst_sk_sub_n_check (line 118) | int blst_sk_sub_n_check(pow256 ret, const pow256 a, const pow256 b)
  function blst_sk_mul_n_check (line 121) | int blst_sk_mul_n_check(pow256 ret, const pow256 a, const pow256 b)
  function blst_sk_inverse (line 145) | void blst_sk_inverse(pow256 ret, const pow256 a)
  function blst_fp_add (line 172) | void blst_fp_add(vec384 ret, const vec384 a, const vec384 b)
  function blst_fp_sub (line 175) | void blst_fp_sub(vec384 ret, const vec384 a, const vec384 b)
  function blst_fp_mul_by_3 (line 178) | void blst_fp_mul_by_3(vec384 ret, const vec384 a)
  function blst_fp_mul_by_8 (line 181) | void blst_fp_mul_by_8(vec384 ret, const vec384 a)
  function blst_fp_lshift (line 184) | void blst_fp_lshift(vec384 ret, const vec384 a, size_t count)
  function blst_fp_mul (line 187) | void blst_fp_mul(vec384 ret, const vec384 a, const vec384 b)
  function blst_fp_sqr (line 190) | void blst_fp_sqr(vec384 ret, const vec384 a)
  function blst_fp_cneg (line 193) | void blst_fp_cneg(vec384 ret, const vec384 a, int flag)
  function blst_fp_to (line 196) | void blst_fp_to(vec384 ret, const vec384 a)
  function blst_fp_from (line 199) | void blst_fp_from(vec384 ret, const vec384 a)
  function blst_fp_from_uint32 (line 205) | void blst_fp_from_uint32(vec384 ret, const unsigned int a[12])
  function blst_uint32_from_fp (line 216) | void blst_uint32_from_fp(unsigned int ret[12], const vec384 a)
  function blst_fp_from_uint64 (line 233) | void blst_fp_from_uint64(vec384 ret, const unsigned long long a[6])
  function blst_uint64_from_fp (line 252) | void blst_uint64_from_fp(unsigned long long ret[6], const vec384 a)
  function blst_fp_from_bendian (line 271) | void blst_fp_from_bendian(vec384 ret, const unsigned char a[48])
  function blst_bendian_from_fp (line 279) | void blst_bendian_from_fp(unsigned char ret[48], const vec384 a)
  function blst_fp_from_lendian (line 287) | void blst_fp_from_lendian(vec384 ret, const unsigned char a[48])
  function blst_lendian_from_fp (line 295) | void blst_lendian_from_fp(unsigned char ret[48], const vec384 a)
  function blst_fp2_add (line 306) | void blst_fp2_add(vec384x ret, const vec384x a, const vec384x b)
  function blst_fp2_sub (line 309) | void blst_fp2_sub(vec384x ret, const vec384x a, const vec384x b)
  function blst_fp2_mul_by_3 (line 312) | void blst_fp2_mul_by_3(vec384x ret, const vec384x a)
  function blst_fp2_mul_by_8 (line 315) | void blst_fp2_mul_by_8(vec384x ret, const vec384x a)
  function blst_fp2_lshift (line 318) | void blst_fp2_lshift(vec384x ret, const vec384x a, size_t count)
  function blst_fp2_mul (line 321) | void blst_fp2_mul(vec384x ret, const vec384x a, const vec384x b)
  function blst_fp2_sqr (line 324) | void blst_fp2_sqr(vec384x ret, const vec384x a)
  function blst_fp2_cneg (line 327) | void blst_fp2_cneg(vec384x ret, const vec384x a, int flag)
  function blst_scalar_from_uint32 (line 333) | void blst_scalar_from_uint32(pow256 ret, const unsigned int a[8])
  function blst_uint32_from_scalar (line 353) | void blst_uint32_from_scalar(unsigned int ret[8], const pow256 a)
  function blst_scalar_from_uint64 (line 373) | void blst_scalar_from_uint64(pow256 ret, const unsigned long long a[4])
  function blst_uint64_from_scalar (line 397) | void blst_uint64_from_scalar(unsigned long long ret[4], const pow256 a)
  function blst_scalar_from_bendian (line 421) | void blst_scalar_from_bendian(pow256 ret, const unsigned char a[32])
  function blst_bendian_from_scalar (line 429) | void blst_bendian_from_scalar(unsigned char ret[32], const pow256 a)
  function blst_scalar_from_lendian (line 437) | void blst_scalar_from_lendian(pow256 ret, const unsigned char a[32])
  function blst_lendian_from_scalar (line 448) | void blst_lendian_from_scalar(unsigned char ret[32], const pow256 a)
  function blst_fr_from_uint64 (line 459) | void blst_fr_from_uint64(vec256 ret, const unsigned long long a[4])
  function blst_uint64_from_fr (line 478) | void blst_uint64_from_fr(unsigned long long ret[4], const vec256 a)
  function blst_scalar_from_le_bytes (line 498) | int blst_scalar_from_le_bytes(pow256 out, const unsigned char *bytes, si...
  function blst_scalar_from_be_bytes (line 526) | int blst_scalar_from_be_bytes(pow256 out, const unsigned char *bytes, si...
  function blst_fp_from_le_bytes (line 553) | void blst_fp_from_le_bytes(vec384 out, const unsigned char *bytes, size_...
  function blst_fp_from_be_bytes (line 572) | void blst_fp_from_be_bytes(vec384 out, const unsigned char *bytes, size_...
  function blst_sha256 (line 595) | void blst_sha256(unsigned char md[32], const void *msg, size_t len)
  function blst_scalar_from_hexascii (line 607) | void blst_scalar_from_hexascii(pow256 ret, const char *hex)
  function blst_fr_from_hexascii (line 610) | void blst_fr_from_hexascii(vec256 ret, const char *hex)
  function blst_fp_from_hexascii (line 616) | void blst_fp_from_hexascii(vec384 ret, const char *hex)

FILE: src/fields.h
  function add_fp (line 15) | static inline void add_fp(vec384 ret, const vec384 a, const vec384 b)
  function sub_fp (line 18) | static inline void sub_fp(vec384 ret, const vec384 a, const vec384 b)
  function mul_by_3_fp (line 21) | static inline void mul_by_3_fp(vec384 ret, const vec384 a)
  function mul_by_8_fp (line 24) | static inline void mul_by_8_fp(vec384 ret, const vec384 a)
  function lshift_fp (line 27) | static inline void lshift_fp(vec384 ret, const vec384 a, size_t count)
  function rshift_fp (line 30) | static inline void rshift_fp(vec384 ret, const vec384 a, size_t count)
  function div_by_2_fp (line 33) | static inline void div_by_2_fp(vec384 ret, const vec384 a)
  function mul_fp (line 36) | static inline void mul_fp(vec384 ret, const vec384 a, const vec384 b)
  function sqr_fp (line 39) | static inline void sqr_fp(vec384 ret, const vec384 a)
  function cneg_fp (line 42) | static inline void cneg_fp(vec384 ret, const vec384 a, bool_t flag)
  function from_fp (line 45) | static inline void from_fp(vec384 ret, const vec384 a)
  function redc_fp (line 48) | static inline void redc_fp(vec384 ret, const vec768 a)
  function add_fp2 (line 54) | static inline void add_fp2(vec384x ret, const vec384x a, const vec384x b)
  function sub_fp2 (line 57) | static inline void sub_fp2(vec384x ret, const vec384x a, const vec384x b)
  function mul_by_3_fp2 (line 60) | static inline void mul_by_3_fp2(vec384x ret, const vec384x a)
  function mul_by_8_fp2 (line 63) | static inline void mul_by_8_fp2(vec384x ret, const vec384x a)
  function lshift_fp2 (line 66) | static inline void lshift_fp2(vec384x ret, const vec384x a, size_t count)
  function mul_fp2 (line 72) | static inline void mul_fp2(vec384x ret, const vec384x a, const vec384x b)
  function sqr_fp2 (line 75) | static inline void sqr_fp2(vec384x ret, const vec384x a)
  function cneg_fp2 (line 78) | static inline void cneg_fp2(vec384x ret, const vec384x a, bool_t flag)
  type vec384x (line 99) | typedef vec384x   vec384fp2;
  type vec384fp2 (line 100) | typedef vec384fp2 vec384fp6[3];
  type vec384fp6 (line 101) | typedef vec384fp6 vec384fp12[2];

FILE: src/fp12_tower.c
  function mul_by_u_plus_1_fp2 (line 15) | static inline void mul_by_u_plus_1_fp2(vec384x ret, const vec384x a)
  type vec768 (line 27) | typedef vec768 vec768x[2];
  function add_fp2x2 (line 29) | static inline void add_fp2x2(vec768x ret, const vec768x a, const vec768x b)
  function sub_fp2x2 (line 35) | static inline void sub_fp2x2(vec768x ret, const vec768x a, const vec768x b)
  function mul_by_u_plus_1_fp2x2 (line 41) | static inline void mul_by_u_plus_1_fp2x2(vec768x ret, const vec768x a)
  function redc_fp2x2 (line 48) | static inline void redc_fp2x2(vec384x ret, const vec768x a)
  function mul_fp2x2 (line 54) | static void mul_fp2x2(vec768x ret, const vec384x a, const vec384x b)
  function sqr_fp2x2 (line 75) | static void sqr_fp2x2(vec768x ret, const vec384x a)
  type vec768x (line 97) | typedef vec768x vec768fp6[3];
  function sub_fp6x2 (line 99) | static inline void sub_fp6x2(vec768fp6 ret, const vec768fp6 a,
  function mul_fp6x2 (line 107) | static void mul_fp6x2(vec768fp6 ret, const vec384fp6 a, const vec384fp6 b)
  function redc_fp6x2 (line 146) | static inline void redc_fp6x2(vec384fp6 ret, const vec768fp6 a)
  function mul_fp6 (line 153) | static void mul_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)
  function sqr_fp6 (line 161) | static void sqr_fp6(vec384fp6 ret, const vec384fp6 a)
  function mul_fp6 (line 197) | static void mul_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)
  function sqr_fp6 (line 237) | static void sqr_fp6(vec384fp6 ret, const vec384fp6 a)
  function add_fp6 (line 271) | static void add_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)
  function sub_fp6 (line 278) | static void sub_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)
  function neg_fp6 (line 285) | static void neg_fp6(vec384fp6 ret, const vec384fp6 a)
  function mul_by_v_fp6 (line 294) | static void mul_by_v_fp6(vec384fp6 ret, const vec384fp6 a)
  function mul_fp12 (line 309) | static void mul_fp12(vec384fp12 ret, const vec384fp12 a, const vec384fp1...
  function mul_by_0y0_fp6x2 (line 334) | static inline void mul_by_0y0_fp6x2(vec768fp6 ret, const vec384fp6 a,
  function mul_by_xy0_fp6x2 (line 343) | static void mul_by_xy0_fp6x2(vec768fp6 ret, const vec384fp6 a,
  function mul_by_xy00z0_fp12 (line 372) | static void mul_by_xy00z0_fp12(vec384fp12 ret, const vec384fp12 a,
  function mul_fp12 (line 399) | static void mul_fp12(vec384fp12 ret, const vec384fp12 a, const vec384fp1...
  function mul_by_0y0_fp6 (line 426) | static inline void mul_by_0y0_fp6(vec384fp6 ret, const vec384fp6 a,
  function mul_by_xy0_fp6 (line 437) | static void mul_by_xy0_fp6(vec384fp6 ret, const vec384fp6 a, const vec38...
  function mul_by_xy00z0_fp12 (line 466) | static void mul_by_xy00z0_fp12(vec384fp12 ret, const vec384fp12 a,
  function sqr_fp12 (line 496) | static void sqr_fp12(vec384fp12 ret, const vec384fp12 a)
  function conjugate_fp12 (line 530) | static void conjugate_fp12(vec384fp12 a)
  function inverse_fp6 (line 533) | static void inverse_fp6(vec384fp6 ret, const vec384fp6 a)
  function inverse_fp12 (line 569) | static void inverse_fp12(vec384fp12 ret, const vec384fp12 a)
  type vec384x (line 592) | typedef vec384x vec384fp4[2];
  function sqr_fp4 (line 595) | static void sqr_fp4(vec384fp4 ret, const vec384x a0, const vec384x a1)
  function sqr_fp4 (line 613) | static void sqr_fp4(vec384fp4 ret, const vec384x a0, const vec384x a1)
  function cyclotomic_sqr_fp12 (line 630) | static void cyclotomic_sqr_fp12(vec384fp12 ret, const vec384fp12 a)
  function frobenius_map_fp2 (line 667) | static inline void frobenius_map_fp2(vec384x ret, const vec384x a, size_...
  function frobenius_map_fp6 (line 673) | static void frobenius_map_fp6(vec384fp6 ret, const vec384fp6 a, size_t n)
  function frobenius_map_fp12 (line 706) | static void frobenius_map_fp12(vec384fp12 ret, const vec384fp12 a, size_...
  function blst_fp12_sqr (line 738) | void blst_fp12_sqr(vec384fp12 ret, const vec384fp12 a)
  function blst_fp12_cyclotomic_sqr (line 741) | void blst_fp12_cyclotomic_sqr(vec384fp12 ret, const vec384fp12 a)
  function blst_fp12_mul (line 744) | void blst_fp12_mul(vec384fp12 ret, const vec384fp12 a, const vec384fp12 b)
  function blst_fp12_mul_by_xy00z0 (line 747) | void blst_fp12_mul_by_xy00z0(vec384fp12 ret, const vec384fp12 a,
  function blst_fp12_conjugate (line 751) | void blst_fp12_conjugate(vec384fp12 a)
  function blst_fp12_inverse (line 754) | void blst_fp12_inverse(vec384fp12 ret, const vec384fp12 a)
  function blst_fp12_frobenius_map (line 758) | void blst_fp12_frobenius_map(vec384fp12 ret, const vec384fp12 a, size_t n)
  function blst_fp12_is_equal (line 761) | int blst_fp12_is_equal(const vec384fp12 a, const vec384fp12 b)
  function blst_fp12_is_one (line 764) | int blst_fp12_is_one(const vec384fp12 a)
  function vec384fp12 (line 770) | const vec384fp12 *blst_fp12_one(void)
  function blst_bendian_from_fp12 (line 773) | void blst_bendian_from_fp12(unsigned char ret[48*12], const vec384fp12 a)
  function blst_fp12_sizeof (line 788) | size_t blst_fp12_sizeof(void)

FILE: src/hash_to_field.c
  function sha256_init_Zpad (line 22) | static void sha256_init_Zpad(SHA256_CTX *ctx)
  function vec_xor (line 37) | static void vec_xor(void *restrict ret, const void *restrict a,
  function expand_message_xmd (line 51) | static void expand_message_xmd(unsigned char *bytes, size_t len_in_bytes,
  function hash_to_field (line 120) | static void hash_to_field(vec384 elems[], size_t nelems,
  function blst_expand_message_xmd (line 156) | void blst_expand_message_xmd(unsigned char *bytes, size_t len_in_bytes,

FILE: src/keygen.c
  type HMAC_SHA256_CTX (line 11) | typedef struct {
  function HMAC_init (line 18) | static void HMAC_init(HMAC_SHA256_CTX *ctx, const void *K, size_t K_len)
  function HMAC_update (line 59) | static void HMAC_update(HMAC_SHA256_CTX *ctx, const unsigned char *inp,
  function HMAC_final (line 63) | static void HMAC_final(unsigned char md[32], HMAC_SHA256_CTX *ctx)
  function HKDF_Extract (line 71) | static void HKDF_Extract(unsigned char PRK[32],
  function HKDF_Expand (line 92) | static void HKDF_Expand(unsigned char *OKM, size_t L,
  function keygen (line 135) | static void keygen(pow256 SK, const void *IKM, size_t IKM_len,
  function blst_keygen (line 214) | void blst_keygen(pow256 SK, const void *IKM, size_t IKM_len,
  function blst_keygen_v3 (line 218) | void blst_keygen_v3(pow256 SK, const void *IKM, size_t IKM_len,
  function blst_keygen_v4_5 (line 222) | void blst_keygen_v4_5(pow256 SK, const void *IKM, size_t IKM_len,
  function blst_keygen_v5 (line 227) | void blst_keygen_v5(pow256 SK, const void *IKM, size_t IKM_len,
  function blst_derive_master_eip2333 (line 235) | void blst_derive_master_eip2333(pow256 SK, const void *seed, size_t seed...
  function parent_SK_to_lamport_PK (line 238) | static void parent_SK_to_lamport_PK(pow256 PK, const pow256 parent_SK,
  function blst_derive_child_eip2333 (line 313) | void blst_derive_child_eip2333(pow256 SK, const pow256 parent_SK,

FILE: src/map_to_g1.c
  function map_fp_times_Zz (line 28) | static void map_fp_times_Zz(vec384 map[], const vec384 isogeny_map[],
  function map_fp (line 35) | static void map_fp(vec384 acc, const vec384 x, const vec384 map[], size_...
  function isogeny_map_to_E1 (line 43) | static void isogeny_map_to_E1(POINTonE1 *out, const POINTonE1 *p)
  function map_to_isogenous_E1 (line 285) | static void map_to_isogenous_E1(POINTonE1 *p, const vec384 u)
  function POINTonE1_add_n_dbl (line 384) | static void POINTonE1_add_n_dbl(POINTonE1 *out, const POINTonE1 *p, size...
  function POINTonE1_times_minus_z (line 391) | static void POINTonE1_times_minus_z(POINTonE1 *out, const POINTonE1 *in)
  function map_to_g1 (line 404) | static void map_to_g1(POINTonE1 *out, const vec384 u, const vec384 v)
  function blst_map_to_g1 (line 422) | void blst_map_to_g1(POINTonE1 *out, const vec384 u, const vec384 v)
  function Encode_to_G1 (line 425) | static void Encode_to_G1(POINTonE1 *p, const unsigned char *msg, size_t ...
  function blst_encode_to_g1 (line 435) | void blst_encode_to_g1(POINTonE1 *p, const unsigned char *msg, size_t ms...
  function Hash_to_G1 (line 440) | static void Hash_to_G1(POINTonE1 *p, const unsigned char *msg, size_t ms...
  function blst_hash_to_g1 (line 450) | void blst_hash_to_g1(POINTonE1 *p, const unsigned char *msg, size_t msg_...
  function POINTonE1_times_zz_minus_1_div_by_3 (line 459) | static void POINTonE1_times_zz_minus_1_div_by_3(POINTonE1 *out,
  function POINTonE1_dbl_n_add (line 475) | static void POINTonE1_dbl_n_add(POINTonE1 *out, size_t n, const POINTonE...
  function POINTonE1_times_zz_minus_1_div_by_3 (line 482) | static void POINTonE1_times_zz_minus_1_div_by_3(POINTonE1 *out,
  function bool_t (line 512) | static bool_t POINTonE1_in_G1(const POINTonE1 *P)
  function bool_t (line 531) | static bool_t POINTonE1_in_G1(const POINTonE1 *P)
  function blst_p1_in_g1 (line 547) | int blst_p1_in_g1(const POINTonE1 *p)
  function blst_p1_affine_in_g1 (line 550) | int blst_p1_affine_in_g1(const POINTonE1_affine *p)

FILE: src/map_to_g2.c
  function map_fp2_times_Zz (line 28) | static void map_fp2_times_Zz(vec384x map[], const vec384x isogeny_map[],
  function map_fp2 (line 35) | static void map_fp2(vec384x acc, const vec384x x, const vec384x map[], s...
  function isogeny_map_to_E2 (line 43) | static void isogeny_map_to_E2(POINTonE2 *out, const POINTonE2 *p)
  function map_to_isogenous_E2 (line 173) | static void map_to_isogenous_E2(POINTonE2 *p, const vec384x u)
  function clear_cofactor (line 301) | static void clear_cofactor(POINTonE2 *out, const POINTonE2 *p)
  function POINTonE2_add_n_dbl (line 308) | static void POINTonE2_add_n_dbl(POINTonE2 *out, const POINTonE2 *p, size...
  function POINTonE2_times_minus_z (line 315) | static void POINTonE2_times_minus_z(POINTonE2 *out, const POINTonE2 *in)
  function clear_cofactor (line 327) | static void clear_cofactor(POINTonE2 *out, const POINTonE2 *p)
  function map_to_g2 (line 355) | static void map_to_g2(POINTonE2 *out, const vec384x u, const vec384x v)
  function blst_map_to_g2 (line 370) | void blst_map_to_g2(POINTonE2 *out, const vec384x u, const vec384x v)
  function Encode_to_G2 (line 373) | static void Encode_to_G2(POINTonE2 *p, const unsigned char *msg, size_t ...
  function blst_encode_to_g2 (line 383) | void blst_encode_to_g2(POINTonE2 *p, const unsigned char *msg, size_t ms...
  function Hash_to_G2 (line 388) | static void Hash_to_G2(POINTonE2 *p, const unsigned char *msg, size_t ms...
  function blst_hash_to_g2 (line 398) | void blst_hash_to_g2(POINTonE2 *p, const unsigned char *msg, size_t msg_...
  function bool_t (line 403) | static bool_t POINTonE2_in_G2(const POINTonE2 *P)
  function blst_p2_in_g2 (line 432) | int blst_p2_in_g2(const POINTonE2 *p)
  function blst_p2_affine_in_g2 (line 435) | int blst_p2_affine_in_g2(const POINTonE2_affine *p)

FILE: src/multi_scalar.c
  function pippenger_window_size (line 303) | static size_t pippenger_window_size(size_t npoints)

FILE: src/no_asm.h
  type llimb_t (line 8) | typedef unsigned long long llimb_t;
  function mul_mont_n (line 29) | static void mul_mont_n(limb_t ret[], const limb_t a[], const limb_t b[],
  function add_mod_n (line 104) | static void add_mod_n(limb_t ret[], const limb_t a[], const limb_t b[],
  function sub_mod_n (line 139) | static void sub_mod_n(limb_t ret[], const limb_t a[], const limb_t b[],
  function mul_by_3_mod_n (line 171) | static void mul_by_3_mod_n(limb_t ret[], const limb_t a[], const limb_t ...
  function lshift_mod_n (line 224) | static void lshift_mod_n(limb_t ret[], const limb_t a[], size_t count,
  function cneg_mod_n (line 264) | static void cneg_mod_n(limb_t ret[], const limb_t a[], bool_t flag,
  function limb_t (line 293) | static limb_t check_mod_n(const byte a[], const limb_t p[], size_t n)
  function limb_t (line 317) | static limb_t add_n_check_mod_n(byte ret[], const byte a[], const byte b[],
  function limb_t (line 341) | static limb_t sub_n_check_mod_n(byte ret[], const byte a[], const byte b[],
  function from_mont_n (line 365) | static void from_mont_n(limb_t ret[], const limb_t a[],
  function redc_mont_n (line 408) | static void redc_mont_n(limb_t ret[], const limb_t a[],
  function rshift_mod_n (line 457) | static void rshift_mod_n(limb_t ret[], const limb_t a[], size_t count,
  function limb_t (line 501) | static limb_t sgn0_pty_mod_n(const limb_t a[], const limb_t p[], size_t n)
  function limb_t (line 526) | inline limb_t sgn0_pty_mod_384(const vec384 a, const vec384 p)
  function limb_t (line 529) | inline limb_t sgn0_pty_mont_384(const vec384 a, const vec384 p, limb_t n0)
  function limb_t (line 538) | inline limb_t sgn0_pty_mod_384x(const vec384x a, const vec384 p)
  function limb_t (line 556) | inline limb_t sgn0_pty_mont_384x(const vec384x a, const vec384 p, limb_t...
  function mul_mont_384x (line 566) | void mul_mont_384x(vec384x ret, const vec384x a, const vec384x b,
  function mul_mont_nonred_n (line 586) | static void mul_mont_nonred_n(limb_t ret[], const limb_t a[], const limb...
  function sqr_n_mul_mont_383 (line 627) | void sqr_n_mul_mont_383(vec384 ret, const vec384 a, size_t count,
  function sqr_mont_382x (line 638) | void sqr_mont_382x(vec384x ret, const vec384x a,
  function num_bits (line 696) | static size_t num_bits(limb_t l)
  function limb_t (line 734) | __attribute__((optnone))
  function ab_approximation_n (line 746) | static void ab_approximation_n(limb_t a_[2], const limb_t a[],
  type factors (line 770) | typedef struct { limb_t f0, g0, f1, g1; } factors;
  function inner_loop_n (line 772) | static void inner_loop_n(factors *fg, const limb_t a_[2], const limb_t b...
  function limb_t (line 829) | static limb_t cneg_n(limb_t ret[], const limb_t a[], limb_t neg, size_t n)
  function limb_t (line 845) | static limb_t add_n(limb_t ret[], const limb_t a[], limb_t b[], size_t n)
  function limb_t (line 861) | static limb_t umul_n(limb_t ret[], const limb_t a[], limb_t b, size_t n)
  function limb_t (line 877) | static limb_t smul_n_shift_n(limb_t ret[], const limb_t a[], limb_t *f_,
  function limb_t (line 920) | static limb_t smul_2n(limb_t ret[], const limb_t u[], limb_t f,
  function ct_inverse_mod_n (line 944) | static void ct_inverse_mod_n(limb_t ret[], const limb_t inp[],
  function limb_t (line 999) | static limb_t legendre_loop_n(limb_t L, factors *fg, const limb_t a_[2],
  function bool_t (line 1062) | static bool_t ct_is_sqr_mod_n(const limb_t inp[], const limb_t mod[], si...
  function limb_t (line 1112) | limb_t div_3_limbs(const limb_t div_top[2], limb_t d_lo, limb_t d_hi)
  function limb_t (line 1155) | static limb_t quot_rem_n(limb_t *div_rem, const limb_t *divisor,
  function limb_t (line 1191) | inline limb_t quot_rem_128(limb_t *div_rem, const limb_t *divisor,
  function limb_t (line 1195) | inline limb_t quot_rem_64(limb_t *div_rem, const limb_t *divisor,
  function vec_prefetch (line 1211) | inline void vec_prefetch(const void *ptr, size_t len)
  function blst_sha256_block_data_order (line 1225) | void blst_sha256_block_data_order(unsigned int *v, const void *inp,
  function blst_sha256_hcopy (line 1316) | void blst_sha256_hcopy(unsigned int dst[8], const unsigned int src[8])
  function blst_sha256_emit (line 1324) | void blst_sha256_emit(unsigned char md[32], const unsigned int h[8])
  function blst_sha256_bcopy (line 1337) | void blst_sha256_bcopy(void *dst_, const void *src_, size_t len)

FILE: src/pairing.c
  function line_add (line 14) | static void line_add(vec384fp6 line, POINTonE2 *T, const POINTonE2 *R,
  function line_dbl (line 78) | static void line_dbl(vec384fp6 line, POINTonE2 *T, const POINTonE2 *Q)
  function line_by_Px2 (line 128) | static void line_by_Px2(vec384fp6 line, const POINTonE1_affine *Px2)
  function add_n_dbl (line 138) | static void add_n_dbl(vec384fp12 ret, POINTonE2 *T, const POINTonE2_affi...
  function miller_loop (line 150) | static void miller_loop(vec384fp12 ret, const POINTonE2 *Q, const POINTo...
  function start_dbl_n (line 181) | static void start_dbl_n(vec384fp12 ret, POINTonE2 T[],
  function add_n_dbl_n (line 199) | static void add_n_dbl_n(vec384fp12 ret, POINTonE2 T[],
  function miller_loop_n (line 220) | static void miller_loop_n(vec384fp12 ret, const POINTonE2_affine Q[],
  function pre_add_n_dbl (line 263) | static void pre_add_n_dbl(vec384fp6 lines[], POINTonE2 *T,
  function precompute_lines (line 272) | static void precompute_lines(vec384fp6 Qlines[68], const POINTonE2_affin...
  function post_line_by_Px2 (line 287) | static void post_line_by_Px2(vec384fp6 out, const vec384fp6 in,
  function post_add_n_dbl (line 299) | static void post_add_n_dbl(vec384fp12 ret, const vec384fp6 lines[],
  function miller_loop_lines (line 313) | static void miller_loop_lines(vec384fp12 ret, const vec384fp6 Qlines[68],
  function miller_loop_alt (line 338) | static void miller_loop_alt(vec384fp12 ret, const POINTonE2_affine *Q,
  function mul_n_sqr (line 348) | static void mul_n_sqr(vec384fp12 ret, const vec384fp12 a, size_t n)
  function raise_to_z_div_by_2 (line 355) | static void raise_to_z_div_by_2(vec384fp12 ret, const vec384fp12 a)
  function final_exp (line 371) | static void final_exp(vec384fp12 ret, const vec384fp12 f)
  function blst_miller_loop (line 406) | void blst_miller_loop(vec384fp12 ret, const POINTonE2_affine *Q,
  function blst_miller_loop_n (line 416) | void blst_miller_loop_n(vec384fp12 out, const POINTonE2_affine *const Qs[],
  function blst_final_exp (line 461) | void blst_final_exp(vec384fp12 ret, const vec384fp12 f)
  function blst_precompute_lines (line 464) | void blst_precompute_lines(vec384fp6 Qlines[68], const POINTonE2_affine *Q)
  function blst_miller_loop_lines (line 467) | void blst_miller_loop_lines(vec384fp12 ret, const vec384fp6 Qlines[68],
  function bool_t (line 471) | static bool_t is_cyclotomic(const vec384fp12 f)
  function blst_fp12_in_group (line 482) | int blst_fp12_in_group(const vec384fp12 f)

FILE: src/pentaroot.c
  function mul_fr (line 9) | static inline void mul_fr(vec256 ret, const vec256 a, const vec256 b)
  function sqr_fr (line 12) | static inline void sqr_fr(vec256 ret, const vec256 a)
  function blst_fr_pentaroot (line 16) | void blst_fr_pentaroot(vec256 out, const vec256 inp)
  function sqr_n_mul_fr (line 40) | static inline void sqr_n_mul_fr(vec256 out, const vec256 a, size_t count,
  function sqr_n_mul_fr (line 44) | static void sqr_n_mul_fr(vec256 out, const vec256 a, size_t count,
  function blst_fr_pentaroot (line 60) | void blst_fr_pentaroot(vec256 out, const vec256 inp)
  function blst_fr_pentapow (line 69) | void blst_fr_pentapow(vec256 out, const vec256 inp)

FILE: src/rb_tree.c
  type node (line 15) | struct node {
  type rb_tree (line 21) | struct rb_tree {
  function bytes_compare (line 27) | static long bytes_compare(const unsigned char *ptr0, size_t len0,
  function rb_tree_insert (line 45) | static int rb_tree_insert(struct rb_tree *tree, const void *data, size_t...
  function blst_uniq_sizeof (line 135) | size_t blst_uniq_sizeof(size_t n_nodes)
  function blst_uniq_init (line 138) | void blst_uniq_init(struct rb_tree *tree)
  function blst_uniq_test (line 144) | int blst_uniq_test(struct rb_tree *tree, const void *data, size_t len)

FILE: src/recip.c
  function flt_reciprocal_fp (line 16) | static void flt_reciprocal_fp(vec384 out, const vec384 inp)
  function flt_reciprocal_fp (line 32) | static void flt_reciprocal_fp(vec384 out, const vec384 inp)
  function flt_reciprocal_fp2 (line 42) | static void flt_reciprocal_fp2(vec384x out, const vec384x inp)
  function reciprocal_fp (line 58) | static void reciprocal_fp(vec384 out, const vec384 inp)
  function blst_fp_inverse (line 84) | void blst_fp_inverse(vec384 out, const vec384 inp)
  function blst_fp_eucl_inverse (line 87) | void blst_fp_eucl_inverse(vec384 ret, const vec384 a)
  function reciprocal_fp2 (line 90) | static void reciprocal_fp2(vec384x out, const vec384x inp)
  function blst_fp2_inverse (line 106) | void blst_fp2_inverse(vec384x out, const vec384x inp)
  function blst_fp2_eucl_inverse (line 109) | void blst_fp2_eucl_inverse(vec384x out, const vec384x inp)
  function reciprocal_fr (line 112) | static void reciprocal_fr(vec256 out, const vec256 inp)
  function blst_fr_inverse (line 125) | void blst_fr_inverse(vec256 out, const vec256 inp)
  function blst_fr_eucl_inverse (line 128) | void blst_fr_eucl_inverse(vec256 out, const vec256 inp)

FILE: src/sha256.h
  type SHA256_CTX (line 32) | typedef struct {
  function sha256_init_h (line 40) | static void sha256_init_h(unsigned int h[8])
  function sha256_init (line 52) | static void sha256_init(SHA256_CTX *ctx)
  function sha256_update (line 60) | static void sha256_update(SHA256_CTX *ctx, const void *_inp, size_t len)
  function sha256_emit (line 104) | static void sha256_emit(unsigned char md[32], const unsigned int h[8])
  function sha256_final (line 119) | static void sha256_final(unsigned char md[32], SHA256_CTX *ctx)

FILE: src/sqrt.c
  function recip_sqrt_fp_3mod4 (line 10) | static void recip_sqrt_fp_3mod4(vec384 out, const vec384 inp)
  function sqr_n_mul_fp (line 28) | static inline void sqr_n_mul_fp(vec384 out, const vec384 a, size_t count,
  function sqr_n_mul_fp (line 32) | static void sqr_n_mul_fp(vec384 out, const vec384 a, size_t count,
  function recip_sqrt_fp_3mod4 (line 48) | static void recip_sqrt_fp_3mod4(vec384 out, const vec384 inp)
  function bool_t (line 59) | static bool_t recip_sqrt_fp(vec384 out, const vec384 inp)
  function bool_t (line 74) | static bool_t sqrt_fp(vec384 out, const vec384 inp)
  function blst_fp_sqrt (line 89) | int blst_fp_sqrt(vec384 out, const vec384 inp)
  function blst_fp_is_square (line 92) | int blst_fp_is_square(const vec384 inp)
  function bool_t (line 97) | static bool_t sqrt_align_fp2(vec384x out, const vec384x ret,
  function bool_t (line 167) | static bool_t recip_sqrt_fp2(vec384x out, const vec384x inp,
  function bool_t (line 218) | static bool_t sqrt_fp2(vec384x out, const vec384x inp)
  function blst_fp2_sqrt (line 249) | int blst_fp2_sqrt(vec384x out, const vec384x inp)
  function blst_fp2_is_square (line 252) | int blst_fp2_is_square(const vec384x inp)

FILE: src/vect.c
  function lshift_mod_384 (line 21) | inline void lshift_mod_384(vec384 ret, const vec384 a, size_t n,
  function mul_by_8_mod_384 (line 30) | inline void mul_by_8_mod_384(vec384 ret, const vec384 a, const vec384 mod)
  function mul_by_3_mod_384 (line 35) | inline void mul_by_3_mod_384(vec384 ret, const vec384 a, const vec384 mod)
  function mul_by_3_mod_384x (line 45) | inline void mul_by_3_mod_384x(vec384x ret, const vec384x a, const vec384...
  function mul_by_8_mod_384x (line 53) | inline void mul_by_8_mod_384x(vec384x ret, const vec384x a, const vec384...
  function mul_by_1_plus_i_mod_384x (line 61) | inline void mul_by_1_plus_i_mod_384x(vec384x ret, const vec384x a,
  function add_mod_384x (line 73) | inline void add_mod_384x(vec384x ret, const vec384x a, const vec384x b,
  function sub_mod_384x (line 82) | inline void sub_mod_384x(vec384x ret, const vec384x a, const vec384x b,
  function lshift_mod_384x (line 91) | inline void lshift_mod_384x(vec384x ret, const vec384x a, size_t n,
  function mul_mont_384x (line 100) | void mul_mont_384x(vec384x ret, const vec384x a, const vec384x b,
  function sqr_mont_384x (line 123) | void sqr_mont_384x(vec384x ret, const vec384x a, const vec384 mod, limb_...
  function div_by_zz (line 144) | static void div_by_zz(limb_t val[])
  function div_by_z (line 163) | static void div_by_z(limb_t val[])

FILE: src/vect.h
  type limb_t (line 14) | typedef unsigned long long limb_t;
  type limb_t (line 18) | typedef unsigned __int64 limb_t;
  type limb_t (line 22) | typedef unsigned int limb_t;
  type limb_t (line 29) | typedef unsigned long limb_t;
  type limb_t (line 50) | typedef limb_t vec256[NLIMBS(256)];
  type limb_t (line 51) | typedef limb_t vec512[NLIMBS(512)];
  type limb_t (line 52) | typedef limb_t vec384[NLIMBS(384)];
  type limb_t (line 53) | typedef limb_t vec768[NLIMBS(768)];
  type vec384 (line 54) | typedef vec384 vec384x[2];
  type byte (line 56) | typedef unsigned char byte;
  type byte (line 61) | typedef byte pow256[256/8];
  type limb_t (line 67) | typedef limb_t bool_t;
  type __UINTPTR_TYPE__ (line 182) | typedef __UINTPTR_TYPE__ uptr_t;
  function bool_t (line 217) | static inline bool_t is_bit_set(const byte *v, size_t i)
  function bool_t (line 224) | static inline bool_t byte_is_zero(unsigned char c)
  function bool_t (line 231) | static inline bool_t bytes_are_zero(const unsigned char *a, size_t num)
  function vec_cswap (line 242) | static inline void vec_cswap(void *restrict a, void *restrict b, size_t ...
  function vec_select (line 269) | static inline void vec_select(void *ret, const void *a, const void *b,
  function bool_t (line 300) | static inline bool_t is_zero(limb_t l)
  function bool_t (line 307) | static inline bool_t vec_is_zero(const void *a, size_t num)
  function bool_t (line 327) | static inline bool_t vec_is_equal(const void *a, const void *b, size_t num)
  function cneg_mod_384x (line 348) | static inline void cneg_mod_384x(vec384x ret, const vec384x a, bool_t flag,
  function vec_copy (line 355) | static inline void vec_copy(void *restrict ret, const void *a, size_t num)
  function vec_zero (line 367) | static inline void vec_zero(void *ret, size_t num)
  function vec_czero (line 382) | static inline void vec_czero(void *ret, size_t num, bool_t cbit)