SYMBOL INDEX (123 symbols across 21 files)

FILE: enforce-conventional-commits.py
  function main (line 4) | def main():

FILE: nanorand-abi/examples/smallcrush.c
  function gen_chacha (line 8) | unsigned int gen_chacha(void)
  function gen_wyrand (line 15) | unsigned int gen_wyrand(void)
  function gen_pcg (line 22) | unsigned int gen_pcg(void)
  function main (line 29) | int main()

FILE: nanorand-abi/examples/test.cpp
  function main (line 4) | int main()

FILE: nanorand-abi/nanorand.h
  type u8 (line 39) | typedef uint8_t u8;
  type u16 (line 40) | typedef uint16_t u16;
  type u32 (line 41) | typedef uint32_t u32;
  type u64 (line 42) | typedef uint64_t u64;
  type usize (line 43) | typedef uintptr_t usize;
  type i8 (line 44) | typedef int8_t i8;
  type i16 (line 45) | typedef int16_t i16;
  type i32 (line 46) | typedef int32_t i32;
  type i64 (line 47) | typedef int64_t i64;
  type isize (line 48) | typedef intptr_t isize;
  type WyRand (line 55) | typedef struct _WyRand WyRand;
  type BufferedWyRand (line 56) | typedef struct _BufferedWyRand BufferedWyRand;
  type Pcg64 (line 60) | typedef struct _Pcg64 Pcg64;
  type BufferedPcg64 (line 61) | typedef struct _BufferedPcg64 BufferedPcg64;
  type ChaCha8 (line 65) | typedef struct _ChaCha8 ChaCha8;
  type BufferedChaCha8 (line 66) | typedef struct _BufferedChaCha8 BufferedChaCha8;
  type ChaCha12 (line 70) | typedef struct _ChaCha12 ChaCha12;
  type BufferedChaCha12 (line 71) | typedef struct _BufferedChaCha12 BufferedChaCha12;
  type ChaCha20 (line 75) | typedef struct _ChaCha20 ChaCha20;
  type BufferedChaCha20 (line 76) | typedef struct _BufferedChaCha20 BufferedChaCha20;

