// ignore_for_file: always_specify_types
// ignore_for_file: camel_case_types
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: unused_field
// ignore_for_file: unused_element

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

/// Bindings to `lib/ffi/libmtorrentserver.h`.
class TorrentLibrary {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
  _lookup;

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

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

  void __va_start(ffi.Pointer<va_list> arg0) {
    return ___va_start(arg0);
  }

  late final ___va_startPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<va_list>)>>(
        '__va_start',
      );
  late final ___va_start = ___va_startPtr
      .asFunction<void Function(ffi.Pointer<va_list>)>();

  void __security_init_cookie() {
    return ___security_init_cookie();
  }

  late final ___security_init_cookiePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>(
        '__security_init_cookie',
      );
  late final ___security_init_cookie = ___security_init_cookiePtr
      .asFunction<void Function()>();

  void __security_check_cookie(int _StackCookie) {
    return ___security_check_cookie(_StackCookie);
  }

  late final ___security_check_cookiePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.UintPtr)>>(
        '__security_check_cookie',
      );
  late final ___security_check_cookie = ___security_check_cookiePtr
      .asFunction<void Function(int)>();

  void __report_gsfailure(int _StackCookie) {
    return ___report_gsfailure(_StackCookie);
  }

  late final ___report_gsfailurePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.UintPtr)>>(
        '__report_gsfailure',
      );
  late final ___report_gsfailure = ___report_gsfailurePtr
      .asFunction<void Function(int)>();

  late final ffi.Pointer<ffi.UintPtr> ___security_cookie = _lookup<ffi.UintPtr>(
    '__security_cookie',
  );

  int get __security_cookie => ___security_cookie.value;

  set __security_cookie(int value) => ___security_cookie.value = value;

  void _invalid_parameter_noinfo() {
    return __invalid_parameter_noinfo();
  }

  late final __invalid_parameter_noinfoPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>(
        '_invalid_parameter_noinfo',
      );
  late final __invalid_parameter_noinfo = __invalid_parameter_noinfoPtr
      .asFunction<void Function()>();

  void _invalid_parameter_noinfo_noreturn() {
    return __invalid_parameter_noinfo_noreturn();
  }

  late final __invalid_parameter_noinfo_noreturnPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>(
        '_invalid_parameter_noinfo_noreturn',
      );
  late final __invalid_parameter_noinfo_noreturn =
      __invalid_parameter_noinfo_noreturnPtr.asFunction<void Function()>();

  void _invoke_watson(
    ffi.Pointer<ffi.WChar> _Expression,
    ffi.Pointer<ffi.WChar> _FunctionName,
    ffi.Pointer<ffi.WChar> _FileName,
    int _LineNo,
    int _Reserved,
  ) {
    return __invoke_watson(
      _Expression,
      _FunctionName,
      _FileName,
      _LineNo,
      _Reserved,
    );
  }

  late final __invoke_watsonPtr =
      _lookup<
        ffi.NativeFunction<
          ffi.Void Function(
            ffi.Pointer<ffi.WChar>,
            ffi.Pointer<ffi.WChar>,
            ffi.Pointer<ffi.WChar>,
            ffi.UnsignedInt,
            ffi.UintPtr,
          )
        >
      >('_invoke_watson');
  late final __invoke_watson = __invoke_watsonPtr
      .asFunction<
        void Function(
          ffi.Pointer<ffi.WChar>,
          ffi.Pointer<ffi.WChar>,
          ffi.Pointer<ffi.WChar>,
          int,
          int,
        )
      >();

  ffi.Pointer<ffi.Int> _errno() {
    return __errno();
  }

  late final __errnoPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int> Function()>>('_errno');
  late final __errno = __errnoPtr.asFunction<ffi.Pointer<ffi.Int> Function()>();

  int _set_errno(int _Value) {
    return __set_errno(_Value);
  }

  late final __set_errnoPtr =
      _lookup<ffi.NativeFunction<errno_t Function(ffi.Int)>>('_set_errno');
  late final __set_errno = __set_errnoPtr.asFunction<int Function(int)>();

  int _get_errno(ffi.Pointer<ffi.Int> _Value) {
    return __get_errno(_Value);
  }

  late final __get_errnoPtr =
      _lookup<ffi.NativeFunction<errno_t Function(ffi.Pointer<ffi.Int>)>>(
        '_get_errno',
      );
  late final __get_errno = __get_errnoPtr
      .asFunction<int Function(ffi.Pointer<ffi.Int>)>();

  int __threadid() {
    return ___threadid();
  }

  late final ___threadidPtr =
      _lookup<ffi.NativeFunction<ffi.UnsignedLong Function()>>('__threadid');
  late final ___threadid = ___threadidPtr.asFunction<int Function()>();

  int __threadhandle() {
    return ___threadhandle();
  }

  late final ___threadhandlePtr =
      _lookup<ffi.NativeFunction<ffi.UintPtr Function()>>('__threadhandle');
  late final ___threadhandle = ___threadhandlePtr.asFunction<int Function()>();

  double cabs(_Dcomplex _Z) {
    return _cabs(_Z);
  }

  late final _cabsPtr =
      _lookup<ffi.NativeFunction<ffi.Double Function(_Dcomplex)>>('cabs');
  late final _cabs = _cabsPtr.asFunction<double Function(_Dcomplex)>();

  _Dcomplex cacos(_Dcomplex _Z) {
    return _cacos(_Z);
  }

  late final _cacosPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('cacos');
  late final _cacos = _cacosPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex cacosh(_Dcomplex _Z) {
    return _cacosh(_Z);
  }

  late final _cacoshPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('cacosh');
  late final _cacosh = _cacoshPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  double carg(_Dcomplex _Z) {
    return _carg(_Z);
  }

  late final _cargPtr =
      _lookup<ffi.NativeFunction<ffi.Double Function(_Dcomplex)>>('carg');
  late final _carg = _cargPtr.asFunction<double Function(_Dcomplex)>();

  _Dcomplex casin(_Dcomplex _Z) {
    return _casin(_Z);
  }

  late final _casinPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('casin');
  late final _casin = _casinPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex casinh(_Dcomplex _Z) {
    return _casinh(_Z);
  }

  late final _casinhPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('casinh');
  late final _casinh = _casinhPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex catan(_Dcomplex _Z) {
    return _catan(_Z);
  }

  late final _catanPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('catan');
  late final _catan = _catanPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex catanh(_Dcomplex _Z) {
    return _catanh(_Z);
  }

  late final _catanhPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('catanh');
  late final _catanh = _catanhPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex ccos(_Dcomplex _Z) {
    return _ccos(_Z);
  }

  late final _ccosPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('ccos');
  late final _ccos = _ccosPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex ccosh(_Dcomplex _Z) {
    return _ccosh(_Z);
  }

  late final _ccoshPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('ccosh');
  late final _ccosh = _ccoshPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex cexp(_Dcomplex _Z) {
    return _cexp(_Z);
  }

  late final _cexpPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('cexp');
  late final _cexp = _cexpPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  double cimag(_Dcomplex _Z) {
    return _cimag(_Z);
  }

  late final _cimagPtr =
      _lookup<ffi.NativeFunction<ffi.Double Function(_Dcomplex)>>('cimag');
  late final _cimag = _cimagPtr.asFunction<double Function(_Dcomplex)>();

  _Dcomplex clog(_Dcomplex _Z) {
    return _clog(_Z);
  }

  late final _clogPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('clog');
  late final _clog = _clogPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex clog10(_Dcomplex _Z) {
    return _clog10(_Z);
  }

  late final _clog10Ptr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('clog10');
  late final _clog10 = _clog10Ptr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex conj(_Dcomplex _Z) {
    return _conj(_Z);
  }

  late final _conjPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('conj');
  late final _conj = _conjPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex cpow(_Dcomplex _X, _Dcomplex _Y) {
    return _cpow(_X, _Y);
  }

  late final _cpowPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex, _Dcomplex)>>(
        'cpow',
      );
  late final _cpow = _cpowPtr
      .asFunction<_Dcomplex Function(_Dcomplex, _Dcomplex)>();

  _Dcomplex cproj(_Dcomplex _Z) {
    return _cproj(_Z);
  }

  late final _cprojPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('cproj');
  late final _cproj = _cprojPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  double creal(_Dcomplex _Z) {
    return _creal(_Z);
  }

  late final _crealPtr =
      _lookup<ffi.NativeFunction<ffi.Double Function(_Dcomplex)>>('creal');
  late final _creal = _crealPtr.asFunction<double Function(_Dcomplex)>();

  _Dcomplex csin(_Dcomplex _Z) {
    return _csin(_Z);
  }

  late final _csinPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('csin');
  late final _csin = _csinPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex csinh(_Dcomplex _Z) {
    return _csinh(_Z);
  }

  late final _csinhPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('csinh');
  late final _csinh = _csinhPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex csqrt(_Dcomplex _Z) {
    return _csqrt(_Z);
  }

  late final _csqrtPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('csqrt');
  late final _csqrt = _csqrtPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex ctan(_Dcomplex _Z) {
    return _ctan(_Z);
  }

  late final _ctanPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('ctan');
  late final _ctan = _ctanPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  _Dcomplex ctanh(_Dcomplex _Z) {
    return _ctanh(_Z);
  }

  late final _ctanhPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex)>>('ctanh');
  late final _ctanh = _ctanhPtr.asFunction<_Dcomplex Function(_Dcomplex)>();

  double norm(_Dcomplex _Z) {
    return _norm(_Z);
  }

  late final _normPtr =
      _lookup<ffi.NativeFunction<ffi.Double Function(_Dcomplex)>>('norm');
  late final _norm = _normPtr.asFunction<double Function(_Dcomplex)>();

  double cabsf(_Fcomplex _Z) {
    return _cabsf(_Z);
  }

  late final _cabsfPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(_Fcomplex)>>('cabsf');
  late final _cabsf = _cabsfPtr.asFunction<double Function(_Fcomplex)>();

  _Fcomplex cacosf(_Fcomplex _Z) {
    return _cacosf(_Z);
  }

  late final _cacosfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('cacosf');
  late final _cacosf = _cacosfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex cacoshf(_Fcomplex _Z) {
    return _cacoshf(_Z);
  }

  late final _cacoshfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('cacoshf');
  late final _cacoshf = _cacoshfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  double cargf(_Fcomplex _Z) {
    return _cargf(_Z);
  }

  late final _cargfPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(_Fcomplex)>>('cargf');
  late final _cargf = _cargfPtr.asFunction<double Function(_Fcomplex)>();

  _Fcomplex casinf(_Fcomplex _Z) {
    return _casinf(_Z);
  }

  late final _casinfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('casinf');
  late final _casinf = _casinfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex casinhf(_Fcomplex _Z) {
    return _casinhf(_Z);
  }

  late final _casinhfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('casinhf');
  late final _casinhf = _casinhfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex catanf(_Fcomplex _Z) {
    return _catanf(_Z);
  }

  late final _catanfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('catanf');
  late final _catanf = _catanfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex catanhf(_Fcomplex _Z) {
    return _catanhf(_Z);
  }

  late final _catanhfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('catanhf');
  late final _catanhf = _catanhfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex ccosf(_Fcomplex _Z) {
    return _ccosf(_Z);
  }

  late final _ccosfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('ccosf');
  late final _ccosf = _ccosfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex ccoshf(_Fcomplex _Z) {
    return _ccoshf(_Z);
  }

  late final _ccoshfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('ccoshf');
  late final _ccoshf = _ccoshfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex cexpf(_Fcomplex _Z) {
    return _cexpf(_Z);
  }

  late final _cexpfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('cexpf');
  late final _cexpf = _cexpfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  double cimagf(_Fcomplex _Z) {
    return _cimagf(_Z);
  }

  late final _cimagfPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(_Fcomplex)>>('cimagf');
  late final _cimagf = _cimagfPtr.asFunction<double Function(_Fcomplex)>();

  _Fcomplex clogf(_Fcomplex _Z) {
    return _clogf(_Z);
  }

  late final _clogfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('clogf');
  late final _clogf = _clogfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex clog10f(_Fcomplex _Z) {
    return _clog10f(_Z);
  }

  late final _clog10fPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('clog10f');
  late final _clog10f = _clog10fPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex conjf(_Fcomplex _Z) {
    return _conjf(_Z);
  }

  late final _conjfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('conjf');
  late final _conjf = _conjfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex cpowf(_Fcomplex _X, _Fcomplex _Y) {
    return _cpowf(_X, _Y);
  }

  late final _cpowfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex, _Fcomplex)>>(
        'cpowf',
      );
  late final _cpowf = _cpowfPtr
      .asFunction<_Fcomplex Function(_Fcomplex, _Fcomplex)>();

  _Fcomplex cprojf(_Fcomplex _Z) {
    return _cprojf(_Z);
  }

  late final _cprojfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('cprojf');
  late final _cprojf = _cprojfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  double crealf(_Fcomplex _Z) {
    return _crealf(_Z);
  }

  late final _crealfPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(_Fcomplex)>>('crealf');
  late final _crealf = _crealfPtr.asFunction<double Function(_Fcomplex)>();

  _Fcomplex csinf(_Fcomplex _Z) {
    return _csinf(_Z);
  }

  late final _csinfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('csinf');
  late final _csinf = _csinfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex csinhf(_Fcomplex _Z) {
    return _csinhf(_Z);
  }

  late final _csinhfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('csinhf');
  late final _csinhf = _csinhfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex csqrtf(_Fcomplex _Z) {
    return _csqrtf(_Z);
  }

  late final _csqrtfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('csqrtf');
  late final _csqrtf = _csqrtfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex ctanf(_Fcomplex _Z) {
    return _ctanf(_Z);
  }

  late final _ctanfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('ctanf');
  late final _ctanf = _ctanfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  _Fcomplex ctanhf(_Fcomplex _Z) {
    return _ctanhf(_Z);
  }

  late final _ctanhfPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex)>>('ctanhf');
  late final _ctanhf = _ctanhfPtr.asFunction<_Fcomplex Function(_Fcomplex)>();

  double normf(_Fcomplex _Z) {
    return _normf(_Z);
  }

  late final _normfPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(_Fcomplex)>>('normf');
  late final _normf = _normfPtr.asFunction<double Function(_Fcomplex)>();

  _Dcomplex _Cbuild(double _Re, double _Im) {
    return __Cbuild(_Re, _Im);
  }

  late final __CbuildPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(ffi.Double, ffi.Double)>>(
        '_Cbuild',
      );
  late final __Cbuild = __CbuildPtr
      .asFunction<_Dcomplex Function(double, double)>();

  _Dcomplex _Cmulcc(_Dcomplex _X, _Dcomplex _Y) {
    return __Cmulcc(_X, _Y);
  }

  late final __CmulccPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex, _Dcomplex)>>(
        '_Cmulcc',
      );
  late final __Cmulcc = __CmulccPtr
      .asFunction<_Dcomplex Function(_Dcomplex, _Dcomplex)>();

  _Dcomplex _Cmulcr(_Dcomplex _X, double _Y) {
    return __Cmulcr(_X, _Y);
  }

  late final __CmulcrPtr =
      _lookup<ffi.NativeFunction<_Dcomplex Function(_Dcomplex, ffi.Double)>>(
        '_Cmulcr',
      );
  late final __Cmulcr = __CmulcrPtr
      .asFunction<_Dcomplex Function(_Dcomplex, double)>();

  _Fcomplex _FCbuild(double _Re, double _Im) {
    return __FCbuild(_Re, _Im);
  }

  late final __FCbuildPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(ffi.Float, ffi.Float)>>(
        '_FCbuild',
      );
  late final __FCbuild = __FCbuildPtr
      .asFunction<_Fcomplex Function(double, double)>();

  _Fcomplex _FCmulcc(_Fcomplex _X, _Fcomplex _Y) {
    return __FCmulcc(_X, _Y);
  }

  late final __FCmulccPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex, _Fcomplex)>>(
        '_FCmulcc',
      );
  late final __FCmulcc = __FCmulccPtr
      .asFunction<_Fcomplex Function(_Fcomplex, _Fcomplex)>();

  _Fcomplex _FCmulcr(_Fcomplex _X, double _Y) {
    return __FCmulcr(_X, _Y);
  }

  late final __FCmulcrPtr =
      _lookup<ffi.NativeFunction<_Fcomplex Function(_Fcomplex, ffi.Float)>>(
        '_FCmulcr',
      );
  late final __FCmulcr = __FCmulcrPtr
      .asFunction<_Fcomplex Function(_Fcomplex, double)>();

  Start_return Start(ffi.Pointer<ffi.Char> mcfg) {
    return _Start(mcfg);
  }

  late final _StartPtr =
      _lookup<ffi.NativeFunction<Start_return Function(ffi.Pointer<ffi.Char>)>>(
        'Start',
      );
  late final _Start =
      _StartPtr.asFunction<Start_return Function(ffi.Pointer<ffi.Char>)>();
}

