libsodium.ffi.dart

// ignore_for_file: unused_field

// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
// ignore_for_file: type=lint
import 'dart:ffi' as ffi;

import 'package:meta/meta.dart';

/// Bindings of libsodium
class LibSodiumFFI {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

  /// The symbols are looked up in [dynamicLibrary].
  LibSodiumFFI(ffi.DynamicLibrary dynamicLibrary)
      : _lookup = dynamicLibrary.lookup;

  /// The symbols are looked up with [lookup].
  LibSodiumFFI.fromLookup(
      ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
          lookup)
      : _lookup = lookup;

  ffi.Pointer<ffi.Char> sodium_version_string() {
    return _sodium_version_string();
  }

  late final _sodium_version_stringPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'sodium_version_string');
  late final _sodium_version_string =
      _sodium_version_stringPtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  int sodium_library_version_major() {
    return _sodium_library_version_major();
  }

  late final _sodium_library_version_majorPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_library_version_major');
  late final _sodium_library_version_major =
      _sodium_library_version_majorPtr.asFunction<int Function()>();

  int sodium_library_version_minor() {
    return _sodium_library_version_minor();
  }

  late final _sodium_library_version_minorPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_library_version_minor');
  late final _sodium_library_version_minor =
      _sodium_library_version_minorPtr.asFunction<int Function()>();

  int sodium_library_minimal() {
    return _sodium_library_minimal();
  }

  late final _sodium_library_minimalPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>('sodium_library_minimal');
  late final _sodium_library_minimal =
      _sodium_library_minimalPtr.asFunction<int Function()>();

  int sodium_init() {
    return _sodium_init();
  }

  late final _sodium_initPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>('sodium_init');
  late final _sodium_init = _sodium_initPtr.asFunction<int Function()>();

  int sodium_set_misuse_handler(
    ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>> handler,
  ) {
    return _sodium_set_misuse_handler(
      handler,
    );
  }

  late final _sodium_set_misuse_handlerPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>>)>>(
      'sodium_set_misuse_handler');
  late final _sodium_set_misuse_handler =
      _sodium_set_misuse_handlerPtr.asFunction<
          int Function(ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>>)>();

  void sodium_misuse() {
    return _sodium_misuse();
  }

  late final _sodium_misusePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('sodium_misuse');
  late final _sodium_misuse = _sodium_misusePtr.asFunction<void Function()>();

  int crypto_aead_aegis128l_keybytes() {
    return _crypto_aead_aegis128l_keybytes();
  }

  late final _crypto_aead_aegis128l_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis128l_keybytes');
  late final _crypto_aead_aegis128l_keybytes =
      _crypto_aead_aegis128l_keybytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis128l_nsecbytes() {
    return _crypto_aead_aegis128l_nsecbytes();
  }

  late final _crypto_aead_aegis128l_nsecbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis128l_nsecbytes');
  late final _crypto_aead_aegis128l_nsecbytes =
      _crypto_aead_aegis128l_nsecbytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis128l_npubbytes() {
    return _crypto_aead_aegis128l_npubbytes();
  }

  late final _crypto_aead_aegis128l_npubbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis128l_npubbytes');
  late final _crypto_aead_aegis128l_npubbytes =
      _crypto_aead_aegis128l_npubbytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis128l_abytes() {
    return _crypto_aead_aegis128l_abytes();
  }

  late final _crypto_aead_aegis128l_abytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis128l_abytes');
  late final _crypto_aead_aegis128l_abytes =
      _crypto_aead_aegis128l_abytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis128l_messagebytes_max() {
    return _crypto_aead_aegis128l_messagebytes_max();
  }

  late final _crypto_aead_aegis128l_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis128l_messagebytes_max');
  late final _crypto_aead_aegis128l_messagebytes_max =
      _crypto_aead_aegis128l_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_aead_aegis128l_encrypt(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis128l_encrypt(
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis128l_encryptPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_aead_aegis128l_encrypt');
  late final _crypto_aead_aegis128l_encrypt =
      _crypto_aead_aegis128l_encryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aegis128l_decrypt(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis128l_decrypt(
      m,
      mlen_p,
      nsec,
      c,
      clen,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis128l_decryptPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_aead_aegis128l_decrypt');
  late final _crypto_aead_aegis128l_decrypt =
      _crypto_aead_aegis128l_decryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aegis128l_encrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedLongLong> maclen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis128l_encrypt_detached(
      c,
      mac,
      maclen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis128l_encrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aegis128l_encrypt_detached');
  late final _crypto_aead_aegis128l_encrypt_detached =
      _crypto_aead_aegis128l_encrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aegis128l_decrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis128l_decrypt_detached(
      m,
      nsec,
      c,
      clen,
      mac,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis128l_decrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aegis128l_decrypt_detached');
  late final _crypto_aead_aegis128l_decrypt_detached =
      _crypto_aead_aegis128l_decrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_aead_aegis128l_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis128l_keygen(
      k,
    );
  }

  late final _crypto_aead_aegis128l_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aegis128l_keygen');
  late final _crypto_aead_aegis128l_keygen = _crypto_aead_aegis128l_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aegis256_keybytes() {
    return _crypto_aead_aegis256_keybytes();
  }

  late final _crypto_aead_aegis256_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis256_keybytes');
  late final _crypto_aead_aegis256_keybytes =
      _crypto_aead_aegis256_keybytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis256_nsecbytes() {
    return _crypto_aead_aegis256_nsecbytes();
  }

  late final _crypto_aead_aegis256_nsecbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis256_nsecbytes');
  late final _crypto_aead_aegis256_nsecbytes =
      _crypto_aead_aegis256_nsecbytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis256_npubbytes() {
    return _crypto_aead_aegis256_npubbytes();
  }

  late final _crypto_aead_aegis256_npubbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis256_npubbytes');
  late final _crypto_aead_aegis256_npubbytes =
      _crypto_aead_aegis256_npubbytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis256_abytes() {
    return _crypto_aead_aegis256_abytes();
  }

  late final _crypto_aead_aegis256_abytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis256_abytes');
  late final _crypto_aead_aegis256_abytes =
      _crypto_aead_aegis256_abytesPtr.asFunction<int Function()>();

  int crypto_aead_aegis256_messagebytes_max() {
    return _crypto_aead_aegis256_messagebytes_max();
  }

  late final _crypto_aead_aegis256_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aegis256_messagebytes_max');
  late final _crypto_aead_aegis256_messagebytes_max =
      _crypto_aead_aegis256_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_aead_aegis256_encrypt(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis256_encrypt(
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis256_encryptPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_aead_aegis256_encrypt');
  late final _crypto_aead_aegis256_encrypt =
      _crypto_aead_aegis256_encryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aegis256_decrypt(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis256_decrypt(
      m,
      mlen_p,
      nsec,
      c,
      clen,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis256_decryptPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_aead_aegis256_decrypt');
  late final _crypto_aead_aegis256_decrypt =
      _crypto_aead_aegis256_decryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aegis256_encrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedLongLong> maclen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis256_encrypt_detached(
      c,
      mac,
      maclen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis256_encrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aegis256_encrypt_detached');
  late final _crypto_aead_aegis256_encrypt_detached =
      _crypto_aead_aegis256_encrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aegis256_decrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis256_decrypt_detached(
      m,
      nsec,
      c,
      clen,
      mac,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_aegis256_decrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aegis256_decrypt_detached');
  late final _crypto_aead_aegis256_decrypt_detached =
      _crypto_aead_aegis256_decrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_aead_aegis256_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aegis256_keygen(
      k,
    );
  }

  late final _crypto_aead_aegis256_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aegis256_keygen');
  late final _crypto_aead_aegis256_keygen = _crypto_aead_aegis256_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aes256gcm_is_available() {
    return _crypto_aead_aes256gcm_is_available();
  }

  late final _crypto_aead_aes256gcm_is_availablePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'crypto_aead_aes256gcm_is_available');
  late final _crypto_aead_aes256gcm_is_available =
      _crypto_aead_aes256gcm_is_availablePtr.asFunction<int Function()>();

  int crypto_aead_aes256gcm_keybytes() {
    return _crypto_aead_aes256gcm_keybytes();
  }

  late final _crypto_aead_aes256gcm_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aes256gcm_keybytes');
  late final _crypto_aead_aes256gcm_keybytes =
      _crypto_aead_aes256gcm_keybytesPtr.asFunction<int Function()>();

  int crypto_aead_aes256gcm_nsecbytes() {
    return _crypto_aead_aes256gcm_nsecbytes();
  }

  late final _crypto_aead_aes256gcm_nsecbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aes256gcm_nsecbytes');
  late final _crypto_aead_aes256gcm_nsecbytes =
      _crypto_aead_aes256gcm_nsecbytesPtr.asFunction<int Function()>();

  int crypto_aead_aes256gcm_npubbytes() {
    return _crypto_aead_aes256gcm_npubbytes();
  }

  late final _crypto_aead_aes256gcm_npubbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aes256gcm_npubbytes');
  late final _crypto_aead_aes256gcm_npubbytes =
      _crypto_aead_aes256gcm_npubbytesPtr.asFunction<int Function()>();

  int crypto_aead_aes256gcm_abytes() {
    return _crypto_aead_aes256gcm_abytes();
  }

  late final _crypto_aead_aes256gcm_abytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aes256gcm_abytes');
  late final _crypto_aead_aes256gcm_abytes =
      _crypto_aead_aes256gcm_abytesPtr.asFunction<int Function()>();

  int crypto_aead_aes256gcm_messagebytes_max() {
    return _crypto_aead_aes256gcm_messagebytes_max();
  }

  late final _crypto_aead_aes256gcm_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aes256gcm_messagebytes_max');
  late final _crypto_aead_aes256gcm_messagebytes_max =
      _crypto_aead_aes256gcm_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_aead_aes256gcm_statebytes() {
    return _crypto_aead_aes256gcm_statebytes();
  }

  late final _crypto_aead_aes256gcm_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_aes256gcm_statebytes');
  late final _crypto_aead_aes256gcm_statebytes =
      _crypto_aead_aes256gcm_statebytesPtr.asFunction<int Function()>();

  int crypto_aead_aes256gcm_encrypt(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aes256gcm_encrypt(
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_aes256gcm_encryptPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_aead_aes256gcm_encrypt');
  late final _crypto_aead_aes256gcm_encrypt =
      _crypto_aead_aes256gcm_encryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aes256gcm_decrypt(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aes256gcm_decrypt(
      m,
      mlen_p,
      nsec,
      c,
      clen,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_aes256gcm_decryptPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_aead_aes256gcm_decrypt');
  late final _crypto_aead_aes256gcm_decrypt =
      _crypto_aead_aes256gcm_decryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aes256gcm_encrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedLongLong> maclen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aes256gcm_encrypt_detached(
      c,
      mac,
      maclen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_aes256gcm_encrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aes256gcm_encrypt_detached');
  late final _crypto_aead_aes256gcm_encrypt_detached =
      _crypto_aead_aes256gcm_encrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aes256gcm_decrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aes256gcm_decrypt_detached(
      m,
      nsec,
      c,
      clen,
      mac,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_aes256gcm_decrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aes256gcm_decrypt_detached');
  late final _crypto_aead_aes256gcm_decrypt_detached =
      _crypto_aead_aes256gcm_decrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aes256gcm_beforenm(
    ffi.Pointer<crypto_aead_aes256gcm_state> ctx_,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aes256gcm_beforenm(
      ctx_,
      k,
    );
  }

  late final _crypto_aead_aes256gcm_beforenmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_aead_aes256gcm_state>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aes256gcm_beforenm');
  late final _crypto_aead_aes256gcm_beforenm =
      _crypto_aead_aes256gcm_beforenmPtr.asFunction<
          int Function(ffi.Pointer<crypto_aead_aes256gcm_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_aes256gcm_encrypt_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<crypto_aead_aes256gcm_state> ctx_,
  ) {
    return _crypto_aead_aes256gcm_encrypt_afternm(
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      ctx_,
    );
  }

  late final _crypto_aead_aes256gcm_encrypt_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<crypto_aead_aes256gcm_state>)>>(
      'crypto_aead_aes256gcm_encrypt_afternm');
  late final _crypto_aead_aes256gcm_encrypt_afternm =
      _crypto_aead_aes256gcm_encrypt_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<crypto_aead_aes256gcm_state>)>();

  int crypto_aead_aes256gcm_decrypt_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<crypto_aead_aes256gcm_state> ctx_,
  ) {
    return _crypto_aead_aes256gcm_decrypt_afternm(
      m,
      mlen_p,
      nsec,
      c,
      clen,
      ad,
      adlen,
      npub,
      ctx_,
    );
  }

  late final _crypto_aead_aes256gcm_decrypt_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<crypto_aead_aes256gcm_state>)>>(
      'crypto_aead_aes256gcm_decrypt_afternm');
  late final _crypto_aead_aes256gcm_decrypt_afternm =
      _crypto_aead_aes256gcm_decrypt_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<crypto_aead_aes256gcm_state>)>();

  int crypto_aead_aes256gcm_encrypt_detached_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedLongLong> maclen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<crypto_aead_aes256gcm_state> ctx_,
  ) {
    return _crypto_aead_aes256gcm_encrypt_detached_afternm(
      c,
      mac,
      maclen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      ctx_,
    );
  }

  late final _crypto_aead_aes256gcm_encrypt_detached_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<crypto_aead_aes256gcm_state>)>>(
      'crypto_aead_aes256gcm_encrypt_detached_afternm');
  late final _crypto_aead_aes256gcm_encrypt_detached_afternm =
      _crypto_aead_aes256gcm_encrypt_detached_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<crypto_aead_aes256gcm_state>)>();

  int crypto_aead_aes256gcm_decrypt_detached_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<crypto_aead_aes256gcm_state> ctx_,
  ) {
    return _crypto_aead_aes256gcm_decrypt_detached_afternm(
      m,
      nsec,
      c,
      clen,
      mac,
      ad,
      adlen,
      npub,
      ctx_,
    );
  }

  late final _crypto_aead_aes256gcm_decrypt_detached_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<crypto_aead_aes256gcm_state>)>>(
      'crypto_aead_aes256gcm_decrypt_detached_afternm');
  late final _crypto_aead_aes256gcm_decrypt_detached_afternm =
      _crypto_aead_aes256gcm_decrypt_detached_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<crypto_aead_aes256gcm_state>)>();

  void crypto_aead_aes256gcm_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_aes256gcm_keygen(
      k,
    );
  }

  late final _crypto_aead_aes256gcm_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_aes256gcm_keygen');
  late final _crypto_aead_aes256gcm_keygen = _crypto_aead_aes256gcm_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_ietf_keybytes() {
    return _crypto_aead_chacha20poly1305_ietf_keybytes();
  }

  late final _crypto_aead_chacha20poly1305_ietf_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_ietf_keybytes');
  late final _crypto_aead_chacha20poly1305_ietf_keybytes =
      _crypto_aead_chacha20poly1305_ietf_keybytesPtr
          .asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_ietf_nsecbytes() {
    return _crypto_aead_chacha20poly1305_ietf_nsecbytes();
  }

  late final _crypto_aead_chacha20poly1305_ietf_nsecbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_ietf_nsecbytes');
  late final _crypto_aead_chacha20poly1305_ietf_nsecbytes =
      _crypto_aead_chacha20poly1305_ietf_nsecbytesPtr
          .asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_ietf_npubbytes() {
    return _crypto_aead_chacha20poly1305_ietf_npubbytes();
  }

  late final _crypto_aead_chacha20poly1305_ietf_npubbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_ietf_npubbytes');
  late final _crypto_aead_chacha20poly1305_ietf_npubbytes =
      _crypto_aead_chacha20poly1305_ietf_npubbytesPtr
          .asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_ietf_abytes() {
    return _crypto_aead_chacha20poly1305_ietf_abytes();
  }

  late final _crypto_aead_chacha20poly1305_ietf_abytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_ietf_abytes');
  late final _crypto_aead_chacha20poly1305_ietf_abytes =
      _crypto_aead_chacha20poly1305_ietf_abytesPtr.asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_ietf_messagebytes_max() {
    return _crypto_aead_chacha20poly1305_ietf_messagebytes_max();
  }

  late final _crypto_aead_chacha20poly1305_ietf_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_ietf_messagebytes_max');
  late final _crypto_aead_chacha20poly1305_ietf_messagebytes_max =
      _crypto_aead_chacha20poly1305_ietf_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_ietf_encrypt(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_ietf_encrypt(
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_ietf_encryptPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_ietf_encrypt');
  late final _crypto_aead_chacha20poly1305_ietf_encrypt =
      _crypto_aead_chacha20poly1305_ietf_encryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_ietf_decrypt(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_ietf_decrypt(
      m,
      mlen_p,
      nsec,
      c,
      clen,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_ietf_decryptPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_ietf_decrypt');
  late final _crypto_aead_chacha20poly1305_ietf_decrypt =
      _crypto_aead_chacha20poly1305_ietf_decryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_ietf_encrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedLongLong> maclen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_ietf_encrypt_detached(
      c,
      mac,
      maclen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_ietf_encrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_ietf_encrypt_detached');
  late final _crypto_aead_chacha20poly1305_ietf_encrypt_detached =
      _crypto_aead_chacha20poly1305_ietf_encrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_ietf_decrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_ietf_decrypt_detached(
      m,
      nsec,
      c,
      clen,
      mac,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_ietf_decrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_ietf_decrypt_detached');
  late final _crypto_aead_chacha20poly1305_ietf_decrypt_detached =
      _crypto_aead_chacha20poly1305_ietf_decrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_aead_chacha20poly1305_ietf_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_ietf_keygen(
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_ietf_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_ietf_keygen');
  late final _crypto_aead_chacha20poly1305_ietf_keygen =
      _crypto_aead_chacha20poly1305_ietf_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_keybytes() {
    return _crypto_aead_chacha20poly1305_keybytes();
  }

  late final _crypto_aead_chacha20poly1305_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_keybytes');
  late final _crypto_aead_chacha20poly1305_keybytes =
      _crypto_aead_chacha20poly1305_keybytesPtr.asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_nsecbytes() {
    return _crypto_aead_chacha20poly1305_nsecbytes();
  }

  late final _crypto_aead_chacha20poly1305_nsecbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_nsecbytes');
  late final _crypto_aead_chacha20poly1305_nsecbytes =
      _crypto_aead_chacha20poly1305_nsecbytesPtr.asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_npubbytes() {
    return _crypto_aead_chacha20poly1305_npubbytes();
  }

  late final _crypto_aead_chacha20poly1305_npubbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_npubbytes');
  late final _crypto_aead_chacha20poly1305_npubbytes =
      _crypto_aead_chacha20poly1305_npubbytesPtr.asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_abytes() {
    return _crypto_aead_chacha20poly1305_abytes();
  }

  late final _crypto_aead_chacha20poly1305_abytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_abytes');
  late final _crypto_aead_chacha20poly1305_abytes =
      _crypto_aead_chacha20poly1305_abytesPtr.asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_messagebytes_max() {
    return _crypto_aead_chacha20poly1305_messagebytes_max();
  }

  late final _crypto_aead_chacha20poly1305_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_chacha20poly1305_messagebytes_max');
  late final _crypto_aead_chacha20poly1305_messagebytes_max =
      _crypto_aead_chacha20poly1305_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_aead_chacha20poly1305_encrypt(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_encrypt(
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_encryptPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_encrypt');
  late final _crypto_aead_chacha20poly1305_encrypt =
      _crypto_aead_chacha20poly1305_encryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_decrypt(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_decrypt(
      m,
      mlen_p,
      nsec,
      c,
      clen,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_decryptPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_decrypt');
  late final _crypto_aead_chacha20poly1305_decrypt =
      _crypto_aead_chacha20poly1305_decryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_encrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedLongLong> maclen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_encrypt_detached(
      c,
      mac,
      maclen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_encrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_encrypt_detached');
  late final _crypto_aead_chacha20poly1305_encrypt_detached =
      _crypto_aead_chacha20poly1305_encrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_chacha20poly1305_decrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_decrypt_detached(
      m,
      nsec,
      c,
      clen,
      mac,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_decrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_decrypt_detached');
  late final _crypto_aead_chacha20poly1305_decrypt_detached =
      _crypto_aead_chacha20poly1305_decrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_aead_chacha20poly1305_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_chacha20poly1305_keygen(
      k,
    );
  }

  late final _crypto_aead_chacha20poly1305_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_chacha20poly1305_keygen');
  late final _crypto_aead_chacha20poly1305_keygen =
      _crypto_aead_chacha20poly1305_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_xchacha20poly1305_ietf_keybytes() {
    return _crypto_aead_xchacha20poly1305_ietf_keybytes();
  }

  late final _crypto_aead_xchacha20poly1305_ietf_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_xchacha20poly1305_ietf_keybytes');
  late final _crypto_aead_xchacha20poly1305_ietf_keybytes =
      _crypto_aead_xchacha20poly1305_ietf_keybytesPtr
          .asFunction<int Function()>();

  int crypto_aead_xchacha20poly1305_ietf_nsecbytes() {
    return _crypto_aead_xchacha20poly1305_ietf_nsecbytes();
  }

  late final _crypto_aead_xchacha20poly1305_ietf_nsecbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_xchacha20poly1305_ietf_nsecbytes');
  late final _crypto_aead_xchacha20poly1305_ietf_nsecbytes =
      _crypto_aead_xchacha20poly1305_ietf_nsecbytesPtr
          .asFunction<int Function()>();

  int crypto_aead_xchacha20poly1305_ietf_npubbytes() {
    return _crypto_aead_xchacha20poly1305_ietf_npubbytes();
  }

  late final _crypto_aead_xchacha20poly1305_ietf_npubbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_xchacha20poly1305_ietf_npubbytes');
  late final _crypto_aead_xchacha20poly1305_ietf_npubbytes =
      _crypto_aead_xchacha20poly1305_ietf_npubbytesPtr
          .asFunction<int Function()>();

  int crypto_aead_xchacha20poly1305_ietf_abytes() {
    return _crypto_aead_xchacha20poly1305_ietf_abytes();
  }

  late final _crypto_aead_xchacha20poly1305_ietf_abytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_xchacha20poly1305_ietf_abytes');
  late final _crypto_aead_xchacha20poly1305_ietf_abytes =
      _crypto_aead_xchacha20poly1305_ietf_abytesPtr
          .asFunction<int Function()>();

  int crypto_aead_xchacha20poly1305_ietf_messagebytes_max() {
    return _crypto_aead_xchacha20poly1305_ietf_messagebytes_max();
  }

  late final _crypto_aead_xchacha20poly1305_ietf_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_aead_xchacha20poly1305_ietf_messagebytes_max');
  late final _crypto_aead_xchacha20poly1305_ietf_messagebytes_max =
      _crypto_aead_xchacha20poly1305_ietf_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_aead_xchacha20poly1305_ietf_encrypt(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_xchacha20poly1305_ietf_encrypt(
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_xchacha20poly1305_ietf_encryptPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_xchacha20poly1305_ietf_encrypt');
  late final _crypto_aead_xchacha20poly1305_ietf_encrypt =
      _crypto_aead_xchacha20poly1305_ietf_encryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_xchacha20poly1305_ietf_decrypt(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_xchacha20poly1305_ietf_decrypt(
      m,
      mlen_p,
      nsec,
      c,
      clen,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_xchacha20poly1305_ietf_decryptPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_xchacha20poly1305_ietf_decrypt');
  late final _crypto_aead_xchacha20poly1305_ietf_decrypt =
      _crypto_aead_xchacha20poly1305_ietf_decryptPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_xchacha20poly1305_ietf_encrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedLongLong> maclen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_xchacha20poly1305_ietf_encrypt_detached(
      c,
      mac,
      maclen_p,
      m,
      mlen,
      ad,
      adlen,
      nsec,
      npub,
      k,
    );
  }

  late final _crypto_aead_xchacha20poly1305_ietf_encrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_xchacha20poly1305_ietf_encrypt_detached');
  late final _crypto_aead_xchacha20poly1305_ietf_encrypt_detached =
      _crypto_aead_xchacha20poly1305_ietf_encrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_aead_xchacha20poly1305_ietf_decrypt_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> nsec,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    ffi.Pointer<ffi.UnsignedChar> npub,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_xchacha20poly1305_ietf_decrypt_detached(
      m,
      nsec,
      c,
      clen,
      mac,
      ad,
      adlen,
      npub,
      k,
    );
  }

  late final _crypto_aead_xchacha20poly1305_ietf_decrypt_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_xchacha20poly1305_ietf_decrypt_detached');
  late final _crypto_aead_xchacha20poly1305_ietf_decrypt_detached =
      _crypto_aead_xchacha20poly1305_ietf_decrypt_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_aead_xchacha20poly1305_ietf_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_aead_xchacha20poly1305_ietf_keygen(
      k,
    );
  }

  late final _crypto_aead_xchacha20poly1305_ietf_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_aead_xchacha20poly1305_ietf_keygen');
  late final _crypto_aead_xchacha20poly1305_ietf_keygen =
      _crypto_aead_xchacha20poly1305_ietf_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_hash_sha512_statebytes() {
    return _crypto_hash_sha512_statebytes();
  }

  late final _crypto_hash_sha512_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_hash_sha512_statebytes');
  late final _crypto_hash_sha512_statebytes =
      _crypto_hash_sha512_statebytesPtr.asFunction<int Function()>();

  int crypto_hash_sha512_bytes() {
    return _crypto_hash_sha512_bytes();
  }

  late final _crypto_hash_sha512_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_hash_sha512_bytes');
  late final _crypto_hash_sha512_bytes =
      _crypto_hash_sha512_bytesPtr.asFunction<int Function()>();

  int crypto_hash_sha512(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_hash_sha512(
      out,
      in1,
      inlen,
    );
  }

  late final _crypto_hash_sha512Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_hash_sha512');
  late final _crypto_hash_sha512 = _crypto_hash_sha512Ptr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_hash_sha512_init(
    ffi.Pointer<crypto_hash_sha512_state> state,
  ) {
    return _crypto_hash_sha512_init(
      state,
    );
  }

  late final _crypto_hash_sha512_initPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_hash_sha512_state>)>>(
      'crypto_hash_sha512_init');
  late final _crypto_hash_sha512_init = _crypto_hash_sha512_initPtr
      .asFunction<int Function(ffi.Pointer<crypto_hash_sha512_state>)>();

  int crypto_hash_sha512_update(
    ffi.Pointer<crypto_hash_sha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_hash_sha512_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_hash_sha512_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_hash_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_hash_sha512_update');
  late final _crypto_hash_sha512_update =
      _crypto_hash_sha512_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_hash_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_hash_sha512_final(
    ffi.Pointer<crypto_hash_sha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
  ) {
    return _crypto_hash_sha512_final(
      state,
      out,
    );
  }

  late final _crypto_hash_sha512_finalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<crypto_hash_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_hash_sha512_final');
  late final _crypto_hash_sha512_final =
      _crypto_hash_sha512_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_hash_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha512_bytes() {
    return _crypto_auth_hmacsha512_bytes();
  }

  late final _crypto_auth_hmacsha512_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha512_bytes');
  late final _crypto_auth_hmacsha512_bytes =
      _crypto_auth_hmacsha512_bytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha512_keybytes() {
    return _crypto_auth_hmacsha512_keybytes();
  }

  late final _crypto_auth_hmacsha512_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha512_keybytes');
  late final _crypto_auth_hmacsha512_keybytes =
      _crypto_auth_hmacsha512_keybytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha512(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha512(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_auth_hmacsha512Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_hmacsha512');
  late final _crypto_auth_hmacsha512 = _crypto_auth_hmacsha512Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha512_verify(
    ffi.Pointer<ffi.UnsignedChar> h,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha512_verify(
      h,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_auth_hmacsha512_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_hmacsha512_verify');
  late final _crypto_auth_hmacsha512_verify =
      _crypto_auth_hmacsha512_verifyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha512_statebytes() {
    return _crypto_auth_hmacsha512_statebytes();
  }

  late final _crypto_auth_hmacsha512_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha512_statebytes');
  late final _crypto_auth_hmacsha512_statebytes =
      _crypto_auth_hmacsha512_statebytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha512_init(
    ffi.Pointer<crypto_auth_hmacsha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
  ) {
    return _crypto_auth_hmacsha512_init(
      state,
      key,
      keylen,
    );
  }

  late final _crypto_auth_hmacsha512_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_auth_hmacsha512_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_auth_hmacsha512_init');
  late final _crypto_auth_hmacsha512_init =
      _crypto_auth_hmacsha512_initPtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha512_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_auth_hmacsha512_update(
    ffi.Pointer<crypto_auth_hmacsha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_auth_hmacsha512_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_auth_hmacsha512_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_auth_hmacsha512_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_auth_hmacsha512_update');
  late final _crypto_auth_hmacsha512_update =
      _crypto_auth_hmacsha512_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha512_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_auth_hmacsha512_final(
    ffi.Pointer<crypto_auth_hmacsha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
  ) {
    return _crypto_auth_hmacsha512_final(
      state,
      out,
    );
  }

  late final _crypto_auth_hmacsha512_finalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<crypto_auth_hmacsha512_state>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_hmacsha512_final');
  late final _crypto_auth_hmacsha512_final =
      _crypto_auth_hmacsha512_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha512_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_auth_hmacsha512_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha512_keygen(
      k,
    );
  }

  late final _crypto_auth_hmacsha512_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_auth_hmacsha512_keygen');
  late final _crypto_auth_hmacsha512_keygen = _crypto_auth_hmacsha512_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha512256_bytes() {
    return _crypto_auth_hmacsha512256_bytes();
  }

  late final _crypto_auth_hmacsha512256_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha512256_bytes');
  late final _crypto_auth_hmacsha512256_bytes =
      _crypto_auth_hmacsha512256_bytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha512256_keybytes() {
    return _crypto_auth_hmacsha512256_keybytes();
  }

  late final _crypto_auth_hmacsha512256_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha512256_keybytes');
  late final _crypto_auth_hmacsha512256_keybytes =
      _crypto_auth_hmacsha512256_keybytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha512256(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha512256(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_auth_hmacsha512256Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_hmacsha512256');
  late final _crypto_auth_hmacsha512256 =
      _crypto_auth_hmacsha512256Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha512256_verify(
    ffi.Pointer<ffi.UnsignedChar> h,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha512256_verify(
      h,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_auth_hmacsha512256_verifyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_auth_hmacsha512256_verify');
  late final _crypto_auth_hmacsha512256_verify =
      _crypto_auth_hmacsha512256_verifyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha512256_statebytes() {
    return _crypto_auth_hmacsha512256_statebytes();
  }

  late final _crypto_auth_hmacsha512256_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha512256_statebytes');
  late final _crypto_auth_hmacsha512256_statebytes =
      _crypto_auth_hmacsha512256_statebytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha512256_init(
    ffi.Pointer<crypto_auth_hmacsha512256_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
  ) {
    return _crypto_auth_hmacsha512256_init(
      state,
      key,
      keylen,
    );
  }

  late final _crypto_auth_hmacsha512256_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_auth_hmacsha512256_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_auth_hmacsha512256_init');
  late final _crypto_auth_hmacsha512256_init =
      _crypto_auth_hmacsha512256_initPtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha512256_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_auth_hmacsha512256_update(
    ffi.Pointer<crypto_auth_hmacsha512256_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_auth_hmacsha512256_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_auth_hmacsha512256_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_auth_hmacsha512256_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_auth_hmacsha512256_update');
  late final _crypto_auth_hmacsha512256_update =
      _crypto_auth_hmacsha512256_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha512256_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_auth_hmacsha512256_final(
    ffi.Pointer<crypto_auth_hmacsha512256_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
  ) {
    return _crypto_auth_hmacsha512256_final(
      state,
      out,
    );
  }

  late final _crypto_auth_hmacsha512256_finalPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_auth_hmacsha512256_state>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_auth_hmacsha512256_final');
  late final _crypto_auth_hmacsha512256_final =
      _crypto_auth_hmacsha512256_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha512256_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_auth_hmacsha512256_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha512256_keygen(
      k,
    );
  }

  late final _crypto_auth_hmacsha512256_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_auth_hmacsha512256_keygen');
  late final _crypto_auth_hmacsha512256_keygen =
      _crypto_auth_hmacsha512256_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_bytes() {
    return _crypto_auth_bytes();
  }

  late final _crypto_auth_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_auth_bytes');
  late final _crypto_auth_bytes =
      _crypto_auth_bytesPtr.asFunction<int Function()>();

  int crypto_auth_keybytes() {
    return _crypto_auth_keybytes();
  }

  late final _crypto_auth_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_auth_keybytes');
  late final _crypto_auth_keybytes =
      _crypto_auth_keybytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_auth_primitive() {
    return _crypto_auth_primitive();
  }

  late final _crypto_auth_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_auth_primitive');
  late final _crypto_auth_primitive =
      _crypto_auth_primitivePtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_auth(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_authPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth');
  late final _crypto_auth = _crypto_authPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_verify(
    ffi.Pointer<ffi.UnsignedChar> h,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_verify(
      h,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_auth_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_verify');
  late final _crypto_auth_verify = _crypto_auth_verifyPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_auth_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_keygen(
      k,
    );
  }

  late final _crypto_auth_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_auth_keygen');
  late final _crypto_auth_keygen = _crypto_auth_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_hash_sha256_statebytes() {
    return _crypto_hash_sha256_statebytes();
  }

  late final _crypto_hash_sha256_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_hash_sha256_statebytes');
  late final _crypto_hash_sha256_statebytes =
      _crypto_hash_sha256_statebytesPtr.asFunction<int Function()>();

  int crypto_hash_sha256_bytes() {
    return _crypto_hash_sha256_bytes();
  }

  late final _crypto_hash_sha256_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_hash_sha256_bytes');
  late final _crypto_hash_sha256_bytes =
      _crypto_hash_sha256_bytesPtr.asFunction<int Function()>();

  int crypto_hash_sha256(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_hash_sha256(
      out,
      in1,
      inlen,
    );
  }

  late final _crypto_hash_sha256Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_hash_sha256');
  late final _crypto_hash_sha256 = _crypto_hash_sha256Ptr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_hash_sha256_init(
    ffi.Pointer<crypto_hash_sha256_state> state,
  ) {
    return _crypto_hash_sha256_init(
      state,
    );
  }

  late final _crypto_hash_sha256_initPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_hash_sha256_state>)>>(
      'crypto_hash_sha256_init');
  late final _crypto_hash_sha256_init = _crypto_hash_sha256_initPtr
      .asFunction<int Function(ffi.Pointer<crypto_hash_sha256_state>)>();

  int crypto_hash_sha256_update(
    ffi.Pointer<crypto_hash_sha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_hash_sha256_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_hash_sha256_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_hash_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_hash_sha256_update');
  late final _crypto_hash_sha256_update =
      _crypto_hash_sha256_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_hash_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_hash_sha256_final(
    ffi.Pointer<crypto_hash_sha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
  ) {
    return _crypto_hash_sha256_final(
      state,
      out,
    );
  }

  late final _crypto_hash_sha256_finalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<crypto_hash_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_hash_sha256_final');
  late final _crypto_hash_sha256_final =
      _crypto_hash_sha256_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_hash_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha256_bytes() {
    return _crypto_auth_hmacsha256_bytes();
  }

  late final _crypto_auth_hmacsha256_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha256_bytes');
  late final _crypto_auth_hmacsha256_bytes =
      _crypto_auth_hmacsha256_bytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha256_keybytes() {
    return _crypto_auth_hmacsha256_keybytes();
  }

  late final _crypto_auth_hmacsha256_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha256_keybytes');
  late final _crypto_auth_hmacsha256_keybytes =
      _crypto_auth_hmacsha256_keybytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha256(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha256(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_auth_hmacsha256Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_hmacsha256');
  late final _crypto_auth_hmacsha256 = _crypto_auth_hmacsha256Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha256_verify(
    ffi.Pointer<ffi.UnsignedChar> h,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha256_verify(
      h,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_auth_hmacsha256_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_hmacsha256_verify');
  late final _crypto_auth_hmacsha256_verify =
      _crypto_auth_hmacsha256_verifyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_auth_hmacsha256_statebytes() {
    return _crypto_auth_hmacsha256_statebytes();
  }

  late final _crypto_auth_hmacsha256_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_auth_hmacsha256_statebytes');
  late final _crypto_auth_hmacsha256_statebytes =
      _crypto_auth_hmacsha256_statebytesPtr.asFunction<int Function()>();

  int crypto_auth_hmacsha256_init(
    ffi.Pointer<crypto_auth_hmacsha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
  ) {
    return _crypto_auth_hmacsha256_init(
      state,
      key,
      keylen,
    );
  }

  late final _crypto_auth_hmacsha256_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_auth_hmacsha256_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_auth_hmacsha256_init');
  late final _crypto_auth_hmacsha256_init =
      _crypto_auth_hmacsha256_initPtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha256_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_auth_hmacsha256_update(
    ffi.Pointer<crypto_auth_hmacsha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_auth_hmacsha256_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_auth_hmacsha256_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_auth_hmacsha256_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_auth_hmacsha256_update');
  late final _crypto_auth_hmacsha256_update =
      _crypto_auth_hmacsha256_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha256_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_auth_hmacsha256_final(
    ffi.Pointer<crypto_auth_hmacsha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
  ) {
    return _crypto_auth_hmacsha256_final(
      state,
      out,
    );
  }

  late final _crypto_auth_hmacsha256_finalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<crypto_auth_hmacsha256_state>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_auth_hmacsha256_final');
  late final _crypto_auth_hmacsha256_final =
      _crypto_auth_hmacsha256_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_auth_hmacsha256_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_auth_hmacsha256_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_auth_hmacsha256_keygen(
      k,
    );
  }

  late final _crypto_auth_hmacsha256_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_auth_hmacsha256_keygen');
  late final _crypto_auth_hmacsha256_keygen = _crypto_auth_hmacsha256_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_xsalsa20_keybytes() {
    return _crypto_stream_xsalsa20_keybytes();
  }

  late final _crypto_stream_xsalsa20_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_xsalsa20_keybytes');
  late final _crypto_stream_xsalsa20_keybytes =
      _crypto_stream_xsalsa20_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_xsalsa20_noncebytes() {
    return _crypto_stream_xsalsa20_noncebytes();
  }

  late final _crypto_stream_xsalsa20_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_xsalsa20_noncebytes');
  late final _crypto_stream_xsalsa20_noncebytes =
      _crypto_stream_xsalsa20_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_xsalsa20_messagebytes_max() {
    return _crypto_stream_xsalsa20_messagebytes_max();
  }

  late final _crypto_stream_xsalsa20_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_xsalsa20_messagebytes_max');
  late final _crypto_stream_xsalsa20_messagebytes_max =
      _crypto_stream_xsalsa20_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_stream_xsalsa20(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xsalsa20(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_stream_xsalsa20Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_xsalsa20');
  late final _crypto_stream_xsalsa20 = _crypto_stream_xsalsa20Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_xsalsa20_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xsalsa20_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_xsalsa20_xorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_xsalsa20_xor');
  late final _crypto_stream_xsalsa20_xor =
      _crypto_stream_xsalsa20_xorPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_xsalsa20_xor_ic(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    int ic,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xsalsa20_xor_ic(
      c,
      m,
      mlen,
      n,
      ic,
      k,
    );
  }

  late final _crypto_stream_xsalsa20_xor_icPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Uint64,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_xsalsa20_xor_ic');
  late final _crypto_stream_xsalsa20_xor_ic =
      _crypto_stream_xsalsa20_xor_icPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_xsalsa20_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xsalsa20_keygen(
      k,
    );
  }

  late final _crypto_stream_xsalsa20_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_xsalsa20_keygen');
  late final _crypto_stream_xsalsa20_keygen = _crypto_stream_xsalsa20_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xsalsa20poly1305_seedbytes() {
    return _crypto_box_curve25519xsalsa20poly1305_seedbytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_seedbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_seedbytes');
  late final _crypto_box_curve25519xsalsa20poly1305_seedbytes =
      _crypto_box_curve25519xsalsa20poly1305_seedbytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_publickeybytes() {
    return _crypto_box_curve25519xsalsa20poly1305_publickeybytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_publickeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_publickeybytes');
  late final _crypto_box_curve25519xsalsa20poly1305_publickeybytes =
      _crypto_box_curve25519xsalsa20poly1305_publickeybytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_secretkeybytes() {
    return _crypto_box_curve25519xsalsa20poly1305_secretkeybytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_secretkeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_secretkeybytes');
  late final _crypto_box_curve25519xsalsa20poly1305_secretkeybytes =
      _crypto_box_curve25519xsalsa20poly1305_secretkeybytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_beforenmbytes() {
    return _crypto_box_curve25519xsalsa20poly1305_beforenmbytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_beforenmbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_beforenmbytes');
  late final _crypto_box_curve25519xsalsa20poly1305_beforenmbytes =
      _crypto_box_curve25519xsalsa20poly1305_beforenmbytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_noncebytes() {
    return _crypto_box_curve25519xsalsa20poly1305_noncebytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_noncebytes');
  late final _crypto_box_curve25519xsalsa20poly1305_noncebytes =
      _crypto_box_curve25519xsalsa20poly1305_noncebytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_macbytes() {
    return _crypto_box_curve25519xsalsa20poly1305_macbytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_macbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_macbytes');
  late final _crypto_box_curve25519xsalsa20poly1305_macbytes =
      _crypto_box_curve25519xsalsa20poly1305_macbytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_messagebytes_max() {
    return _crypto_box_curve25519xsalsa20poly1305_messagebytes_max();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_messagebytes_max');
  late final _crypto_box_curve25519xsalsa20poly1305_messagebytes_max =
      _crypto_box_curve25519xsalsa20poly1305_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_seed_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
    ffi.Pointer<ffi.UnsignedChar> seed,
  ) {
    return _crypto_box_curve25519xsalsa20poly1305_seed_keypair(
      pk,
      sk,
      seed,
    );
  }

  late final _crypto_box_curve25519xsalsa20poly1305_seed_keypairPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xsalsa20poly1305_seed_keypair');
  late final _crypto_box_curve25519xsalsa20poly1305_seed_keypair =
      _crypto_box_curve25519xsalsa20poly1305_seed_keypairPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xsalsa20poly1305_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xsalsa20poly1305_keypair(
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xsalsa20poly1305_keypairPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xsalsa20poly1305_keypair');
  late final _crypto_box_curve25519xsalsa20poly1305_keypair =
      _crypto_box_curve25519xsalsa20poly1305_keypairPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xsalsa20poly1305_beforenm(
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xsalsa20poly1305_beforenm(
      k,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xsalsa20poly1305_beforenmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xsalsa20poly1305_beforenm');
  late final _crypto_box_curve25519xsalsa20poly1305_beforenm =
      _crypto_box_curve25519xsalsa20poly1305_beforenmPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xsalsa20poly1305_boxzerobytes() {
    return _crypto_box_curve25519xsalsa20poly1305_boxzerobytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_boxzerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_boxzerobytes');
  late final _crypto_box_curve25519xsalsa20poly1305_boxzerobytes =
      _crypto_box_curve25519xsalsa20poly1305_boxzerobytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305_zerobytes() {
    return _crypto_box_curve25519xsalsa20poly1305_zerobytes();
  }

  late final _crypto_box_curve25519xsalsa20poly1305_zerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xsalsa20poly1305_zerobytes');
  late final _crypto_box_curve25519xsalsa20poly1305_zerobytes =
      _crypto_box_curve25519xsalsa20poly1305_zerobytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xsalsa20poly1305(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xsalsa20poly1305(
      c,
      m,
      mlen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xsalsa20poly1305Ptr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xsalsa20poly1305');
  late final _crypto_box_curve25519xsalsa20poly1305 =
      _crypto_box_curve25519xsalsa20poly1305Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xsalsa20poly1305_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xsalsa20poly1305_open(
      m,
      c,
      clen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xsalsa20poly1305_openPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xsalsa20poly1305_open');
  late final _crypto_box_curve25519xsalsa20poly1305_open =
      _crypto_box_curve25519xsalsa20poly1305_openPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xsalsa20poly1305_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_curve25519xsalsa20poly1305_afternm(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_box_curve25519xsalsa20poly1305_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xsalsa20poly1305_afternm');
  late final _crypto_box_curve25519xsalsa20poly1305_afternm =
      _crypto_box_curve25519xsalsa20poly1305_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xsalsa20poly1305_open_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_curve25519xsalsa20poly1305_open_afternm(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_box_curve25519xsalsa20poly1305_open_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xsalsa20poly1305_open_afternm');
  late final _crypto_box_curve25519xsalsa20poly1305_open_afternm =
      _crypto_box_curve25519xsalsa20poly1305_open_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_seedbytes() {
    return _crypto_box_seedbytes();
  }

  late final _crypto_box_seedbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_box_seedbytes');
  late final _crypto_box_seedbytes =
      _crypto_box_seedbytesPtr.asFunction<int Function()>();

  int crypto_box_publickeybytes() {
    return _crypto_box_publickeybytes();
  }

  late final _crypto_box_publickeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_publickeybytes');
  late final _crypto_box_publickeybytes =
      _crypto_box_publickeybytesPtr.asFunction<int Function()>();

  int crypto_box_secretkeybytes() {
    return _crypto_box_secretkeybytes();
  }

  late final _crypto_box_secretkeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_secretkeybytes');
  late final _crypto_box_secretkeybytes =
      _crypto_box_secretkeybytesPtr.asFunction<int Function()>();

  int crypto_box_noncebytes() {
    return _crypto_box_noncebytes();
  }

  late final _crypto_box_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_box_noncebytes');
  late final _crypto_box_noncebytes =
      _crypto_box_noncebytesPtr.asFunction<int Function()>();

  int crypto_box_macbytes() {
    return _crypto_box_macbytes();
  }

  late final _crypto_box_macbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_box_macbytes');
  late final _crypto_box_macbytes =
      _crypto_box_macbytesPtr.asFunction<int Function()>();

  int crypto_box_messagebytes_max() {
    return _crypto_box_messagebytes_max();
  }

  late final _crypto_box_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_messagebytes_max');
  late final _crypto_box_messagebytes_max =
      _crypto_box_messagebytes_maxPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_box_primitive() {
    return _crypto_box_primitive();
  }

  late final _crypto_box_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_box_primitive');
  late final _crypto_box_primitive =
      _crypto_box_primitivePtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_box_seed_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
    ffi.Pointer<ffi.UnsignedChar> seed,
  ) {
    return _crypto_box_seed_keypair(
      pk,
      sk,
      seed,
    );
  }

  late final _crypto_box_seed_keypairPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_seed_keypair');
  late final _crypto_box_seed_keypair = _crypto_box_seed_keypairPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_keypair(
      pk,
      sk,
    );
  }

  late final _crypto_box_keypairPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_keypair');
  late final _crypto_box_keypair = _crypto_box_keypairPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_easy(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_easy(
      c,
      m,
      mlen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_easyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_easy');
  late final _crypto_box_easy = _crypto_box_easyPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_open_easy(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_open_easy(
      m,
      c,
      clen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_open_easyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_open_easy');
  late final _crypto_box_open_easy = _crypto_box_open_easyPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_detached(
      c,
      mac,
      m,
      mlen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_detachedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_detached');
  late final _crypto_box_detached = _crypto_box_detachedPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_open_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_open_detached(
      m,
      c,
      mac,
      clen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_open_detachedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_open_detached');
  late final _crypto_box_open_detached =
      _crypto_box_open_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_beforenmbytes() {
    return _crypto_box_beforenmbytes();
  }

  late final _crypto_box_beforenmbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_beforenmbytes');
  late final _crypto_box_beforenmbytes =
      _crypto_box_beforenmbytesPtr.asFunction<int Function()>();

  int crypto_box_beforenm(
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_beforenm(
      k,
      pk,
      sk,
    );
  }

  late final _crypto_box_beforenmPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_beforenm');
  late final _crypto_box_beforenm = _crypto_box_beforenmPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_easy_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_easy_afternm(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_box_easy_afternmPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_easy_afternm');
  late final _crypto_box_easy_afternm = _crypto_box_easy_afternmPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_open_easy_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_open_easy_afternm(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_box_open_easy_afternmPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_open_easy_afternm');
  late final _crypto_box_open_easy_afternm =
      _crypto_box_open_easy_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_detached_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_detached_afternm(
      c,
      mac,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_box_detached_afternmPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_detached_afternm');
  late final _crypto_box_detached_afternm =
      _crypto_box_detached_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_open_detached_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_open_detached_afternm(
      m,
      c,
      mac,
      clen,
      n,
      k,
    );
  }

  late final _crypto_box_open_detached_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_open_detached_afternm');
  late final _crypto_box_open_detached_afternm =
      _crypto_box_open_detached_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_sealbytes() {
    return _crypto_box_sealbytes();
  }

  late final _crypto_box_sealbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_box_sealbytes');
  late final _crypto_box_sealbytes =
      _crypto_box_sealbytesPtr.asFunction<int Function()>();

  int crypto_box_seal(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_box_seal(
      c,
      m,
      mlen,
      pk,
    );
  }

  late final _crypto_box_sealPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_seal');
  late final _crypto_box_seal = _crypto_box_sealPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_seal_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_seal_open(
      m,
      c,
      clen,
      pk,
      sk,
    );
  }

  late final _crypto_box_seal_openPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_seal_open');
  late final _crypto_box_seal_open = _crypto_box_seal_openPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_zerobytes() {
    return _crypto_box_zerobytes();
  }

  late final _crypto_box_zerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_box_zerobytes');
  late final _crypto_box_zerobytes =
      _crypto_box_zerobytesPtr.asFunction<int Function()>();

  int crypto_box_boxzerobytes() {
    return _crypto_box_boxzerobytes();
  }

  late final _crypto_box_boxzerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_boxzerobytes');
  late final _crypto_box_boxzerobytes =
      _crypto_box_boxzerobytesPtr.asFunction<int Function()>();

  int crypto_box(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box(
      c,
      m,
      mlen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_boxPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box');
  late final _crypto_box = _crypto_boxPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_open(
      m,
      c,
      clen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_openPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_open');
  late final _crypto_box_open = _crypto_box_openPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_afternm(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_box_afternmPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_afternm');
  late final _crypto_box_afternm = _crypto_box_afternmPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_open_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_open_afternm(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_box_open_afternmPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_box_open_afternm');
  late final _crypto_box_open_afternm = _crypto_box_open_afternmPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_hchacha20_outputbytes() {
    return _crypto_core_hchacha20_outputbytes();
  }

  late final _crypto_core_hchacha20_outputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hchacha20_outputbytes');
  late final _crypto_core_hchacha20_outputbytes =
      _crypto_core_hchacha20_outputbytesPtr.asFunction<int Function()>();

  int crypto_core_hchacha20_inputbytes() {
    return _crypto_core_hchacha20_inputbytes();
  }

  late final _crypto_core_hchacha20_inputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hchacha20_inputbytes');
  late final _crypto_core_hchacha20_inputbytes =
      _crypto_core_hchacha20_inputbytesPtr.asFunction<int Function()>();

  int crypto_core_hchacha20_keybytes() {
    return _crypto_core_hchacha20_keybytes();
  }

  late final _crypto_core_hchacha20_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hchacha20_keybytes');
  late final _crypto_core_hchacha20_keybytes =
      _crypto_core_hchacha20_keybytesPtr.asFunction<int Function()>();

  int crypto_core_hchacha20_constbytes() {
    return _crypto_core_hchacha20_constbytes();
  }

  late final _crypto_core_hchacha20_constbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hchacha20_constbytes');
  late final _crypto_core_hchacha20_constbytes =
      _crypto_core_hchacha20_constbytesPtr.asFunction<int Function()>();

  int crypto_core_hchacha20(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> c,
  ) {
    return _crypto_core_hchacha20(
      out,
      in1,
      k,
      c,
    );
  }

  late final _crypto_core_hchacha20Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_hchacha20');
  late final _crypto_core_hchacha20 = _crypto_core_hchacha20Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_hsalsa20_outputbytes() {
    return _crypto_core_hsalsa20_outputbytes();
  }

  late final _crypto_core_hsalsa20_outputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hsalsa20_outputbytes');
  late final _crypto_core_hsalsa20_outputbytes =
      _crypto_core_hsalsa20_outputbytesPtr.asFunction<int Function()>();

  int crypto_core_hsalsa20_inputbytes() {
    return _crypto_core_hsalsa20_inputbytes();
  }

  late final _crypto_core_hsalsa20_inputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hsalsa20_inputbytes');
  late final _crypto_core_hsalsa20_inputbytes =
      _crypto_core_hsalsa20_inputbytesPtr.asFunction<int Function()>();

  int crypto_core_hsalsa20_keybytes() {
    return _crypto_core_hsalsa20_keybytes();
  }

  late final _crypto_core_hsalsa20_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hsalsa20_keybytes');
  late final _crypto_core_hsalsa20_keybytes =
      _crypto_core_hsalsa20_keybytesPtr.asFunction<int Function()>();

  int crypto_core_hsalsa20_constbytes() {
    return _crypto_core_hsalsa20_constbytes();
  }

  late final _crypto_core_hsalsa20_constbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_hsalsa20_constbytes');
  late final _crypto_core_hsalsa20_constbytes =
      _crypto_core_hsalsa20_constbytesPtr.asFunction<int Function()>();

  int crypto_core_hsalsa20(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> c,
  ) {
    return _crypto_core_hsalsa20(
      out,
      in1,
      k,
      c,
    );
  }

  late final _crypto_core_hsalsa20Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_hsalsa20');
  late final _crypto_core_hsalsa20 = _crypto_core_hsalsa20Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_salsa20_outputbytes() {
    return _crypto_core_salsa20_outputbytes();
  }

  late final _crypto_core_salsa20_outputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa20_outputbytes');
  late final _crypto_core_salsa20_outputbytes =
      _crypto_core_salsa20_outputbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa20_inputbytes() {
    return _crypto_core_salsa20_inputbytes();
  }

  late final _crypto_core_salsa20_inputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa20_inputbytes');
  late final _crypto_core_salsa20_inputbytes =
      _crypto_core_salsa20_inputbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa20_keybytes() {
    return _crypto_core_salsa20_keybytes();
  }

  late final _crypto_core_salsa20_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa20_keybytes');
  late final _crypto_core_salsa20_keybytes =
      _crypto_core_salsa20_keybytesPtr.asFunction<int Function()>();

  int crypto_core_salsa20_constbytes() {
    return _crypto_core_salsa20_constbytes();
  }

  late final _crypto_core_salsa20_constbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa20_constbytes');
  late final _crypto_core_salsa20_constbytes =
      _crypto_core_salsa20_constbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa20(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> c,
  ) {
    return _crypto_core_salsa20(
      out,
      in1,
      k,
      c,
    );
  }

  late final _crypto_core_salsa20Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_salsa20');
  late final _crypto_core_salsa20 = _crypto_core_salsa20Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_salsa2012_outputbytes() {
    return _crypto_core_salsa2012_outputbytes();
  }

  late final _crypto_core_salsa2012_outputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa2012_outputbytes');
  late final _crypto_core_salsa2012_outputbytes =
      _crypto_core_salsa2012_outputbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa2012_inputbytes() {
    return _crypto_core_salsa2012_inputbytes();
  }

  late final _crypto_core_salsa2012_inputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa2012_inputbytes');
  late final _crypto_core_salsa2012_inputbytes =
      _crypto_core_salsa2012_inputbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa2012_keybytes() {
    return _crypto_core_salsa2012_keybytes();
  }

  late final _crypto_core_salsa2012_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa2012_keybytes');
  late final _crypto_core_salsa2012_keybytes =
      _crypto_core_salsa2012_keybytesPtr.asFunction<int Function()>();

  int crypto_core_salsa2012_constbytes() {
    return _crypto_core_salsa2012_constbytes();
  }

  late final _crypto_core_salsa2012_constbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa2012_constbytes');
  late final _crypto_core_salsa2012_constbytes =
      _crypto_core_salsa2012_constbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa2012(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> c,
  ) {
    return _crypto_core_salsa2012(
      out,
      in1,
      k,
      c,
    );
  }

  late final _crypto_core_salsa2012Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_salsa2012');
  late final _crypto_core_salsa2012 = _crypto_core_salsa2012Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_salsa208_outputbytes() {
    return _crypto_core_salsa208_outputbytes();
  }

  late final _crypto_core_salsa208_outputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa208_outputbytes');
  late final _crypto_core_salsa208_outputbytes =
      _crypto_core_salsa208_outputbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa208_inputbytes() {
    return _crypto_core_salsa208_inputbytes();
  }

  late final _crypto_core_salsa208_inputbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa208_inputbytes');
  late final _crypto_core_salsa208_inputbytes =
      _crypto_core_salsa208_inputbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa208_keybytes() {
    return _crypto_core_salsa208_keybytes();
  }

  late final _crypto_core_salsa208_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa208_keybytes');
  late final _crypto_core_salsa208_keybytes =
      _crypto_core_salsa208_keybytesPtr.asFunction<int Function()>();

  int crypto_core_salsa208_constbytes() {
    return _crypto_core_salsa208_constbytes();
  }

  late final _crypto_core_salsa208_constbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_salsa208_constbytes');
  late final _crypto_core_salsa208_constbytes =
      _crypto_core_salsa208_constbytesPtr.asFunction<int Function()>();

  int crypto_core_salsa208(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> c,
  ) {
    return _crypto_core_salsa208(
      out,
      in1,
      k,
      c,
    );
  }

  late final _crypto_core_salsa208Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_salsa208');
  late final _crypto_core_salsa208 = _crypto_core_salsa208Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_generichash_blake2b_bytes_min() {
    return _crypto_generichash_blake2b_bytes_min();
  }

  late final _crypto_generichash_blake2b_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_bytes_min');
  late final _crypto_generichash_blake2b_bytes_min =
      _crypto_generichash_blake2b_bytes_minPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_bytes_max() {
    return _crypto_generichash_blake2b_bytes_max();
  }

  late final _crypto_generichash_blake2b_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_bytes_max');
  late final _crypto_generichash_blake2b_bytes_max =
      _crypto_generichash_blake2b_bytes_maxPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_bytes() {
    return _crypto_generichash_blake2b_bytes();
  }

  late final _crypto_generichash_blake2b_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_bytes');
  late final _crypto_generichash_blake2b_bytes =
      _crypto_generichash_blake2b_bytesPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_keybytes_min() {
    return _crypto_generichash_blake2b_keybytes_min();
  }

  late final _crypto_generichash_blake2b_keybytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_keybytes_min');
  late final _crypto_generichash_blake2b_keybytes_min =
      _crypto_generichash_blake2b_keybytes_minPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_keybytes_max() {
    return _crypto_generichash_blake2b_keybytes_max();
  }

  late final _crypto_generichash_blake2b_keybytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_keybytes_max');
  late final _crypto_generichash_blake2b_keybytes_max =
      _crypto_generichash_blake2b_keybytes_maxPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_keybytes() {
    return _crypto_generichash_blake2b_keybytes();
  }

  late final _crypto_generichash_blake2b_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_keybytes');
  late final _crypto_generichash_blake2b_keybytes =
      _crypto_generichash_blake2b_keybytesPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_saltbytes() {
    return _crypto_generichash_blake2b_saltbytes();
  }

  late final _crypto_generichash_blake2b_saltbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_saltbytes');
  late final _crypto_generichash_blake2b_saltbytes =
      _crypto_generichash_blake2b_saltbytesPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_personalbytes() {
    return _crypto_generichash_blake2b_personalbytes();
  }

  late final _crypto_generichash_blake2b_personalbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_personalbytes');
  late final _crypto_generichash_blake2b_personalbytes =
      _crypto_generichash_blake2b_personalbytesPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b_statebytes() {
    return _crypto_generichash_blake2b_statebytes();
  }

  late final _crypto_generichash_blake2b_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_blake2b_statebytes');
  late final _crypto_generichash_blake2b_statebytes =
      _crypto_generichash_blake2b_statebytesPtr.asFunction<int Function()>();

  int crypto_generichash_blake2b(
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
  ) {
    return _crypto_generichash_blake2b(
      out,
      outlen,
      in1,
      inlen,
      key,
      keylen,
    );
  }

  late final _crypto_generichash_blake2bPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_generichash_blake2b');
  late final _crypto_generichash_blake2b =
      _crypto_generichash_blake2bPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int)>();

  int crypto_generichash_blake2b_salt_personal(
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
    ffi.Pointer<ffi.UnsignedChar> salt,
    ffi.Pointer<ffi.UnsignedChar> personal,
  ) {
    return _crypto_generichash_blake2b_salt_personal(
      out,
      outlen,
      in1,
      inlen,
      key,
      keylen,
      salt,
      personal,
    );
  }

  late final _crypto_generichash_blake2b_salt_personalPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Size,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Size,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_generichash_blake2b_salt_personal');
  late final _crypto_generichash_blake2b_salt_personal =
      _crypto_generichash_blake2b_salt_personalPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_generichash_blake2b_init(
    ffi.Pointer<crypto_generichash_blake2b_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
    int outlen,
  ) {
    return _crypto_generichash_blake2b_init(
      state,
      key,
      keylen,
      outlen,
    );
  }

  late final _crypto_generichash_blake2b_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_generichash_blake2b_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Size)>>('crypto_generichash_blake2b_init');
  late final _crypto_generichash_blake2b_init =
      _crypto_generichash_blake2b_initPtr.asFunction<
          int Function(ffi.Pointer<crypto_generichash_blake2b_state>,
              ffi.Pointer<ffi.UnsignedChar>, int, int)>();

  int crypto_generichash_blake2b_init_salt_personal(
    ffi.Pointer<crypto_generichash_blake2b_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
    int outlen,
    ffi.Pointer<ffi.UnsignedChar> salt,
    ffi.Pointer<ffi.UnsignedChar> personal,
  ) {
    return _crypto_generichash_blake2b_init_salt_personal(
      state,
      key,
      keylen,
      outlen,
      salt,
      personal,
    );
  }

  late final _crypto_generichash_blake2b_init_salt_personalPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<crypto_generichash_blake2b_state>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Size,
                  ffi.Size,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_generichash_blake2b_init_salt_personal');
  late final _crypto_generichash_blake2b_init_salt_personal =
      _crypto_generichash_blake2b_init_salt_personalPtr.asFunction<
          int Function(
              ffi.Pointer<crypto_generichash_blake2b_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_generichash_blake2b_update(
    ffi.Pointer<crypto_generichash_blake2b_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_generichash_blake2b_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_generichash_blake2b_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_generichash_blake2b_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_generichash_blake2b_update');
  late final _crypto_generichash_blake2b_update =
      _crypto_generichash_blake2b_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_generichash_blake2b_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_generichash_blake2b_final(
    ffi.Pointer<crypto_generichash_blake2b_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
  ) {
    return _crypto_generichash_blake2b_final(
      state,
      out,
      outlen,
    );
  }

  late final _crypto_generichash_blake2b_finalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_generichash_blake2b_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_generichash_blake2b_final');
  late final _crypto_generichash_blake2b_final =
      _crypto_generichash_blake2b_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_generichash_blake2b_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  void crypto_generichash_blake2b_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_generichash_blake2b_keygen(
      k,
    );
  }

  late final _crypto_generichash_blake2b_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_generichash_blake2b_keygen');
  late final _crypto_generichash_blake2b_keygen =
      _crypto_generichash_blake2b_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_generichash_bytes_min() {
    return _crypto_generichash_bytes_min();
  }

  late final _crypto_generichash_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_bytes_min');
  late final _crypto_generichash_bytes_min =
      _crypto_generichash_bytes_minPtr.asFunction<int Function()>();

  int crypto_generichash_bytes_max() {
    return _crypto_generichash_bytes_max();
  }

  late final _crypto_generichash_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_bytes_max');
  late final _crypto_generichash_bytes_max =
      _crypto_generichash_bytes_maxPtr.asFunction<int Function()>();

  int crypto_generichash_bytes() {
    return _crypto_generichash_bytes();
  }

  late final _crypto_generichash_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_bytes');
  late final _crypto_generichash_bytes =
      _crypto_generichash_bytesPtr.asFunction<int Function()>();

  int crypto_generichash_keybytes_min() {
    return _crypto_generichash_keybytes_min();
  }

  late final _crypto_generichash_keybytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_keybytes_min');
  late final _crypto_generichash_keybytes_min =
      _crypto_generichash_keybytes_minPtr.asFunction<int Function()>();

  int crypto_generichash_keybytes_max() {
    return _crypto_generichash_keybytes_max();
  }

  late final _crypto_generichash_keybytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_keybytes_max');
  late final _crypto_generichash_keybytes_max =
      _crypto_generichash_keybytes_maxPtr.asFunction<int Function()>();

  int crypto_generichash_keybytes() {
    return _crypto_generichash_keybytes();
  }

  late final _crypto_generichash_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_keybytes');
  late final _crypto_generichash_keybytes =
      _crypto_generichash_keybytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_generichash_primitive() {
    return _crypto_generichash_primitive();
  }

  late final _crypto_generichash_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_generichash_primitive');
  late final _crypto_generichash_primitive = _crypto_generichash_primitivePtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_generichash_statebytes() {
    return _crypto_generichash_statebytes();
  }

  late final _crypto_generichash_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_generichash_statebytes');
  late final _crypto_generichash_statebytes =
      _crypto_generichash_statebytesPtr.asFunction<int Function()>();

  int crypto_generichash(
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
  ) {
    return _crypto_generichash(
      out,
      outlen,
      in1,
      inlen,
      key,
      keylen,
    );
  }

  late final _crypto_generichashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_generichash');
  late final _crypto_generichash = _crypto_generichashPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>,
          int)>();

  int crypto_generichash_init(
    ffi.Pointer<crypto_generichash_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
    int keylen,
    int outlen,
  ) {
    return _crypto_generichash_init(
      state,
      key,
      keylen,
      outlen,
    );
  }

  late final _crypto_generichash_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_generichash_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Size)>>('crypto_generichash_init');
  late final _crypto_generichash_init = _crypto_generichash_initPtr.asFunction<
      int Function(ffi.Pointer<crypto_generichash_state>,
          ffi.Pointer<ffi.UnsignedChar>, int, int)>();

  int crypto_generichash_update(
    ffi.Pointer<crypto_generichash_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_generichash_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_generichash_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_generichash_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_generichash_update');
  late final _crypto_generichash_update =
      _crypto_generichash_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_generichash_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_generichash_final(
    ffi.Pointer<crypto_generichash_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
  ) {
    return _crypto_generichash_final(
      state,
      out,
      outlen,
    );
  }

  late final _crypto_generichash_finalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_generichash_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_generichash_final');
  late final _crypto_generichash_final =
      _crypto_generichash_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_generichash_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  void crypto_generichash_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_generichash_keygen(
      k,
    );
  }

  late final _crypto_generichash_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_generichash_keygen');
  late final _crypto_generichash_keygen = _crypto_generichash_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_hash_bytes() {
    return _crypto_hash_bytes();
  }

  late final _crypto_hash_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_hash_bytes');
  late final _crypto_hash_bytes =
      _crypto_hash_bytesPtr.asFunction<int Function()>();

  int crypto_hash(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_hash(
      out,
      in1,
      inlen,
    );
  }

  late final _crypto_hashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_hash');
  late final _crypto_hash = _crypto_hashPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>, int)>();

  ffi.Pointer<ffi.Char> crypto_hash_primitive() {
    return _crypto_hash_primitive();
  }

  late final _crypto_hash_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_hash_primitive');
  late final _crypto_hash_primitive =
      _crypto_hash_primitivePtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_kdf_blake2b_bytes_min() {
    return _crypto_kdf_blake2b_bytes_min();
  }

  late final _crypto_kdf_blake2b_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_blake2b_bytes_min');
  late final _crypto_kdf_blake2b_bytes_min =
      _crypto_kdf_blake2b_bytes_minPtr.asFunction<int Function()>();

  int crypto_kdf_blake2b_bytes_max() {
    return _crypto_kdf_blake2b_bytes_max();
  }

  late final _crypto_kdf_blake2b_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_blake2b_bytes_max');
  late final _crypto_kdf_blake2b_bytes_max =
      _crypto_kdf_blake2b_bytes_maxPtr.asFunction<int Function()>();

  int crypto_kdf_blake2b_contextbytes() {
    return _crypto_kdf_blake2b_contextbytes();
  }

  late final _crypto_kdf_blake2b_contextbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_blake2b_contextbytes');
  late final _crypto_kdf_blake2b_contextbytes =
      _crypto_kdf_blake2b_contextbytesPtr.asFunction<int Function()>();

  int crypto_kdf_blake2b_keybytes() {
    return _crypto_kdf_blake2b_keybytes();
  }

  late final _crypto_kdf_blake2b_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_blake2b_keybytes');
  late final _crypto_kdf_blake2b_keybytes =
      _crypto_kdf_blake2b_keybytesPtr.asFunction<int Function()>();

  int crypto_kdf_blake2b_derive_from_key(
    ffi.Pointer<ffi.UnsignedChar> subkey,
    int subkey_len,
    int subkey_id,
    ffi.Pointer<ffi.Char> ctx,
    ffi.Pointer<ffi.UnsignedChar> key,
  ) {
    return _crypto_kdf_blake2b_derive_from_key(
      subkey,
      subkey_len,
      subkey_id,
      ctx,
      key,
    );
  }

  late final _crypto_kdf_blake2b_derive_from_keyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Size,
                  ffi.Uint64,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_kdf_blake2b_derive_from_key');
  late final _crypto_kdf_blake2b_derive_from_key =
      _crypto_kdf_blake2b_derive_from_keyPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>, int, int,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kdf_bytes_min() {
    return _crypto_kdf_bytes_min();
  }

  late final _crypto_kdf_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_kdf_bytes_min');
  late final _crypto_kdf_bytes_min =
      _crypto_kdf_bytes_minPtr.asFunction<int Function()>();

  int crypto_kdf_bytes_max() {
    return _crypto_kdf_bytes_max();
  }

  late final _crypto_kdf_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_kdf_bytes_max');
  late final _crypto_kdf_bytes_max =
      _crypto_kdf_bytes_maxPtr.asFunction<int Function()>();

  int crypto_kdf_contextbytes() {
    return _crypto_kdf_contextbytes();
  }

  late final _crypto_kdf_contextbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_contextbytes');
  late final _crypto_kdf_contextbytes =
      _crypto_kdf_contextbytesPtr.asFunction<int Function()>();

  int crypto_kdf_keybytes() {
    return _crypto_kdf_keybytes();
  }

  late final _crypto_kdf_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_kdf_keybytes');
  late final _crypto_kdf_keybytes =
      _crypto_kdf_keybytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_kdf_primitive() {
    return _crypto_kdf_primitive();
  }

  late final _crypto_kdf_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_kdf_primitive');
  late final _crypto_kdf_primitive =
      _crypto_kdf_primitivePtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_kdf_derive_from_key(
    ffi.Pointer<ffi.UnsignedChar> subkey,
    int subkey_len,
    int subkey_id,
    ffi.Pointer<ffi.Char> ctx,
    ffi.Pointer<ffi.UnsignedChar> key,
  ) {
    return _crypto_kdf_derive_from_key(
      subkey,
      subkey_len,
      subkey_id,
      ctx,
      key,
    );
  }

  late final _crypto_kdf_derive_from_keyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Uint64,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_kdf_derive_from_key');
  late final _crypto_kdf_derive_from_key =
      _crypto_kdf_derive_from_keyPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>, int, int,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_kdf_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_kdf_keygen(
      k,
    );
  }

  late final _crypto_kdf_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_kdf_keygen');
  late final _crypto_kdf_keygen = _crypto_kdf_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kdf_hkdf_sha256_keybytes() {
    return _crypto_kdf_hkdf_sha256_keybytes();
  }

  late final _crypto_kdf_hkdf_sha256_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha256_keybytes');
  late final _crypto_kdf_hkdf_sha256_keybytes =
      _crypto_kdf_hkdf_sha256_keybytesPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha256_bytes_min() {
    return _crypto_kdf_hkdf_sha256_bytes_min();
  }

  late final _crypto_kdf_hkdf_sha256_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha256_bytes_min');
  late final _crypto_kdf_hkdf_sha256_bytes_min =
      _crypto_kdf_hkdf_sha256_bytes_minPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha256_bytes_max() {
    return _crypto_kdf_hkdf_sha256_bytes_max();
  }

  late final _crypto_kdf_hkdf_sha256_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha256_bytes_max');
  late final _crypto_kdf_hkdf_sha256_bytes_max =
      _crypto_kdf_hkdf_sha256_bytes_maxPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha256_extract(
    ffi.Pointer<ffi.UnsignedChar> prk,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int salt_len,
    ffi.Pointer<ffi.UnsignedChar> ikm,
    int ikm_len,
  ) {
    return _crypto_kdf_hkdf_sha256_extract(
      prk,
      salt,
      salt_len,
      ikm,
      ikm_len,
    );
  }

  late final _crypto_kdf_hkdf_sha256_extractPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_kdf_hkdf_sha256_extract');
  late final _crypto_kdf_hkdf_sha256_extract =
      _crypto_kdf_hkdf_sha256_extractPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int)>();

  void crypto_kdf_hkdf_sha256_keygen(
    ffi.Pointer<ffi.UnsignedChar> prk,
  ) {
    return _crypto_kdf_hkdf_sha256_keygen(
      prk,
    );
  }

  late final _crypto_kdf_hkdf_sha256_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_kdf_hkdf_sha256_keygen');
  late final _crypto_kdf_hkdf_sha256_keygen = _crypto_kdf_hkdf_sha256_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kdf_hkdf_sha256_expand(
    ffi.Pointer<ffi.UnsignedChar> out,
    int out_len,
    ffi.Pointer<ffi.Char> ctx,
    int ctx_len,
    ffi.Pointer<ffi.UnsignedChar> prk,
  ) {
    return _crypto_kdf_hkdf_sha256_expand(
      out,
      out_len,
      ctx,
      ctx_len,
      prk,
    );
  }

  late final _crypto_kdf_hkdf_sha256_expandPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_kdf_hkdf_sha256_expand');
  late final _crypto_kdf_hkdf_sha256_expand =
      _crypto_kdf_hkdf_sha256_expandPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>, int,
              ffi.Pointer<ffi.Char>, int, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kdf_hkdf_sha256_statebytes() {
    return _crypto_kdf_hkdf_sha256_statebytes();
  }

  late final _crypto_kdf_hkdf_sha256_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha256_statebytes');
  late final _crypto_kdf_hkdf_sha256_statebytes =
      _crypto_kdf_hkdf_sha256_statebytesPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha256_extract_init(
    ffi.Pointer<crypto_kdf_hkdf_sha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int salt_len,
  ) {
    return _crypto_kdf_hkdf_sha256_extract_init(
      state,
      salt,
      salt_len,
    );
  }

  late final _crypto_kdf_hkdf_sha256_extract_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_kdf_hkdf_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_kdf_hkdf_sha256_extract_init');
  late final _crypto_kdf_hkdf_sha256_extract_init =
      _crypto_kdf_hkdf_sha256_extract_initPtr.asFunction<
          int Function(ffi.Pointer<crypto_kdf_hkdf_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_kdf_hkdf_sha256_extract_update(
    ffi.Pointer<crypto_kdf_hkdf_sha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> ikm,
    int ikm_len,
  ) {
    return _crypto_kdf_hkdf_sha256_extract_update(
      state,
      ikm,
      ikm_len,
    );
  }

  late final _crypto_kdf_hkdf_sha256_extract_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_kdf_hkdf_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_kdf_hkdf_sha256_extract_update');
  late final _crypto_kdf_hkdf_sha256_extract_update =
      _crypto_kdf_hkdf_sha256_extract_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_kdf_hkdf_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_kdf_hkdf_sha256_extract_final(
    ffi.Pointer<crypto_kdf_hkdf_sha256_state> state,
    ffi.Pointer<ffi.UnsignedChar> prk,
  ) {
    return _crypto_kdf_hkdf_sha256_extract_final(
      state,
      prk,
    );
  }

  late final _crypto_kdf_hkdf_sha256_extract_finalPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_kdf_hkdf_sha256_state>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_kdf_hkdf_sha256_extract_final');
  late final _crypto_kdf_hkdf_sha256_extract_final =
      _crypto_kdf_hkdf_sha256_extract_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_kdf_hkdf_sha256_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kdf_hkdf_sha512_keybytes() {
    return _crypto_kdf_hkdf_sha512_keybytes();
  }

  late final _crypto_kdf_hkdf_sha512_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha512_keybytes');
  late final _crypto_kdf_hkdf_sha512_keybytes =
      _crypto_kdf_hkdf_sha512_keybytesPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha512_bytes_min() {
    return _crypto_kdf_hkdf_sha512_bytes_min();
  }

  late final _crypto_kdf_hkdf_sha512_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha512_bytes_min');
  late final _crypto_kdf_hkdf_sha512_bytes_min =
      _crypto_kdf_hkdf_sha512_bytes_minPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha512_bytes_max() {
    return _crypto_kdf_hkdf_sha512_bytes_max();
  }

  late final _crypto_kdf_hkdf_sha512_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha512_bytes_max');
  late final _crypto_kdf_hkdf_sha512_bytes_max =
      _crypto_kdf_hkdf_sha512_bytes_maxPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha512_extract(
    ffi.Pointer<ffi.UnsignedChar> prk,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int salt_len,
    ffi.Pointer<ffi.UnsignedChar> ikm,
    int ikm_len,
  ) {
    return _crypto_kdf_hkdf_sha512_extract(
      prk,
      salt,
      salt_len,
      ikm,
      ikm_len,
    );
  }

  late final _crypto_kdf_hkdf_sha512_extractPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_kdf_hkdf_sha512_extract');
  late final _crypto_kdf_hkdf_sha512_extract =
      _crypto_kdf_hkdf_sha512_extractPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int)>();

  void crypto_kdf_hkdf_sha512_keygen(
    ffi.Pointer<ffi.UnsignedChar> prk,
  ) {
    return _crypto_kdf_hkdf_sha512_keygen(
      prk,
    );
  }

  late final _crypto_kdf_hkdf_sha512_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_kdf_hkdf_sha512_keygen');
  late final _crypto_kdf_hkdf_sha512_keygen = _crypto_kdf_hkdf_sha512_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kdf_hkdf_sha512_expand(
    ffi.Pointer<ffi.UnsignedChar> out,
    int out_len,
    ffi.Pointer<ffi.Char> ctx,
    int ctx_len,
    ffi.Pointer<ffi.UnsignedChar> prk,
  ) {
    return _crypto_kdf_hkdf_sha512_expand(
      out,
      out_len,
      ctx,
      ctx_len,
      prk,
    );
  }

  late final _crypto_kdf_hkdf_sha512_expandPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_kdf_hkdf_sha512_expand');
  late final _crypto_kdf_hkdf_sha512_expand =
      _crypto_kdf_hkdf_sha512_expandPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>, int,
              ffi.Pointer<ffi.Char>, int, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kdf_hkdf_sha512_statebytes() {
    return _crypto_kdf_hkdf_sha512_statebytes();
  }

  late final _crypto_kdf_hkdf_sha512_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kdf_hkdf_sha512_statebytes');
  late final _crypto_kdf_hkdf_sha512_statebytes =
      _crypto_kdf_hkdf_sha512_statebytesPtr.asFunction<int Function()>();

  int crypto_kdf_hkdf_sha512_extract_init(
    ffi.Pointer<crypto_kdf_hkdf_sha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int salt_len,
  ) {
    return _crypto_kdf_hkdf_sha512_extract_init(
      state,
      salt,
      salt_len,
    );
  }

  late final _crypto_kdf_hkdf_sha512_extract_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_kdf_hkdf_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_kdf_hkdf_sha512_extract_init');
  late final _crypto_kdf_hkdf_sha512_extract_init =
      _crypto_kdf_hkdf_sha512_extract_initPtr.asFunction<
          int Function(ffi.Pointer<crypto_kdf_hkdf_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_kdf_hkdf_sha512_extract_update(
    ffi.Pointer<crypto_kdf_hkdf_sha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> ikm,
    int ikm_len,
  ) {
    return _crypto_kdf_hkdf_sha512_extract_update(
      state,
      ikm,
      ikm_len,
    );
  }

  late final _crypto_kdf_hkdf_sha512_extract_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_kdf_hkdf_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size)>>('crypto_kdf_hkdf_sha512_extract_update');
  late final _crypto_kdf_hkdf_sha512_extract_update =
      _crypto_kdf_hkdf_sha512_extract_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_kdf_hkdf_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_kdf_hkdf_sha512_extract_final(
    ffi.Pointer<crypto_kdf_hkdf_sha512_state> state,
    ffi.Pointer<ffi.UnsignedChar> prk,
  ) {
    return _crypto_kdf_hkdf_sha512_extract_final(
      state,
      prk,
    );
  }

  late final _crypto_kdf_hkdf_sha512_extract_finalPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_kdf_hkdf_sha512_state>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_kdf_hkdf_sha512_extract_final');
  late final _crypto_kdf_hkdf_sha512_extract_final =
      _crypto_kdf_hkdf_sha512_extract_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_kdf_hkdf_sha512_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kx_publickeybytes() {
    return _crypto_kx_publickeybytes();
  }

  late final _crypto_kx_publickeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kx_publickeybytes');
  late final _crypto_kx_publickeybytes =
      _crypto_kx_publickeybytesPtr.asFunction<int Function()>();

  int crypto_kx_secretkeybytes() {
    return _crypto_kx_secretkeybytes();
  }

  late final _crypto_kx_secretkeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kx_secretkeybytes');
  late final _crypto_kx_secretkeybytes =
      _crypto_kx_secretkeybytesPtr.asFunction<int Function()>();

  int crypto_kx_seedbytes() {
    return _crypto_kx_seedbytes();
  }

  late final _crypto_kx_seedbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_kx_seedbytes');
  late final _crypto_kx_seedbytes =
      _crypto_kx_seedbytesPtr.asFunction<int Function()>();

  int crypto_kx_sessionkeybytes() {
    return _crypto_kx_sessionkeybytes();
  }

  late final _crypto_kx_sessionkeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_kx_sessionkeybytes');
  late final _crypto_kx_sessionkeybytes =
      _crypto_kx_sessionkeybytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_kx_primitive() {
    return _crypto_kx_primitive();
  }

  late final _crypto_kx_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_kx_primitive');
  late final _crypto_kx_primitive =
      _crypto_kx_primitivePtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_kx_seed_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
    ffi.Pointer<ffi.UnsignedChar> seed,
  ) {
    return _crypto_kx_seed_keypair(
      pk,
      sk,
      seed,
    );
  }

  late final _crypto_kx_seed_keypairPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_kx_seed_keypair');
  late final _crypto_kx_seed_keypair = _crypto_kx_seed_keypairPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kx_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_kx_keypair(
      pk,
      sk,
    );
  }

  late final _crypto_kx_keypairPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_kx_keypair');
  late final _crypto_kx_keypair = _crypto_kx_keypairPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kx_client_session_keys(
    ffi.Pointer<ffi.UnsignedChar> rx,
    ffi.Pointer<ffi.UnsignedChar> tx,
    ffi.Pointer<ffi.UnsignedChar> client_pk,
    ffi.Pointer<ffi.UnsignedChar> client_sk,
    ffi.Pointer<ffi.UnsignedChar> server_pk,
  ) {
    return _crypto_kx_client_session_keys(
      rx,
      tx,
      client_pk,
      client_sk,
      server_pk,
    );
  }

  late final _crypto_kx_client_session_keysPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_kx_client_session_keys');
  late final _crypto_kx_client_session_keys =
      _crypto_kx_client_session_keysPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_kx_server_session_keys(
    ffi.Pointer<ffi.UnsignedChar> rx,
    ffi.Pointer<ffi.UnsignedChar> tx,
    ffi.Pointer<ffi.UnsignedChar> server_pk,
    ffi.Pointer<ffi.UnsignedChar> server_sk,
    ffi.Pointer<ffi.UnsignedChar> client_pk,
  ) {
    return _crypto_kx_server_session_keys(
      rx,
      tx,
      server_pk,
      server_sk,
      client_pk,
    );
  }

  late final _crypto_kx_server_session_keysPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_kx_server_session_keys');
  late final _crypto_kx_server_session_keys =
      _crypto_kx_server_session_keysPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_poly1305_statebytes() {
    return _crypto_onetimeauth_poly1305_statebytes();
  }

  late final _crypto_onetimeauth_poly1305_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_onetimeauth_poly1305_statebytes');
  late final _crypto_onetimeauth_poly1305_statebytes =
      _crypto_onetimeauth_poly1305_statebytesPtr.asFunction<int Function()>();

  int crypto_onetimeauth_poly1305_bytes() {
    return _crypto_onetimeauth_poly1305_bytes();
  }

  late final _crypto_onetimeauth_poly1305_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_onetimeauth_poly1305_bytes');
  late final _crypto_onetimeauth_poly1305_bytes =
      _crypto_onetimeauth_poly1305_bytesPtr.asFunction<int Function()>();

  int crypto_onetimeauth_poly1305_keybytes() {
    return _crypto_onetimeauth_poly1305_keybytes();
  }

  late final _crypto_onetimeauth_poly1305_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_onetimeauth_poly1305_keybytes');
  late final _crypto_onetimeauth_poly1305_keybytes =
      _crypto_onetimeauth_poly1305_keybytesPtr.asFunction<int Function()>();

  int crypto_onetimeauth_poly1305(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_onetimeauth_poly1305(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_onetimeauth_poly1305Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_onetimeauth_poly1305');
  late final _crypto_onetimeauth_poly1305 =
      _crypto_onetimeauth_poly1305Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_poly1305_verify(
    ffi.Pointer<ffi.UnsignedChar> h,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_onetimeauth_poly1305_verify(
      h,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_onetimeauth_poly1305_verifyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_onetimeauth_poly1305_verify');
  late final _crypto_onetimeauth_poly1305_verify =
      _crypto_onetimeauth_poly1305_verifyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_poly1305_init(
    ffi.Pointer<crypto_onetimeauth_poly1305_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
  ) {
    return _crypto_onetimeauth_poly1305_init(
      state,
      key,
    );
  }

  late final _crypto_onetimeauth_poly1305_initPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_onetimeauth_poly1305_state>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_onetimeauth_poly1305_init');
  late final _crypto_onetimeauth_poly1305_init =
      _crypto_onetimeauth_poly1305_initPtr.asFunction<
          int Function(ffi.Pointer<crypto_onetimeauth_poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_poly1305_update(
    ffi.Pointer<crypto_onetimeauth_poly1305_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_onetimeauth_poly1305_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_onetimeauth_poly1305_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_onetimeauth_poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_onetimeauth_poly1305_update');
  late final _crypto_onetimeauth_poly1305_update =
      _crypto_onetimeauth_poly1305_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_onetimeauth_poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_onetimeauth_poly1305_final(
    ffi.Pointer<crypto_onetimeauth_poly1305_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
  ) {
    return _crypto_onetimeauth_poly1305_final(
      state,
      out,
    );
  }

  late final _crypto_onetimeauth_poly1305_finalPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_onetimeauth_poly1305_state>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_onetimeauth_poly1305_final');
  late final _crypto_onetimeauth_poly1305_final =
      _crypto_onetimeauth_poly1305_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_onetimeauth_poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_onetimeauth_poly1305_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_onetimeauth_poly1305_keygen(
      k,
    );
  }

  late final _crypto_onetimeauth_poly1305_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_onetimeauth_poly1305_keygen');
  late final _crypto_onetimeauth_poly1305_keygen =
      _crypto_onetimeauth_poly1305_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_statebytes() {
    return _crypto_onetimeauth_statebytes();
  }

  late final _crypto_onetimeauth_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_onetimeauth_statebytes');
  late final _crypto_onetimeauth_statebytes =
      _crypto_onetimeauth_statebytesPtr.asFunction<int Function()>();

  int crypto_onetimeauth_bytes() {
    return _crypto_onetimeauth_bytes();
  }

  late final _crypto_onetimeauth_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_onetimeauth_bytes');
  late final _crypto_onetimeauth_bytes =
      _crypto_onetimeauth_bytesPtr.asFunction<int Function()>();

  int crypto_onetimeauth_keybytes() {
    return _crypto_onetimeauth_keybytes();
  }

  late final _crypto_onetimeauth_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_onetimeauth_keybytes');
  late final _crypto_onetimeauth_keybytes =
      _crypto_onetimeauth_keybytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_onetimeauth_primitive() {
    return _crypto_onetimeauth_primitive();
  }

  late final _crypto_onetimeauth_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_onetimeauth_primitive');
  late final _crypto_onetimeauth_primitive = _crypto_onetimeauth_primitivePtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_onetimeauth(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_onetimeauth(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_onetimeauthPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_onetimeauth');
  late final _crypto_onetimeauth = _crypto_onetimeauthPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_verify(
    ffi.Pointer<ffi.UnsignedChar> h,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_onetimeauth_verify(
      h,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_onetimeauth_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_onetimeauth_verify');
  late final _crypto_onetimeauth_verify =
      _crypto_onetimeauth_verifyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_init(
    ffi.Pointer<crypto_onetimeauth_state> state,
    ffi.Pointer<ffi.UnsignedChar> key,
  ) {
    return _crypto_onetimeauth_init(
      state,
      key,
    );
  }

  late final _crypto_onetimeauth_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<crypto_onetimeauth_state>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_onetimeauth_init');
  late final _crypto_onetimeauth_init = _crypto_onetimeauth_initPtr.asFunction<
      int Function(ffi.Pointer<crypto_onetimeauth_state>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_onetimeauth_update(
    ffi.Pointer<crypto_onetimeauth_state> state,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
  ) {
    return _crypto_onetimeauth_update(
      state,
      in1,
      inlen,
    );
  }

  late final _crypto_onetimeauth_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_onetimeauth_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_onetimeauth_update');
  late final _crypto_onetimeauth_update =
      _crypto_onetimeauth_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_onetimeauth_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_onetimeauth_final(
    ffi.Pointer<crypto_onetimeauth_state> state,
    ffi.Pointer<ffi.UnsignedChar> out,
  ) {
    return _crypto_onetimeauth_final(
      state,
      out,
    );
  }

  late final _crypto_onetimeauth_finalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<crypto_onetimeauth_state>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_onetimeauth_final');
  late final _crypto_onetimeauth_final =
      _crypto_onetimeauth_finalPtr.asFunction<
          int Function(ffi.Pointer<crypto_onetimeauth_state>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_onetimeauth_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_onetimeauth_keygen(
      k,
    );
  }

  late final _crypto_onetimeauth_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_onetimeauth_keygen');
  late final _crypto_onetimeauth_keygen = _crypto_onetimeauth_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_pwhash_argon2i_alg_argon2i13() {
    return _crypto_pwhash_argon2i_alg_argon2i13();
  }

  late final _crypto_pwhash_argon2i_alg_argon2i13Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'crypto_pwhash_argon2i_alg_argon2i13');
  late final _crypto_pwhash_argon2i_alg_argon2i13 =
      _crypto_pwhash_argon2i_alg_argon2i13Ptr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_bytes_min() {
    return _crypto_pwhash_argon2i_bytes_min();
  }

  late final _crypto_pwhash_argon2i_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_bytes_min');
  late final _crypto_pwhash_argon2i_bytes_min =
      _crypto_pwhash_argon2i_bytes_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_bytes_max() {
    return _crypto_pwhash_argon2i_bytes_max();
  }

  late final _crypto_pwhash_argon2i_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_bytes_max');
  late final _crypto_pwhash_argon2i_bytes_max =
      _crypto_pwhash_argon2i_bytes_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_passwd_min() {
    return _crypto_pwhash_argon2i_passwd_min();
  }

  late final _crypto_pwhash_argon2i_passwd_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_passwd_min');
  late final _crypto_pwhash_argon2i_passwd_min =
      _crypto_pwhash_argon2i_passwd_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_passwd_max() {
    return _crypto_pwhash_argon2i_passwd_max();
  }

  late final _crypto_pwhash_argon2i_passwd_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_passwd_max');
  late final _crypto_pwhash_argon2i_passwd_max =
      _crypto_pwhash_argon2i_passwd_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_saltbytes() {
    return _crypto_pwhash_argon2i_saltbytes();
  }

  late final _crypto_pwhash_argon2i_saltbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_saltbytes');
  late final _crypto_pwhash_argon2i_saltbytes =
      _crypto_pwhash_argon2i_saltbytesPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_strbytes() {
    return _crypto_pwhash_argon2i_strbytes();
  }

  late final _crypto_pwhash_argon2i_strbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_strbytes');
  late final _crypto_pwhash_argon2i_strbytes =
      _crypto_pwhash_argon2i_strbytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_pwhash_argon2i_strprefix() {
    return _crypto_pwhash_argon2i_strprefix();
  }

  late final _crypto_pwhash_argon2i_strprefixPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_pwhash_argon2i_strprefix');
  late final _crypto_pwhash_argon2i_strprefix =
      _crypto_pwhash_argon2i_strprefixPtr
          .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_pwhash_argon2i_opslimit_min() {
    return _crypto_pwhash_argon2i_opslimit_min();
  }

  late final _crypto_pwhash_argon2i_opslimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_opslimit_min');
  late final _crypto_pwhash_argon2i_opslimit_min =
      _crypto_pwhash_argon2i_opslimit_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_opslimit_max() {
    return _crypto_pwhash_argon2i_opslimit_max();
  }

  late final _crypto_pwhash_argon2i_opslimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_opslimit_max');
  late final _crypto_pwhash_argon2i_opslimit_max =
      _crypto_pwhash_argon2i_opslimit_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_memlimit_min() {
    return _crypto_pwhash_argon2i_memlimit_min();
  }

  late final _crypto_pwhash_argon2i_memlimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_memlimit_min');
  late final _crypto_pwhash_argon2i_memlimit_min =
      _crypto_pwhash_argon2i_memlimit_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_memlimit_max() {
    return _crypto_pwhash_argon2i_memlimit_max();
  }

  late final _crypto_pwhash_argon2i_memlimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_memlimit_max');
  late final _crypto_pwhash_argon2i_memlimit_max =
      _crypto_pwhash_argon2i_memlimit_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_opslimit_interactive() {
    return _crypto_pwhash_argon2i_opslimit_interactive();
  }

  late final _crypto_pwhash_argon2i_opslimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_opslimit_interactive');
  late final _crypto_pwhash_argon2i_opslimit_interactive =
      _crypto_pwhash_argon2i_opslimit_interactivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_argon2i_memlimit_interactive() {
    return _crypto_pwhash_argon2i_memlimit_interactive();
  }

  late final _crypto_pwhash_argon2i_memlimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_memlimit_interactive');
  late final _crypto_pwhash_argon2i_memlimit_interactive =
      _crypto_pwhash_argon2i_memlimit_interactivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_argon2i_opslimit_moderate() {
    return _crypto_pwhash_argon2i_opslimit_moderate();
  }

  late final _crypto_pwhash_argon2i_opslimit_moderatePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_opslimit_moderate');
  late final _crypto_pwhash_argon2i_opslimit_moderate =
      _crypto_pwhash_argon2i_opslimit_moderatePtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_memlimit_moderate() {
    return _crypto_pwhash_argon2i_memlimit_moderate();
  }

  late final _crypto_pwhash_argon2i_memlimit_moderatePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_memlimit_moderate');
  late final _crypto_pwhash_argon2i_memlimit_moderate =
      _crypto_pwhash_argon2i_memlimit_moderatePtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_opslimit_sensitive() {
    return _crypto_pwhash_argon2i_opslimit_sensitive();
  }

  late final _crypto_pwhash_argon2i_opslimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_opslimit_sensitive');
  late final _crypto_pwhash_argon2i_opslimit_sensitive =
      _crypto_pwhash_argon2i_opslimit_sensitivePtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i_memlimit_sensitive() {
    return _crypto_pwhash_argon2i_memlimit_sensitive();
  }

  late final _crypto_pwhash_argon2i_memlimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2i_memlimit_sensitive');
  late final _crypto_pwhash_argon2i_memlimit_sensitive =
      _crypto_pwhash_argon2i_memlimit_sensitivePtr.asFunction<int Function()>();

  int crypto_pwhash_argon2i(
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int opslimit,
    int memlimit,
    int alg,
  ) {
    return _crypto_pwhash_argon2i(
      out,
      outlen,
      passwd,
      passwdlen,
      salt,
      opslimit,
      memlimit,
      alg,
    );
  }

  late final _crypto_pwhash_argon2iPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Size,
              ffi.Int)>>('crypto_pwhash_argon2i');
  late final _crypto_pwhash_argon2i = _crypto_pwhash_argon2iPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int, ffi.Pointer<ffi.Char>,
          int, ffi.Pointer<ffi.UnsignedChar>, int, int, int)>();

  int crypto_pwhash_argon2i_str(
    ffi.Pointer<ffi.Char> out,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_argon2i_str(
      out,
      passwd,
      passwdlen,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_argon2i_strPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_argon2i_str');
  late final _crypto_pwhash_argon2i_str =
      _crypto_pwhash_argon2i_strPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int, int, int)>();

  int crypto_pwhash_argon2i_str_verify(
    ffi.Pointer<ffi.Char> str,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
  ) {
    return _crypto_pwhash_argon2i_str_verify(
      str,
      passwd,
      passwdlen,
    );
  }

  late final _crypto_pwhash_argon2i_str_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong)>>('crypto_pwhash_argon2i_str_verify');
  late final _crypto_pwhash_argon2i_str_verify =
      _crypto_pwhash_argon2i_str_verifyPtr.asFunction<
          int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();

  int crypto_pwhash_argon2i_str_needs_rehash(
    ffi.Pointer<ffi.Char> str,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_argon2i_str_needs_rehash(
      str,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_argon2i_str_needs_rehashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Char>, ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_argon2i_str_needs_rehash');
  late final _crypto_pwhash_argon2i_str_needs_rehash =
      _crypto_pwhash_argon2i_str_needs_rehashPtr
          .asFunction<int Function(ffi.Pointer<ffi.Char>, int, int)>();

  int crypto_pwhash_argon2id_alg_argon2id13() {
    return _crypto_pwhash_argon2id_alg_argon2id13();
  }

  late final _crypto_pwhash_argon2id_alg_argon2id13Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'crypto_pwhash_argon2id_alg_argon2id13');
  late final _crypto_pwhash_argon2id_alg_argon2id13 =
      _crypto_pwhash_argon2id_alg_argon2id13Ptr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_bytes_min() {
    return _crypto_pwhash_argon2id_bytes_min();
  }

  late final _crypto_pwhash_argon2id_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_bytes_min');
  late final _crypto_pwhash_argon2id_bytes_min =
      _crypto_pwhash_argon2id_bytes_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_bytes_max() {
    return _crypto_pwhash_argon2id_bytes_max();
  }

  late final _crypto_pwhash_argon2id_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_bytes_max');
  late final _crypto_pwhash_argon2id_bytes_max =
      _crypto_pwhash_argon2id_bytes_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_passwd_min() {
    return _crypto_pwhash_argon2id_passwd_min();
  }

  late final _crypto_pwhash_argon2id_passwd_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_passwd_min');
  late final _crypto_pwhash_argon2id_passwd_min =
      _crypto_pwhash_argon2id_passwd_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_passwd_max() {
    return _crypto_pwhash_argon2id_passwd_max();
  }

  late final _crypto_pwhash_argon2id_passwd_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_passwd_max');
  late final _crypto_pwhash_argon2id_passwd_max =
      _crypto_pwhash_argon2id_passwd_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_saltbytes() {
    return _crypto_pwhash_argon2id_saltbytes();
  }

  late final _crypto_pwhash_argon2id_saltbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_saltbytes');
  late final _crypto_pwhash_argon2id_saltbytes =
      _crypto_pwhash_argon2id_saltbytesPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_strbytes() {
    return _crypto_pwhash_argon2id_strbytes();
  }

  late final _crypto_pwhash_argon2id_strbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_strbytes');
  late final _crypto_pwhash_argon2id_strbytes =
      _crypto_pwhash_argon2id_strbytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_pwhash_argon2id_strprefix() {
    return _crypto_pwhash_argon2id_strprefix();
  }

  late final _crypto_pwhash_argon2id_strprefixPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_pwhash_argon2id_strprefix');
  late final _crypto_pwhash_argon2id_strprefix =
      _crypto_pwhash_argon2id_strprefixPtr
          .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_pwhash_argon2id_opslimit_min() {
    return _crypto_pwhash_argon2id_opslimit_min();
  }

  late final _crypto_pwhash_argon2id_opslimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_opslimit_min');
  late final _crypto_pwhash_argon2id_opslimit_min =
      _crypto_pwhash_argon2id_opslimit_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_opslimit_max() {
    return _crypto_pwhash_argon2id_opslimit_max();
  }

  late final _crypto_pwhash_argon2id_opslimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_opslimit_max');
  late final _crypto_pwhash_argon2id_opslimit_max =
      _crypto_pwhash_argon2id_opslimit_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_memlimit_min() {
    return _crypto_pwhash_argon2id_memlimit_min();
  }

  late final _crypto_pwhash_argon2id_memlimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_memlimit_min');
  late final _crypto_pwhash_argon2id_memlimit_min =
      _crypto_pwhash_argon2id_memlimit_minPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_memlimit_max() {
    return _crypto_pwhash_argon2id_memlimit_max();
  }

  late final _crypto_pwhash_argon2id_memlimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_memlimit_max');
  late final _crypto_pwhash_argon2id_memlimit_max =
      _crypto_pwhash_argon2id_memlimit_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_opslimit_interactive() {
    return _crypto_pwhash_argon2id_opslimit_interactive();
  }

  late final _crypto_pwhash_argon2id_opslimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_opslimit_interactive');
  late final _crypto_pwhash_argon2id_opslimit_interactive =
      _crypto_pwhash_argon2id_opslimit_interactivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_argon2id_memlimit_interactive() {
    return _crypto_pwhash_argon2id_memlimit_interactive();
  }

  late final _crypto_pwhash_argon2id_memlimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_memlimit_interactive');
  late final _crypto_pwhash_argon2id_memlimit_interactive =
      _crypto_pwhash_argon2id_memlimit_interactivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_argon2id_opslimit_moderate() {
    return _crypto_pwhash_argon2id_opslimit_moderate();
  }

  late final _crypto_pwhash_argon2id_opslimit_moderatePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_opslimit_moderate');
  late final _crypto_pwhash_argon2id_opslimit_moderate =
      _crypto_pwhash_argon2id_opslimit_moderatePtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_memlimit_moderate() {
    return _crypto_pwhash_argon2id_memlimit_moderate();
  }

  late final _crypto_pwhash_argon2id_memlimit_moderatePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_memlimit_moderate');
  late final _crypto_pwhash_argon2id_memlimit_moderate =
      _crypto_pwhash_argon2id_memlimit_moderatePtr.asFunction<int Function()>();

  int crypto_pwhash_argon2id_opslimit_sensitive() {
    return _crypto_pwhash_argon2id_opslimit_sensitive();
  }

  late final _crypto_pwhash_argon2id_opslimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_opslimit_sensitive');
  late final _crypto_pwhash_argon2id_opslimit_sensitive =
      _crypto_pwhash_argon2id_opslimit_sensitivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_argon2id_memlimit_sensitive() {
    return _crypto_pwhash_argon2id_memlimit_sensitive();
  }

  late final _crypto_pwhash_argon2id_memlimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_argon2id_memlimit_sensitive');
  late final _crypto_pwhash_argon2id_memlimit_sensitive =
      _crypto_pwhash_argon2id_memlimit_sensitivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_argon2id(
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int opslimit,
    int memlimit,
    int alg,
  ) {
    return _crypto_pwhash_argon2id(
      out,
      outlen,
      passwd,
      passwdlen,
      salt,
      opslimit,
      memlimit,
      alg,
    );
  }

  late final _crypto_pwhash_argon2idPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Size,
              ffi.Int)>>('crypto_pwhash_argon2id');
  late final _crypto_pwhash_argon2id = _crypto_pwhash_argon2idPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int, ffi.Pointer<ffi.Char>,
          int, ffi.Pointer<ffi.UnsignedChar>, int, int, int)>();

  int crypto_pwhash_argon2id_str(
    ffi.Pointer<ffi.Char> out,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_argon2id_str(
      out,
      passwd,
      passwdlen,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_argon2id_strPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_argon2id_str');
  late final _crypto_pwhash_argon2id_str =
      _crypto_pwhash_argon2id_strPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int, int, int)>();

  int crypto_pwhash_argon2id_str_verify(
    ffi.Pointer<ffi.Char> str,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
  ) {
    return _crypto_pwhash_argon2id_str_verify(
      str,
      passwd,
      passwdlen,
    );
  }

  late final _crypto_pwhash_argon2id_str_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong)>>('crypto_pwhash_argon2id_str_verify');
  late final _crypto_pwhash_argon2id_str_verify =
      _crypto_pwhash_argon2id_str_verifyPtr.asFunction<
          int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();

  int crypto_pwhash_argon2id_str_needs_rehash(
    ffi.Pointer<ffi.Char> str,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_argon2id_str_needs_rehash(
      str,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_argon2id_str_needs_rehashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Char>, ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_argon2id_str_needs_rehash');
  late final _crypto_pwhash_argon2id_str_needs_rehash =
      _crypto_pwhash_argon2id_str_needs_rehashPtr
          .asFunction<int Function(ffi.Pointer<ffi.Char>, int, int)>();

  int crypto_pwhash_alg_argon2i13() {
    return _crypto_pwhash_alg_argon2i13();
  }

  late final _crypto_pwhash_alg_argon2i13Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'crypto_pwhash_alg_argon2i13');
  late final _crypto_pwhash_alg_argon2i13 =
      _crypto_pwhash_alg_argon2i13Ptr.asFunction<int Function()>();

  int crypto_pwhash_alg_argon2id13() {
    return _crypto_pwhash_alg_argon2id13();
  }

  late final _crypto_pwhash_alg_argon2id13Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'crypto_pwhash_alg_argon2id13');
  late final _crypto_pwhash_alg_argon2id13 =
      _crypto_pwhash_alg_argon2id13Ptr.asFunction<int Function()>();

  int crypto_pwhash_alg_default() {
    return _crypto_pwhash_alg_default();
  }

  late final _crypto_pwhash_alg_defaultPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'crypto_pwhash_alg_default');
  late final _crypto_pwhash_alg_default =
      _crypto_pwhash_alg_defaultPtr.asFunction<int Function()>();

  int crypto_pwhash_bytes_min() {
    return _crypto_pwhash_bytes_min();
  }

  late final _crypto_pwhash_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_bytes_min');
  late final _crypto_pwhash_bytes_min =
      _crypto_pwhash_bytes_minPtr.asFunction<int Function()>();

  int crypto_pwhash_bytes_max() {
    return _crypto_pwhash_bytes_max();
  }

  late final _crypto_pwhash_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_bytes_max');
  late final _crypto_pwhash_bytes_max =
      _crypto_pwhash_bytes_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_passwd_min() {
    return _crypto_pwhash_passwd_min();
  }

  late final _crypto_pwhash_passwd_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_passwd_min');
  late final _crypto_pwhash_passwd_min =
      _crypto_pwhash_passwd_minPtr.asFunction<int Function()>();

  int crypto_pwhash_passwd_max() {
    return _crypto_pwhash_passwd_max();
  }

  late final _crypto_pwhash_passwd_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_passwd_max');
  late final _crypto_pwhash_passwd_max =
      _crypto_pwhash_passwd_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_saltbytes() {
    return _crypto_pwhash_saltbytes();
  }

  late final _crypto_pwhash_saltbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_saltbytes');
  late final _crypto_pwhash_saltbytes =
      _crypto_pwhash_saltbytesPtr.asFunction<int Function()>();

  int crypto_pwhash_strbytes() {
    return _crypto_pwhash_strbytes();
  }

  late final _crypto_pwhash_strbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_strbytes');
  late final _crypto_pwhash_strbytes =
      _crypto_pwhash_strbytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_pwhash_strprefix() {
    return _crypto_pwhash_strprefix();
  }

  late final _crypto_pwhash_strprefixPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_pwhash_strprefix');
  late final _crypto_pwhash_strprefix = _crypto_pwhash_strprefixPtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_pwhash_opslimit_min() {
    return _crypto_pwhash_opslimit_min();
  }

  late final _crypto_pwhash_opslimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_opslimit_min');
  late final _crypto_pwhash_opslimit_min =
      _crypto_pwhash_opslimit_minPtr.asFunction<int Function()>();

  int crypto_pwhash_opslimit_max() {
    return _crypto_pwhash_opslimit_max();
  }

  late final _crypto_pwhash_opslimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_opslimit_max');
  late final _crypto_pwhash_opslimit_max =
      _crypto_pwhash_opslimit_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_memlimit_min() {
    return _crypto_pwhash_memlimit_min();
  }

  late final _crypto_pwhash_memlimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_memlimit_min');
  late final _crypto_pwhash_memlimit_min =
      _crypto_pwhash_memlimit_minPtr.asFunction<int Function()>();

  int crypto_pwhash_memlimit_max() {
    return _crypto_pwhash_memlimit_max();
  }

  late final _crypto_pwhash_memlimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_memlimit_max');
  late final _crypto_pwhash_memlimit_max =
      _crypto_pwhash_memlimit_maxPtr.asFunction<int Function()>();

  int crypto_pwhash_opslimit_interactive() {
    return _crypto_pwhash_opslimit_interactive();
  }

  late final _crypto_pwhash_opslimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_opslimit_interactive');
  late final _crypto_pwhash_opslimit_interactive =
      _crypto_pwhash_opslimit_interactivePtr.asFunction<int Function()>();

  int crypto_pwhash_memlimit_interactive() {
    return _crypto_pwhash_memlimit_interactive();
  }

  late final _crypto_pwhash_memlimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_memlimit_interactive');
  late final _crypto_pwhash_memlimit_interactive =
      _crypto_pwhash_memlimit_interactivePtr.asFunction<int Function()>();

  int crypto_pwhash_opslimit_moderate() {
    return _crypto_pwhash_opslimit_moderate();
  }

  late final _crypto_pwhash_opslimit_moderatePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_opslimit_moderate');
  late final _crypto_pwhash_opslimit_moderate =
      _crypto_pwhash_opslimit_moderatePtr.asFunction<int Function()>();

  int crypto_pwhash_memlimit_moderate() {
    return _crypto_pwhash_memlimit_moderate();
  }

  late final _crypto_pwhash_memlimit_moderatePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_memlimit_moderate');
  late final _crypto_pwhash_memlimit_moderate =
      _crypto_pwhash_memlimit_moderatePtr.asFunction<int Function()>();

  int crypto_pwhash_opslimit_sensitive() {
    return _crypto_pwhash_opslimit_sensitive();
  }

  late final _crypto_pwhash_opslimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_opslimit_sensitive');
  late final _crypto_pwhash_opslimit_sensitive =
      _crypto_pwhash_opslimit_sensitivePtr.asFunction<int Function()>();

  int crypto_pwhash_memlimit_sensitive() {
    return _crypto_pwhash_memlimit_sensitive();
  }

  late final _crypto_pwhash_memlimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_memlimit_sensitive');
  late final _crypto_pwhash_memlimit_sensitive =
      _crypto_pwhash_memlimit_sensitivePtr.asFunction<int Function()>();

  int crypto_pwhash(
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int opslimit,
    int memlimit,
    int alg,
  ) {
    return _crypto_pwhash(
      out,
      outlen,
      passwd,
      passwdlen,
      salt,
      opslimit,
      memlimit,
      alg,
    );
  }

  late final _crypto_pwhashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Size,
              ffi.Int)>>('crypto_pwhash');
  late final _crypto_pwhash = _crypto_pwhashPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int, ffi.Pointer<ffi.Char>,
          int, ffi.Pointer<ffi.UnsignedChar>, int, int, int)>();

  int crypto_pwhash_str(
    ffi.Pointer<ffi.Char> out,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_str(
      out,
      passwd,
      passwdlen,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_strPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_str');
  late final _crypto_pwhash_str = _crypto_pwhash_strPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int, int, int)>();

  int crypto_pwhash_str_alg(
    ffi.Pointer<ffi.Char> out,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    int opslimit,
    int memlimit,
    int alg,
  ) {
    return _crypto_pwhash_str_alg(
      out,
      passwd,
      passwdlen,
      opslimit,
      memlimit,
      alg,
    );
  }

  late final _crypto_pwhash_str_algPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.UnsignedLongLong,
              ffi.Size,
              ffi.Int)>>('crypto_pwhash_str_alg');
  late final _crypto_pwhash_str_alg = _crypto_pwhash_str_algPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int, int, int, int)>();

  int crypto_pwhash_str_verify(
    ffi.Pointer<ffi.Char> str,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
  ) {
    return _crypto_pwhash_str_verify(
      str,
      passwd,
      passwdlen,
    );
  }

  late final _crypto_pwhash_str_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong)>>('crypto_pwhash_str_verify');
  late final _crypto_pwhash_str_verify =
      _crypto_pwhash_str_verifyPtr.asFunction<
          int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();

  int crypto_pwhash_str_needs_rehash(
    ffi.Pointer<ffi.Char> str,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_str_needs_rehash(
      str,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_str_needs_rehashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Char>, ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_str_needs_rehash');
  late final _crypto_pwhash_str_needs_rehash =
      _crypto_pwhash_str_needs_rehashPtr
          .asFunction<int Function(ffi.Pointer<ffi.Char>, int, int)>();

  ffi.Pointer<ffi.Char> crypto_pwhash_primitive() {
    return _crypto_pwhash_primitive();
  }

  late final _crypto_pwhash_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_pwhash_primitive');
  late final _crypto_pwhash_primitive = _crypto_pwhash_primitivePtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_scalarmult_curve25519_bytes() {
    return _crypto_scalarmult_curve25519_bytes();
  }

  late final _crypto_scalarmult_curve25519_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_curve25519_bytes');
  late final _crypto_scalarmult_curve25519_bytes =
      _crypto_scalarmult_curve25519_bytesPtr.asFunction<int Function()>();

  int crypto_scalarmult_curve25519_scalarbytes() {
    return _crypto_scalarmult_curve25519_scalarbytes();
  }

  late final _crypto_scalarmult_curve25519_scalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_curve25519_scalarbytes');
  late final _crypto_scalarmult_curve25519_scalarbytes =
      _crypto_scalarmult_curve25519_scalarbytesPtr.asFunction<int Function()>();

  int crypto_scalarmult_curve25519(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_scalarmult_curve25519(
      q,
      n,
      p,
    );
  }

  late final _crypto_scalarmult_curve25519Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_scalarmult_curve25519');
  late final _crypto_scalarmult_curve25519 =
      _crypto_scalarmult_curve25519Ptr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult_curve25519_base(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
  ) {
    return _crypto_scalarmult_curve25519_base(
      q,
      n,
    );
  }

  late final _crypto_scalarmult_curve25519_basePtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_scalarmult_curve25519_base');
  late final _crypto_scalarmult_curve25519_base =
      _crypto_scalarmult_curve25519_basePtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult_bytes() {
    return _crypto_scalarmult_bytes();
  }

  late final _crypto_scalarmult_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_bytes');
  late final _crypto_scalarmult_bytes =
      _crypto_scalarmult_bytesPtr.asFunction<int Function()>();

  int crypto_scalarmult_scalarbytes() {
    return _crypto_scalarmult_scalarbytes();
  }

  late final _crypto_scalarmult_scalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_scalarbytes');
  late final _crypto_scalarmult_scalarbytes =
      _crypto_scalarmult_scalarbytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_scalarmult_primitive() {
    return _crypto_scalarmult_primitive();
  }

  late final _crypto_scalarmult_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_scalarmult_primitive');
  late final _crypto_scalarmult_primitive = _crypto_scalarmult_primitivePtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_scalarmult_base(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
  ) {
    return _crypto_scalarmult_base(
      q,
      n,
    );
  }

  late final _crypto_scalarmult_basePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_scalarmult_base');
  late final _crypto_scalarmult_base = _crypto_scalarmult_basePtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_scalarmult(
      q,
      n,
      p,
    );
  }

  late final _crypto_scalarmultPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_scalarmult');
  late final _crypto_scalarmult = _crypto_scalarmultPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_xsalsa20poly1305_keybytes() {
    return _crypto_secretbox_xsalsa20poly1305_keybytes();
  }

  late final _crypto_secretbox_xsalsa20poly1305_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xsalsa20poly1305_keybytes');
  late final _crypto_secretbox_xsalsa20poly1305_keybytes =
      _crypto_secretbox_xsalsa20poly1305_keybytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xsalsa20poly1305_noncebytes() {
    return _crypto_secretbox_xsalsa20poly1305_noncebytes();
  }

  late final _crypto_secretbox_xsalsa20poly1305_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xsalsa20poly1305_noncebytes');
  late final _crypto_secretbox_xsalsa20poly1305_noncebytes =
      _crypto_secretbox_xsalsa20poly1305_noncebytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xsalsa20poly1305_macbytes() {
    return _crypto_secretbox_xsalsa20poly1305_macbytes();
  }

  late final _crypto_secretbox_xsalsa20poly1305_macbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xsalsa20poly1305_macbytes');
  late final _crypto_secretbox_xsalsa20poly1305_macbytes =
      _crypto_secretbox_xsalsa20poly1305_macbytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xsalsa20poly1305_messagebytes_max() {
    return _crypto_secretbox_xsalsa20poly1305_messagebytes_max();
  }

  late final _crypto_secretbox_xsalsa20poly1305_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xsalsa20poly1305_messagebytes_max');
  late final _crypto_secretbox_xsalsa20poly1305_messagebytes_max =
      _crypto_secretbox_xsalsa20poly1305_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xsalsa20poly1305(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_xsalsa20poly1305(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_xsalsa20poly1305Ptr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_xsalsa20poly1305');
  late final _crypto_secretbox_xsalsa20poly1305 =
      _crypto_secretbox_xsalsa20poly1305Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_xsalsa20poly1305_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_xsalsa20poly1305_open(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_xsalsa20poly1305_openPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_xsalsa20poly1305_open');
  late final _crypto_secretbox_xsalsa20poly1305_open =
      _crypto_secretbox_xsalsa20poly1305_openPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_secretbox_xsalsa20poly1305_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_xsalsa20poly1305_keygen(
      k,
    );
  }

  late final _crypto_secretbox_xsalsa20poly1305_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_xsalsa20poly1305_keygen');
  late final _crypto_secretbox_xsalsa20poly1305_keygen =
      _crypto_secretbox_xsalsa20poly1305_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_xsalsa20poly1305_boxzerobytes() {
    return _crypto_secretbox_xsalsa20poly1305_boxzerobytes();
  }

  late final _crypto_secretbox_xsalsa20poly1305_boxzerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xsalsa20poly1305_boxzerobytes');
  late final _crypto_secretbox_xsalsa20poly1305_boxzerobytes =
      _crypto_secretbox_xsalsa20poly1305_boxzerobytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xsalsa20poly1305_zerobytes() {
    return _crypto_secretbox_xsalsa20poly1305_zerobytes();
  }

  late final _crypto_secretbox_xsalsa20poly1305_zerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xsalsa20poly1305_zerobytes');
  late final _crypto_secretbox_xsalsa20poly1305_zerobytes =
      _crypto_secretbox_xsalsa20poly1305_zerobytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_keybytes() {
    return _crypto_secretbox_keybytes();
  }

  late final _crypto_secretbox_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_keybytes');
  late final _crypto_secretbox_keybytes =
      _crypto_secretbox_keybytesPtr.asFunction<int Function()>();

  int crypto_secretbox_noncebytes() {
    return _crypto_secretbox_noncebytes();
  }

  late final _crypto_secretbox_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_noncebytes');
  late final _crypto_secretbox_noncebytes =
      _crypto_secretbox_noncebytesPtr.asFunction<int Function()>();

  int crypto_secretbox_macbytes() {
    return _crypto_secretbox_macbytes();
  }

  late final _crypto_secretbox_macbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_macbytes');
  late final _crypto_secretbox_macbytes =
      _crypto_secretbox_macbytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_secretbox_primitive() {
    return _crypto_secretbox_primitive();
  }

  late final _crypto_secretbox_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_secretbox_primitive');
  late final _crypto_secretbox_primitive = _crypto_secretbox_primitivePtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_secretbox_messagebytes_max() {
    return _crypto_secretbox_messagebytes_max();
  }

  late final _crypto_secretbox_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_messagebytes_max');
  late final _crypto_secretbox_messagebytes_max =
      _crypto_secretbox_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_secretbox_easy(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_easy(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_easyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_secretbox_easy');
  late final _crypto_secretbox_easy = _crypto_secretbox_easyPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_open_easy(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_open_easy(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_open_easyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_secretbox_open_easy');
  late final _crypto_secretbox_open_easy =
      _crypto_secretbox_open_easyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_detached(
      c,
      mac,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_detachedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_secretbox_detached');
  late final _crypto_secretbox_detached =
      _crypto_secretbox_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_open_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_open_detached(
      m,
      c,
      mac,
      clen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_open_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_open_detached');
  late final _crypto_secretbox_open_detached =
      _crypto_secretbox_open_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_secretbox_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_keygen(
      k,
    );
  }

  late final _crypto_secretbox_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_keygen');
  late final _crypto_secretbox_keygen = _crypto_secretbox_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_zerobytes() {
    return _crypto_secretbox_zerobytes();
  }

  late final _crypto_secretbox_zerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_zerobytes');
  late final _crypto_secretbox_zerobytes =
      _crypto_secretbox_zerobytesPtr.asFunction<int Function()>();

  int crypto_secretbox_boxzerobytes() {
    return _crypto_secretbox_boxzerobytes();
  }

  late final _crypto_secretbox_boxzerobytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_boxzerobytes');
  late final _crypto_secretbox_boxzerobytes =
      _crypto_secretbox_boxzerobytesPtr.asFunction<int Function()>();

  int crypto_secretbox(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_secretboxPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_secretbox');
  late final _crypto_secretbox = _crypto_secretboxPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_open(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_openPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_secretbox_open');
  late final _crypto_secretbox_open = _crypto_secretbox_openPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_chacha20_keybytes() {
    return _crypto_stream_chacha20_keybytes();
  }

  late final _crypto_stream_chacha20_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_chacha20_keybytes');
  late final _crypto_stream_chacha20_keybytes =
      _crypto_stream_chacha20_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_chacha20_noncebytes() {
    return _crypto_stream_chacha20_noncebytes();
  }

  late final _crypto_stream_chacha20_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_chacha20_noncebytes');
  late final _crypto_stream_chacha20_noncebytes =
      _crypto_stream_chacha20_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_chacha20_messagebytes_max() {
    return _crypto_stream_chacha20_messagebytes_max();
  }

  late final _crypto_stream_chacha20_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_chacha20_messagebytes_max');
  late final _crypto_stream_chacha20_messagebytes_max =
      _crypto_stream_chacha20_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_stream_chacha20(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_stream_chacha20Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_chacha20');
  late final _crypto_stream_chacha20 = _crypto_stream_chacha20Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_chacha20_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_chacha20_xorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_chacha20_xor');
  late final _crypto_stream_chacha20_xor =
      _crypto_stream_chacha20_xorPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_chacha20_xor_ic(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    int ic,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20_xor_ic(
      c,
      m,
      mlen,
      n,
      ic,
      k,
    );
  }

  late final _crypto_stream_chacha20_xor_icPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Uint64,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_chacha20_xor_ic');
  late final _crypto_stream_chacha20_xor_ic =
      _crypto_stream_chacha20_xor_icPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_chacha20_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20_keygen(
      k,
    );
  }

  late final _crypto_stream_chacha20_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_chacha20_keygen');
  late final _crypto_stream_chacha20_keygen = _crypto_stream_chacha20_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_chacha20_ietf_keybytes() {
    return _crypto_stream_chacha20_ietf_keybytes();
  }

  late final _crypto_stream_chacha20_ietf_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_chacha20_ietf_keybytes');
  late final _crypto_stream_chacha20_ietf_keybytes =
      _crypto_stream_chacha20_ietf_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_chacha20_ietf_noncebytes() {
    return _crypto_stream_chacha20_ietf_noncebytes();
  }

  late final _crypto_stream_chacha20_ietf_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_chacha20_ietf_noncebytes');
  late final _crypto_stream_chacha20_ietf_noncebytes =
      _crypto_stream_chacha20_ietf_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_chacha20_ietf_messagebytes_max() {
    return _crypto_stream_chacha20_ietf_messagebytes_max();
  }

  late final _crypto_stream_chacha20_ietf_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_chacha20_ietf_messagebytes_max');
  late final _crypto_stream_chacha20_ietf_messagebytes_max =
      _crypto_stream_chacha20_ietf_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_stream_chacha20_ietf(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20_ietf(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_stream_chacha20_ietfPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_chacha20_ietf');
  late final _crypto_stream_chacha20_ietf =
      _crypto_stream_chacha20_ietfPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>, int,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_chacha20_ietf_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20_ietf_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_chacha20_ietf_xorPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_chacha20_ietf_xor');
  late final _crypto_stream_chacha20_ietf_xor =
      _crypto_stream_chacha20_ietf_xorPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_chacha20_ietf_xor_ic(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    int ic,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20_ietf_xor_ic(
      c,
      m,
      mlen,
      n,
      ic,
      k,
    );
  }

  late final _crypto_stream_chacha20_ietf_xor_icPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Uint32,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_chacha20_ietf_xor_ic');
  late final _crypto_stream_chacha20_ietf_xor_ic =
      _crypto_stream_chacha20_ietf_xor_icPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_chacha20_ietf_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_chacha20_ietf_keygen(
      k,
    );
  }

  late final _crypto_stream_chacha20_ietf_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_chacha20_ietf_keygen');
  late final _crypto_stream_chacha20_ietf_keygen =
      _crypto_stream_chacha20_ietf_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretstream_xchacha20poly1305_abytes() {
    return _crypto_secretstream_xchacha20poly1305_abytes();
  }

  late final _crypto_secretstream_xchacha20poly1305_abytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretstream_xchacha20poly1305_abytes');
  late final _crypto_secretstream_xchacha20poly1305_abytes =
      _crypto_secretstream_xchacha20poly1305_abytesPtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_headerbytes() {
    return _crypto_secretstream_xchacha20poly1305_headerbytes();
  }

  late final _crypto_secretstream_xchacha20poly1305_headerbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretstream_xchacha20poly1305_headerbytes');
  late final _crypto_secretstream_xchacha20poly1305_headerbytes =
      _crypto_secretstream_xchacha20poly1305_headerbytesPtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_keybytes() {
    return _crypto_secretstream_xchacha20poly1305_keybytes();
  }

  late final _crypto_secretstream_xchacha20poly1305_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretstream_xchacha20poly1305_keybytes');
  late final _crypto_secretstream_xchacha20poly1305_keybytes =
      _crypto_secretstream_xchacha20poly1305_keybytesPtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_messagebytes_max() {
    return _crypto_secretstream_xchacha20poly1305_messagebytes_max();
  }

  late final _crypto_secretstream_xchacha20poly1305_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretstream_xchacha20poly1305_messagebytes_max');
  late final _crypto_secretstream_xchacha20poly1305_messagebytes_max =
      _crypto_secretstream_xchacha20poly1305_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_tag_message() {
    return _crypto_secretstream_xchacha20poly1305_tag_message();
  }

  late final _crypto_secretstream_xchacha20poly1305_tag_messagePtr =
      _lookup<ffi.NativeFunction<ffi.UnsignedChar Function()>>(
          'crypto_secretstream_xchacha20poly1305_tag_message');
  late final _crypto_secretstream_xchacha20poly1305_tag_message =
      _crypto_secretstream_xchacha20poly1305_tag_messagePtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_tag_push() {
    return _crypto_secretstream_xchacha20poly1305_tag_push();
  }

  late final _crypto_secretstream_xchacha20poly1305_tag_pushPtr =
      _lookup<ffi.NativeFunction<ffi.UnsignedChar Function()>>(
          'crypto_secretstream_xchacha20poly1305_tag_push');
  late final _crypto_secretstream_xchacha20poly1305_tag_push =
      _crypto_secretstream_xchacha20poly1305_tag_pushPtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_tag_rekey() {
    return _crypto_secretstream_xchacha20poly1305_tag_rekey();
  }

  late final _crypto_secretstream_xchacha20poly1305_tag_rekeyPtr =
      _lookup<ffi.NativeFunction<ffi.UnsignedChar Function()>>(
          'crypto_secretstream_xchacha20poly1305_tag_rekey');
  late final _crypto_secretstream_xchacha20poly1305_tag_rekey =
      _crypto_secretstream_xchacha20poly1305_tag_rekeyPtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_tag_final() {
    return _crypto_secretstream_xchacha20poly1305_tag_final();
  }

  late final _crypto_secretstream_xchacha20poly1305_tag_finalPtr =
      _lookup<ffi.NativeFunction<ffi.UnsignedChar Function()>>(
          'crypto_secretstream_xchacha20poly1305_tag_final');
  late final _crypto_secretstream_xchacha20poly1305_tag_final =
      _crypto_secretstream_xchacha20poly1305_tag_finalPtr
          .asFunction<int Function()>();

  int crypto_secretstream_xchacha20poly1305_statebytes() {
    return _crypto_secretstream_xchacha20poly1305_statebytes();
  }

  late final _crypto_secretstream_xchacha20poly1305_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretstream_xchacha20poly1305_statebytes');
  late final _crypto_secretstream_xchacha20poly1305_statebytes =
      _crypto_secretstream_xchacha20poly1305_statebytesPtr
          .asFunction<int Function()>();

  void crypto_secretstream_xchacha20poly1305_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretstream_xchacha20poly1305_keygen(
      k,
    );
  }

  late final _crypto_secretstream_xchacha20poly1305_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretstream_xchacha20poly1305_keygen');
  late final _crypto_secretstream_xchacha20poly1305_keygen =
      _crypto_secretstream_xchacha20poly1305_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretstream_xchacha20poly1305_init_push(
    ffi.Pointer<crypto_secretstream_xchacha20poly1305_state> state,
    ffi.Pointer<ffi.UnsignedChar> header,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretstream_xchacha20poly1305_init_push(
      state,
      header,
      k,
    );
  }

  late final _crypto_secretstream_xchacha20poly1305_init_pushPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretstream_xchacha20poly1305_init_push');
  late final _crypto_secretstream_xchacha20poly1305_init_push =
      _crypto_secretstream_xchacha20poly1305_init_pushPtr.asFunction<
          int Function(ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretstream_xchacha20poly1305_push(
    ffi.Pointer<crypto_secretstream_xchacha20poly1305_state> state,
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedLongLong> clen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
    int tag,
  ) {
    return _crypto_secretstream_xchacha20poly1305_push(
      state,
      c,
      clen_p,
      m,
      mlen,
      ad,
      adlen,
      tag,
    );
  }

  late final _crypto_secretstream_xchacha20poly1305_pushPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.UnsignedChar)>>('crypto_secretstream_xchacha20poly1305_push');
  late final _crypto_secretstream_xchacha20poly1305_push =
      _crypto_secretstream_xchacha20poly1305_pushPtr.asFunction<
          int Function(
              ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              int)>();

  int crypto_secretstream_xchacha20poly1305_init_pull(
    ffi.Pointer<crypto_secretstream_xchacha20poly1305_state> state,
    ffi.Pointer<ffi.UnsignedChar> header,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretstream_xchacha20poly1305_init_pull(
      state,
      header,
      k,
    );
  }

  late final _crypto_secretstream_xchacha20poly1305_init_pullPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretstream_xchacha20poly1305_init_pull');
  late final _crypto_secretstream_xchacha20poly1305_init_pull =
      _crypto_secretstream_xchacha20poly1305_init_pullPtr.asFunction<
          int Function(ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretstream_xchacha20poly1305_pull(
    ffi.Pointer<crypto_secretstream_xchacha20poly1305_state> state,
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> tag_p,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> ad,
    int adlen,
  ) {
    return _crypto_secretstream_xchacha20poly1305_pull(
      state,
      m,
      mlen_p,
      tag_p,
      c,
      clen,
      ad,
      adlen,
    );
  }

  late final _crypto_secretstream_xchacha20poly1305_pullPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong)>>(
      'crypto_secretstream_xchacha20poly1305_pull');
  late final _crypto_secretstream_xchacha20poly1305_pull =
      _crypto_secretstream_xchacha20poly1305_pullPtr.asFunction<
          int Function(
              ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int)>();

  void crypto_secretstream_xchacha20poly1305_rekey(
    ffi.Pointer<crypto_secretstream_xchacha20poly1305_state> state,
  ) {
    return _crypto_secretstream_xchacha20poly1305_rekey(
      state,
    );
  }

  late final _crypto_secretstream_xchacha20poly1305_rekeyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>)>>(
      'crypto_secretstream_xchacha20poly1305_rekey');
  late final _crypto_secretstream_xchacha20poly1305_rekey =
      _crypto_secretstream_xchacha20poly1305_rekeyPtr.asFunction<
          void Function(
              ffi.Pointer<crypto_secretstream_xchacha20poly1305_state>)>();

  int crypto_shorthash_siphash24_bytes() {
    return _crypto_shorthash_siphash24_bytes();
  }

  late final _crypto_shorthash_siphash24_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_shorthash_siphash24_bytes');
  late final _crypto_shorthash_siphash24_bytes =
      _crypto_shorthash_siphash24_bytesPtr.asFunction<int Function()>();

  int crypto_shorthash_siphash24_keybytes() {
    return _crypto_shorthash_siphash24_keybytes();
  }

  late final _crypto_shorthash_siphash24_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_shorthash_siphash24_keybytes');
  late final _crypto_shorthash_siphash24_keybytes =
      _crypto_shorthash_siphash24_keybytesPtr.asFunction<int Function()>();

  int crypto_shorthash_siphash24(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_shorthash_siphash24(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_shorthash_siphash24Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_shorthash_siphash24');
  late final _crypto_shorthash_siphash24 =
      _crypto_shorthash_siphash24Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_shorthash_siphashx24_bytes() {
    return _crypto_shorthash_siphashx24_bytes();
  }

  late final _crypto_shorthash_siphashx24_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_shorthash_siphashx24_bytes');
  late final _crypto_shorthash_siphashx24_bytes =
      _crypto_shorthash_siphashx24_bytesPtr.asFunction<int Function()>();

  int crypto_shorthash_siphashx24_keybytes() {
    return _crypto_shorthash_siphashx24_keybytes();
  }

  late final _crypto_shorthash_siphashx24_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_shorthash_siphashx24_keybytes');
  late final _crypto_shorthash_siphashx24_keybytes =
      _crypto_shorthash_siphashx24_keybytesPtr.asFunction<int Function()>();

  int crypto_shorthash_siphashx24(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_shorthash_siphashx24(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_shorthash_siphashx24Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_shorthash_siphashx24');
  late final _crypto_shorthash_siphashx24 =
      _crypto_shorthash_siphashx24Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_shorthash_bytes() {
    return _crypto_shorthash_bytes();
  }

  late final _crypto_shorthash_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_shorthash_bytes');
  late final _crypto_shorthash_bytes =
      _crypto_shorthash_bytesPtr.asFunction<int Function()>();

  int crypto_shorthash_keybytes() {
    return _crypto_shorthash_keybytes();
  }

  late final _crypto_shorthash_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_shorthash_keybytes');
  late final _crypto_shorthash_keybytes =
      _crypto_shorthash_keybytesPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_shorthash_primitive() {
    return _crypto_shorthash_primitive();
  }

  late final _crypto_shorthash_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_shorthash_primitive');
  late final _crypto_shorthash_primitive = _crypto_shorthash_primitivePtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_shorthash(
    ffi.Pointer<ffi.UnsignedChar> out,
    ffi.Pointer<ffi.UnsignedChar> in1,
    int inlen,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_shorthash(
      out,
      in1,
      inlen,
      k,
    );
  }

  late final _crypto_shorthashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_shorthash');
  late final _crypto_shorthash = _crypto_shorthashPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_shorthash_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_shorthash_keygen(
      k,
    );
  }

  late final _crypto_shorthash_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_shorthash_keygen');
  late final _crypto_shorthash_keygen = _crypto_shorthash_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519ph_statebytes() {
    return _crypto_sign_ed25519ph_statebytes();
  }

  late final _crypto_sign_ed25519ph_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_ed25519ph_statebytes');
  late final _crypto_sign_ed25519ph_statebytes =
      _crypto_sign_ed25519ph_statebytesPtr.asFunction<int Function()>();

  int crypto_sign_ed25519_bytes() {
    return _crypto_sign_ed25519_bytes();
  }

  late final _crypto_sign_ed25519_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_ed25519_bytes');
  late final _crypto_sign_ed25519_bytes =
      _crypto_sign_ed25519_bytesPtr.asFunction<int Function()>();

  int crypto_sign_ed25519_seedbytes() {
    return _crypto_sign_ed25519_seedbytes();
  }

  late final _crypto_sign_ed25519_seedbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_ed25519_seedbytes');
  late final _crypto_sign_ed25519_seedbytes =
      _crypto_sign_ed25519_seedbytesPtr.asFunction<int Function()>();

  int crypto_sign_ed25519_publickeybytes() {
    return _crypto_sign_ed25519_publickeybytes();
  }

  late final _crypto_sign_ed25519_publickeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_ed25519_publickeybytes');
  late final _crypto_sign_ed25519_publickeybytes =
      _crypto_sign_ed25519_publickeybytesPtr.asFunction<int Function()>();

  int crypto_sign_ed25519_secretkeybytes() {
    return _crypto_sign_ed25519_secretkeybytes();
  }

  late final _crypto_sign_ed25519_secretkeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_ed25519_secretkeybytes');
  late final _crypto_sign_ed25519_secretkeybytes =
      _crypto_sign_ed25519_secretkeybytesPtr.asFunction<int Function()>();

  int crypto_sign_ed25519_messagebytes_max() {
    return _crypto_sign_ed25519_messagebytes_max();
  }

  late final _crypto_sign_ed25519_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_ed25519_messagebytes_max');
  late final _crypto_sign_ed25519_messagebytes_max =
      _crypto_sign_ed25519_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_sign_ed25519(
    ffi.Pointer<ffi.UnsignedChar> sm,
    ffi.Pointer<ffi.UnsignedLongLong> smlen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_ed25519(
      sm,
      smlen_p,
      m,
      mlen,
      sk,
    );
  }

  late final _crypto_sign_ed25519Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_ed25519');
  late final _crypto_sign_ed25519 = _crypto_sign_ed25519Ptr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedLongLong>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> sm,
    int smlen,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_sign_ed25519_open(
      m,
      mlen_p,
      sm,
      smlen,
      pk,
    );
  }

  late final _crypto_sign_ed25519_openPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_ed25519_open');
  late final _crypto_sign_ed25519_open =
      _crypto_sign_ed25519_openPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_detached(
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedLongLong> siglen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_ed25519_detached(
      sig,
      siglen_p,
      m,
      mlen,
      sk,
    );
  }

  late final _crypto_sign_ed25519_detachedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_ed25519_detached');
  late final _crypto_sign_ed25519_detached =
      _crypto_sign_ed25519_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_verify_detached(
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_sign_ed25519_verify_detached(
      sig,
      m,
      mlen,
      pk,
    );
  }

  late final _crypto_sign_ed25519_verify_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_sign_ed25519_verify_detached');
  late final _crypto_sign_ed25519_verify_detached =
      _crypto_sign_ed25519_verify_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_ed25519_keypair(
      pk,
      sk,
    );
  }

  late final _crypto_sign_ed25519_keypairPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_ed25519_keypair');
  late final _crypto_sign_ed25519_keypair =
      _crypto_sign_ed25519_keypairPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_seed_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
    ffi.Pointer<ffi.UnsignedChar> seed,
  ) {
    return _crypto_sign_ed25519_seed_keypair(
      pk,
      sk,
      seed,
    );
  }

  late final _crypto_sign_ed25519_seed_keypairPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_sign_ed25519_seed_keypair');
  late final _crypto_sign_ed25519_seed_keypair =
      _crypto_sign_ed25519_seed_keypairPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_pk_to_curve25519(
    ffi.Pointer<ffi.UnsignedChar> curve25519_pk,
    ffi.Pointer<ffi.UnsignedChar> ed25519_pk,
  ) {
    return _crypto_sign_ed25519_pk_to_curve25519(
      curve25519_pk,
      ed25519_pk,
    );
  }

  late final _crypto_sign_ed25519_pk_to_curve25519Ptr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_sign_ed25519_pk_to_curve25519');
  late final _crypto_sign_ed25519_pk_to_curve25519 =
      _crypto_sign_ed25519_pk_to_curve25519Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_sk_to_curve25519(
    ffi.Pointer<ffi.UnsignedChar> curve25519_sk,
    ffi.Pointer<ffi.UnsignedChar> ed25519_sk,
  ) {
    return _crypto_sign_ed25519_sk_to_curve25519(
      curve25519_sk,
      ed25519_sk,
    );
  }

  late final _crypto_sign_ed25519_sk_to_curve25519Ptr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_sign_ed25519_sk_to_curve25519');
  late final _crypto_sign_ed25519_sk_to_curve25519 =
      _crypto_sign_ed25519_sk_to_curve25519Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_sk_to_seed(
    ffi.Pointer<ffi.UnsignedChar> seed,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_ed25519_sk_to_seed(
      seed,
      sk,
    );
  }

  late final _crypto_sign_ed25519_sk_to_seedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_sign_ed25519_sk_to_seed');
  late final _crypto_sign_ed25519_sk_to_seed =
      _crypto_sign_ed25519_sk_to_seedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519_sk_to_pk(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_ed25519_sk_to_pk(
      pk,
      sk,
    );
  }

  late final _crypto_sign_ed25519_sk_to_pkPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_ed25519_sk_to_pk');
  late final _crypto_sign_ed25519_sk_to_pk =
      _crypto_sign_ed25519_sk_to_pkPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519ph_init(
    ffi.Pointer<crypto_sign_ed25519ph_state> state,
  ) {
    return _crypto_sign_ed25519ph_init(
      state,
    );
  }

  late final _crypto_sign_ed25519ph_initPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<crypto_sign_ed25519ph_state>)>>(
      'crypto_sign_ed25519ph_init');
  late final _crypto_sign_ed25519ph_init = _crypto_sign_ed25519ph_initPtr
      .asFunction<int Function(ffi.Pointer<crypto_sign_ed25519ph_state>)>();

  int crypto_sign_ed25519ph_update(
    ffi.Pointer<crypto_sign_ed25519ph_state> state,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
  ) {
    return _crypto_sign_ed25519ph_update(
      state,
      m,
      mlen,
    );
  }

  late final _crypto_sign_ed25519ph_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_sign_ed25519ph_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_sign_ed25519ph_update');
  late final _crypto_sign_ed25519ph_update =
      _crypto_sign_ed25519ph_updatePtr.asFunction<
          int Function(ffi.Pointer<crypto_sign_ed25519ph_state>,
              ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_sign_ed25519ph_final_create(
    ffi.Pointer<crypto_sign_ed25519ph_state> state,
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedLongLong> siglen_p,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_ed25519ph_final_create(
      state,
      sig,
      siglen_p,
      sk,
    );
  }

  late final _crypto_sign_ed25519ph_final_createPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<crypto_sign_ed25519ph_state>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedLongLong>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_sign_ed25519ph_final_create');
  late final _crypto_sign_ed25519ph_final_create =
      _crypto_sign_ed25519ph_final_createPtr.asFunction<
          int Function(
              ffi.Pointer<crypto_sign_ed25519ph_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_ed25519ph_final_verify(
    ffi.Pointer<crypto_sign_ed25519ph_state> state,
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_sign_ed25519ph_final_verify(
      state,
      sig,
      pk,
    );
  }

  late final _crypto_sign_ed25519ph_final_verifyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<crypto_sign_ed25519ph_state>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_sign_ed25519ph_final_verify');
  late final _crypto_sign_ed25519ph_final_verify =
      _crypto_sign_ed25519ph_final_verifyPtr.asFunction<
          int Function(ffi.Pointer<crypto_sign_ed25519ph_state>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_statebytes() {
    return _crypto_sign_statebytes();
  }

  late final _crypto_sign_statebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_statebytes');
  late final _crypto_sign_statebytes =
      _crypto_sign_statebytesPtr.asFunction<int Function()>();

  int crypto_sign_bytes() {
    return _crypto_sign_bytes();
  }

  late final _crypto_sign_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_sign_bytes');
  late final _crypto_sign_bytes =
      _crypto_sign_bytesPtr.asFunction<int Function()>();

  int crypto_sign_seedbytes() {
    return _crypto_sign_seedbytes();
  }

  late final _crypto_sign_seedbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('crypto_sign_seedbytes');
  late final _crypto_sign_seedbytes =
      _crypto_sign_seedbytesPtr.asFunction<int Function()>();

  int crypto_sign_publickeybytes() {
    return _crypto_sign_publickeybytes();
  }

  late final _crypto_sign_publickeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_publickeybytes');
  late final _crypto_sign_publickeybytes =
      _crypto_sign_publickeybytesPtr.asFunction<int Function()>();

  int crypto_sign_secretkeybytes() {
    return _crypto_sign_secretkeybytes();
  }

  late final _crypto_sign_secretkeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_secretkeybytes');
  late final _crypto_sign_secretkeybytes =
      _crypto_sign_secretkeybytesPtr.asFunction<int Function()>();

  int crypto_sign_messagebytes_max() {
    return _crypto_sign_messagebytes_max();
  }

  late final _crypto_sign_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_sign_messagebytes_max');
  late final _crypto_sign_messagebytes_max =
      _crypto_sign_messagebytes_maxPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_sign_primitive() {
    return _crypto_sign_primitive();
  }

  late final _crypto_sign_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_sign_primitive');
  late final _crypto_sign_primitive =
      _crypto_sign_primitivePtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_sign_seed_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
    ffi.Pointer<ffi.UnsignedChar> seed,
  ) {
    return _crypto_sign_seed_keypair(
      pk,
      sk,
      seed,
    );
  }

  late final _crypto_sign_seed_keypairPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_seed_keypair');
  late final _crypto_sign_seed_keypair =
      _crypto_sign_seed_keypairPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_keypair(
      pk,
      sk,
    );
  }

  late final _crypto_sign_keypairPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_keypair');
  late final _crypto_sign_keypair = _crypto_sign_keypairPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign(
    ffi.Pointer<ffi.UnsignedChar> sm,
    ffi.Pointer<ffi.UnsignedLongLong> smlen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign(
      sm,
      smlen_p,
      m,
      mlen,
      sk,
    );
  }

  late final _crypto_signPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign');
  late final _crypto_sign = _crypto_signPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedLongLong>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedLongLong> mlen_p,
    ffi.Pointer<ffi.UnsignedChar> sm,
    int smlen,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_sign_open(
      m,
      mlen_p,
      sm,
      smlen,
      pk,
    );
  }

  late final _crypto_sign_openPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_open');
  late final _crypto_sign_open = _crypto_sign_openPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedLongLong>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_detached(
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedLongLong> siglen_p,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_detached(
      sig,
      siglen_p,
      m,
      mlen,
      sk,
    );
  }

  late final _crypto_sign_detachedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_detached');
  late final _crypto_sign_detached = _crypto_sign_detachedPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedLongLong>,
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_verify_detached(
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_sign_verify_detached(
      sig,
      m,
      mlen,
      pk,
    );
  }

  late final _crypto_sign_verify_detachedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_verify_detached');
  late final _crypto_sign_verify_detached =
      _crypto_sign_verify_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_init(
    ffi.Pointer<crypto_sign_state> state,
  ) {
    return _crypto_sign_init(
      state,
    );
  }

  late final _crypto_sign_initPtr = _lookup<
          ffi.NativeFunction<ffi.Int Function(ffi.Pointer<crypto_sign_state>)>>(
      'crypto_sign_init');
  late final _crypto_sign_init = _crypto_sign_initPtr
      .asFunction<int Function(ffi.Pointer<crypto_sign_state>)>();

  int crypto_sign_update(
    ffi.Pointer<crypto_sign_state> state,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
  ) {
    return _crypto_sign_update(
      state,
      m,
      mlen,
    );
  }

  late final _crypto_sign_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_sign_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('crypto_sign_update');
  late final _crypto_sign_update = _crypto_sign_updatePtr.asFunction<
      int Function(ffi.Pointer<crypto_sign_state>,
          ffi.Pointer<ffi.UnsignedChar>, int)>();

  int crypto_sign_final_create(
    ffi.Pointer<crypto_sign_state> state,
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedLongLong> siglen_p,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_sign_final_create(
      state,
      sig,
      siglen_p,
      sk,
    );
  }

  late final _crypto_sign_final_createPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_sign_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_final_create');
  late final _crypto_sign_final_create =
      _crypto_sign_final_createPtr.asFunction<
          int Function(
              ffi.Pointer<crypto_sign_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedLongLong>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_sign_final_verify(
    ffi.Pointer<crypto_sign_state> state,
    ffi.Pointer<ffi.UnsignedChar> sig,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_sign_final_verify(
      state,
      sig,
      pk,
    );
  }

  late final _crypto_sign_final_verifyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<crypto_sign_state>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_sign_final_verify');
  late final _crypto_sign_final_verify =
      _crypto_sign_final_verifyPtr.asFunction<
          int Function(ffi.Pointer<crypto_sign_state>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_keybytes() {
    return _crypto_stream_keybytes();
  }

  late final _crypto_stream_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_keybytes');
  late final _crypto_stream_keybytes =
      _crypto_stream_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_noncebytes() {
    return _crypto_stream_noncebytes();
  }

  late final _crypto_stream_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_noncebytes');
  late final _crypto_stream_noncebytes =
      _crypto_stream_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_messagebytes_max() {
    return _crypto_stream_messagebytes_max();
  }

  late final _crypto_stream_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_messagebytes_max');
  late final _crypto_stream_messagebytes_max =
      _crypto_stream_messagebytes_maxPtr.asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_stream_primitive() {
    return _crypto_stream_primitive();
  }

  late final _crypto_stream_primitivePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_stream_primitive');
  late final _crypto_stream_primitive = _crypto_stream_primitivePtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_stream(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_streamPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream');
  late final _crypto_stream = _crypto_streamPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_xorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_xor');
  late final _crypto_stream_xor = _crypto_stream_xorPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          int, ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_keygen(
      k,
    );
  }

  late final _crypto_stream_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_keygen');
  late final _crypto_stream_keygen = _crypto_stream_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_salsa20_keybytes() {
    return _crypto_stream_salsa20_keybytes();
  }

  late final _crypto_stream_salsa20_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa20_keybytes');
  late final _crypto_stream_salsa20_keybytes =
      _crypto_stream_salsa20_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_salsa20_noncebytes() {
    return _crypto_stream_salsa20_noncebytes();
  }

  late final _crypto_stream_salsa20_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa20_noncebytes');
  late final _crypto_stream_salsa20_noncebytes =
      _crypto_stream_salsa20_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_salsa20_messagebytes_max() {
    return _crypto_stream_salsa20_messagebytes_max();
  }

  late final _crypto_stream_salsa20_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa20_messagebytes_max');
  late final _crypto_stream_salsa20_messagebytes_max =
      _crypto_stream_salsa20_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_stream_salsa20(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa20(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_stream_salsa20Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_salsa20');
  late final _crypto_stream_salsa20 = _crypto_stream_salsa20Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_salsa20_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa20_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_salsa20_xorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_salsa20_xor');
  late final _crypto_stream_salsa20_xor =
      _crypto_stream_salsa20_xorPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_salsa20_xor_ic(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    int ic,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa20_xor_ic(
      c,
      m,
      mlen,
      n,
      ic,
      k,
    );
  }

  late final _crypto_stream_salsa20_xor_icPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Uint64,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_salsa20_xor_ic');
  late final _crypto_stream_salsa20_xor_ic =
      _crypto_stream_salsa20_xor_icPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_salsa20_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa20_keygen(
      k,
    );
  }

  late final _crypto_stream_salsa20_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_salsa20_keygen');
  late final _crypto_stream_salsa20_keygen = _crypto_stream_salsa20_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_verify_16_bytes() {
    return _crypto_verify_16_bytes();
  }

  late final _crypto_verify_16_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_verify_16_bytes');
  late final _crypto_verify_16_bytes =
      _crypto_verify_16_bytesPtr.asFunction<int Function()>();

  int crypto_verify_16(
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_verify_16(
      x,
      y,
    );
  }

  late final _crypto_verify_16Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_verify_16');
  late final _crypto_verify_16 = _crypto_verify_16Ptr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_verify_32_bytes() {
    return _crypto_verify_32_bytes();
  }

  late final _crypto_verify_32_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_verify_32_bytes');
  late final _crypto_verify_32_bytes =
      _crypto_verify_32_bytesPtr.asFunction<int Function()>();

  int crypto_verify_32(
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_verify_32(
      x,
      y,
    );
  }

  late final _crypto_verify_32Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_verify_32');
  late final _crypto_verify_32 = _crypto_verify_32Ptr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_verify_64_bytes() {
    return _crypto_verify_64_bytes();
  }

  late final _crypto_verify_64_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_verify_64_bytes');
  late final _crypto_verify_64_bytes =
      _crypto_verify_64_bytesPtr.asFunction<int Function()>();

  int crypto_verify_64(
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_verify_64(
      x,
      y,
    );
  }

  late final _crypto_verify_64Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_verify_64');
  late final _crypto_verify_64 = _crypto_verify_64Ptr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int randombytes_seedbytes() {
    return _randombytes_seedbytes();
  }

  late final _randombytes_seedbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>('randombytes_seedbytes');
  late final _randombytes_seedbytes =
      _randombytes_seedbytesPtr.asFunction<int Function()>();

  void randombytes_buf(
    ffi.Pointer<ffi.Void> buf,
    int size,
  ) {
    return _randombytes_buf(
      buf,
      size,
    );
  }

  late final _randombytes_bufPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Size)>>(
      'randombytes_buf');
  late final _randombytes_buf = _randombytes_bufPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void randombytes_buf_deterministic(
    ffi.Pointer<ffi.Void> buf,
    int size,
    ffi.Pointer<ffi.UnsignedChar> seed,
  ) {
    return _randombytes_buf_deterministic(
      buf,
      size,
      seed,
    );
  }

  late final _randombytes_buf_deterministicPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>)>>('randombytes_buf_deterministic');
  late final _randombytes_buf_deterministic =
      _randombytes_buf_deterministicPtr.asFunction<
          void Function(
              ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.UnsignedChar>)>();

  int randombytes_random() {
    return _randombytes_random();
  }

  late final _randombytes_randomPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function()>>('randombytes_random');
  late final _randombytes_random =
      _randombytes_randomPtr.asFunction<int Function()>();

  int randombytes_uniform(
    int upper_bound,
  ) {
    return _randombytes_uniform(
      upper_bound,
    );
  }

  late final _randombytes_uniformPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Uint32)>>(
          'randombytes_uniform');
  late final _randombytes_uniform =
      _randombytes_uniformPtr.asFunction<int Function(int)>();

  void randombytes_stir() {
    return _randombytes_stir();
  }

  late final _randombytes_stirPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('randombytes_stir');
  late final _randombytes_stir =
      _randombytes_stirPtr.asFunction<void Function()>();

  int randombytes_close() {
    return _randombytes_close();
  }

  late final _randombytes_closePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>('randombytes_close');
  late final _randombytes_close =
      _randombytes_closePtr.asFunction<int Function()>();

  int randombytes_set_implementation(
    ffi.Pointer<randombytes_implementation> impl,
  ) {
    return _randombytes_set_implementation(
      impl,
    );
  }

  late final _randombytes_set_implementationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<randombytes_implementation>)>>(
      'randombytes_set_implementation');
  late final _randombytes_set_implementation =
      _randombytes_set_implementationPtr
          .asFunction<int Function(ffi.Pointer<randombytes_implementation>)>();

  ffi.Pointer<ffi.Char> randombytes_implementation_name() {
    return _randombytes_implementation_name();
  }

  late final _randombytes_implementation_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'randombytes_implementation_name');
  late final _randombytes_implementation_name =
      _randombytes_implementation_namePtr
          .asFunction<ffi.Pointer<ffi.Char> Function()>();

  void randombytes(
    ffi.Pointer<ffi.UnsignedChar> buf,
    int buf_len,
  ) {
    return _randombytes(
      buf,
      buf_len,
    );
  }

  late final _randombytesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong)>>('randombytes');
  late final _randombytes = _randombytesPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>, int)>();

  late final ffi.Pointer<randombytes_implementation>
      _randombytes_internal_implementation =
      _lookup<randombytes_implementation>(
          'randombytes_internal_implementation');

  randombytes_implementation get randombytes_internal_implementation =>
      _randombytes_internal_implementation.ref;

  late final ffi.Pointer<randombytes_implementation>
      _randombytes_sysrandom_implementation =
      _lookup<randombytes_implementation>(
          'randombytes_sysrandom_implementation');

  randombytes_implementation get randombytes_sysrandom_implementation =>
      _randombytes_sysrandom_implementation.ref;

  int sodium_runtime_has_neon() {
    return _sodium_runtime_has_neon();
  }

  late final _sodium_runtime_has_neonPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_neon');
  late final _sodium_runtime_has_neon =
      _sodium_runtime_has_neonPtr.asFunction<int Function()>();

  int sodium_runtime_has_armcrypto() {
    return _sodium_runtime_has_armcrypto();
  }

  late final _sodium_runtime_has_armcryptoPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_armcrypto');
  late final _sodium_runtime_has_armcrypto =
      _sodium_runtime_has_armcryptoPtr.asFunction<int Function()>();

  int sodium_runtime_has_sse2() {
    return _sodium_runtime_has_sse2();
  }

  late final _sodium_runtime_has_sse2Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_sse2');
  late final _sodium_runtime_has_sse2 =
      _sodium_runtime_has_sse2Ptr.asFunction<int Function()>();

  int sodium_runtime_has_sse3() {
    return _sodium_runtime_has_sse3();
  }

  late final _sodium_runtime_has_sse3Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_sse3');
  late final _sodium_runtime_has_sse3 =
      _sodium_runtime_has_sse3Ptr.asFunction<int Function()>();

  int sodium_runtime_has_ssse3() {
    return _sodium_runtime_has_ssse3();
  }

  late final _sodium_runtime_has_ssse3Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_ssse3');
  late final _sodium_runtime_has_ssse3 =
      _sodium_runtime_has_ssse3Ptr.asFunction<int Function()>();

  int sodium_runtime_has_sse41() {
    return _sodium_runtime_has_sse41();
  }

  late final _sodium_runtime_has_sse41Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_sse41');
  late final _sodium_runtime_has_sse41 =
      _sodium_runtime_has_sse41Ptr.asFunction<int Function()>();

  int sodium_runtime_has_avx() {
    return _sodium_runtime_has_avx();
  }

  late final _sodium_runtime_has_avxPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>('sodium_runtime_has_avx');
  late final _sodium_runtime_has_avx =
      _sodium_runtime_has_avxPtr.asFunction<int Function()>();

  int sodium_runtime_has_avx2() {
    return _sodium_runtime_has_avx2();
  }

  late final _sodium_runtime_has_avx2Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_avx2');
  late final _sodium_runtime_has_avx2 =
      _sodium_runtime_has_avx2Ptr.asFunction<int Function()>();

  int sodium_runtime_has_avx512f() {
    return _sodium_runtime_has_avx512f();
  }

  late final _sodium_runtime_has_avx512fPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_avx512f');
  late final _sodium_runtime_has_avx512f =
      _sodium_runtime_has_avx512fPtr.asFunction<int Function()>();

  int sodium_runtime_has_pclmul() {
    return _sodium_runtime_has_pclmul();
  }

  late final _sodium_runtime_has_pclmulPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_pclmul');
  late final _sodium_runtime_has_pclmul =
      _sodium_runtime_has_pclmulPtr.asFunction<int Function()>();

  int sodium_runtime_has_aesni() {
    return _sodium_runtime_has_aesni();
  }

  late final _sodium_runtime_has_aesniPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_aesni');
  late final _sodium_runtime_has_aesni =
      _sodium_runtime_has_aesniPtr.asFunction<int Function()>();

  int sodium_runtime_has_rdrand() {
    return _sodium_runtime_has_rdrand();
  }

  late final _sodium_runtime_has_rdrandPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>(
          'sodium_runtime_has_rdrand');
  late final _sodium_runtime_has_rdrand =
      _sodium_runtime_has_rdrandPtr.asFunction<int Function()>();

  void sodium_memzero(
    ffi.Pointer<ffi.Void> pnt,
    int len,
  ) {
    return _sodium_memzero(
      pnt,
      len,
    );
  }

  late final _sodium_memzeroPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Size)>>(
      'sodium_memzero');
  late final _sodium_memzero = _sodium_memzeroPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  void sodium_stackzero(
    int len,
  ) {
    return _sodium_stackzero(
      len,
    );
  }

  late final _sodium_stackzeroPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Size)>>(
          'sodium_stackzero');
  late final _sodium_stackzero =
      _sodium_stackzeroPtr.asFunction<void Function(int)>();

  int sodium_memcmp(
    ffi.Pointer<ffi.Void> b1_,
    ffi.Pointer<ffi.Void> b2_,
    int len,
  ) {
    return _sodium_memcmp(
      b1_,
      b2_,
      len,
    );
  }

  late final _sodium_memcmpPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Size)>>('sodium_memcmp');
  late final _sodium_memcmp = _sodium_memcmpPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, int)>();

  int sodium_compare(
    ffi.Pointer<ffi.UnsignedChar> b1_,
    ffi.Pointer<ffi.UnsignedChar> b2_,
    int len,
  ) {
    return _sodium_compare(
      b1_,
      b2_,
      len,
    );
  }

  late final _sodium_comparePtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Size)>>('sodium_compare');
  late final _sodium_compare = _sodium_comparePtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>, int)>();

  int sodium_is_zero(
    ffi.Pointer<ffi.UnsignedChar> n,
    int nlen,
  ) {
    return _sodium_is_zero(
      n,
      nlen,
    );
  }

  late final _sodium_is_zeroPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Size)>>('sodium_is_zero');
  late final _sodium_is_zero = _sodium_is_zeroPtr
      .asFunction<int Function(ffi.Pointer<ffi.UnsignedChar>, int)>();

  void sodium_increment(
    ffi.Pointer<ffi.UnsignedChar> n,
    int nlen,
  ) {
    return _sodium_increment(
      n,
      nlen,
    );
  }

  late final _sodium_incrementPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Size)>>('sodium_increment');
  late final _sodium_increment = _sodium_incrementPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>, int)>();

  void sodium_add(
    ffi.Pointer<ffi.UnsignedChar> a,
    ffi.Pointer<ffi.UnsignedChar> b,
    int len,
  ) {
    return _sodium_add(
      a,
      b,
      len,
    );
  }

  late final _sodium_addPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Size)>>('sodium_add');
  late final _sodium_add = _sodium_addPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>, int)>();

  void sodium_sub(
    ffi.Pointer<ffi.UnsignedChar> a,
    ffi.Pointer<ffi.UnsignedChar> b,
    int len,
  ) {
    return _sodium_sub(
      a,
      b,
      len,
    );
  }

  late final _sodium_subPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Size)>>('sodium_sub');
  late final _sodium_sub = _sodium_subPtr.asFunction<
      void Function(
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>, int)>();

  ffi.Pointer<ffi.Char> sodium_bin2hex(
    ffi.Pointer<ffi.Char> hex,
    int hex_maxlen,
    ffi.Pointer<ffi.UnsignedChar> bin,
    int bin_len,
  ) {
    return _sodium_bin2hex(
      hex,
      hex_maxlen,
      bin,
      bin_len,
    );
  }

  late final _sodium_bin2hexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Size)>>('sodium_bin2hex');
  late final _sodium_bin2hex = _sodium_bin2hexPtr.asFunction<
      ffi.Pointer<ffi.Char> Function(
          ffi.Pointer<ffi.Char>, int, ffi.Pointer<ffi.UnsignedChar>, int)>();

  int sodium_hex2bin(
    ffi.Pointer<ffi.UnsignedChar> bin,
    int bin_maxlen,
    ffi.Pointer<ffi.Char> hex,
    int hex_len,
    ffi.Pointer<ffi.Char> ignore,
    ffi.Pointer<ffi.Size> bin_len,
    ffi.Pointer<ffi.Pointer<ffi.Char>> hex_end,
  ) {
    return _sodium_hex2bin(
      bin,
      bin_maxlen,
      hex,
      hex_len,
      ignore,
      bin_len,
      hex_end,
    );
  }

  late final _sodium_hex2binPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Size>,
              ffi.Pointer<ffi.Pointer<ffi.Char>>)>>('sodium_hex2bin');
  late final _sodium_hex2bin = _sodium_hex2binPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.Char>,
          int,
          ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Size>,
          ffi.Pointer<ffi.Pointer<ffi.Char>>)>();

  int sodium_base64_encoded_len(
    int bin_len,
    int variant,
  ) {
    return _sodium_base64_encoded_len(
      bin_len,
      variant,
    );
  }

  late final _sodium_base64_encoded_lenPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Size, ffi.Int)>>(
          'sodium_base64_encoded_len');
  late final _sodium_base64_encoded_len =
      _sodium_base64_encoded_lenPtr.asFunction<int Function(int, int)>();

  ffi.Pointer<ffi.Char> sodium_bin2base64(
    ffi.Pointer<ffi.Char> b64,
    int b64_maxlen,
    ffi.Pointer<ffi.UnsignedChar> bin,
    int bin_len,
    int variant,
  ) {
    return _sodium_bin2base64(
      b64,
      b64_maxlen,
      bin,
      bin_len,
      variant,
    );
  }

  late final _sodium_bin2base64Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Char>,
              ffi.Size,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Int)>>('sodium_bin2base64');
  late final _sodium_bin2base64 = _sodium_bin2base64Ptr.asFunction<
      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, int,
          ffi.Pointer<ffi.UnsignedChar>, int, int)>();

  int sodium_base642bin(
    ffi.Pointer<ffi.UnsignedChar> bin,
    int bin_maxlen,
    ffi.Pointer<ffi.Char> b64,
    int b64_len,
    ffi.Pointer<ffi.Char> ignore,
    ffi.Pointer<ffi.Size> bin_len,
    ffi.Pointer<ffi.Pointer<ffi.Char>> b64_end,
    int variant,
  ) {
    return _sodium_base642bin(
      bin,
      bin_maxlen,
      b64,
      b64_len,
      ignore,
      bin_len,
      b64_end,
      variant,
    );
  }

  late final _sodium_base642binPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Size>,
              ffi.Pointer<ffi.Pointer<ffi.Char>>,
              ffi.Int)>>('sodium_base642bin');
  late final _sodium_base642bin = _sodium_base642binPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.UnsignedChar>,
          int,
          ffi.Pointer<ffi.Char>,
          int,
          ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Size>,
          ffi.Pointer<ffi.Pointer<ffi.Char>>,
          int)>();

  int sodium_mlock(
    ffi.Pointer<ffi.Void> addr,
    int len,
  ) {
    return _sodium_mlock(
      addr,
      len,
    );
  }

  late final _sodium_mlockPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>, ffi.Size)>>('sodium_mlock');
  late final _sodium_mlock =
      _sodium_mlockPtr.asFunction<int Function(ffi.Pointer<ffi.Void>, int)>();

  int sodium_munlock(
    ffi.Pointer<ffi.Void> addr,
    int len,
  ) {
    return _sodium_munlock(
      addr,
      len,
    );
  }

  late final _sodium_munlockPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>, ffi.Size)>>('sodium_munlock');
  late final _sodium_munlock =
      _sodium_munlockPtr.asFunction<int Function(ffi.Pointer<ffi.Void>, int)>();

  ffi.Pointer<ffi.Void> sodium_malloc(
    int size,
  ) {
    return _sodium_malloc(
      size,
    );
  }

  late final _sodium_mallocPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(ffi.Size)>>(
          'sodium_malloc');
  late final _sodium_malloc =
      _sodium_mallocPtr.asFunction<ffi.Pointer<ffi.Void> Function(int)>();

  ffi.Pointer<ffi.Void> sodium_allocarray(
    int count,
    int size,
  ) {
    return _sodium_allocarray(
      count,
      size,
    );
  }

  late final _sodium_allocarrayPtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Void> Function(ffi.Size, ffi.Size)>>(
      'sodium_allocarray');
  late final _sodium_allocarray = _sodium_allocarrayPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(int, int)>();

  void sodium_free(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _sodium_free(
      ptr,
    );
  }

  @internal
  late final sodium_freePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'sodium_free');
  late final _sodium_free =
      sodium_freePtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  int sodium_mprotect_noaccess(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _sodium_mprotect_noaccess(
      ptr,
    );
  }

  late final _sodium_mprotect_noaccessPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'sodium_mprotect_noaccess');
  late final _sodium_mprotect_noaccess = _sodium_mprotect_noaccessPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int sodium_mprotect_readonly(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _sodium_mprotect_readonly(
      ptr,
    );
  }

  late final _sodium_mprotect_readonlyPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'sodium_mprotect_readonly');
  late final _sodium_mprotect_readonly = _sodium_mprotect_readonlyPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int sodium_mprotect_readwrite(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _sodium_mprotect_readwrite(
      ptr,
    );
  }

  late final _sodium_mprotect_readwritePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'sodium_mprotect_readwrite');
  late final _sodium_mprotect_readwrite = _sodium_mprotect_readwritePtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int sodium_pad(
    ffi.Pointer<ffi.Size> padded_buflen_p,
    ffi.Pointer<ffi.UnsignedChar> buf,
    int unpadded_buflen,
    int blocksize,
    int max_buflen,
  ) {
    return _sodium_pad(
      padded_buflen_p,
      buf,
      unpadded_buflen,
      blocksize,
      max_buflen,
    );
  }

  late final _sodium_padPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Size>, ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size, ffi.Size, ffi.Size)>>('sodium_pad');
  late final _sodium_pad = _sodium_padPtr.asFunction<
      int Function(ffi.Pointer<ffi.Size>, ffi.Pointer<ffi.UnsignedChar>, int,
          int, int)>();

  int sodium_unpad(
    ffi.Pointer<ffi.Size> unpadded_buflen_p,
    ffi.Pointer<ffi.UnsignedChar> buf,
    int padded_buflen,
    int blocksize,
  ) {
    return _sodium_unpad(
      unpadded_buflen_p,
      buf,
      padded_buflen,
      blocksize,
    );
  }

  late final _sodium_unpadPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Size>, ffi.Pointer<ffi.UnsignedChar>,
              ffi.Size, ffi.Size)>>('sodium_unpad');
  late final _sodium_unpad = _sodium_unpadPtr.asFunction<
      int Function(
          ffi.Pointer<ffi.Size>, ffi.Pointer<ffi.UnsignedChar>, int, int)>();

  int crypto_stream_xchacha20_keybytes() {
    return _crypto_stream_xchacha20_keybytes();
  }

  late final _crypto_stream_xchacha20_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_xchacha20_keybytes');
  late final _crypto_stream_xchacha20_keybytes =
      _crypto_stream_xchacha20_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_xchacha20_noncebytes() {
    return _crypto_stream_xchacha20_noncebytes();
  }

  late final _crypto_stream_xchacha20_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_xchacha20_noncebytes');
  late final _crypto_stream_xchacha20_noncebytes =
      _crypto_stream_xchacha20_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_xchacha20_messagebytes_max() {
    return _crypto_stream_xchacha20_messagebytes_max();
  }

  late final _crypto_stream_xchacha20_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_xchacha20_messagebytes_max');
  late final _crypto_stream_xchacha20_messagebytes_max =
      _crypto_stream_xchacha20_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_stream_xchacha20(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xchacha20(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_stream_xchacha20Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_xchacha20');
  late final _crypto_stream_xchacha20 = _crypto_stream_xchacha20Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_xchacha20_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xchacha20_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_xchacha20_xorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_xchacha20_xor');
  late final _crypto_stream_xchacha20_xor =
      _crypto_stream_xchacha20_xorPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_xchacha20_xor_ic(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    int ic,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xchacha20_xor_ic(
      c,
      m,
      mlen,
      n,
      ic,
      k,
    );
  }

  late final _crypto_stream_xchacha20_xor_icPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Uint64,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_xchacha20_xor_ic');
  late final _crypto_stream_xchacha20_xor_ic =
      _crypto_stream_xchacha20_xor_icPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_xchacha20_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_xchacha20_keygen(
      k,
    );
  }

  late final _crypto_stream_xchacha20_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_xchacha20_keygen');
  late final _crypto_stream_xchacha20_keygen =
      _crypto_stream_xchacha20_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_seedbytes() {
    return _crypto_box_curve25519xchacha20poly1305_seedbytes();
  }

  late final _crypto_box_curve25519xchacha20poly1305_seedbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_seedbytes');
  late final _crypto_box_curve25519xchacha20poly1305_seedbytes =
      _crypto_box_curve25519xchacha20poly1305_seedbytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_publickeybytes() {
    return _crypto_box_curve25519xchacha20poly1305_publickeybytes();
  }

  late final _crypto_box_curve25519xchacha20poly1305_publickeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_publickeybytes');
  late final _crypto_box_curve25519xchacha20poly1305_publickeybytes =
      _crypto_box_curve25519xchacha20poly1305_publickeybytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_secretkeybytes() {
    return _crypto_box_curve25519xchacha20poly1305_secretkeybytes();
  }

  late final _crypto_box_curve25519xchacha20poly1305_secretkeybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_secretkeybytes');
  late final _crypto_box_curve25519xchacha20poly1305_secretkeybytes =
      _crypto_box_curve25519xchacha20poly1305_secretkeybytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_beforenmbytes() {
    return _crypto_box_curve25519xchacha20poly1305_beforenmbytes();
  }

  late final _crypto_box_curve25519xchacha20poly1305_beforenmbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_beforenmbytes');
  late final _crypto_box_curve25519xchacha20poly1305_beforenmbytes =
      _crypto_box_curve25519xchacha20poly1305_beforenmbytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_noncebytes() {
    return _crypto_box_curve25519xchacha20poly1305_noncebytes();
  }

  late final _crypto_box_curve25519xchacha20poly1305_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_noncebytes');
  late final _crypto_box_curve25519xchacha20poly1305_noncebytes =
      _crypto_box_curve25519xchacha20poly1305_noncebytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_macbytes() {
    return _crypto_box_curve25519xchacha20poly1305_macbytes();
  }

  late final _crypto_box_curve25519xchacha20poly1305_macbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_macbytes');
  late final _crypto_box_curve25519xchacha20poly1305_macbytes =
      _crypto_box_curve25519xchacha20poly1305_macbytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_messagebytes_max() {
    return _crypto_box_curve25519xchacha20poly1305_messagebytes_max();
  }

  late final _crypto_box_curve25519xchacha20poly1305_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_messagebytes_max');
  late final _crypto_box_curve25519xchacha20poly1305_messagebytes_max =
      _crypto_box_curve25519xchacha20poly1305_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_seed_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
    ffi.Pointer<ffi.UnsignedChar> seed,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_seed_keypair(
      pk,
      sk,
      seed,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_seed_keypairPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_seed_keypair');
  late final _crypto_box_curve25519xchacha20poly1305_seed_keypair =
      _crypto_box_curve25519xchacha20poly1305_seed_keypairPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_keypair(
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_keypair(
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_keypairPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_keypair');
  late final _crypto_box_curve25519xchacha20poly1305_keypair =
      _crypto_box_curve25519xchacha20poly1305_keypairPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_easy(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_easy(
      c,
      m,
      mlen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_easyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_easy');
  late final _crypto_box_curve25519xchacha20poly1305_easy =
      _crypto_box_curve25519xchacha20poly1305_easyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_open_easy(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_open_easy(
      m,
      c,
      clen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_open_easyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_open_easy');
  late final _crypto_box_curve25519xchacha20poly1305_open_easy =
      _crypto_box_curve25519xchacha20poly1305_open_easyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_detached(
      c,
      mac,
      m,
      mlen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_detached');
  late final _crypto_box_curve25519xchacha20poly1305_detached =
      _crypto_box_curve25519xchacha20poly1305_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_open_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_open_detached(
      m,
      c,
      mac,
      clen,
      n,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_open_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_open_detached');
  late final _crypto_box_curve25519xchacha20poly1305_open_detached =
      _crypto_box_curve25519xchacha20poly1305_open_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_beforenm(
    ffi.Pointer<ffi.UnsignedChar> k,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_beforenm(
      k,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_beforenmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_beforenm');
  late final _crypto_box_curve25519xchacha20poly1305_beforenm =
      _crypto_box_curve25519xchacha20poly1305_beforenmPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_easy_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_easy_afternm(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_easy_afternmPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_easy_afternm');
  late final _crypto_box_curve25519xchacha20poly1305_easy_afternm =
      _crypto_box_curve25519xchacha20poly1305_easy_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_open_easy_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_open_easy_afternm(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_open_easy_afternmPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.UnsignedLongLong,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>)>>(
          'crypto_box_curve25519xchacha20poly1305_open_easy_afternm');
  late final _crypto_box_curve25519xchacha20poly1305_open_easy_afternm =
      _crypto_box_curve25519xchacha20poly1305_open_easy_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_detached_afternm(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_detached_afternm(
      c,
      mac,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_detached_afternmPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.UnsignedLongLong,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>)>>(
          'crypto_box_curve25519xchacha20poly1305_detached_afternm');
  late final _crypto_box_curve25519xchacha20poly1305_detached_afternm =
      _crypto_box_curve25519xchacha20poly1305_detached_afternmPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
      m,
      c,
      mac,
      clen,
      n,
      k,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_open_detached_afternmPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.UnsignedLongLong,
                      ffi.Pointer<ffi.UnsignedChar>,
                      ffi.Pointer<ffi.UnsignedChar>)>>(
          'crypto_box_curve25519xchacha20poly1305_open_detached_afternm');
  late final _crypto_box_curve25519xchacha20poly1305_open_detached_afternm =
      _crypto_box_curve25519xchacha20poly1305_open_detached_afternmPtr
          .asFunction<
              int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  int,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_sealbytes() {
    return _crypto_box_curve25519xchacha20poly1305_sealbytes();
  }

  late final _crypto_box_curve25519xchacha20poly1305_sealbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_box_curve25519xchacha20poly1305_sealbytes');
  late final _crypto_box_curve25519xchacha20poly1305_sealbytes =
      _crypto_box_curve25519xchacha20poly1305_sealbytesPtr
          .asFunction<int Function()>();

  int crypto_box_curve25519xchacha20poly1305_seal(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> pk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_seal(
      c,
      m,
      mlen,
      pk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_sealPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_seal');
  late final _crypto_box_curve25519xchacha20poly1305_seal =
      _crypto_box_curve25519xchacha20poly1305_sealPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_box_curve25519xchacha20poly1305_seal_open(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> pk,
    ffi.Pointer<ffi.UnsignedChar> sk,
  ) {
    return _crypto_box_curve25519xchacha20poly1305_seal_open(
      m,
      c,
      clen,
      pk,
      sk,
    );
  }

  late final _crypto_box_curve25519xchacha20poly1305_seal_openPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_box_curve25519xchacha20poly1305_seal_open');
  late final _crypto_box_curve25519xchacha20poly1305_seal_open =
      _crypto_box_curve25519xchacha20poly1305_seal_openPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ed25519_bytes() {
    return _crypto_core_ed25519_bytes();
  }

  late final _crypto_core_ed25519_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ed25519_bytes');
  late final _crypto_core_ed25519_bytes =
      _crypto_core_ed25519_bytesPtr.asFunction<int Function()>();

  int crypto_core_ed25519_uniformbytes() {
    return _crypto_core_ed25519_uniformbytes();
  }

  late final _crypto_core_ed25519_uniformbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ed25519_uniformbytes');
  late final _crypto_core_ed25519_uniformbytes =
      _crypto_core_ed25519_uniformbytesPtr.asFunction<int Function()>();

  int crypto_core_ed25519_hashbytes() {
    return _crypto_core_ed25519_hashbytes();
  }

  late final _crypto_core_ed25519_hashbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ed25519_hashbytes');
  late final _crypto_core_ed25519_hashbytes =
      _crypto_core_ed25519_hashbytesPtr.asFunction<int Function()>();

  int crypto_core_ed25519_scalarbytes() {
    return _crypto_core_ed25519_scalarbytes();
  }

  late final _crypto_core_ed25519_scalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ed25519_scalarbytes');
  late final _crypto_core_ed25519_scalarbytes =
      _crypto_core_ed25519_scalarbytesPtr.asFunction<int Function()>();

  int crypto_core_ed25519_nonreducedscalarbytes() {
    return _crypto_core_ed25519_nonreducedscalarbytes();
  }

  late final _crypto_core_ed25519_nonreducedscalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ed25519_nonreducedscalarbytes');
  late final _crypto_core_ed25519_nonreducedscalarbytes =
      _crypto_core_ed25519_nonreducedscalarbytesPtr
          .asFunction<int Function()>();

  int crypto_core_ed25519_is_valid_point(
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_core_ed25519_is_valid_point(
      p,
    );
  }

  late final _crypto_core_ed25519_is_valid_pointPtr = _lookup<
          ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_is_valid_point');
  late final _crypto_core_ed25519_is_valid_point =
      _crypto_core_ed25519_is_valid_pointPtr
          .asFunction<int Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ed25519_add(
    ffi.Pointer<ffi.UnsignedChar> r,
    ffi.Pointer<ffi.UnsignedChar> p,
    ffi.Pointer<ffi.UnsignedChar> q,
  ) {
    return _crypto_core_ed25519_add(
      r,
      p,
      q,
    );
  }

  late final _crypto_core_ed25519_addPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_ed25519_add');
  late final _crypto_core_ed25519_add = _crypto_core_ed25519_addPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ed25519_sub(
    ffi.Pointer<ffi.UnsignedChar> r,
    ffi.Pointer<ffi.UnsignedChar> p,
    ffi.Pointer<ffi.UnsignedChar> q,
  ) {
    return _crypto_core_ed25519_sub(
      r,
      p,
      q,
    );
  }

  late final _crypto_core_ed25519_subPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_ed25519_sub');
  late final _crypto_core_ed25519_sub = _crypto_core_ed25519_subPtr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>,
          ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ed25519_from_uniform(
    ffi.Pointer<ffi.UnsignedChar> p,
    ffi.Pointer<ffi.UnsignedChar> r,
  ) {
    return _crypto_core_ed25519_from_uniform(
      p,
      r,
    );
  }

  late final _crypto_core_ed25519_from_uniformPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_from_uniform');
  late final _crypto_core_ed25519_from_uniform =
      _crypto_core_ed25519_from_uniformPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ed25519_from_hash(
    ffi.Pointer<ffi.UnsignedChar> p,
    ffi.Pointer<ffi.UnsignedChar> h,
  ) {
    return _crypto_core_ed25519_from_hash(
      p,
      h,
    );
  }

  late final _crypto_core_ed25519_from_hashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_ed25519_from_hash');
  late final _crypto_core_ed25519_from_hash =
      _crypto_core_ed25519_from_hashPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_random(
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_core_ed25519_random(
      p,
    );
  }

  late final _crypto_core_ed25519_randomPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_random');
  late final _crypto_core_ed25519_random = _crypto_core_ed25519_randomPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_scalar_random(
    ffi.Pointer<ffi.UnsignedChar> r,
  ) {
    return _crypto_core_ed25519_scalar_random(
      r,
    );
  }

  late final _crypto_core_ed25519_scalar_randomPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_random');
  late final _crypto_core_ed25519_scalar_random =
      _crypto_core_ed25519_scalar_randomPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ed25519_scalar_invert(
    ffi.Pointer<ffi.UnsignedChar> recip,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ed25519_scalar_invert(
      recip,
      s,
    );
  }

  late final _crypto_core_ed25519_scalar_invertPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_invert');
  late final _crypto_core_ed25519_scalar_invert =
      _crypto_core_ed25519_scalar_invertPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_scalar_negate(
    ffi.Pointer<ffi.UnsignedChar> neg,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ed25519_scalar_negate(
      neg,
      s,
    );
  }

  late final _crypto_core_ed25519_scalar_negatePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_negate');
  late final _crypto_core_ed25519_scalar_negate =
      _crypto_core_ed25519_scalar_negatePtr.asFunction<
          void Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_scalar_complement(
    ffi.Pointer<ffi.UnsignedChar> comp,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ed25519_scalar_complement(
      comp,
      s,
    );
  }

  late final _crypto_core_ed25519_scalar_complementPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_complement');
  late final _crypto_core_ed25519_scalar_complement =
      _crypto_core_ed25519_scalar_complementPtr.asFunction<
          void Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_scalar_add(
    ffi.Pointer<ffi.UnsignedChar> z,
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_core_ed25519_scalar_add(
      z,
      x,
      y,
    );
  }

  late final _crypto_core_ed25519_scalar_addPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_add');
  late final _crypto_core_ed25519_scalar_add =
      _crypto_core_ed25519_scalar_addPtr.asFunction<
          void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_scalar_sub(
    ffi.Pointer<ffi.UnsignedChar> z,
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_core_ed25519_scalar_sub(
      z,
      x,
      y,
    );
  }

  late final _crypto_core_ed25519_scalar_subPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_sub');
  late final _crypto_core_ed25519_scalar_sub =
      _crypto_core_ed25519_scalar_subPtr.asFunction<
          void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_scalar_mul(
    ffi.Pointer<ffi.UnsignedChar> z,
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_core_ed25519_scalar_mul(
      z,
      x,
      y,
    );
  }

  late final _crypto_core_ed25519_scalar_mulPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_mul');
  late final _crypto_core_ed25519_scalar_mul =
      _crypto_core_ed25519_scalar_mulPtr.asFunction<
          void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ed25519_scalar_reduce(
    ffi.Pointer<ffi.UnsignedChar> r,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ed25519_scalar_reduce(
      r,
      s,
    );
  }

  late final _crypto_core_ed25519_scalar_reducePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ed25519_scalar_reduce');
  late final _crypto_core_ed25519_scalar_reduce =
      _crypto_core_ed25519_scalar_reducePtr.asFunction<
          void Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ristretto255_bytes() {
    return _crypto_core_ristretto255_bytes();
  }

  late final _crypto_core_ristretto255_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ristretto255_bytes');
  late final _crypto_core_ristretto255_bytes =
      _crypto_core_ristretto255_bytesPtr.asFunction<int Function()>();

  int crypto_core_ristretto255_hashbytes() {
    return _crypto_core_ristretto255_hashbytes();
  }

  late final _crypto_core_ristretto255_hashbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ristretto255_hashbytes');
  late final _crypto_core_ristretto255_hashbytes =
      _crypto_core_ristretto255_hashbytesPtr.asFunction<int Function()>();

  int crypto_core_ristretto255_scalarbytes() {
    return _crypto_core_ristretto255_scalarbytes();
  }

  late final _crypto_core_ristretto255_scalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ristretto255_scalarbytes');
  late final _crypto_core_ristretto255_scalarbytes =
      _crypto_core_ristretto255_scalarbytesPtr.asFunction<int Function()>();

  int crypto_core_ristretto255_nonreducedscalarbytes() {
    return _crypto_core_ristretto255_nonreducedscalarbytes();
  }

  late final _crypto_core_ristretto255_nonreducedscalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_core_ristretto255_nonreducedscalarbytes');
  late final _crypto_core_ristretto255_nonreducedscalarbytes =
      _crypto_core_ristretto255_nonreducedscalarbytesPtr
          .asFunction<int Function()>();

  int crypto_core_ristretto255_is_valid_point(
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_core_ristretto255_is_valid_point(
      p,
    );
  }

  late final _crypto_core_ristretto255_is_valid_pointPtr = _lookup<
          ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_is_valid_point');
  late final _crypto_core_ristretto255_is_valid_point =
      _crypto_core_ristretto255_is_valid_pointPtr
          .asFunction<int Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ristretto255_add(
    ffi.Pointer<ffi.UnsignedChar> r,
    ffi.Pointer<ffi.UnsignedChar> p,
    ffi.Pointer<ffi.UnsignedChar> q,
  ) {
    return _crypto_core_ristretto255_add(
      r,
      p,
      q,
    );
  }

  late final _crypto_core_ristretto255_addPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_ristretto255_add');
  late final _crypto_core_ristretto255_add =
      _crypto_core_ristretto255_addPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ristretto255_sub(
    ffi.Pointer<ffi.UnsignedChar> r,
    ffi.Pointer<ffi.UnsignedChar> p,
    ffi.Pointer<ffi.UnsignedChar> q,
  ) {
    return _crypto_core_ristretto255_sub(
      r,
      p,
      q,
    );
  }

  late final _crypto_core_ristretto255_subPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_core_ristretto255_sub');
  late final _crypto_core_ristretto255_sub =
      _crypto_core_ristretto255_subPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ristretto255_from_hash(
    ffi.Pointer<ffi.UnsignedChar> p,
    ffi.Pointer<ffi.UnsignedChar> r,
  ) {
    return _crypto_core_ristretto255_from_hash(
      p,
      r,
    );
  }

  late final _crypto_core_ristretto255_from_hashPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_from_hash');
  late final _crypto_core_ristretto255_from_hash =
      _crypto_core_ristretto255_from_hashPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_random(
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_core_ristretto255_random(
      p,
    );
  }

  late final _crypto_core_ristretto255_randomPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_random');
  late final _crypto_core_ristretto255_random =
      _crypto_core_ristretto255_randomPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_scalar_random(
    ffi.Pointer<ffi.UnsignedChar> r,
  ) {
    return _crypto_core_ristretto255_scalar_random(
      r,
    );
  }

  late final _crypto_core_ristretto255_scalar_randomPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_random');
  late final _crypto_core_ristretto255_scalar_random =
      _crypto_core_ristretto255_scalar_randomPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_core_ristretto255_scalar_invert(
    ffi.Pointer<ffi.UnsignedChar> recip,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ristretto255_scalar_invert(
      recip,
      s,
    );
  }

  late final _crypto_core_ristretto255_scalar_invertPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_invert');
  late final _crypto_core_ristretto255_scalar_invert =
      _crypto_core_ristretto255_scalar_invertPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_scalar_negate(
    ffi.Pointer<ffi.UnsignedChar> neg,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ristretto255_scalar_negate(
      neg,
      s,
    );
  }

  late final _crypto_core_ristretto255_scalar_negatePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_negate');
  late final _crypto_core_ristretto255_scalar_negate =
      _crypto_core_ristretto255_scalar_negatePtr.asFunction<
          void Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_scalar_complement(
    ffi.Pointer<ffi.UnsignedChar> comp,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ristretto255_scalar_complement(
      comp,
      s,
    );
  }

  late final _crypto_core_ristretto255_scalar_complementPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_complement');
  late final _crypto_core_ristretto255_scalar_complement =
      _crypto_core_ristretto255_scalar_complementPtr.asFunction<
          void Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_scalar_add(
    ffi.Pointer<ffi.UnsignedChar> z,
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_core_ristretto255_scalar_add(
      z,
      x,
      y,
    );
  }

  late final _crypto_core_ristretto255_scalar_addPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_add');
  late final _crypto_core_ristretto255_scalar_add =
      _crypto_core_ristretto255_scalar_addPtr.asFunction<
          void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_scalar_sub(
    ffi.Pointer<ffi.UnsignedChar> z,
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_core_ristretto255_scalar_sub(
      z,
      x,
      y,
    );
  }

  late final _crypto_core_ristretto255_scalar_subPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_sub');
  late final _crypto_core_ristretto255_scalar_sub =
      _crypto_core_ristretto255_scalar_subPtr.asFunction<
          void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_scalar_mul(
    ffi.Pointer<ffi.UnsignedChar> z,
    ffi.Pointer<ffi.UnsignedChar> x,
    ffi.Pointer<ffi.UnsignedChar> y,
  ) {
    return _crypto_core_ristretto255_scalar_mul(
      z,
      x,
      y,
    );
  }

  late final _crypto_core_ristretto255_scalar_mulPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_mul');
  late final _crypto_core_ristretto255_scalar_mul =
      _crypto_core_ristretto255_scalar_mulPtr.asFunction<
          void Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_core_ristretto255_scalar_reduce(
    ffi.Pointer<ffi.UnsignedChar> r,
    ffi.Pointer<ffi.UnsignedChar> s,
  ) {
    return _crypto_core_ristretto255_scalar_reduce(
      r,
      s,
    );
  }

  late final _crypto_core_ristretto255_scalar_reducePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_core_ristretto255_scalar_reduce');
  late final _crypto_core_ristretto255_scalar_reduce =
      _crypto_core_ristretto255_scalar_reducePtr.asFunction<
          void Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_pwhash_scryptsalsa208sha256_bytes_min() {
    return _crypto_pwhash_scryptsalsa208sha256_bytes_min();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_bytes_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_bytes_min');
  late final _crypto_pwhash_scryptsalsa208sha256_bytes_min =
      _crypto_pwhash_scryptsalsa208sha256_bytes_minPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_bytes_max() {
    return _crypto_pwhash_scryptsalsa208sha256_bytes_max();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_bytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_bytes_max');
  late final _crypto_pwhash_scryptsalsa208sha256_bytes_max =
      _crypto_pwhash_scryptsalsa208sha256_bytes_maxPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_passwd_min() {
    return _crypto_pwhash_scryptsalsa208sha256_passwd_min();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_passwd_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_passwd_min');
  late final _crypto_pwhash_scryptsalsa208sha256_passwd_min =
      _crypto_pwhash_scryptsalsa208sha256_passwd_minPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_passwd_max() {
    return _crypto_pwhash_scryptsalsa208sha256_passwd_max();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_passwd_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_passwd_max');
  late final _crypto_pwhash_scryptsalsa208sha256_passwd_max =
      _crypto_pwhash_scryptsalsa208sha256_passwd_maxPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_saltbytes() {
    return _crypto_pwhash_scryptsalsa208sha256_saltbytes();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_saltbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_saltbytes');
  late final _crypto_pwhash_scryptsalsa208sha256_saltbytes =
      _crypto_pwhash_scryptsalsa208sha256_saltbytesPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_strbytes() {
    return _crypto_pwhash_scryptsalsa208sha256_strbytes();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_strbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_strbytes');
  late final _crypto_pwhash_scryptsalsa208sha256_strbytes =
      _crypto_pwhash_scryptsalsa208sha256_strbytesPtr
          .asFunction<int Function()>();

  ffi.Pointer<ffi.Char> crypto_pwhash_scryptsalsa208sha256_strprefix() {
    return _crypto_pwhash_scryptsalsa208sha256_strprefix();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_strprefixPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_strprefix');
  late final _crypto_pwhash_scryptsalsa208sha256_strprefix =
      _crypto_pwhash_scryptsalsa208sha256_strprefixPtr
          .asFunction<ffi.Pointer<ffi.Char> Function()>();

  int crypto_pwhash_scryptsalsa208sha256_opslimit_min() {
    return _crypto_pwhash_scryptsalsa208sha256_opslimit_min();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_opslimit_min');
  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_min =
      _crypto_pwhash_scryptsalsa208sha256_opslimit_minPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_opslimit_max() {
    return _crypto_pwhash_scryptsalsa208sha256_opslimit_max();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_opslimit_max');
  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_max =
      _crypto_pwhash_scryptsalsa208sha256_opslimit_maxPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_memlimit_min() {
    return _crypto_pwhash_scryptsalsa208sha256_memlimit_min();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_minPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_memlimit_min');
  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_min =
      _crypto_pwhash_scryptsalsa208sha256_memlimit_minPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_memlimit_max() {
    return _crypto_pwhash_scryptsalsa208sha256_memlimit_max();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_memlimit_max');
  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_max =
      _crypto_pwhash_scryptsalsa208sha256_memlimit_maxPtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_opslimit_interactive() {
    return _crypto_pwhash_scryptsalsa208sha256_opslimit_interactive();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_opslimit_interactive');
  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_interactive =
      _crypto_pwhash_scryptsalsa208sha256_opslimit_interactivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_memlimit_interactive() {
    return _crypto_pwhash_scryptsalsa208sha256_memlimit_interactive();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_interactivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_memlimit_interactive');
  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_interactive =
      _crypto_pwhash_scryptsalsa208sha256_memlimit_interactivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive() {
    return _crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive');
  late final _crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive =
      _crypto_pwhash_scryptsalsa208sha256_opslimit_sensitivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive() {
    return _crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive();
  }

  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_sensitivePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive');
  late final _crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive =
      _crypto_pwhash_scryptsalsa208sha256_memlimit_sensitivePtr
          .asFunction<int Function()>();

  int crypto_pwhash_scryptsalsa208sha256(
    ffi.Pointer<ffi.UnsignedChar> out,
    int outlen,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    ffi.Pointer<ffi.UnsignedChar> salt,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_scryptsalsa208sha256(
      out,
      outlen,
      passwd,
      passwdlen,
      salt,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_scryptsalsa208sha256Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_scryptsalsa208sha256');
  late final _crypto_pwhash_scryptsalsa208sha256 =
      _crypto_pwhash_scryptsalsa208sha256Ptr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.Char>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              int)>();

  int crypto_pwhash_scryptsalsa208sha256_str(
    ffi.Pointer<ffi.Char> out,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_scryptsalsa208sha256_str(
      out,
      passwd,
      passwdlen,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_scryptsalsa208sha256_strPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.UnsignedLongLong,
              ffi.UnsignedLongLong,
              ffi.Size)>>('crypto_pwhash_scryptsalsa208sha256_str');
  late final _crypto_pwhash_scryptsalsa208sha256_str =
      _crypto_pwhash_scryptsalsa208sha256_strPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int, int, int)>();

  int crypto_pwhash_scryptsalsa208sha256_str_verify(
    ffi.Pointer<ffi.Char> str,
    ffi.Pointer<ffi.Char> passwd,
    int passwdlen,
  ) {
    return _crypto_pwhash_scryptsalsa208sha256_str_verify(
      str,
      passwd,
      passwdlen,
    );
  }

  late final _crypto_pwhash_scryptsalsa208sha256_str_verifyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
                  ffi.UnsignedLongLong)>>(
      'crypto_pwhash_scryptsalsa208sha256_str_verify');
  late final _crypto_pwhash_scryptsalsa208sha256_str_verify =
      _crypto_pwhash_scryptsalsa208sha256_str_verifyPtr.asFunction<
          int Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();

  int crypto_pwhash_scryptsalsa208sha256_ll(
    ffi.Pointer<ffi.Uint8> passwd,
    int passwdlen,
    ffi.Pointer<ffi.Uint8> salt,
    int saltlen,
    int N,
    int r,
    int p,
    ffi.Pointer<ffi.Uint8> buf,
    int buflen,
  ) {
    return _crypto_pwhash_scryptsalsa208sha256_ll(
      passwd,
      passwdlen,
      salt,
      saltlen,
      N,
      r,
      p,
      buf,
      buflen,
    );
  }

  late final _crypto_pwhash_scryptsalsa208sha256_llPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.Uint8>,
              ffi.Size,
              ffi.Pointer<ffi.Uint8>,
              ffi.Size,
              ffi.Uint64,
              ffi.Uint32,
              ffi.Uint32,
              ffi.Pointer<ffi.Uint8>,
              ffi.Size)>>('crypto_pwhash_scryptsalsa208sha256_ll');
  late final _crypto_pwhash_scryptsalsa208sha256_ll =
      _crypto_pwhash_scryptsalsa208sha256_llPtr.asFunction<
          int Function(ffi.Pointer<ffi.Uint8>, int, ffi.Pointer<ffi.Uint8>, int,
              int, int, int, ffi.Pointer<ffi.Uint8>, int)>();

  int crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(
    ffi.Pointer<ffi.Char> str,
    int opslimit,
    int memlimit,
  ) {
    return _crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(
      str,
      opslimit,
      memlimit,
    );
  }

  late final _crypto_pwhash_scryptsalsa208sha256_str_needs_rehashPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.Char>, ffi.UnsignedLongLong, ffi.Size)>>(
      'crypto_pwhash_scryptsalsa208sha256_str_needs_rehash');
  late final _crypto_pwhash_scryptsalsa208sha256_str_needs_rehash =
      _crypto_pwhash_scryptsalsa208sha256_str_needs_rehashPtr
          .asFunction<int Function(ffi.Pointer<ffi.Char>, int, int)>();

  int crypto_scalarmult_ed25519_bytes() {
    return _crypto_scalarmult_ed25519_bytes();
  }

  late final _crypto_scalarmult_ed25519_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_ed25519_bytes');
  late final _crypto_scalarmult_ed25519_bytes =
      _crypto_scalarmult_ed25519_bytesPtr.asFunction<int Function()>();

  int crypto_scalarmult_ed25519_scalarbytes() {
    return _crypto_scalarmult_ed25519_scalarbytes();
  }

  late final _crypto_scalarmult_ed25519_scalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_ed25519_scalarbytes');
  late final _crypto_scalarmult_ed25519_scalarbytes =
      _crypto_scalarmult_ed25519_scalarbytesPtr.asFunction<int Function()>();

  int crypto_scalarmult_ed25519(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_scalarmult_ed25519(
      q,
      n,
      p,
    );
  }

  late final _crypto_scalarmult_ed25519Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_scalarmult_ed25519');
  late final _crypto_scalarmult_ed25519 =
      _crypto_scalarmult_ed25519Ptr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult_ed25519_noclamp(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_scalarmult_ed25519_noclamp(
      q,
      n,
      p,
    );
  }

  late final _crypto_scalarmult_ed25519_noclampPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_scalarmult_ed25519_noclamp');
  late final _crypto_scalarmult_ed25519_noclamp =
      _crypto_scalarmult_ed25519_noclampPtr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult_ed25519_base(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
  ) {
    return _crypto_scalarmult_ed25519_base(
      q,
      n,
    );
  }

  late final _crypto_scalarmult_ed25519_basePtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_scalarmult_ed25519_base');
  late final _crypto_scalarmult_ed25519_base =
      _crypto_scalarmult_ed25519_basePtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult_ed25519_base_noclamp(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
  ) {
    return _crypto_scalarmult_ed25519_base_noclamp(
      q,
      n,
    );
  }

  late final _crypto_scalarmult_ed25519_base_noclampPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_scalarmult_ed25519_base_noclamp');
  late final _crypto_scalarmult_ed25519_base_noclamp =
      _crypto_scalarmult_ed25519_base_noclampPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult_ristretto255_bytes() {
    return _crypto_scalarmult_ristretto255_bytes();
  }

  late final _crypto_scalarmult_ristretto255_bytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_ristretto255_bytes');
  late final _crypto_scalarmult_ristretto255_bytes =
      _crypto_scalarmult_ristretto255_bytesPtr.asFunction<int Function()>();

  int crypto_scalarmult_ristretto255_scalarbytes() {
    return _crypto_scalarmult_ristretto255_scalarbytes();
  }

  late final _crypto_scalarmult_ristretto255_scalarbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_scalarmult_ristretto255_scalarbytes');
  late final _crypto_scalarmult_ristretto255_scalarbytes =
      _crypto_scalarmult_ristretto255_scalarbytesPtr
          .asFunction<int Function()>();

  int crypto_scalarmult_ristretto255(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> p,
  ) {
    return _crypto_scalarmult_ristretto255(
      q,
      n,
      p,
    );
  }

  late final _crypto_scalarmult_ristretto255Ptr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_scalarmult_ristretto255');
  late final _crypto_scalarmult_ristretto255 =
      _crypto_scalarmult_ristretto255Ptr.asFunction<
          int Function(ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_scalarmult_ristretto255_base(
    ffi.Pointer<ffi.UnsignedChar> q,
    ffi.Pointer<ffi.UnsignedChar> n,
  ) {
    return _crypto_scalarmult_ristretto255_base(
      q,
      n,
    );
  }

  late final _crypto_scalarmult_ristretto255_basePtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_scalarmult_ristretto255_base');
  late final _crypto_scalarmult_ristretto255_base =
      _crypto_scalarmult_ristretto255_basePtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_xchacha20poly1305_keybytes() {
    return _crypto_secretbox_xchacha20poly1305_keybytes();
  }

  late final _crypto_secretbox_xchacha20poly1305_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xchacha20poly1305_keybytes');
  late final _crypto_secretbox_xchacha20poly1305_keybytes =
      _crypto_secretbox_xchacha20poly1305_keybytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xchacha20poly1305_noncebytes() {
    return _crypto_secretbox_xchacha20poly1305_noncebytes();
  }

  late final _crypto_secretbox_xchacha20poly1305_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xchacha20poly1305_noncebytes');
  late final _crypto_secretbox_xchacha20poly1305_noncebytes =
      _crypto_secretbox_xchacha20poly1305_noncebytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xchacha20poly1305_macbytes() {
    return _crypto_secretbox_xchacha20poly1305_macbytes();
  }

  late final _crypto_secretbox_xchacha20poly1305_macbytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xchacha20poly1305_macbytes');
  late final _crypto_secretbox_xchacha20poly1305_macbytes =
      _crypto_secretbox_xchacha20poly1305_macbytesPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xchacha20poly1305_messagebytes_max() {
    return _crypto_secretbox_xchacha20poly1305_messagebytes_max();
  }

  late final _crypto_secretbox_xchacha20poly1305_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_secretbox_xchacha20poly1305_messagebytes_max');
  late final _crypto_secretbox_xchacha20poly1305_messagebytes_max =
      _crypto_secretbox_xchacha20poly1305_messagebytes_maxPtr
          .asFunction<int Function()>();

  int crypto_secretbox_xchacha20poly1305_easy(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_xchacha20poly1305_easy(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_xchacha20poly1305_easyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_xchacha20poly1305_easy');
  late final _crypto_secretbox_xchacha20poly1305_easy =
      _crypto_secretbox_xchacha20poly1305_easyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_xchacha20poly1305_open_easy(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_xchacha20poly1305_open_easy(
      m,
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_xchacha20poly1305_open_easyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_xchacha20poly1305_open_easy');
  late final _crypto_secretbox_xchacha20poly1305_open_easy =
      _crypto_secretbox_xchacha20poly1305_open_easyPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_xchacha20poly1305_detached(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_xchacha20poly1305_detached(
      c,
      mac,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_xchacha20poly1305_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_xchacha20poly1305_detached');
  late final _crypto_secretbox_xchacha20poly1305_detached =
      _crypto_secretbox_xchacha20poly1305_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_secretbox_xchacha20poly1305_open_detached(
    ffi.Pointer<ffi.UnsignedChar> m,
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> mac,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_secretbox_xchacha20poly1305_open_detached(
      m,
      c,
      mac,
      clen,
      n,
      k,
    );
  }

  late final _crypto_secretbox_xchacha20poly1305_open_detachedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Int Function(
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.UnsignedLongLong,
                  ffi.Pointer<ffi.UnsignedChar>,
                  ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_secretbox_xchacha20poly1305_open_detached');
  late final _crypto_secretbox_xchacha20poly1305_open_detached =
      _crypto_secretbox_xchacha20poly1305_open_detachedPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_salsa2012_keybytes() {
    return _crypto_stream_salsa2012_keybytes();
  }

  late final _crypto_stream_salsa2012_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa2012_keybytes');
  late final _crypto_stream_salsa2012_keybytes =
      _crypto_stream_salsa2012_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_salsa2012_noncebytes() {
    return _crypto_stream_salsa2012_noncebytes();
  }

  late final _crypto_stream_salsa2012_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa2012_noncebytes');
  late final _crypto_stream_salsa2012_noncebytes =
      _crypto_stream_salsa2012_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_salsa2012_messagebytes_max() {
    return _crypto_stream_salsa2012_messagebytes_max();
  }

  late final _crypto_stream_salsa2012_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa2012_messagebytes_max');
  late final _crypto_stream_salsa2012_messagebytes_max =
      _crypto_stream_salsa2012_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_stream_salsa2012(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa2012(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_stream_salsa2012Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_salsa2012');
  late final _crypto_stream_salsa2012 = _crypto_stream_salsa2012Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_salsa2012_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa2012_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_salsa2012_xorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_salsa2012_xor');
  late final _crypto_stream_salsa2012_xor =
      _crypto_stream_salsa2012_xorPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_salsa2012_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa2012_keygen(
      k,
    );
  }

  late final _crypto_stream_salsa2012_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_salsa2012_keygen');
  late final _crypto_stream_salsa2012_keygen =
      _crypto_stream_salsa2012_keygenPtr
          .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_salsa208_keybytes() {
    return _crypto_stream_salsa208_keybytes();
  }

  late final _crypto_stream_salsa208_keybytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa208_keybytes');
  late final _crypto_stream_salsa208_keybytes =
      _crypto_stream_salsa208_keybytesPtr.asFunction<int Function()>();

  int crypto_stream_salsa208_noncebytes() {
    return _crypto_stream_salsa208_noncebytes();
  }

  late final _crypto_stream_salsa208_noncebytesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa208_noncebytes');
  late final _crypto_stream_salsa208_noncebytes =
      _crypto_stream_salsa208_noncebytesPtr.asFunction<int Function()>();

  int crypto_stream_salsa208_messagebytes_max() {
    return _crypto_stream_salsa208_messagebytes_max();
  }

  late final _crypto_stream_salsa208_messagebytes_maxPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function()>>(
          'crypto_stream_salsa208_messagebytes_max');
  late final _crypto_stream_salsa208_messagebytes_max =
      _crypto_stream_salsa208_messagebytes_maxPtr.asFunction<int Function()>();

  int crypto_stream_salsa208(
    ffi.Pointer<ffi.UnsignedChar> c,
    int clen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa208(
      c,
      clen,
      n,
      k,
    );
  }

  late final _crypto_stream_salsa208Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_salsa208');
  late final _crypto_stream_salsa208 = _crypto_stream_salsa208Ptr.asFunction<
      int Function(ffi.Pointer<ffi.UnsignedChar>, int,
          ffi.Pointer<ffi.UnsignedChar>, ffi.Pointer<ffi.UnsignedChar>)>();

  int crypto_stream_salsa208_xor(
    ffi.Pointer<ffi.UnsignedChar> c,
    ffi.Pointer<ffi.UnsignedChar> m,
    int mlen,
    ffi.Pointer<ffi.UnsignedChar> n,
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa208_xor(
      c,
      m,
      mlen,
      n,
      k,
    );
  }

  late final _crypto_stream_salsa208_xorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.UnsignedLongLong,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>>('crypto_stream_salsa208_xor');
  late final _crypto_stream_salsa208_xor =
      _crypto_stream_salsa208_xorPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>,
              int,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Pointer<ffi.UnsignedChar>)>();

  void crypto_stream_salsa208_keygen(
    ffi.Pointer<ffi.UnsignedChar> k,
  ) {
    return _crypto_stream_salsa208_keygen(
      k,
    );
  }

  late final _crypto_stream_salsa208_keygenPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.UnsignedChar>)>>(
      'crypto_stream_salsa208_keygen');
  late final _crypto_stream_salsa208_keygen = _crypto_stream_salsa208_keygenPtr
      .asFunction<void Function(ffi.Pointer<ffi.UnsignedChar>)>();
}

final class crypto_aead_aes256gcm_state_ extends ffi.Struct {
  @ffi.Array.multi([512])
  external ffi.Array<ffi.UnsignedChar> opaque;
}

typedef crypto_aead_aes256gcm_state = crypto_aead_aes256gcm_state_;

final class crypto_hash_sha512_state extends ffi.Struct {
  @ffi.Array.multi([8])
  external ffi.Array<ffi.Uint64> state;

  @ffi.Array.multi([2])
  external ffi.Array<ffi.Uint64> count;

  @ffi.Array.multi([128])
  external ffi.Array<ffi.Uint8> buf;
}

final class crypto_auth_hmacsha512_state extends ffi.Struct {
  external crypto_hash_sha512_state ictx;

  external crypto_hash_sha512_state octx;
}

typedef crypto_auth_hmacsha512256_state = crypto_auth_hmacsha512_state;

final class crypto_hash_sha256_state extends ffi.Struct {
  @ffi.Array.multi([8])
  external ffi.Array<ffi.Uint32> state;

  @ffi.Uint64()
  external int count;

  @ffi.Array.multi([64])
  external ffi.Array<ffi.Uint8> buf;
}

final class crypto_auth_hmacsha256_state extends ffi.Struct {
  external crypto_hash_sha256_state ictx;

  external crypto_hash_sha256_state octx;
}

final class crypto_generichash_blake2b_state extends ffi.Struct {
  @ffi.Array.multi([384])
  external ffi.Array<ffi.UnsignedChar> opaque;
}

typedef crypto_generichash_state = crypto_generichash_blake2b_state;

final class crypto_kdf_hkdf_sha256_state extends ffi.Struct {
  external crypto_auth_hmacsha256_state st;
}

final class crypto_kdf_hkdf_sha512_state extends ffi.Struct {
  external crypto_auth_hmacsha512_state st;
}

final class crypto_onetimeauth_poly1305_state extends ffi.Struct {
  @ffi.Array.multi([256])
  external ffi.Array<ffi.UnsignedChar> opaque;
}

typedef crypto_onetimeauth_state = crypto_onetimeauth_poly1305_state;

final class crypto_secretstream_xchacha20poly1305_state extends ffi.Struct {
  @ffi.Array.multi([32])
  external ffi.Array<ffi.UnsignedChar> k;

  @ffi.Array.multi([12])
  external ffi.Array<ffi.UnsignedChar> nonce;

  @ffi.Array.multi([8])
  external ffi.Array<ffi.UnsignedChar> _pad;
}

final class crypto_sign_ed25519ph_state extends ffi.Struct {
  external crypto_hash_sha512_state hs;
}

typedef crypto_sign_state = crypto_sign_ed25519ph_state;

final class randombytes_implementation extends ffi.Struct {
  external ffi.Pointer<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>
      implementation_name;

  external ffi.Pointer<ffi.NativeFunction<ffi.Uint32 Function()>> random;

  external ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>> stir;

  external ffi
      .Pointer<ffi.NativeFunction<ffi.Uint32 Function(ffi.Uint32 upper_bound)>>
      uniform;

  external ffi.Pointer<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void> buf, ffi.Size size)>> buf;

  external ffi.Pointer<ffi.NativeFunction<ffi.Int Function()>> close;
}

const int SODIUM_SIZE_MAX = -1;

const String SODIUM_VERSION_STRING = '1.0.19';

const int SODIUM_LIBRARY_VERSION_MAJOR = 26;

const int SODIUM_LIBRARY_VERSION_MINOR = 1;

const int crypto_aead_aegis128l_KEYBYTES = 16;

const int crypto_aead_aegis128l_NSECBYTES = 0;

const int crypto_aead_aegis128l_NPUBBYTES = 16;

const int crypto_aead_aegis128l_ABYTES = 32;

const int crypto_aead_aegis128l_MESSAGEBYTES_MAX = 2305843009213693951;

const int crypto_aead_aegis256_KEYBYTES = 32;

const int crypto_aead_aegis256_NSECBYTES = 0;

const int crypto_aead_aegis256_NPUBBYTES = 32;

const int crypto_aead_aegis256_ABYTES = 32;

const int crypto_aead_aegis256_MESSAGEBYTES_MAX = 2305843009213693951;

const int crypto_aead_aes256gcm_KEYBYTES = 32;

const int crypto_aead_aes256gcm_NSECBYTES = 0;

const int crypto_aead_aes256gcm_NPUBBYTES = 12;

const int crypto_aead_aes256gcm_ABYTES = 16;

const int crypto_aead_aes256gcm_MESSAGEBYTES_MAX = 68719476704;

const int crypto_aead_chacha20poly1305_ietf_KEYBYTES = 32;

const int crypto_aead_chacha20poly1305_ietf_NSECBYTES = 0;

const int crypto_aead_chacha20poly1305_ietf_NPUBBYTES = 12;

const int crypto_aead_chacha20poly1305_ietf_ABYTES = 16;

const int crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX = 274877906880;

const int crypto_aead_chacha20poly1305_KEYBYTES = 32;

const int crypto_aead_chacha20poly1305_NSECBYTES = 0;

const int crypto_aead_chacha20poly1305_NPUBBYTES = 8;

const int crypto_aead_chacha20poly1305_ABYTES = 16;

const int crypto_aead_chacha20poly1305_MESSAGEBYTES_MAX = -17;

const int crypto_aead_chacha20poly1305_IETF_KEYBYTES = 32;

const int crypto_aead_chacha20poly1305_IETF_NSECBYTES = 0;

const int crypto_aead_chacha20poly1305_IETF_NPUBBYTES = 12;

const int crypto_aead_chacha20poly1305_IETF_ABYTES = 16;

const int crypto_aead_chacha20poly1305_IETF_MESSAGEBYTES_MAX = 274877906880;

const int crypto_aead_xchacha20poly1305_ietf_KEYBYTES = 32;

const int crypto_aead_xchacha20poly1305_ietf_NSECBYTES = 0;

const int crypto_aead_xchacha20poly1305_ietf_NPUBBYTES = 24;

const int crypto_aead_xchacha20poly1305_ietf_ABYTES = 16;

const int crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX = -17;

const int crypto_aead_xchacha20poly1305_IETF_KEYBYTES = 32;

const int crypto_aead_xchacha20poly1305_IETF_NSECBYTES = 0;

const int crypto_aead_xchacha20poly1305_IETF_NPUBBYTES = 24;

const int crypto_aead_xchacha20poly1305_IETF_ABYTES = 16;

const int crypto_aead_xchacha20poly1305_IETF_MESSAGEBYTES_MAX = -17;

const int crypto_hash_sha512_BYTES = 64;

const int crypto_auth_hmacsha512_BYTES = 64;

const int crypto_auth_hmacsha512_KEYBYTES = 32;

const int crypto_auth_hmacsha512256_BYTES = 32;

const int crypto_auth_hmacsha512256_KEYBYTES = 32;

const int crypto_auth_BYTES = 32;

const int crypto_auth_KEYBYTES = 32;

const String crypto_auth_PRIMITIVE = 'hmacsha512256';

const int crypto_hash_sha256_BYTES = 32;

const int crypto_auth_hmacsha256_BYTES = 32;

const int crypto_auth_hmacsha256_KEYBYTES = 32;

const int crypto_stream_xsalsa20_KEYBYTES = 32;

const int crypto_stream_xsalsa20_NONCEBYTES = 24;

const int crypto_stream_xsalsa20_MESSAGEBYTES_MAX = -1;

const int crypto_box_curve25519xsalsa20poly1305_SEEDBYTES = 32;

const int crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES = 32;

const int crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES = 32;

const int crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES = 32;

const int crypto_box_curve25519xsalsa20poly1305_NONCEBYTES = 24;

const int crypto_box_curve25519xsalsa20poly1305_MACBYTES = 16;

const int crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX = -17;

const int crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES = 16;

const int crypto_box_curve25519xsalsa20poly1305_ZEROBYTES = 32;

const int crypto_box_SEEDBYTES = 32;

const int crypto_box_PUBLICKEYBYTES = 32;

const int crypto_box_SECRETKEYBYTES = 32;

const int crypto_box_NONCEBYTES = 24;

const int crypto_box_MACBYTES = 16;

const int crypto_box_MESSAGEBYTES_MAX = -17;

const String crypto_box_PRIMITIVE = 'curve25519xsalsa20poly1305';

const int crypto_box_BEFORENMBYTES = 32;

const int crypto_box_SEALBYTES = 48;

const int crypto_box_ZEROBYTES = 32;

const int crypto_box_BOXZEROBYTES = 16;

const int crypto_core_hchacha20_OUTPUTBYTES = 32;

const int crypto_core_hchacha20_INPUTBYTES = 16;

const int crypto_core_hchacha20_KEYBYTES = 32;

const int crypto_core_hchacha20_CONSTBYTES = 16;

const int crypto_core_hsalsa20_OUTPUTBYTES = 32;

const int crypto_core_hsalsa20_INPUTBYTES = 16;

const int crypto_core_hsalsa20_KEYBYTES = 32;

const int crypto_core_hsalsa20_CONSTBYTES = 16;

const int crypto_core_salsa20_OUTPUTBYTES = 64;

const int crypto_core_salsa20_INPUTBYTES = 16;

const int crypto_core_salsa20_KEYBYTES = 32;

const int crypto_core_salsa20_CONSTBYTES = 16;

const int crypto_core_salsa2012_OUTPUTBYTES = 64;

const int crypto_core_salsa2012_INPUTBYTES = 16;

const int crypto_core_salsa2012_KEYBYTES = 32;

const int crypto_core_salsa2012_CONSTBYTES = 16;

const int crypto_core_salsa208_OUTPUTBYTES = 64;

const int crypto_core_salsa208_INPUTBYTES = 16;

const int crypto_core_salsa208_KEYBYTES = 32;

const int crypto_core_salsa208_CONSTBYTES = 16;

const int crypto_generichash_blake2b_BYTES_MIN = 16;

const int crypto_generichash_blake2b_BYTES_MAX = 64;

const int crypto_generichash_blake2b_BYTES = 32;

const int crypto_generichash_blake2b_KEYBYTES_MIN = 16;

const int crypto_generichash_blake2b_KEYBYTES_MAX = 64;

const int crypto_generichash_blake2b_KEYBYTES = 32;

const int crypto_generichash_blake2b_SALTBYTES = 16;

const int crypto_generichash_blake2b_PERSONALBYTES = 16;

const int crypto_generichash_BYTES_MIN = 16;

const int crypto_generichash_BYTES_MAX = 64;

const int crypto_generichash_BYTES = 32;

const int crypto_generichash_KEYBYTES_MIN = 16;

const int crypto_generichash_KEYBYTES_MAX = 64;

const int crypto_generichash_KEYBYTES = 32;

const String crypto_generichash_PRIMITIVE = 'blake2b';

const int crypto_hash_BYTES = 64;

const String crypto_hash_PRIMITIVE = 'sha512';

const int crypto_kdf_blake2b_BYTES_MIN = 16;

const int crypto_kdf_blake2b_BYTES_MAX = 64;

const int crypto_kdf_blake2b_CONTEXTBYTES = 8;

const int crypto_kdf_blake2b_KEYBYTES = 32;

const int crypto_kdf_BYTES_MIN = 16;

const int crypto_kdf_BYTES_MAX = 64;

const int crypto_kdf_CONTEXTBYTES = 8;

const int crypto_kdf_KEYBYTES = 32;

const String crypto_kdf_PRIMITIVE = 'blake2b';

const int crypto_kdf_hkdf_sha256_KEYBYTES = 32;

const int crypto_kdf_hkdf_sha256_BYTES_MIN = 0;

const int crypto_kdf_hkdf_sha256_BYTES_MAX = 8160;

const int crypto_kdf_hkdf_sha512_KEYBYTES = 64;

const int crypto_kdf_hkdf_sha512_BYTES_MIN = 0;

const int crypto_kdf_hkdf_sha512_BYTES_MAX = 16320;

const int crypto_kx_PUBLICKEYBYTES = 32;

const int crypto_kx_SECRETKEYBYTES = 32;

const int crypto_kx_SEEDBYTES = 32;

const int crypto_kx_SESSIONKEYBYTES = 32;

const String crypto_kx_PRIMITIVE = 'x25519blake2b';

const int crypto_onetimeauth_poly1305_BYTES = 16;

const int crypto_onetimeauth_poly1305_KEYBYTES = 32;

const int crypto_onetimeauth_BYTES = 16;

const int crypto_onetimeauth_KEYBYTES = 32;

const String crypto_onetimeauth_PRIMITIVE = 'poly1305';

const int crypto_pwhash_argon2i_ALG_ARGON2I13 = 1;

const int crypto_pwhash_argon2i_BYTES_MIN = 16;

const int crypto_pwhash_argon2i_BYTES_MAX = 4294967295;

const int crypto_pwhash_argon2i_PASSWD_MIN = 0;

const int crypto_pwhash_argon2i_PASSWD_MAX = 4294967295;

const int crypto_pwhash_argon2i_SALTBYTES = 16;

const int crypto_pwhash_argon2i_STRBYTES = 128;

const String crypto_pwhash_argon2i_STRPREFIX = '\$argon2i\$';

const int crypto_pwhash_argon2i_OPSLIMIT_MIN = 3;

const int crypto_pwhash_argon2i_OPSLIMIT_MAX = 4294967295;

const int crypto_pwhash_argon2i_MEMLIMIT_MIN = 8192;

const int crypto_pwhash_argon2i_MEMLIMIT_MAX = 4398046510080;

const int crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE = 4;

const int crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE = 33554432;

const int crypto_pwhash_argon2i_OPSLIMIT_MODERATE = 6;

const int crypto_pwhash_argon2i_MEMLIMIT_MODERATE = 134217728;

const int crypto_pwhash_argon2i_OPSLIMIT_SENSITIVE = 8;

const int crypto_pwhash_argon2i_MEMLIMIT_SENSITIVE = 536870912;

const int crypto_pwhash_argon2id_ALG_ARGON2ID13 = 2;

const int crypto_pwhash_argon2id_BYTES_MIN = 16;

const int crypto_pwhash_argon2id_BYTES_MAX = 4294967295;

const int crypto_pwhash_argon2id_PASSWD_MIN = 0;

const int crypto_pwhash_argon2id_PASSWD_MAX = 4294967295;

const int crypto_pwhash_argon2id_SALTBYTES = 16;

const int crypto_pwhash_argon2id_STRBYTES = 128;

const String crypto_pwhash_argon2id_STRPREFIX = '\$argon2id\$';

const int crypto_pwhash_argon2id_OPSLIMIT_MIN = 1;

const int crypto_pwhash_argon2id_OPSLIMIT_MAX = 4294967295;

const int crypto_pwhash_argon2id_MEMLIMIT_MIN = 8192;

const int crypto_pwhash_argon2id_MEMLIMIT_MAX = 4398046510080;

const int crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE = 2;

const int crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE = 67108864;

const int crypto_pwhash_argon2id_OPSLIMIT_MODERATE = 3;

const int crypto_pwhash_argon2id_MEMLIMIT_MODERATE = 268435456;

const int crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE = 4;

const int crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE = 1073741824;

const int crypto_pwhash_ALG_ARGON2I13 = 1;

const int crypto_pwhash_ALG_ARGON2ID13 = 2;

const int crypto_pwhash_ALG_DEFAULT = 2;

const int crypto_pwhash_BYTES_MIN = 16;

const int crypto_pwhash_BYTES_MAX = 4294967295;

const int crypto_pwhash_PASSWD_MIN = 0;

const int crypto_pwhash_PASSWD_MAX = 4294967295;

const int crypto_pwhash_SALTBYTES = 16;

const int crypto_pwhash_STRBYTES = 128;

const String crypto_pwhash_STRPREFIX = '\$argon2id\$';

const int crypto_pwhash_OPSLIMIT_MIN = 1;

const int crypto_pwhash_OPSLIMIT_MAX = 4294967295;

const int crypto_pwhash_MEMLIMIT_MIN = 8192;

const int crypto_pwhash_MEMLIMIT_MAX = 4398046510080;

const int crypto_pwhash_OPSLIMIT_INTERACTIVE = 2;

const int crypto_pwhash_MEMLIMIT_INTERACTIVE = 67108864;

const int crypto_pwhash_OPSLIMIT_MODERATE = 3;

const int crypto_pwhash_MEMLIMIT_MODERATE = 268435456;

const int crypto_pwhash_OPSLIMIT_SENSITIVE = 4;

const int crypto_pwhash_MEMLIMIT_SENSITIVE = 1073741824;

const String crypto_pwhash_PRIMITIVE = 'argon2i';

const int crypto_scalarmult_curve25519_BYTES = 32;

const int crypto_scalarmult_curve25519_SCALARBYTES = 32;

const int crypto_scalarmult_BYTES = 32;

const int crypto_scalarmult_SCALARBYTES = 32;

const String crypto_scalarmult_PRIMITIVE = 'curve25519';

const int crypto_secretbox_xsalsa20poly1305_KEYBYTES = 32;

const int crypto_secretbox_xsalsa20poly1305_NONCEBYTES = 24;

const int crypto_secretbox_xsalsa20poly1305_MACBYTES = 16;

const int crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX = -17;

const int crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES = 16;

const int crypto_secretbox_xsalsa20poly1305_ZEROBYTES = 32;

const int crypto_secretbox_KEYBYTES = 32;

const int crypto_secretbox_NONCEBYTES = 24;

const int crypto_secretbox_MACBYTES = 16;

const String crypto_secretbox_PRIMITIVE = 'xsalsa20poly1305';

const int crypto_secretbox_MESSAGEBYTES_MAX = -17;

const int crypto_secretbox_ZEROBYTES = 32;

const int crypto_secretbox_BOXZEROBYTES = 16;

const int crypto_stream_chacha20_KEYBYTES = 32;

const int crypto_stream_chacha20_NONCEBYTES = 8;

const int crypto_stream_chacha20_MESSAGEBYTES_MAX = -1;

const int crypto_stream_chacha20_ietf_KEYBYTES = 32;

const int crypto_stream_chacha20_ietf_NONCEBYTES = 12;

const int crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX = 274877906944;

const int crypto_stream_chacha20_IETF_KEYBYTES = 32;

const int crypto_stream_chacha20_IETF_NONCEBYTES = 12;

const int crypto_stream_chacha20_IETF_MESSAGEBYTES_MAX = 274877906944;

const int crypto_secretstream_xchacha20poly1305_ABYTES = 17;

const int crypto_secretstream_xchacha20poly1305_HEADERBYTES = 24;

const int crypto_secretstream_xchacha20poly1305_KEYBYTES = 32;

const int crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX = 274877906816;

const int crypto_secretstream_xchacha20poly1305_TAG_MESSAGE = 0;

const int crypto_secretstream_xchacha20poly1305_TAG_PUSH = 1;

const int crypto_secretstream_xchacha20poly1305_TAG_REKEY = 2;

const int crypto_secretstream_xchacha20poly1305_TAG_FINAL = 3;

const int crypto_shorthash_siphash24_BYTES = 8;

const int crypto_shorthash_siphash24_KEYBYTES = 16;

const int crypto_shorthash_siphashx24_BYTES = 16;

const int crypto_shorthash_siphashx24_KEYBYTES = 16;

const int crypto_shorthash_BYTES = 8;

const int crypto_shorthash_KEYBYTES = 16;

const String crypto_shorthash_PRIMITIVE = 'siphash24';

const int crypto_sign_ed25519_BYTES = 64;

const int crypto_sign_ed25519_SEEDBYTES = 32;

const int crypto_sign_ed25519_PUBLICKEYBYTES = 32;

const int crypto_sign_ed25519_SECRETKEYBYTES = 64;

const int crypto_sign_ed25519_MESSAGEBYTES_MAX = -65;

const int crypto_sign_BYTES = 64;

const int crypto_sign_SEEDBYTES = 32;

const int crypto_sign_PUBLICKEYBYTES = 32;

const int crypto_sign_SECRETKEYBYTES = 64;

const int crypto_sign_MESSAGEBYTES_MAX = -65;

const String crypto_sign_PRIMITIVE = 'ed25519';

const int crypto_stream_KEYBYTES = 32;

const int crypto_stream_NONCEBYTES = 24;

const int crypto_stream_MESSAGEBYTES_MAX = -1;

const String crypto_stream_PRIMITIVE = 'xsalsa20';

const int crypto_stream_salsa20_KEYBYTES = 32;

const int crypto_stream_salsa20_NONCEBYTES = 8;

const int crypto_stream_salsa20_MESSAGEBYTES_MAX = -1;

const int crypto_verify_16_BYTES = 16;

const int crypto_verify_32_BYTES = 32;

const int crypto_verify_64_BYTES = 64;

const int randombytes_BYTES_MAX = 4294967295;

const int randombytes_SEEDBYTES = 32;

const int sodium_base64_VARIANT_ORIGINAL = 1;

const int sodium_base64_VARIANT_ORIGINAL_NO_PADDING = 3;

const int sodium_base64_VARIANT_URLSAFE = 5;

const int sodium_base64_VARIANT_URLSAFE_NO_PADDING = 7;

const int crypto_stream_xchacha20_KEYBYTES = 32;

const int crypto_stream_xchacha20_NONCEBYTES = 24;

const int crypto_stream_xchacha20_MESSAGEBYTES_MAX = -1;

const int crypto_box_curve25519xchacha20poly1305_SEEDBYTES = 32;

const int crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES = 32;

const int crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES = 32;

const int crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES = 32;

const int crypto_box_curve25519xchacha20poly1305_NONCEBYTES = 24;

const int crypto_box_curve25519xchacha20poly1305_MACBYTES = 16;

const int crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX = -17;

const int crypto_box_curve25519xchacha20poly1305_SEALBYTES = 48;

const int crypto_core_ed25519_BYTES = 32;

const int crypto_core_ed25519_UNIFORMBYTES = 32;

const int crypto_core_ed25519_HASHBYTES = 64;

const int crypto_core_ed25519_SCALARBYTES = 32;

const int crypto_core_ed25519_NONREDUCEDSCALARBYTES = 64;

const int crypto_core_ristretto255_BYTES = 32;

const int crypto_core_ristretto255_HASHBYTES = 64;

const int crypto_core_ristretto255_SCALARBYTES = 32;

const int crypto_core_ristretto255_NONREDUCEDSCALARBYTES = 64;

const int crypto_pwhash_scryptsalsa208sha256_BYTES_MIN = 16;

const int crypto_pwhash_scryptsalsa208sha256_BYTES_MAX = 137438953440;

const int crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN = 0;

const int crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX = -1;

const int crypto_pwhash_scryptsalsa208sha256_SALTBYTES = 32;

const int crypto_pwhash_scryptsalsa208sha256_STRBYTES = 102;

const String crypto_pwhash_scryptsalsa208sha256_STRPREFIX = '\$7\$';

const int crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN = 32768;

const int crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX = 4294967295;

const int crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN = 16777216;

const int crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX = 68719476736;

const int crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE = 524288;

const int crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE = 16777216;

const int crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE = 33554432;

const int crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE = 1073741824;

const int crypto_scalarmult_ed25519_BYTES = 32;

const int crypto_scalarmult_ed25519_SCALARBYTES = 32;

const int crypto_scalarmult_ristretto255_BYTES = 32;

const int crypto_scalarmult_ristretto255_SCALARBYTES = 32;

const int crypto_secretbox_xchacha20poly1305_KEYBYTES = 32;

const int crypto_secretbox_xchacha20poly1305_NONCEBYTES = 24;

const int crypto_secretbox_xchacha20poly1305_MACBYTES = 16;

const int crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX = -17;

const int crypto_stream_salsa2012_KEYBYTES = 32;

const int crypto_stream_salsa2012_NONCEBYTES = 8;

const int crypto_stream_salsa2012_MESSAGEBYTES_MAX = -1;

const int crypto_stream_salsa208_KEYBYTES = 32;

const int crypto_stream_salsa208_NONCEBYTES = 8;

const int crypto_stream_salsa208_MESSAGEBYTES_MAX = -1;