FILE: nanorand-bench/benches/speed.rs
  function criterion_benchmark (line 6) | fn criterion_benchmark(c: &mut Criterion) {

FILE: nanorand-bench/src/main.rs
  function main (line 1) | fn main() {

FILE: nanorand-fuzz/fuzz_targets/chacha20.rs
  constant KEY_LEN (line 9) | const KEY_LEN: usize = 32;
  constant NONCE_LEN (line 10) | const NONCE_LEN: usize = 8;

FILE: src/buffer.rs
  type BufferedRng (line 20) | pub struct BufferedRng<InternalGenerator: Rng<OUTPUT>, const OUTPUT: usi...
  function new (line 27) | pub const fn new(rng: InternalGenerator) -> Self {
  function into_inner (line 36) | pub fn into_inner(self) -> InternalGenerator {
  function buffered (line 41) | pub fn buffered(&self) -> usize {
  function rand (line 49) | fn rand(&mut self) -> [u8; OUTPUT] {
  function fill_bytes (line 55) | fn fill_bytes<Bytes>(&mut self, mut output: Bytes)
  function read (line 79) | fn read(&mut self, output: &mut [u8]) -> std::io::Result<usize> {
  function read_to_end (line 84) | fn read_to_end(&mut self, buf: &mut Vec<u8>) -> std::io::Result<usize> {
  function read_to_string (line 89) | fn read_to_string(&mut self, _buf: &mut String) -> std::io::Result<usize> {
  function reseed (line 100) | fn reseed(&mut self, seed: [u8; SEED_SIZE]) {
  method default (line 108) | fn default() -> Self {

FILE: src/crypto/chacha.rs
  constant CHACHA_TAU (line 1) | const CHACHA_TAU: &[u8] = b"expand 32-byte k";
  function chacha_quarter_round (line 3) | fn chacha_quarter_round(state: &mut [u32; 16], a: usize, b: usize, c: us...
  function chacha_pack (line 21) | const fn chacha_pack(unpacked: &[u8], idx: usize) -> u32 {
  function chacha_block (line 29) | pub fn chacha_block<const ROUNDS: u8>(input: [u32; 16]) -> [u32; 16] {
  function chacha_init (line 51) | pub const fn chacha_init(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]...
  function chacha_increment_counter (line 78) | pub fn chacha_increment_counter(state: &mut [u32; 16]) -> bool {
  function test_ietf_chacha20_test_vectors (line 118) | fn test_ietf_chacha20_test_vectors() {

FILE: src/entropy.rs
  function system (line 47) | pub fn system(out: &mut [u8]) {
  function system (line 64) | pub fn system(out: &mut [u8]) {
  function stupid_rdseed_hack (line 70) | fn stupid_rdseed_hack() -> Option<u64> {
  function rdseed (line 90) | pub fn rdseed(out: &mut [u8]) -> Option<usize> {
  function rdseed (line 117) | pub fn rdseed(_out: &mut [u8]) -> Option<usize> {
  function backup (line 129) | pub fn backup(out: &mut [u8]) {
  function backup (line 141) | pub fn backup(_: &mut [u8]) {

FILE: src/entropy/bsd.rs
  function arc4random_buf (line 4) | fn arc4random_buf(buf: *mut c_void, nbytes: usize);
  function entropy (line 8) | pub fn entropy(out: &mut [u8]) -> bool {

FILE: src/entropy/darwin.rs
  function SecRandomCopyBytes (line 5) | fn SecRandomCopyBytes(rnd: *const c_void, count: usize, bytes: *mut u8) ...
  function entropy (line 9) | pub fn entropy(out: &mut [u8]) -> bool {

FILE: src/entropy/linux.rs
  function getrandom (line 2) | fn getrandom(buf: *mut u8, buflen: usize, flags: u32) -> isize;
  function entropy (line 6) | pub fn entropy(out: &mut [u8]) -> bool {

FILE: src/entropy/windows.rs
  function RtlGenRandom (line 5) | fn RtlGenRandom(pBuffer: *mut c_void, cbBuffer: c_ulong) -> c_char;
  function entropy (line 9) | pub fn entropy(out: &mut [u8]) -> bool {

FILE: src/entropy/windows_uwp.rs
  constant BCRYPT_USE_SYSTEM_PREFERRED_RNG (line 5) | const BCRYPT_USE_SYSTEM_PREFERRED_RNG: u32 = 0x00000002;
  function BCryptGenRandom (line 8) | fn BCryptGenRandom(
  function entropy (line 17) | pub fn entropy(out: &mut [u8]) -> bool {

FILE: src/gen.rs
  type RandomGen (line 72) | pub trait RandomGen<Generator: Rng<OUTPUT>, const OUTPUT: usize> {
    method random (line 74) | fn random(rng: &mut Generator) -> Self;
  type RandomRange (line 78) | pub trait RandomRange<Generator: Rng<OUTPUT>, const OUTPUT: usize>:
    method random_range (line 85) | fn random_range<Bounds: RangeBounds<Self>>(nng: &mut Generator, range:...
  function random (line 89) | fn random(rng: &mut Generator) -> Self {
  function random (line 95) | fn random(rng: &mut Generator) -> Self {
  function random (line 101) | fn random(rng: &mut Generator) -> Self {
  function ensure_unsigned_in_range (line 124) | fn ensure_unsigned_in_range() {
  function ensure_signed_in_range (line 160) | fn ensure_signed_in_range() {
  function ensure_floats_generate_properly (line 191) | fn ensure_floats_generate_properly() {
  function ensure_invalid_range_panics (line 206) | fn ensure_invalid_range_panics() {

FILE: src/rand.rs
  type Rng (line 27) | pub trait Rng<const OUTPUT: usize>: Clone {
    method rand (line 29) | fn rand(&mut self) -> [u8; OUTPUT];
    method generate (line 32) | fn generate<Generated>(&mut self) -> Generated
    method fill_bytes (line 40) | fn fill_bytes<Bytes>(&mut self, mut buffer: Bytes)
    method fill (line 56) | fn fill<Contents, Array>(&mut self, mut target: Array)
    method generate_range (line 66) | fn generate_range<Number, Bounds>(&mut self, range: Bounds) -> Number
    method shuffle (line 75) | fn shuffle<Contents, Array>(&mut self, mut target: Array)
  type SeedableRng (line 89) | pub trait SeedableRng<const SEED_SIZE: usize, const OUTPUT: usize>: Rng<...
    method reseed (line 91) | fn reseed(&mut self, seed: [u8; SEED_SIZE]);

FILE: src/rand/chacha.rs
  type ChaCha8 (line 10) | pub type ChaCha8 = ChaCha<8>;
  type ChaCha12 (line 13) | pub type ChaCha12 = ChaCha<12>;
  type ChaCha20 (line 16) | pub type ChaCha20 = ChaCha<20>;
  type ChaCha (line 23) | pub struct ChaCha<const ROUNDS: u8> {
  function new (line 31) | pub fn new() -> Self {
  function new_key (line 43) | pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) ->...
  method default (line 51) | fn default() -> Self {
  function rand (line 63) | fn rand(&mut self) -> [u8; 64] {
  method clone (line 86) | fn clone(&self) -> Self {
  method fmt (line 92) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function reseed (line 98) | fn reseed(&mut self, seed: [u8; 40]) {
  method fmt (line 109) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: src/rand/pcg64.rs
  constant PCG_DEFAULT_MULTIPLIER_128 (line 8) | const PCG_DEFAULT_MULTIPLIER_128: u128 = 4702624768794212184814420749183...
  type Pcg64 (line 15) | pub struct Pcg64 {
    method new (line 25) | pub fn new() -> Self {
    method new_seed (line 37) | pub const fn new_seed(seed: u128) -> Self {
    method step (line 45) | fn step(&mut self) {
    method rand128 (line 52) | fn rand128(&mut self) -> u64 {
    method rand (line 78) | fn rand(&mut self) -> [u8; 8] {
    method reseed (line 86) | fn reseed(&mut self, seed: [u8; 16]) {
  method default (line 66) | fn default() -> Self {
  method clone (line 92) | fn clone(&self) -> Self {
  method fmt (line 102) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method fmt (line 108) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: src/rand/wyrand.rs
  type WyRand (line 13) | pub struct WyRand {
    method new (line 21) | pub fn new() -> Self {
    method new_seed (line 27) | pub const fn new_seed(seed: u64) -> Self {
    method rand (line 45) | fn rand(&mut self) -> [u8; 8] {
    method reseed (line 74) | fn reseed(&mut self, seed: [u8; 8]) {
  method default (line 35) | fn default() -> Self {
  method clone (line 54) | fn clone(&self) -> Self {
  method fmt (line 60) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method fmt (line 66) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: src/tls.rs
  type TlsWyRand (line 10) | pub struct TlsWyRand(Rc<RefCell<WyRand>>);
    method rand (line 13) | fn rand(&mut self) -> [u8; 8] {
    method reseed (line 19) | fn reseed(&mut self, seed: [u8; 8]) {
  function tls_rng (line 40) | pub fn tls_rng() -> TlsWyRand {