typedef va_list = ffi.Pointer<ffi.Char>;

final class __crt_locale_data_public extends ffi.Struct {
  external ffi.Pointer<ffi.UnsignedShort> _locale_pctype;

  @ffi.Int()
  external int _locale_mb_cur_max;

  @ffi.UnsignedInt()
  external int _locale_lc_codepage;
}

final class __crt_locale_pointers extends ffi.Struct {
  external ffi.Pointer<__crt_locale_data> locinfo;

  external ffi.Pointer<__crt_multibyte_data> mbcinfo;
}

final class __crt_locale_data extends ffi.Opaque {}

final class __crt_multibyte_data extends ffi.Opaque {}

final class _Mbstatet extends ffi.Struct {
  @ffi.UnsignedLong()
  external int _Wchar;

  @ffi.UnsignedShort()
  external int _Byte;

  @ffi.UnsignedShort()
  external int _State;
}

typedef errno_t = ffi.Int;
typedef Darterrno_t = int;

final class _GoString_ extends ffi.Struct {
  external ffi.Pointer<ffi.Char> p;

  @ptrdiff_t()
  external int n;
}

typedef ptrdiff_t = ffi.LongLong;
typedef Dartptrdiff_t = int;

final class _C_double_complex extends ffi.Struct {
  @ffi.Array.multi([2])
  external ffi.Array<ffi.Double> _Val;
}

final class _C_float_complex extends ffi.Struct {
  @ffi.Array.multi([2])
  external ffi.Array<ffi.Float> _Val;
}

final class _C_ldouble_complex extends ffi.Opaque {}

typedef _Dcomplex = _C_double_complex;
typedef _Fcomplex = _C_float_complex;

final class GoInterface extends ffi.Struct {
  external ffi.Pointer<ffi.Void> t;

  external ffi.Pointer<ffi.Void> v;
}

final class GoSlice extends ffi.Struct {
  external ffi.Pointer<ffi.Void> data;

  @GoInt()
  external int len;

  @GoInt()
  external int cap;
}

typedef GoInt = GoInt64;
typedef GoInt64 = ffi.LongLong;
typedef DartGoInt64 = int;

/// Return type for Start
final class Start_return extends ffi.Struct {
  @GoInt()
  external int r0;

  external ffi.Pointer<ffi.Char> r1;
}

const int _VCRT_COMPILER_PREPROCESSOR = 1;

const int _SAL_VERSION = 20;

const int __SAL_H_VERSION = 180000000;

const int _USE_DECLSPECS_FOR_SAL = 0;

const int _USE_ATTRIBUTES_FOR_SAL = 0;

const int _CRT_PACKING = 8;

const int _VCRUNTIME_DISABLED_WARNINGS = 4514;

const int _HAS_EXCEPTIONS = 1;

const int _WCHAR_T_DEFINED = 1;

const int NULL = 0;

const int _HAS_CXX17 = 0;

const int _HAS_CXX20 = 0;

const int _HAS_CXX23 = 0;

const int _HAS_NODISCARD = 1;

const int _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE = 1;

const int _CRT_BUILD_DESKTOP_APP = 1;

const int _UCRT_DISABLED_WARNINGS = 4324;

const int _ARGMAX = 100;

const int _TRUNCATE = -1;

const int _CRT_INT_MAX = 2147483647;

const int _CRT_SIZE_MAX = -1;

const String __FILEW__ = 'C';

const int _CRT_FUNCTIONS_REQUIRED = 1;

const int _CRT_HAS_CXX17 = 0;

const int _CRT_HAS_C11 = 0;

const int _CRT_INTERNAL_NONSTDC_NAMES = 1;

const int __STDC_SECURE_LIB__ = 200411;

const int __GOT_SECURE_LIB__ = 200411;

const int __STDC_WANT_SECURE_LIB__ = 1;

const int _SECURECRT_FILL_BUFFER_PATTERN = 254;

const int _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES = 0;

const int _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT = 0;

const int _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES = 1;

const int _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY = 0;

const int _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY = 0;