bindings.dart

// ignore_for_file: type=lint, unused_element, unused_field
// dart format off
// AUTO GENERATED FILE, DO NOT EDIT.
// 
// Generated by `package:ffigen`.
// ignore_for_file: unused_import
import 'dart:ffi' as ffi;
/// bindings to libedax
class LibEdaxBindings{
/// Holds the symbol lookup function.
final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) _lookup;

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

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

/// conversion from an 8-bit line to the A1-A8 line
late final ffi.Pointer<ffi.UnsignedLongLong> _A1_A8 = _lookup<ffi.UnsignedLongLong>('A1_A8');

ffi.Pointer<ffi.UnsignedLongLong> get A1_A8 => _A1_A8;

late final ffi.Pointer<Link> _BAD_LINK = _lookup<Link>('BAD_LINK');

Link get BAD_LINK => _BAD_LINK.ref;

late final ffi.Pointer<ffi.Int> _BOOK_INFO_RESOLUTION = _lookup<ffi.Int>('BOOK_INFO_RESOLUTION');

int get BOOK_INFO_RESOLUTION => _BOOK_INFO_RESOLUTION.value;

late final ffi.Pointer<ffi.Char> _COUNT_FLIP_2 = _lookup<ffi.Char>('COUNT_FLIP_2');

ffi.Pointer<ffi.Char> get COUNT_FLIP_2 => _COUNT_FLIP_2;

late final ffi.Pointer<ffi.Char> _COUNT_FLIP_3 = _lookup<ffi.Char>('COUNT_FLIP_3');

ffi.Pointer<ffi.Char> get COUNT_FLIP_3 => _COUNT_FLIP_3;

late final ffi.Pointer<ffi.Char> _COUNT_FLIP_4 = _lookup<ffi.Char>('COUNT_FLIP_4');

ffi.Pointer<ffi.Char> get COUNT_FLIP_4 => _COUNT_FLIP_4;

late final ffi.Pointer<ffi.Char> _COUNT_FLIP_5 = _lookup<ffi.Char>('COUNT_FLIP_5');

ffi.Pointer<ffi.Char> get COUNT_FLIP_5 => _COUNT_FLIP_5;

late final ffi.Pointer<ffi.Char> _COUNT_FLIP_L = _lookup<ffi.Char>('COUNT_FLIP_L');

ffi.Pointer<ffi.Char> get COUNT_FLIP_L => _COUNT_FLIP_L;

/// precomputed count flip array
late final ffi.Pointer<ffi.Char> _COUNT_FLIP_R = _lookup<ffi.Char>('COUNT_FLIP_R');

ffi.Pointer<ffi.Char> get COUNT_FLIP_R => _COUNT_FLIP_R;

/// Array of functions to count flipped discs of the last move
late final ffi.Pointer<ffi.Pointer<ffi.NativeFunction<ffi.Int Function(ffi.UnsignedLongLong )>>> _COUNT_LAST_FLIP = _lookup<ffi.Pointer<ffi.NativeFunction<ffi.Int Function(ffi.UnsignedLongLong )>>>('COUNT_LAST_FLIP');

ffi.Pointer<ffi.Pointer<ffi.NativeFunction<ffi.Int Function(ffi.UnsignedLongLong )>>> get COUNT_LAST_FLIP => _COUNT_LAST_FLIP;

/// evaluation function error coefficient parameters
late final ffi.Pointer<ffi.Double> _EVAL_A = _lookup<ffi.Double>('EVAL_A');

double get EVAL_A => _EVAL_A.value;

set EVAL_A(double value) =>_EVAL_A.value = value;

late final ffi.Pointer<ffi.Double> _EVAL_B = _lookup<ffi.Double>('EVAL_B');

double get EVAL_B => _EVAL_B.value;

set EVAL_B(double value) =>_EVAL_B.value = value;

late final ffi.Pointer<ffi.Double> _EVAL_C = _lookup<ffi.Double>('EVAL_C');

double get EVAL_C => _EVAL_C.value;

set EVAL_C(double value) =>_EVAL_C.value = value;

/// feature symetry packing
late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_C10 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_C10');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_C10 => _EVAL_C10;

late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_C9 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_C9');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_C9 => _EVAL_C9;

/// array to convert features into coordinates
late final ffi.Pointer<FeatureToCoordinate> _EVAL_F2X = _lookup<FeatureToCoordinate>('EVAL_F2X');

ffi.Pointer<FeatureToCoordinate> get EVAL_F2X => _EVAL_F2X;

/// eval weight load status
late final ffi.Pointer<ffi.Int> _EVAL_LOADED = _lookup<ffi.Int>('EVAL_LOADED');

int get EVAL_LOADED => _EVAL_LOADED.value;

set EVAL_LOADED(int value) =>_EVAL_LOADED.value = value;

late final ffi.Pointer<ffi.Int> _EVAL_MAX_VALUE = _lookup<ffi.Int>('EVAL_MAX_VALUE');

ffi.Pointer<ffi.Int> get EVAL_MAX_VALUE => _EVAL_MAX_VALUE;

/// number of features
late final ffi.Pointer<ffi.Int> _EVAL_N_FEATURE = _lookup<ffi.Int>('EVAL_N_FEATURE');

int get EVAL_N_FEATURE => _EVAL_N_FEATURE.value;

/// number of plies
late final ffi.Pointer<ffi.Int> _EVAL_N_PLY = _lookup<ffi.Int>('EVAL_N_PLY');

int get EVAL_N_PLY => _EVAL_N_PLY.value;

/// number of (unpacked) weights
late final ffi.Pointer<ffi.Int> _EVAL_N_WEIGHT = _lookup<ffi.Int>('EVAL_N_WEIGHT');

int get EVAL_N_WEIGHT => _EVAL_N_WEIGHT.value;

/// feature offset
late final ffi.Pointer<ffi.Int> _EVAL_OFFSET = _lookup<ffi.Int>('EVAL_OFFSET');

ffi.Pointer<ffi.Int> get EVAL_OFFSET => _EVAL_OFFSET;

/// packed feature size
late final ffi.Pointer<ffi.Int> _EVAL_PACKED_SIZE = _lookup<ffi.Int>('EVAL_PACKED_SIZE');

ffi.Pointer<ffi.Int> get EVAL_PACKED_SIZE => _EVAL_PACKED_SIZE;

late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_S10 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_S10');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_S10 => _EVAL_S10;

late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_S4 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_S4');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_S4 => _EVAL_S4;

late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_S5 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_S5');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_S5 => _EVAL_S5;

late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_S6 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_S6');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_S6 => _EVAL_S6;

late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_S7 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_S7');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_S7 => _EVAL_S7;

late final ffi.Pointer<ffi.Pointer<ffi.Int>> _EVAL_S8 = _lookup<ffi.Pointer<ffi.Int>>('EVAL_S8');

ffi.Pointer<ffi.Pointer<ffi.Int>> get EVAL_S8 => _EVAL_S8;

/// feature size
late final ffi.Pointer<ffi.Int> _EVAL_SIZE = _lookup<ffi.Int>('EVAL_SIZE');

ffi.Pointer<ffi.Int> get EVAL_SIZE => _EVAL_SIZE;

/// eval weights
late final ffi.Pointer<ffi.Pointer<ffi.Pointer<ffi.Pointer<ffi.Short>>>> _EVAL_WEIGHT = _lookup<ffi.Pointer<ffi.Pointer<ffi.Pointer<ffi.Short>>>>('EVAL_WEIGHT');

ffi.Pointer<ffi.Pointer<ffi.Pointer<ffi.Short>>> get EVAL_WEIGHT => _EVAL_WEIGHT.value;

set EVAL_WEIGHT(ffi.Pointer<ffi.Pointer<ffi.Pointer<ffi.Short>>> value) =>_EVAL_WEIGHT.value = value;

/// array to convert coordinates into feature
late final ffi.Pointer<CoordinateToFeature> _EVAL_X2F = _lookup<CoordinateToFeature>('EVAL_X2F');

ffi.Pointer<CoordinateToFeature> get EVAL_X2F => _EVAL_X2F;

late final ffi.Pointer<ffi.Double> _EVAL_a = _lookup<ffi.Double>('EVAL_a');

double get EVAL_a => _EVAL_a.value;

set EVAL_a(double value) =>_EVAL_a.value = value;

late final ffi.Pointer<ffi.Double> _EVAL_b = _lookup<ffi.Double>('EVAL_b');

double get EVAL_b => _EVAL_b.value;

set EVAL_b(double value) =>_EVAL_b.value = value;

late final ffi.Pointer<ffi.Double> _EVAL_c = _lookup<ffi.Double>('EVAL_c');

double get EVAL_c => _EVAL_c.value;

set EVAL_c(double value) =>_EVAL_c.value = value;

/// flip array (indexed with outflank, returns inner 6 bits)
late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_2_H = _lookup<ffi.UnsignedLongLong>('FLIPPED_2_H');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_2_H => _FLIPPED_2_H;

late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_2_V = _lookup<ffi.UnsignedLongLong>('FLIPPED_2_V');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_2_V => _FLIPPED_2_V;

late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_3_H = _lookup<ffi.UnsignedLongLong>('FLIPPED_3_H');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_3_H => _FLIPPED_3_H;

late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_3_V = _lookup<ffi.UnsignedLongLong>('FLIPPED_3_V');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_3_V => _FLIPPED_3_V;

late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_4_H = _lookup<ffi.UnsignedLongLong>('FLIPPED_4_H');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_4_H => _FLIPPED_4_H;

late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_4_V = _lookup<ffi.UnsignedLongLong>('FLIPPED_4_V');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_4_V => _FLIPPED_4_V;

late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_5_H = _lookup<ffi.UnsignedLongLong>('FLIPPED_5_H');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_5_H => _FLIPPED_5_H;

late final ffi.Pointer<ffi.UnsignedLongLong> _FLIPPED_5_V = _lookup<ffi.UnsignedLongLong>('FLIPPED_5_V');

ffi.Pointer<ffi.UnsignedLongLong> get FLIPPED_5_V => _FLIPPED_5_V;

/// Hash entry initial value
late final ffi.Pointer<GameHash> _GAME_HASH_INIT = _lookup<GameHash>('GAME_HASH_INIT');

GameHash get GAME_HASH_INIT => _GAME_HASH_INIT.ref;

/// initial statistics
late final ffi.Pointer<GameStatistics> _GAME_STATISTICS_INIT = _lookup<GameStatistics>('GAME_STATISTICS_INIT');

GameStatistics get GAME_STATISTICS_INIT => _GAME_STATISTICS_INIT.ref;

late final ffi.Pointer<GGSClock> _GGS_CLOCK_INI = _lookup<GGSClock>('GGS_CLOCK_INI');

GGSClock get GGS_CLOCK_INI => _GGS_CLOCK_INI.ref;

late final ffi.Pointer<GGSMatchType> _GGS_MATCH_TYPE_INI = _lookup<GGSMatchType>('GGS_MATCH_TYPE_INI');

GGSMatchType get GGS_MATCH_TYPE_INI => _GGS_MATCH_TYPE_INI.ref;

/// conversion from an 8-bit line to the H1-H8 line
late final ffi.Pointer<ffi.UnsignedLongLong> _H1_H8 = _lookup<ffi.UnsignedLongLong>('H1_H8');

ffi.Pointer<ffi.UnsignedLongLong> get H1_H8 => _H1_H8;

/// HashData init value
late final ffi.Pointer<HashData> _HASH_DATA_INIT = _lookup<HashData>('HASH_DATA_INIT');

HashData get HASH_DATA_INIT => _HASH_DATA_INIT.ref;

late final ffi.Pointer<ffi.Pointer<Level>> _LEVEL = _lookup<ffi.Pointer<Level>>('LEVEL');

ffi.Pointer<ffi.Pointer<Level>> get LEVEL => _LEVEL;

late final ffi.Pointer<Move> _MOVE_INIT = _lookup<Move>('MOVE_INIT');

Move get MOVE_INIT => _MOVE_INIT.ref;

late final ffi.Pointer<Move> _MOVE_PASS = _lookup<Move>('MOVE_PASS');

Move get MOVE_PASS => _MOVE_PASS.ref;

/// Conversion array: neighbour bits
late final ffi.Pointer<ffi.Pointer<ffi.UnsignedLongLong>> _NEIGHBOUR = _lookup<ffi.Pointer<ffi.UnsignedLongLong>>('NEIGHBOUR');

ffi.Pointer<ffi.UnsignedLongLong> get NEIGHBOUR => _NEIGHBOUR.value;

set NEIGHBOUR(ffi.Pointer<ffi.UnsignedLongLong> value) =>_NEIGHBOUR.value = value;

/// The list of french opening names
late final ffi.Pointer<PositionName> _NOM_POSITION = _lookup<PositionName>('NOM_POSITION');

ffi.Pointer<PositionName> get NOM_POSITION => _NOM_POSITION;

/// level with no selectivity
late final ffi.Pointer<ffi.Int> _NO_SELECTIVITY = _lookup<ffi.Int>('NO_SELECTIVITY');

int get NO_SELECTIVITY => _NO_SELECTIVITY.value;

/// threshold values to try stability cutoff during NWS search
late final ffi.Pointer<ffi.Pointer<ffi.Int>> _NWS_STABILITY_THRESHOLD = _lookup<ffi.Pointer<ffi.Int>>('NWS_STABILITY_THRESHOLD');

ffi.Pointer<ffi.Int> get NWS_STABILITY_THRESHOLD => _NWS_STABILITY_THRESHOLD.value;

set NWS_STABILITY_THRESHOLD(ffi.Pointer<ffi.Int> value) =>_NWS_STABILITY_THRESHOLD.value = value;

/// The list of french & english opening names
late final ffi.Pointer<OpeningName> _OPENING_NAME = _lookup<OpeningName>('OPENING_NAME');

ffi.Pointer<OpeningName> get OPENING_NAME => _OPENING_NAME;

late final ffi.Pointer<ffi.UnsignedChar> _OUTFLANK_2 = _lookup<ffi.UnsignedChar>('OUTFLANK_2');

ffi.Pointer<ffi.UnsignedChar> get OUTFLANK_2 => _OUTFLANK_2;

late final ffi.Pointer<ffi.UnsignedChar> _OUTFLANK_3 = _lookup<ffi.UnsignedChar>('OUTFLANK_3');

ffi.Pointer<ffi.UnsignedChar> get OUTFLANK_3 => _OUTFLANK_3;

late final ffi.Pointer<ffi.UnsignedChar> _OUTFLANK_4 = _lookup<ffi.UnsignedChar>('OUTFLANK_4');

ffi.Pointer<ffi.UnsignedChar> get OUTFLANK_4 => _OUTFLANK_4;

late final ffi.Pointer<ffi.UnsignedChar> _OUTFLANK_5 = _lookup<ffi.UnsignedChar>('OUTFLANK_5');

ffi.Pointer<ffi.UnsignedChar> get OUTFLANK_5 => _OUTFLANK_5;

late final ffi.Pointer<ffi.UnsignedChar> _OUTFLANK_7 = _lookup<ffi.UnsignedChar>('OUTFLANK_7');

ffi.Pointer<ffi.UnsignedChar> get OUTFLANK_7 => _OUTFLANK_7;

/// The list of french opening names
late final ffi.Pointer<PositionName> _POSITION_NAME = _lookup<PositionName>('POSITION_NAME');

ffi.Pointer<PositionName> get POSITION_NAME => _POSITION_NAME;

/// threshold values to try stability cutoff during PVS search
late final ffi.Pointer<ffi.Pointer<ffi.Int>> _PVS_STABILITY_THRESHOLD = _lookup<ffi.Pointer<ffi.Int>>('PVS_STABILITY_THRESHOLD');

ffi.Pointer<ffi.Int> get PVS_STABILITY_THRESHOLD => _PVS_STABILITY_THRESHOLD.value;

set PVS_STABILITY_THRESHOLD(ffi.Pointer<ffi.Int> value) =>_PVS_STABILITY_THRESHOLD.value = value;

/// a quadrant id for each square
late final ffi.Pointer<ffi.Pointer<ffi.Int>> _QUADRANT_ID = _lookup<ffi.Pointer<ffi.Int>>('QUADRANT_ID');

ffi.Pointer<ffi.Int> get QUADRANT_ID => _QUADRANT_ID.value;

set QUADRANT_ID(ffi.Pointer<ffi.Int> value) =>_QUADRANT_ID.value = value;

/// square type
late final ffi.Pointer<ffi.Pointer<ffi.Int>> _SQUARE_TYPE = _lookup<ffi.Pointer<ffi.Int>>('SQUARE_TYPE');

ffi.Pointer<ffi.Int> get SQUARE_TYPE => _SQUARE_TYPE.value;

set SQUARE_TYPE(ffi.Pointer<ffi.Int> value) =>_SQUARE_TYPE.value = value;

late final ffi.Pointer<ffi.Int> _SQUARE_VALUE = _lookup<ffi.Int>('SQUARE_VALUE');

ffi.Pointer<ffi.Int> get SQUARE_VALUE => _SQUARE_VALUE;

/// coordinate to bit table converter
late final ffi.Pointer<ffi.Pointer<ffi.UnsignedLongLong>> _X_TO_BIT = _lookup<ffi.Pointer<ffi.UnsignedLongLong>>('X_TO_BIT');

ffi.Pointer<ffi.UnsignedLongLong> get X_TO_BIT => _X_TO_BIT.value;

set X_TO_BIT(ffi.Pointer<ffi.UnsignedLongLong> value) =>_X_TO_BIT.value = value;

late final ffi.Pointer<ffi.Pointer<_RuneLocale>> __CurrentRuneLocale = _lookup<ffi.Pointer<_RuneLocale>>('_CurrentRuneLocale');

ffi.Pointer<_RuneLocale> get _CurrentRuneLocale => __CurrentRuneLocale.value;

set _CurrentRuneLocale(ffi.Pointer<_RuneLocale> value) =>__CurrentRuneLocale.value = value;

late final ffi.Pointer<_RuneLocale> __DefaultRuneLocale = _lookup<_RuneLocale>('_DefaultRuneLocale');

_RuneLocale get _DefaultRuneLocale => __DefaultRuneLocale.ref;

late final ffi.Pointer<ffi.Int> ___mb_cur_max = _lookup<ffi.Int>('__mb_cur_max');

int get __mb_cur_max => ___mb_cur_max.value;

set __mb_cur_max(int value) =>___mb_cur_max.value = value;

late final ffi.Pointer<ffi.Pointer<FILE>> ___stderrp = _lookup<ffi.Pointer<FILE>>('__stderrp');

ffi.Pointer<FILE> get __stderrp => ___stderrp.value;

set __stderrp(ffi.Pointer<FILE> value) =>___stderrp.value = value;

late final ffi.Pointer<ffi.Pointer<FILE>> ___stdinp = _lookup<ffi.Pointer<FILE>>('__stdinp');

ffi.Pointer<FILE> get __stdinp => ___stdinp.value;

set __stdinp(ffi.Pointer<FILE> value) =>___stdinp.value = value;

late final ffi.Pointer<ffi.Pointer<FILE>> ___stdoutp = _lookup<ffi.Pointer<FILE>>('__stdoutp');

ffi.Pointer<FILE> get __stdoutp => ___stdoutp.value;

set __stdoutp(ffi.Pointer<FILE> value) =>___stdoutp.value = value;

late final ffi.Pointer<ffi.Pointer<ffi.Char>> _admin_list = _lookup<ffi.Pointer<ffi.Char>>('admin_list');

ffi.Pointer<ffi.Pointer<ffi.Char>> get admin_list => _admin_list;

/// @brief Count the number of bits set to one in an unsigned long long.
/// 
/// This is the classical popcount function.
/// Since 2007, it is part of the instruction set of some modern CPU,
/// (>= barcelona for AMD or >= nelhacem for Intel). Alternatively,
/// a fast SWAR algorithm, adding bits in parallel is provided here.
/// This function is massively used to count discs on the board,
/// the mobility, or the stability.
/// 
/// @param b 64-bit integer to count bits of.
/// @return the number of bits set.
int bit_count(int arg0,
) {
  return _bit_count(arg0,
);
}

late final _bit_countPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.UnsignedLongLong )>>('bit_count');
late final _bit_count = _bit_countPtr.asFunction<int Function(int )>();

late final ffi.Pointer<ffi.Bool> _book_verbose = _lookup<ffi.Bool>('book_verbose');

bool get book_verbose => _book_verbose.value;

set book_verbose(bool value) =>_book_verbose.value = value;

late final ffi.Pointer<ffi.Int> _daylight = _lookup<ffi.Int>('daylight');

int get daylight => _daylight.value;

set daylight(int value) =>_daylight.value = value;

int edax_board_get_square_color(ffi.Pointer<Board> arg0,
int arg1,
) {
  return _edax_board_get_square_color(arg0,
arg1,
);
}

late final _edax_board_get_square_colorPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.Pointer<Board> , ffi.Int )>>('edax_board_get_square_color');
late final _edax_board_get_square_color = _edax_board_get_square_colorPtr.asFunction<int Function(ffi.Pointer<Board> , int )>();

int edax_board_is_pass(ffi.Pointer<Board> arg0,
) {
  return _edax_board_is_pass(arg0,
);
}

late final _edax_board_is_passPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.Pointer<Board> )>>('edax_board_is_pass');
late final _edax_board_is_pass = _edax_board_is_passPtr.asFunction<int Function(ffi.Pointer<Board> )>();

void edax_book_count_bestpath(ffi.Pointer<Board> arg0,
ffi.Pointer<Position> arg1,
) {
  return _edax_book_count_bestpath(arg0,
arg1,
);
}

late final _edax_book_count_bestpathPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<Board> , ffi.Pointer<Position> )>>('edax_book_count_bestpath');
late final _edax_book_count_bestpath = _edax_book_count_bestpathPtr.asFunction<void Function(ffi.Pointer<Board> , ffi.Pointer<Position> )>();

void edax_book_count_board_bestpath(ffi.Pointer<Board> arg0,
ffi.Pointer<Position> arg1,
int arg2,
int arg3,
int arg4,
) {
  return _edax_book_count_board_bestpath(arg0,
arg1,
arg2,
arg3,
arg4,
);
}

late final _edax_book_count_board_bestpathPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<Board> , ffi.Pointer<Position> , ffi.Int , ffi.Int , ffi.Int )>>('edax_book_count_board_bestpath');
late final _edax_book_count_board_bestpath = _edax_book_count_board_bestpathPtr.asFunction<void Function(ffi.Pointer<Board> , ffi.Pointer<Position> , int , int , int )>();

void edax_book_deviate(int arg0,
int arg1,
) {
  return _edax_book_deviate(arg0,
arg1,
);
}

late final _edax_book_deviatePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int , ffi.Int )>>('edax_book_deviate');
late final _edax_book_deviate = _edax_book_deviatePtr.asFunction<void Function(int , int )>();

void edax_book_fix() {
  return _edax_book_fix();
}

late final _edax_book_fixPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_book_fix');
late final _edax_book_fix = _edax_book_fixPtr.asFunction<void Function()>();

void edax_book_load(ffi.Pointer<ffi.Char> arg0,
) {
  return _edax_book_load(arg0,
);
}

late final _edax_book_loadPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char> )>>('edax_book_load');
late final _edax_book_load = _edax_book_loadPtr.asFunction<void Function(ffi.Pointer<ffi.Char> )>();

void edax_book_new(int arg0,
int arg1,
) {
  return _edax_book_new(arg0,
arg1,
);
}

late final _edax_book_newPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int , ffi.Int )>>('edax_book_new');
late final _edax_book_new = _edax_book_newPtr.asFunction<void Function(int , int )>();

void edax_book_off() {
  return _edax_book_off();
}

late final _edax_book_offPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_book_off');
late final _edax_book_off = _edax_book_offPtr.asFunction<void Function()>();

void edax_book_on() {
  return _edax_book_on();
}

late final _edax_book_onPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_book_on');
late final _edax_book_on = _edax_book_onPtr.asFunction<void Function()>();

void edax_book_randomness(int arg0,
) {
  return _edax_book_randomness(arg0,
);
}

late final _edax_book_randomnessPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int )>>('edax_book_randomness');
late final _edax_book_randomness = _edax_book_randomnessPtr.asFunction<void Function(int )>();

void edax_book_save(ffi.Pointer<ffi.Char> arg0,
) {
  return _edax_book_save(arg0,
);
}

late final _edax_book_savePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char> )>>('edax_book_save');
late final _edax_book_save = _edax_book_savePtr.asFunction<void Function(ffi.Pointer<ffi.Char> )>();

void edax_book_show(ffi.Pointer<Position> arg0,
) {
  return _edax_book_show(arg0,
);
}

late final _edax_book_showPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<Position> )>>('edax_book_show');
late final _edax_book_show = _edax_book_showPtr.asFunction<void Function(ffi.Pointer<Position> )>();

void edax_book_stop_count_bestpath() {
  return _edax_book_stop_count_bestpath();
}

late final _edax_book_stop_count_bestpathPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_book_stop_count_bestpath');
late final _edax_book_stop_count_bestpath = _edax_book_stop_count_bestpathPtr.asFunction<void Function()>();

void edax_book_store() {
  return _edax_book_store();
}

late final _edax_book_storePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_book_store');
late final _edax_book_store = _edax_book_storePtr.asFunction<void Function()>();

void edax_book_verbose(int arg0,
) {
  return _edax_book_verbose(arg0,
);
}

late final _edax_book_verbosePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int )>>('edax_book_verbose');
late final _edax_book_verbose = _edax_book_verbosePtr.asFunction<void Function(int )>();

int edax_can_move() {
  return _edax_can_move();
}

late final _edax_can_movePtr = _lookup<
    ffi.NativeFunction<ffi.Int Function()>>('edax_can_move');
late final _edax_can_move = _edax_can_movePtr.asFunction<int Function()>();

void edax_disable_book_verbose() {
  return _edax_disable_book_verbose();
}

late final _edax_disable_book_verbosePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_disable_book_verbose');
late final _edax_disable_book_verbose = _edax_disable_book_verbosePtr.asFunction<void Function()>();

void edax_enable_book_verbose() {
  return _edax_enable_book_verbose();
}

late final _edax_enable_book_verbosePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_enable_book_verbose');
late final _edax_enable_book_verbose = _edax_enable_book_verbosePtr.asFunction<void Function()>();

void edax_get_board(ffi.Pointer<Board> arg0,
) {
  return _edax_get_board(arg0,
);
}

late final _edax_get_boardPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<Board> )>>('edax_get_board');
late final _edax_get_board = _edax_get_boardPtr.asFunction<void Function(ffi.Pointer<Board> )>();

void edax_get_bookmove(ffi.Pointer<MoveList> arg0,
) {
  return _edax_get_bookmove(arg0,
);
}

late final _edax_get_bookmovePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<MoveList> )>>('edax_get_bookmove');
late final _edax_get_bookmove = _edax_get_bookmovePtr.asFunction<void Function(ffi.Pointer<MoveList> )>();

int edax_get_bookmove_with_position(ffi.Pointer<MoveList> arg0,
ffi.Pointer<Position> arg1,
) {
  return _edax_get_bookmove_with_position(arg0,
arg1,
);
}

late final _edax_get_bookmove_with_positionPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.Pointer<MoveList> , ffi.Pointer<Position> )>>('edax_get_bookmove_with_position');
late final _edax_get_bookmove_with_position = _edax_get_bookmove_with_positionPtr.asFunction<int Function(ffi.Pointer<MoveList> , ffi.Pointer<Position> )>();

int edax_get_bookmove_with_position_by_moves(ffi.Pointer<ffi.Char> arg0,
ffi.Pointer<MoveList> arg1,
ffi.Pointer<Position> arg2,
) {
  return _edax_get_bookmove_with_position_by_moves(arg0,
arg1,
arg2,
);
}

late final _edax_get_bookmove_with_position_by_movesPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Char> , ffi.Pointer<MoveList> , ffi.Pointer<Position> )>>('edax_get_bookmove_with_position_by_moves');
late final _edax_get_bookmove_with_position_by_moves = _edax_get_bookmove_with_position_by_movesPtr.asFunction<int Function(ffi.Pointer<ffi.Char> , ffi.Pointer<MoveList> , ffi.Pointer<Position> )>();

int edax_get_current_player() {
  return _edax_get_current_player();
}

late final _edax_get_current_playerPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function()>>('edax_get_current_player');
late final _edax_get_current_player = _edax_get_current_playerPtr.asFunction<int Function()>();

int edax_get_disc(int arg0,
) {
  return _edax_get_disc(arg0,
);
}

late final _edax_get_discPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.Int )>>('edax_get_disc');
late final _edax_get_disc = _edax_get_discPtr.asFunction<int Function(int )>();

void edax_get_last_move(ffi.Pointer<Move> arg0,
) {
  return _edax_get_last_move(arg0,
);
}

late final _edax_get_last_movePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<Move> )>>('edax_get_last_move');
late final _edax_get_last_move = _edax_get_last_movePtr.asFunction<void Function(ffi.Pointer<Move> )>();

int edax_get_mobility_count(int arg0,
) {
  return _edax_get_mobility_count(arg0,
);
}

late final _edax_get_mobility_countPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.Int )>>('edax_get_mobility_count');
late final _edax_get_mobility_count = _edax_get_mobility_countPtr.asFunction<int Function(int )>();

ffi.Pointer<ffi.Char> edax_get_moves(ffi.Pointer<ffi.Char> arg0,
) {
  return _edax_get_moves(arg0,
);
}

late final _edax_get_movesPtr = _lookup<
    ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char> )>>('edax_get_moves');
late final _edax_get_moves = _edax_get_movesPtr.asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char> )>();

void edax_go() {
  return _edax_go();
}

late final _edax_goPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_go');
late final _edax_go = _edax_goPtr.asFunction<void Function()>();

void edax_hint(int arg0,
ffi.Pointer<HintList> arg1,
) {
  return _edax_hint(arg0,
arg1,
);
}

late final _edax_hintPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int , ffi.Pointer<HintList> )>>('edax_hint');
late final _edax_hint = _edax_hintPtr.asFunction<void Function(int , ffi.Pointer<HintList> )>();

void edax_hint_next(ffi.Pointer<Hint> arg0,
) {
  return _edax_hint_next(arg0,
);
}

late final _edax_hint_nextPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<Hint> )>>('edax_hint_next');
late final _edax_hint_next = _edax_hint_nextPtr.asFunction<void Function(ffi.Pointer<Hint> )>();

void edax_hint_next_no_multipv_depth(ffi.Pointer<Hint> arg0,
) {
  return _edax_hint_next_no_multipv_depth(arg0,
);
}

late final _edax_hint_next_no_multipv_depthPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<Hint> )>>('edax_hint_next_no_multipv_depth');
late final _edax_hint_next_no_multipv_depth = _edax_hint_next_no_multipv_depthPtr.asFunction<void Function(ffi.Pointer<Hint> )>();

void edax_hint_prepare(ffi.Pointer<MoveList> arg0,
) {
  return _edax_hint_prepare(arg0,
);
}

late final _edax_hint_preparePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<MoveList> )>>('edax_hint_prepare');
late final _edax_hint_prepare = _edax_hint_preparePtr.asFunction<void Function(ffi.Pointer<MoveList> )>();

void edax_init() {
  return _edax_init();
}

late final _edax_initPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_init');
late final _edax_init = _edax_initPtr.asFunction<void Function()>();

int edax_is_game_over() {
  return _edax_is_game_over();
}

late final _edax_is_game_overPtr = _lookup<
    ffi.NativeFunction<ffi.Int Function()>>('edax_is_game_over');
late final _edax_is_game_over = _edax_is_game_overPtr.asFunction<int Function()>();

late final ffi.Pointer<Log> _edax_log = _lookup<Log>('edax_log');

ffi.Pointer<Log> get edax_log => _edax_log;

void edax_mode(int arg0,
) {
  return _edax_mode(arg0,
);
}

late final _edax_modePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int )>>('edax_mode');
late final _edax_mode = _edax_modePtr.asFunction<void Function(int )>();

int edax_move(ffi.Pointer<ffi.Char> arg0,
) {
  return _edax_move(arg0,
);
}

late final _edax_movePtr = _lookup<
    ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Char> )>>('edax_move');
late final _edax_move = _edax_movePtr.asFunction<int Function(ffi.Pointer<ffi.Char> )>();

void edax_new() {
  return _edax_new();
}

late final _edax_newPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_new');
late final _edax_new = _edax_newPtr.asFunction<void Function()>();

ffi.Pointer<ffi.Char> edax_opening() {
  return _edax_opening();
}

late final _edax_openingPtr = _lookup<
    ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>('edax_opening');
late final _edax_opening = _edax_openingPtr.asFunction<ffi.Pointer<ffi.Char> Function()>();

void edax_options_dump() {
  return _edax_options_dump();
}

late final _edax_options_dumpPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_options_dump');
late final _edax_options_dump = _edax_options_dumpPtr.asFunction<void Function()>();

void edax_play(ffi.Pointer<ffi.Char> arg0,
) {
  return _edax_play(arg0,
);
}

late final _edax_playPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char> )>>('edax_play');
late final _edax_play = _edax_playPtr.asFunction<void Function(ffi.Pointer<ffi.Char> )>();

void edax_play_print() {
  return _edax_play_print();
}

late final _edax_play_printPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_play_print');
late final _edax_play_print = _edax_play_printPtr.asFunction<void Function()>();

void edax_redo() {
  return _edax_redo();
}

late final _edax_redoPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_redo');
late final _edax_redo = _edax_redoPtr.asFunction<void Function()>();

void edax_rotate(int arg0,
) {
  return _edax_rotate(arg0,
);
}

late final _edax_rotatePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int )>>('edax_rotate');
late final _edax_rotate = _edax_rotatePtr.asFunction<void Function(int )>();

void edax_set_option(ffi.Pointer<ffi.Char> arg0,
ffi.Pointer<ffi.Char> arg1,
) {
  return _edax_set_option(arg0,
arg1,
);
}

late final _edax_set_optionPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char> , ffi.Pointer<ffi.Char> )>>('edax_set_option');
late final _edax_set_option = _edax_set_optionPtr.asFunction<void Function(ffi.Pointer<ffi.Char> , ffi.Pointer<ffi.Char> )>();

void edax_setboard(ffi.Pointer<ffi.Char> arg0,
) {
  return _edax_setboard(arg0,
);
}

late final _edax_setboardPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char> )>>('edax_setboard');
late final _edax_setboard = _edax_setboardPtr.asFunction<void Function(ffi.Pointer<ffi.Char> )>();

void edax_stop() {
  return _edax_stop();
}

late final _edax_stopPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_stop');
late final _edax_stop = _edax_stopPtr.asFunction<void Function()>();

void edax_undo() {
  return _edax_undo();
}

late final _edax_undoPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_undo');
late final _edax_undo = _edax_undoPtr.asFunction<void Function()>();

void edax_version() {
  return _edax_version();
}

late final _edax_versionPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_version');
late final _edax_version = _edax_versionPtr.asFunction<void Function()>();

void edax_vmirror() {
  return _edax_vmirror();
}

late final _edax_vmirrorPtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('edax_vmirror');
late final _edax_vmirror = _edax_vmirrorPtr.asFunction<void Function()>();

/// edge stability global data
late final ffi.Pointer<ffi.Pointer<ffi.UnsignedChar>> _edge_stability = _lookup<ffi.Pointer<ffi.UnsignedChar>>('edge_stability');

ffi.Pointer<ffi.Pointer<ffi.UnsignedChar>> get edge_stability => _edge_stability;

late final ffi.Pointer<Log> _engine_log = _lookup<Log>('engine_log');

ffi.Pointer<Log> get engine_log => _engine_log;

/// a global variable used to display the search result
late final ffi.Pointer<ffi.Char> _engine_result = _lookup<ffi.Char>('engine_result');

ffi.Pointer<ffi.Char> get engine_result => _engine_result;

/// Array of functions to compute flipped discs
late final ffi.Pointer<ffi.Pointer<ffi.NativeFunction<ffi.UnsignedLongLong Function(ffi.UnsignedLongLong , ffi.UnsignedLongLong )>>> _flip = _lookup<ffi.Pointer<ffi.NativeFunction<ffi.UnsignedLongLong Function(ffi.UnsignedLongLong , ffi.UnsignedLongLong )>>>('flip');

ffi.Pointer<ffi.Pointer<ffi.NativeFunction<ffi.UnsignedLongLong Function(ffi.UnsignedLongLong , ffi.UnsignedLongLong )>>> get flip => _flip;

late final ffi.Pointer<ffi.Int> _getdate_err = _lookup<ffi.Int>('getdate_err');

int get getdate_err => _getdate_err.value;

set getdate_err(int value) =>_getdate_err.value = value;

late final ffi.Pointer<Log> _ggs_log = _lookup<Log>('ggs_log');

ffi.Pointer<Log> get ggs_log => _ggs_log;

late final ffi.Pointer<Log> _gtp_log = _lookup<Log>('gtp_log');

ffi.Pointer<Log> get gtp_log => _gtp_log;

late final ffi.Pointer<ffi.Int> _h_errno = _lookup<ffi.Int>('h_errno');

int get h_errno => _h_errno.value;

set h_errno(int value) =>_h_errno.value = value;

/// hashing global data
late final ffi.Pointer<ffi.Pointer<ffi.UnsignedLongLong>> _hash_move = _lookup<ffi.Pointer<ffi.UnsignedLongLong>>('hash_move');

ffi.Pointer<ffi.Pointer<ffi.UnsignedLongLong>> get hash_move => _hash_move;

/// hashing global data
late final ffi.Pointer<ffi.Pointer<ffi.UnsignedLongLong>> _hash_rank = _lookup<ffi.Pointer<ffi.UnsignedLongLong>>('hash_rank');

ffi.Pointer<ffi.Pointer<ffi.UnsignedLongLong>> get hash_rank => _hash_rank;

late final ffi.Pointer<in6_addr> _in6addr_any = _lookup<in6_addr>('in6addr_any');

in6_addr get in6addr_any => _in6addr_any.ref;

late final ffi.Pointer<in6_addr> _in6addr_linklocal_allnodes = _lookup<in6_addr>('in6addr_linklocal_allnodes');

in6_addr get in6addr_linklocal_allnodes => _in6addr_linklocal_allnodes.ref;

late final ffi.Pointer<in6_addr> _in6addr_linklocal_allrouters = _lookup<in6_addr>('in6addr_linklocal_allrouters');

in6_addr get in6addr_linklocal_allrouters => _in6addr_linklocal_allrouters.ref;

late final ffi.Pointer<in6_addr> _in6addr_linklocal_allv2routers = _lookup<in6_addr>('in6addr_linklocal_allv2routers');

in6_addr get in6addr_linklocal_allv2routers => _in6addr_linklocal_allv2routers.ref;

late final ffi.Pointer<in6_addr> _in6addr_loopback = _lookup<in6_addr>('in6addr_loopback');

in6_addr get in6addr_loopback => _in6addr_loopback.ref;

late final ffi.Pointer<in6_addr> _in6addr_nodelocal_allnodes = _lookup<in6_addr>('in6addr_nodelocal_allnodes');

in6_addr get in6addr_nodelocal_allnodes => _in6addr_nodelocal_allnodes.ref;

/// a global string with the last result sent to avoid duplicate result lines
late final ffi.Pointer<ffi.Char> _last_line_sent = _lookup<ffi.Char>('last_line_sent');

ffi.Pointer<ffi.Char> get last_line_sent => _last_line_sent;

void libedax_initialize(int arg0,
ffi.Pointer<ffi.Pointer<ffi.Char>> arg1,
) {
  return _libedax_initialize(arg0,
arg1,
);
}

late final _libedax_initializePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function(ffi.Int , ffi.Pointer<ffi.Pointer<ffi.Char>> )>>('libedax_initialize');
late final _libedax_initialize = _libedax_initializePtr.asFunction<void Function(int , ffi.Pointer<ffi.Pointer<ffi.Char>> )>();

void libedax_terminate() {
  return _libedax_terminate();
}

late final _libedax_terminatePtr = _lookup<
    ffi.NativeFunction<ffi.Void Function()>>('libedax_terminate');
late final _libedax_terminate = _libedax_terminatePtr.asFunction<void Function()>();

late final ffi.Pointer<Log> _nboard_log = _lookup<Log>('nboard_log');

ffi.Pointer<Log> get nboard_log => _nboard_log;

late final ffi.Pointer<ffi.Pointer<ffi.Char>> _optarg = _lookup<ffi.Pointer<ffi.Char>>('optarg');

ffi.Pointer<ffi.Char> get optarg => _optarg.value;

set optarg(ffi.Pointer<ffi.Char> value) =>_optarg.value = value;

late final ffi.Pointer<ffi.Int> _opterr = _lookup<ffi.Int>('opterr');

int get opterr => _opterr.value;

set opterr(int value) =>_opterr.value = value;

late final ffi.Pointer<ffi.Int> _optind = _lookup<ffi.Int>('optind');

int get optind => _optind.value;

set optind(int value) =>_optind.value = value;

/// global options with default value
late final ffi.Pointer<Options> _options = _lookup<Options>('options');

Options get options => _options.ref;

late final ffi.Pointer<ffi.Int> _optopt = _lookup<ffi.Int>('optopt');

int get optopt => _optopt.value;

set optopt(int value) =>_optopt.value = value;

late final ffi.Pointer<ffi.Int> _optreset = _lookup<ffi.Int>('optreset');

int get optreset => _optreset.value;

set optreset(int value) =>_optreset.value = value;

late final ffi.Pointer<Log> _search_log = _lookup<Log>('search_log');

ffi.Pointer<Log> get search_log => _search_log;

/// predefined selectivity
late final ffi.Pointer<ffi.Pointer<Selectivity>> _selectivity_table = _lookup<ffi.Pointer<Selectivity>>('selectivity_table');

ffi.Pointer<Selectivity> get selectivity_table => _selectivity_table.value;

set selectivity_table(ffi.Pointer<Selectivity> value) =>_selectivity_table.value = value;

late final ffi.Pointer<ffi.Int> _signgam = _lookup<ffi.Int>('signgam');

int get signgam => _signgam.value;

set signgam(int value) =>_signgam.value = value;

late final ffi.Pointer<Statistics> _statistics = _lookup<Statistics>('statistics');

Statistics get statistics => _statistics.ref;

late final ffi.Pointer<ffi.Pointer<ffi.Char>> _suboptarg = _lookup<ffi.Pointer<ffi.Char>>('suboptarg');

ffi.Pointer<ffi.Char> get suboptarg => _suboptarg.value;

set suboptarg(ffi.Pointer<ffi.Char> value) =>_suboptarg.value = value;

late final ffi.Pointer<ffi.Pointer<ffi.Pointer<ffi.Char>>> _sys_errlist = _lookup<ffi.Pointer<ffi.Pointer<ffi.Char>>>('sys_errlist');

ffi.Pointer<ffi.Pointer<ffi.Char>> get sys_errlist => _sys_errlist.value;

set sys_errlist(ffi.Pointer<ffi.Pointer<ffi.Char>> value) =>_sys_errlist.value = value;

late final ffi.Pointer<ffi.Int> _sys_nerr = _lookup<ffi.Int>('sys_nerr');

int get sys_nerr => _sys_nerr.value;

late final ffi.Pointer<ffi.Pointer<ffi.Char>> _sys_siglist = _lookup<ffi.Pointer<ffi.Char>>('sys_siglist');

ffi.Pointer<ffi.Pointer<ffi.Char>> get sys_siglist => _sys_siglist;

late final ffi.Pointer<ffi.Pointer<ffi.Char>> _sys_signame = _lookup<ffi.Pointer<ffi.Char>>('sys_signame');

ffi.Pointer<ffi.Pointer<ffi.Char>> get sys_signame => _sys_signame;

/// @brief Time clock.
/// 
/// Can be set as a real_clock or a cpu_clock.
/// 
/// @return time in milliseconds.
late final ffi.Pointer<ffi.Pointer<ffi.NativeFunction<ffi.LongLong Function()>>> _time_clock = _lookup<ffi.Pointer<ffi.NativeFunction<ffi.LongLong Function()>>>('time_clock');

ffi.Pointer<ffi.NativeFunction<ffi.LongLong Function()>> get time_clock => _time_clock.value;

set time_clock(ffi.Pointer<ffi.NativeFunction<ffi.LongLong Function()>> value) =>_time_clock.value = value;

late final ffi.Pointer<ffi.Long> _timezone = _lookup<ffi.Long>('timezone');

int get timezone => _timezone.value;

set timezone(int value) =>_timezone.value = value;

late final ffi.Pointer<ffi.Pointer<ffi.Pointer<ffi.Char>>> _tzname = _lookup<ffi.Pointer<ffi.Pointer<ffi.Char>>>('tzname');

ffi.Pointer<ffi.Pointer<ffi.Char>> get tzname => _tzname.value;

set tzname(ffi.Pointer<ffi.Pointer<ffi.Char>> value) =>_tzname.value = value;

late final ffi.Pointer<Log> _xboard_log = _lookup<Log>('xboard_log');

ffi.Pointer<Log> get xboard_log => _xboard_log;

}


const int A1 = 0;


const int A2 = 8;


const int A3 = 16;


const int A4 = 24;


const int A5 = 32;


const int A6 = 40;


const int A7 = 48;


const int A8 = 56;


const int ACCESSPERMS = 511;


const int ACCESSX_MAX_DESCRIPTORS = 100;


const int ACCESSX_MAX_TABLESIZE = 16384;


const int AF_APPLETALK = 16;


const int AF_CCITT = 10;


const int AF_CHAOS = 5;


const int AF_CNT = 21;


const int AF_COIP = 20;


const int AF_DATAKIT = 9;


const int AF_DECnet = 12;


const int AF_DLI = 13;


const int AF_E164 = 28;


const int AF_ECMA = 8;


const int AF_HYLINK = 15;


const int AF_IEEE80211 = 37;


const int AF_IMPLINK = 3;


const int AF_INET = 2;


const int AF_INET6 = 30;


const int AF_IPX = 23;


const int AF_ISDN = 28;


const int AF_ISO = 7;


const int AF_LAT = 14;


const int AF_LINK = 18;


const int AF_LOCAL = 1;


const int AF_MAX = 41;


const int AF_NATM = 31;


const int AF_NDRV = 27;


const int AF_NETBIOS = 33;


const int AF_NS = 6;


const int AF_OSI = 7;


const int AF_PPP = 34;


const int AF_PUP = 4;


const int AF_RESERVED_36 = 36;


const int AF_ROUTE = 17;


const int AF_SIP = 24;


const int AF_SNA = 11;


const int AF_SYSTEM = 32;


const int AF_UNIX = 1;


const int AF_UNSPEC = 0;


const int AF_UTUN = 38;


const int AF_VSOCK = 40;


const int AI_ADDRCONFIG = 1024;


const int AI_ALL = 256;


const int AI_CANONNAME = 2;


const int AI_DEFAULT = 1536;


const int AI_MASK = 5127;


const int AI_NUMERICHOST = 4;


const int AI_NUMERICSERV = 4096;


const int AI_PASSIVE = 1;


const int AI_UNUSABLE = 268435456;


const int AI_V4MAPPED = 2048;


const int AI_V4MAPPED_CFG = 512;


const int ALLPERMS = 4095;


const int ARG_MAX = 1048576;


const int B1 = 1;


const int B2 = 9;


const int B3 = 17;


const int B4 = 25;


const int B5 = 33;


const int B6 = 41;


const int B7 = 49;


const int B8 = 57;


const int BC_BASE_MAX = 99;


const int BC_DIM_MAX = 2048;


const int BC_SCALE_MAX = 99;


const int BC_STRING_MAX = 1000;


const int BESTPATH_BEST = 128;


const int BIG_ENDIAN = 4321;


const int BLACK = 0;


const int BOARD_SIZE = 64;


const int BOOK = 1112493899;


const int BOOK_DEBUG = 0;


const double BRANCHING_FACTOR = 2.24;


const int BUFSIZ = 1024;


const int BUS_ADRALN = 1;


const int BUS_ADRERR = 2;


const int BUS_NOOP = 0;


const int BUS_OBJERR = 3;


const int BYTE_ORDER = 1234;

final class Base extends ffi.Struct{
  external ffi.Pointer<Game> game;

  @ffi.Int()
  external int n_games;

  @ffi.Int()
  external int size;

}

/// Bench result structure
final class BenchResult extends ffi.Struct{
  @ffi.UnsignedLongLong()
  external int T;

  @ffi.UnsignedLongLong()
  external int n_nodes;

  @ffi.Int()
  external int positions;

  external Lock lock;

}

/// Board : board representation
final class Board extends ffi.Struct{
  /// < bitboard representation
  @ffi.UnsignedLongLong()
  external int player;

  @ffi.UnsignedLongLong()
  external int opponent;

}

/// HashTable of shapes
final class BoardCache extends ffi.Struct{
  external ffi.Pointer<Board> array;

  @ffi.Int()
  external int size;

  @ffi.Int()
  external int mask;

}

/// struct Book
/// @brief The opening book.
final class Book extends ffi.Struct{
  external UnnamedStruct$3 date;

  external UnnamedStruct$4 options$1;

  external UnnamedStruct$5 stats;

  external ffi.Pointer<PositionArray> array;

  external ffi.Pointer<PositionStack> stack;

  @ffi.Int()
  external int n;

  @ffi.Int()
  external int n_nodes;

  @ffi.Bool()
  external bool need_saving;

@ffi.Array.multi([1])
  external ffi.Array<Random> random;

  external ffi.Pointer<Search> search;

  @ffi.UnsignedInt()
  external int count_bestpath_stopAsInt;

Stop get count_bestpath_stop => Stop.fromValue(count_bestpath_stopAsInt);

}

final class BookCheckGame extends ffi.Struct{
  @ffi.UnsignedLongLong()
  external int missing;

  @ffi.UnsignedLongLong()
  external int good;

  @ffi.UnsignedLongLong()
  external int bad;

}

/// Bound
final class Bound extends ffi.Struct{
  @ffi.Int()
  external int lower;

  @ffi.Int()
  external int upper;

}


const int C1 = 2;


const int C2 = 10;


const int C3 = 18;


const int C4 = 26;


const int C5 = 34;


const int C6 = 42;


const int C7 = 50;


const int C8 = 58;

final class CBoard extends ffi.Struct{
@ffi.Array.multi([13])
  external ffi.Array<ffi.UnsignedChar> x;

}


const int CHARCLASS_NAME_MAX = 14;


const int CHAR_BIT = 8;


const int CHAR_MAX = 127;


const int CHAR_MIN = -128;


const int CHILD_MAX = 266;


const int CLD_CONTINUED = 6;


const int CLD_DUMPED = 3;


const int CLD_EXITED = 1;


const int CLD_KILLED = 2;


const int CLD_NOOP = 0;


const int CLD_STOPPED = 5;


const int CLD_TRAPPED = 4;


const int CLK_TCK = 100;


const int CLOCKS_PER_SEC = 1000000;


const int CLOCK_MONOTONIC = 6;


const int CLOCK_MONOTONIC_RAW = 4;


const int CLOCK_MONOTONIC_RAW_APPROX = 5;


const int CLOCK_PROCESS_CPUTIME_ID = 12;


const int CLOCK_REALTIME = 0;


const int CLOCK_THREAD_CPUTIME_ID = 16;


const int CLOCK_UPTIME_RAW = 8;


const int CLOCK_UPTIME_RAW_APPROX = 9;


const int COLL_WEIGHTS_MAX = 2;


const int CONNECT_DATA_AUTHENTICATED = 4;


const int CONNECT_DATA_IDEMPOTENT = 2;


const int CONNECT_RESUME_ON_READ_WRITE = 1;


const int COUNT_NODES = 7;


const int CPUMON_MAKE_FATAL = 4096;

/// typedef conditional variable
typedef Condition = pthread_cond_t;
/// coordinate to feature conversion
final class CoordinateToFeature extends ffi.Struct{
  @ffi.Int()
  external int n_feature;

@ffi.Array.multi([16])
  external ffi.Array<UnnamedStruct$1> feature;

}


const int D1 = 3;


const int D2 = 11;


const int D3 = 19;


const int D4 = 27;


const int D5 = 35;


const int D6 = 43;


const int D7 = 51;


const int D8 = 59;


const int DEFFILEMODE = 438;


const int DEPTH_MIDGAME_TO_ENDGAME = 15;


const int DEPTH_TO_SHALLOW_SEARCH = 7;


const int DOMAIN = 1;


const int DST_AUST = 2;


const int DST_CAN = 6;


const int DST_EET = 5;


const int DST_MET = 4;


const int DST_NONE = 0;


const int DST_USA = 1;


const int DST_WET = 3;


const int E1 = 4;


const int E2 = 12;


const int E2BIG = 7;


const int E3 = 20;


const int E4 = 28;


const int E5 = 36;


const int E6 = 44;


const int E7 = 52;


const int E8 = 60;


const int EACCES = 13;


const int EADDRINUSE = 48;


const int EADDRNOTAVAIL = 49;


const int EAFNOSUPPORT = 47;


const int EAGAIN = 35;


const int EAI_ADDRFAMILY = 1;


const int EAI_AGAIN = 2;


const int EAI_BADFLAGS = 3;


const int EAI_BADHINTS = 12;


const int EAI_FAIL = 4;


const int EAI_FAMILY = 5;


const int EAI_MAX = 15;


const int EAI_MEMORY = 6;


const int EAI_NODATA = 7;


const int EAI_NONAME = 8;


const int EAI_OVERFLOW = 14;


const int EAI_PROTOCOL = 13;


const int EAI_SERVICE = 9;


const int EAI_SOCKTYPE = 10;


const int EAI_SYSTEM = 11;


const int EALREADY = 37;


const int EAUTH = 80;


const int EBADARCH = 86;


const int EBADEXEC = 85;


const int EBADF = 9;


const int EBADMACHO = 88;


const int EBADMSG = 94;


const int EBADRPC = 72;


const int EBUSY = 16;


const int ECANCELED = 89;


const int ECHILD = 10;


const int ECONNABORTED = 53;


const int ECONNREFUSED = 61;


const int ECONNRESET = 54;


const int EDAX = 1162101080;


const String EDAX_NAME = 'Edax 4.4';


const int EDEADLK = 11;


const int EDESTADDRREQ = 39;


const int EDEVERR = 83;


const int EDOM = 33;


const int EDQUOT = 69;


const int EEXIST = 17;


const int EFAULT = 14;


const int EFBIG = 27;


const int EFTYPE = 79;


const int EF_IS_PURGEABLE = 8;


const int EF_IS_SPARSE = 16;


const int EF_IS_SYNC_ROOT = 4;


const int EF_IS_SYNTHETIC = 32;


const int EF_MAY_SHARE_BLOCKS = 1;


const int EF_NO_XATTRS = 2;


const int EF_SHARES_ALL_BLOCKS = 64;


const int EHOSTDOWN = 64;


const int EHOSTUNREACH = 65;


const int EIDRM = 90;


const int EILSEQ = 92;


const int EINPROGRESS = 36;


const int EINTR = 4;


const int EINVAL = 22;


const int EIO = 5;


const int EISCONN = 56;


const int EISDIR = 21;


const int ELAST = 106;


const int ELOOP = 62;


const int EMFILE = 24;


const int EMLINK = 31;


const int EMPTY = 2;


const int EMSGSIZE = 40;


const int EMULTIHOP = 95;


const int ENAMETOOLONG = 63;


const int ENEEDAUTH = 81;


const int ENETDOWN = 50;


const int ENETRESET = 52;


const int ENETUNREACH = 51;


const int ENFILE = 23;


const int ENGINE_N_POSITION = 1024;


const int ENOATTR = 93;


const int ENOBUFS = 55;


const int ENODATA = 96;


const int ENODEV = 19;


const int ENOENT = 2;


const int ENOEXEC = 8;


const int ENOLCK = 77;


const int ENOLINK = 97;


const int ENOMEM = 12;


const int ENOMSG = 91;


const int ENOPOLICY = 103;


const int ENOPROTOOPT = 42;


const int ENOSPC = 28;


const int ENOSR = 98;


const int ENOSTR = 99;


const int ENOSYS = 78;


const int ENOTBLK = 15;


const int ENOTCONN = 57;


const int ENOTDIR = 20;


const int ENOTEMPTY = 66;


const int ENOTRECOVERABLE = 104;


const int ENOTSOCK = 38;


const int ENOTSUP = 45;


const int ENOTTY = 25;


const int ENXIO = 6;


const int EOF = -1;


const int EOPNOTSUPP = 102;


const int EOVERFLOW = 84;


const int EOWNERDEAD = 105;


const int EPERM = 1;


const int EPFNOSUPPORT = 46;


const int EPIPE = 32;


const int EPROCLIM = 67;


const int EPROCUNAVAIL = 76;


const int EPROGMISMATCH = 75;


const int EPROGUNAVAIL = 74;


const int EPROTO = 100;


const int EPROTONOSUPPORT = 43;


const int EPROTOTYPE = 41;


const int EPWROFF = 82;


const int EQFULL = 106;


const int EQUIV_CLASS_MAX = 2;


const int ERANGE = 34;


const int EREMOTE = 71;


const int EROFS = 30;


const int ERPCMISMATCH = 73;


const int ESHLIBVERS = 87;


const int ESHUTDOWN = 58;


const int ESOCKTNOSUPPORT = 44;


const int ESPIPE = 29;


const int ESRCH = 3;


const int ESTALE = 70;


const int ETC_MIN_DEPTH = 5;


const int ETIME = 101;


const int ETIMEDOUT = 60;


const int ETOOMANYREFS = 59;


const int ETXTBSY = 26;


const int EUSERS = 68;


const int EVAL = 1163280716;


const int EWOULDBLOCK = 35;


const int EXDEV = 18;


const int EXIT_FAILURE = 1;


const int EXIT_SUCCESS = 0;


const int EXPR_NEST_MAX = 32;

/// Engine management data
final class Engine extends ffi.Struct{
@ffi.Array.multi([1])
  external ffi.Array<Event> event;

  /// Events
  external ffi.Pointer<Search> search;

  external UnnamedStruct$6 last_position;

  @ffi.Bool()
  external bool is_searching;

}

/// struct Eval
/// @brief evaluation function
final class Eval extends ffi.Struct{
  external ffi.Pointer<ffi.Int> feature;

  /// !< discs' features
  @ffi.Int()
  external int player;

}

/// Event management data
final class Event extends ffi.Struct{
  /// !< flag allowing to loop, waiting for events
  @ffi.Bool()
  external bool loop;

  /// !< ring of buffers
  external ffi.Pointer<ffi.Pointer<ffi.Char>> ring;

  /// !< size of the buffer ring
  @ffi.Int()
  external int size;

  /// !< first position in the ring
  @ffi.Int()
  external int first;

  /// !< one past the last position in the ring
  @ffi.Int()
  external int end;

  /// !< thread
  external Thread thread;

  /// !< spin lock
  @SpinLock()
  external int spin;

  /// !< lock
  external Lock lock;

  /// !< condition
  external Condition cond;

}


const int F1 = 5;


const int F2 = 13;


const int F3 = 21;


const int F4 = 29;


const int F5 = 37;


const int F6 = 45;


const int F7 = 53;


const int F8 = 61;


const int FAST_PERFT = 1;


const int FD_SETSIZE = 1024;

typedef FILE = __sFILE;

const int FILENAME_MAX = 1024;


const int FLAG_BESTPATH_BLACK = 4;


const int FLAG_DONE = 1;


const int FLAG_TODO = 2;


const int FOOTPRINT_INTERVAL_RESET = 1;


const int FOPEN_MAX = 20;


const int FPE_FLTDIV = 1;


const int FPE_FLTINV = 5;


const int FPE_FLTOVF = 2;


const int FPE_FLTRES = 4;


const int FPE_FLTSUB = 6;


const int FPE_FLTUND = 3;


const int FPE_INTDIV = 7;


const int FPE_INTOVF = 8;


const int FPE_NOOP = 0;


const int FP_FAST_FMA = 1;


const int FP_FAST_FMAF = 1;


const int FP_FAST_FMAL = 1;


const int FP_ILOGB0 = -2147483648;


const int FP_ILOGBNAN = -2147483648;


const int FP_INFINITE = 2;


const int FP_NAN = 1;


const int FP_NORMAL = 4;


const int FP_QNAN = 1;


const int FP_SNAN = 1;


const int FP_SUBNORMAL = 5;


const int FP_SUPERNORMAL = 6;


const int FP_ZERO = 3;


const int F_LOCK = 1;


const int F_OK = 0;


const int F_TEST = 3;


const int F_TLOCK = 2;


const int F_ULOCK = 0;

/// feature to coordinates conversion
final class FeatureToCoordinate extends ffi.Struct{
  @ffi.Int()
  external int n_square;

@ffi.Array.multi([16])
  external ffi.Array<ffi.Int> x;

}


const int G1 = 6;


const int G2 = 14;


const int G3 = 22;


const int G4 = 30;


const int G5 = 38;


const int G6 = 46;


const int G7 = 54;


const int G8 = 62;


const int GAME_SIZE = 80;

final class GGSAdmin extends ffi.Struct{
  /// < admin command
  external ffi.Pointer<ffi.Char> command;

  /// < admin name
@ffi.Array.multi([16])
  external ffi.Array<ffi.Char> name;

}

final class GGSBoard extends ffi.Struct{
  /// < match request id
  external ffi.Pointer<ffi.Char> id;

  /// < match players
@ffi.Array.multi([2])
  external ffi.Array<GGSPlayer> player;

  /// < match type
@ffi.Array.multi([1])
  external ffi.Array<GGSMatchType> match_type;

  /// < match clock
@ffi.Array.multi([2])
  external ffi.Array<GGSClock> clock;

  /// < komi value
  @ffi.Double()
  external double komi;

  /// < join a new game ?
  @ffi.Int()
  external int is_join;

  /// < update an existing game?
  @ffi.Int()
  external int is_update;

  /// < move
  @ffi.Int()
  external int move;

  /// < move number
  @ffi.Int()
  external int move_no;

  /// < color
@ffi.Array.multi([2])
  external ffi.Array<ffi.Char> color;

  /// < current board
@ffi.Array.multi([256])
  external ffi.Array<ffi.Char> board;

  /// < player on turn
  @ffi.Char()
  external int turn;

  /// < initial board
@ffi.Array.multi([256])
  external ffi.Array<ffi.Char> board_init;

  /// < first player
  @ffi.Char()
  external int turn_init;

  /// < list of played moves
@ffi.Array.multi([256])
  external ffi.Array<ffi.Int> move_list;

  /// < number of played moves
  @ffi.Int()
  external int move_list_n;

}

final class GGSClient extends ffi.Struct{
  /// < ggs board
@ffi.Array.multi([1])
  external ffi.Array<GGSBoard> board;

  /// < ggs request
@ffi.Array.multi([1])
  external ffi.Array<GGSRequest> request;

  /// < ggs match on
@ffi.Array.multi([1])
  external ffi.Array<GGSMatchOn> match_on;

  /// < ggs match off
@ffi.Array.multi([1])
  external ffi.Array<GGSMatchOff> match_off;

  /// < ggs admin
@ffi.Array.multi([1])
  external ffi.Array<GGSAdmin> admin;

  /// < ggs event
  external GGSEvent event;

  /// < Edax's name on GGS
  external ffi.Pointer<ffi.Char> me;

  /// < is Edax playing ?
  @ffi.Bool()
  external bool is_playing;

  /// < date of last refresh
  @ffi.LongLong()
  external int last_refresh;

  /// < loop instruction
@ffi.Array.multi([1])
  external ffi.Array<UnnamedStruct$7> loop;

  /// < command issued once after some delay
@ffi.Array.multi([1])
  external ffi.Array<UnnamedStruct$8> once;

}

/// GGS clock (to play a game)
final class GGSClock extends ffi.Struct{
  /// < base time flag. true = NOT loss
  @ffi.Int()
  external int ini_flag;

  /// < incremental time flag.  true = NOT additive
  @ffi.Int()
  external int inc_flag;

  /// < extra time flag. true = NOT add
  @ffi.Int()
  external int ext_flag;

  /// < number of moves allowed during base time
  @ffi.Int()
  external int ini_move;

  /// < number of moves allowed during incremental time
  @ffi.Int()
  external int inc_move;

  /// < number of moves allowed during extra time
  @ffi.Int()
  external int ext_move;

  /// < base time in ms.
  @ffi.Int()
  external int ini_time;

  /// < incremental time in ms.
  @ffi.Int()
  external int inc_time;

  /// < extra time in ms.
  @ffi.Int()
  external int ext_time;

}

final class GGSEvent extends ffi.Struct{
  /// < socket
  @ffi.Int()
  external int socket;

  /// < loop
  @ffi.Bool()
  external bool loop;

  /// < read buffer
  external ffi.Pointer<ffi.Char> buffer;

  /// < thread
  external Thread thread;

  /// < lock
  external Lock lock;

}

final class GGSMatchOff extends ffi.Struct{
  /// < match id
  external ffi.Pointer<ffi.Char> id;

  /// < match players
@ffi.Array.multi([2])
  external ffi.Array<GGSPlayer> player;

}

final class GGSMatchOn extends ffi.Struct{
  /// < match id
  external ffi.Pointer<ffi.Char> id;

  /// < match players
@ffi.Array.multi([2])
  external ffi.Array<GGSPlayer> player;

  /// < match type
@ffi.Array.multi([1])
  external ffi.Array<GGSMatchType> match_type;

}

/// Match type description
final class GGSMatchType extends ffi.Struct{
  /// < is game saved ?
  @ffi.Int()
  external int is_saved;

  /// < is game rated ?
  @ffi.Int()
  external int is_rated;

  /// < is game synchro ?
  @ffi.Int()
  external int is_synchro;

  /// < is game komi ?
  @ffi.Int()
  external int is_komi;

  /// < is game rand ?
  @ffi.Int()
  external int is_rand;

  /// < is game anti ?
  @ffi.Int()
  external int is_anti;

  /// < game disc number
  @ffi.Int()
  external int discs;

  /// < game size
  @ffi.Int()
  external int size;

}

/// GGS player
final class GGSPlayer extends ffi.Struct{
  /// < player's name on GGS
  external ffi.Pointer<ffi.Char> name;

  /// < player's rating
  @ffi.Double()
  external double rating;

}

final class GGSRequest extends ffi.Struct{
  /// < match request id
  external ffi.Pointer<ffi.Char> id;

  /// < match players
@ffi.Array.multi([2])
  external ffi.Array<GGSPlayer> player;

  /// < match type
@ffi.Array.multi([1])
  external ffi.Array<GGSMatchType> match_type;

  /// < match clock
@ffi.Array.multi([2])
  external ffi.Array<GGSClock> clock;

}


const int GGS_BOARD_SIZE = 256;


const int GID_MAX = 2147483647;

final class Game extends ffi.Struct{
@ffi.Array.multi([1])
  external ffi.Array<Board> initial_board;

  external UnnamedStruct$2 date;

@ffi.Array.multi([2, 32])
  external ffi.Array<ffi.Array<ffi.Char>> name;

@ffi.Array.multi([60])
  external ffi.Array<ffi.Char> move;

  @ffi.Char()
  external int player;

  @ffi.UnsignedLongLong()
  external int hash;

}

/// Hash entry;
final class GameHash extends ffi.Struct{
  /// < board
  external Board board;

  /// < statistics
  external GameStatistics stats;

  /// < depth
  @ffi.Int()
  external int depth;

}

/// HashTable
final class GameHashTable extends ffi.Struct{
  /// < array of hash entries
  external ffi.Pointer<GameHash> array;

  /// < size
  @ffi.Int()
  external int size;

  /// < mask
  @ffi.Int()
  external int mask;

  /// < n_tries
  @ffi.UnsignedLongLong()
  external int n_tries;

  /// < n_tries
  @ffi.UnsignedLongLong()
  external int n_hits;

}

/// Gathered statistiscs
final class GameStatistics extends ffi.Struct{
  @ffi.UnsignedLongLong()
  external int n_moves;

  @ffi.UnsignedLongLong()
  external int n_draws;

  @ffi.UnsignedLongLong()
  external int n_losses;

  @ffi.UnsignedLongLong()
  external int n_wins;

  @ffi.UnsignedLongLong()
  external int n_passes;

  @ffi.UnsignedInt()
  external int min_mobility;

  @ffi.UnsignedInt()
  external int max_mobility;

}

/// struct GameStat
/// @brief Game statistics
final class GameStats extends ffi.Struct{
  /// < game win count
  @ffi.UnsignedLongLong()
  external int n_wins;

  /// < game draw count
  @ffi.UnsignedLongLong()
  external int n_draws;

  /// < game loss count
  @ffi.UnsignedLongLong()
  external int n_losses;

  /// < unterminated line count
  @ffi.UnsignedLongLong()
  external int n_lines;

}


const int H1 = 7;


const int H2 = 15;


const int H3 = 23;


const int H4 = 31;


const int H5 = 39;


const int H6 = 47;


const int H7 = 55;


const int H8 = 63;


const int HASH_ALIGNED = 1;


const int HASH_N_WAY = 4;


const int HOST_NOT_FOUND = 1;


const int HOUR = 3600000;


const double HUGE = 3.4028234663852886e+38;


const double HUGE_VAL = double.infinity;


const double HUGE_VALF = double.infinity;


const double HUGE_VALL = double.infinity;

/// Hash  : item stored in the hash table
final class Hash extends ffi.Struct{
  external Board board;

  external HashData data;

}

/// HashData : data stored in the hash table
final class HashData extends ffi.Struct{
  /// !< depth
  @ffi.UnsignedChar()
  external int depth;

  /// !< selectivity
  @ffi.UnsignedChar()
  external int selectivity;

  /// !< search cost
  @ffi.UnsignedChar()
  external int cost;

  /// !< dating technique
  @ffi.UnsignedChar()
  external int date;

  /// !< lower bound of the position score
  @ffi.SignedChar()
  external int lower;

  /// !< upper bound of the position score
  @ffi.SignedChar()
  external int upper;

  /// !< best moves
@ffi.Array.multi([2])
  external ffi.Array<ffi.UnsignedChar> move;

}

/// HashLock : lock for table entries
final class HashLock extends ffi.Struct{
  @SpinLock()
  external int spin;

}

/// HashTable: position storage
final class HashTable extends ffi.Struct{
  /// !< allocated memory
  external ffi.Pointer<ffi.Void> memory;

  /// !< hash table
  external ffi.Pointer<Hash> hash;

  /// !< table with locks
  external ffi.Pointer<HashLock> lock;

  /// !< a bit mask for hash entries
  @ffi.UnsignedLongLong()
  external int hash_mask;

  /// !< a bit mask for lock entries
  @ffi.UnsignedInt()
  external int lock_mask;

  /// !< hash table size
  @ffi.Int()
  external int n_hash;

  /// !< number of locks
  @ffi.Int()
  external int n_lock;

  /// !< date
  @ffi.UnsignedChar()
  external int date;

}

/// Hint (for libEdax)
/// 
/// @author lavox
/// @date 2018/1/17
final class Hint extends ffi.Struct{
  /// < searched depth(except book moves)
  @ffi.Int()
  external int depth;

  /// < searched selectivity(except book moves)
  @ffi.Int()
  external int selectivity;

  /// < best move found
  @ffi.Int()
  external int move;

  /// < best score
  @ffi.Int()
  external int score;

  /// < upper score(except book moves)
  @ffi.Int()
  external int upper;

  /// < lower score(except book moves)
  @ffi.Int()
  external int lower;

  /// < principal variation
@ffi.Array.multi([1])
  external ffi.Array<Line> pv;

  /// < searched time(except book moves)
  @ffi.LongLong()
  external int time;

  /// < searched node count(except book moves)
  @ffi.UnsignedLongLong()
  external int n_nodes;

  /// < book move origin
  @ffi.Bool()
  external bool book_move;

}

/// Hint list (for libEdax)
/// 
/// @author lavox
/// @date 2018/1/17
final class HintList extends ffi.Struct{
  /// < array of hints
@ffi.Array.multi([34])
  external ffi.Array<Hint> hint;

  @ffi.Int()
  external int n_hints;

}


const int ICMP6_FILTER = 18;


const int ICMPV6CTL_ND6_ONLINKNSRFC4861 = 50;


const int ILL_BADSTK = 8;


const int ILL_COPROC = 7;


const int ILL_ILLADR = 5;


const int ILL_ILLOPC = 1;


const int ILL_ILLOPN = 4;


const int ILL_ILLTRP = 2;


const int ILL_NOOP = 0;


const int ILL_PRVOPC = 3;


const int ILL_PRVREG = 6;


const int INADDR_ALLHOSTS_GROUP = 3758096385;


const int INADDR_ALLMDNS_GROUP = 3758096635;


const int INADDR_ALLRPTS_GROUP = 3758096406;


const int INADDR_ALLRTRS_GROUP = 3758096386;


const int INADDR_ANY = 0;


const int INADDR_BROADCAST = 4294967295;


const int INADDR_CARP_GROUP = 3758096402;


const int INADDR_LOOPBACK = 2130706433;


const int INADDR_MAX_LOCAL_GROUP = 3758096639;


const int INADDR_NONE = 4294967295;


const int INADDR_PFSYNC_GROUP = 3758096624;


const int INADDR_UNSPEC_GROUP = 3758096384;


const int INET6_ADDRSTRLEN = 46;


const int INET_ADDRSTRLEN = 16;


const double INFINITY = double.infinity;


const int INT16_MAX = 32767;


const int INT16_MIN = -32768;


const int INT32_MAX = 2147483647;


const int INT32_MIN = -2147483648;


const int INT64_MAX = 9223372036854775807;


const int INT64_MIN = -9223372036854775808;


const int INT8_MAX = 127;


const int INT8_MIN = -128;


const int INTMAX_MAX = 9223372036854775807;


const int INTMAX_MIN = -9223372036854775808;


const int INTPTR_MAX = 9223372036854775807;


const int INTPTR_MIN = -9223372036854775808;


const int INT_FAST16_MAX = 32767;


const int INT_FAST16_MIN = -32768;


const int INT_FAST32_MAX = 2147483647;


const int INT_FAST32_MIN = -2147483648;


const int INT_FAST64_MAX = 9223372036854775807;


const int INT_FAST64_MIN = -9223372036854775808;


const int INT_FAST8_MAX = 127;


const int INT_FAST8_MIN = -128;


const int INT_LEAST16_MAX = 32767;


const int INT_LEAST16_MIN = -32768;


const int INT_LEAST32_MAX = 2147483647;


const int INT_LEAST32_MIN = -2147483648;


const int INT_LEAST64_MAX = 9223372036854775807;


const int INT_LEAST64_MIN = -9223372036854775808;


const int INT_LEAST8_MAX = 127;


const int INT_LEAST8_MIN = -128;


const int INT_MAX = 2147483647;


const int INT_MIN = -2147483648;


const int IN_CLASSA_HOST = 16777215;


const int IN_CLASSA_MAX = 128;


const int IN_CLASSA_NET = 4278190080;


const int IN_CLASSA_NSHIFT = 24;


const int IN_CLASSB_HOST = 65535;


const int IN_CLASSB_MAX = 65536;


const int IN_CLASSB_NET = 4294901760;


const int IN_CLASSB_NSHIFT = 16;


const int IN_CLASSC_HOST = 255;


const int IN_CLASSC_NET = 4294967040;


const int IN_CLASSC_NSHIFT = 8;


const int IN_CLASSD_HOST = 268435455;


const int IN_CLASSD_NET = 4026531840;


const int IN_CLASSD_NSHIFT = 28;


const int IN_LINKLOCALNETNUM = 2851995648;


const int IN_LOOPBACKNET = 127;


const int IOPOL_APPLICATION = 5;


const int IOPOL_ATIME_UPDATES_DEFAULT = 0;


const int IOPOL_ATIME_UPDATES_OFF = 1;


const int IOPOL_DEFAULT = 0;


const int IOPOL_IMPORTANT = 1;


const int IOPOL_MATERIALIZE_DATALESS_FILES_DEFAULT = 0;


const int IOPOL_MATERIALIZE_DATALESS_FILES_OFF = 1;


const int IOPOL_MATERIALIZE_DATALESS_FILES_ON = 2;


const int IOPOL_NORMAL = 1;


const int IOPOL_PASSIVE = 2;


const int IOPOL_SCOPE_DARWIN_BG = 2;


const int IOPOL_SCOPE_PROCESS = 0;


const int IOPOL_SCOPE_THREAD = 1;


const int IOPOL_STANDARD = 5;


const int IOPOL_THROTTLE = 3;


const int IOPOL_TYPE_DISK = 0;


const int IOPOL_TYPE_VFS_ALLOW_LOW_SPACE_WRITES = 9;


const int IOPOL_TYPE_VFS_ATIME_UPDATES = 2;


const int IOPOL_TYPE_VFS_DISALLOW_RW_FOR_O_EVTONLY = 10;


const int IOPOL_TYPE_VFS_IGNORE_CONTENT_PROTECTION = 6;


const int IOPOL_TYPE_VFS_IGNORE_PERMISSIONS = 7;


const int IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES = 3;


const int IOPOL_TYPE_VFS_SKIP_MTIME_UPDATE = 8;


const int IOPOL_TYPE_VFS_STATFS_NO_DATA_VOLUME = 4;


const int IOPOL_TYPE_VFS_TRIGGER_RESOLVE = 5;


const int IOPOL_UTILITY = 4;


const int IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_OFF = 0;


const int IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_ON = 1;


const int IOPOL_VFS_CONTENT_PROTECTION_DEFAULT = 0;


const int IOPOL_VFS_CONTENT_PROTECTION_IGNORE = 1;


const int IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_DEFAULT = 0;


const int IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_ON = 1;


const int IOPOL_VFS_IGNORE_PERMISSIONS_OFF = 0;


const int IOPOL_VFS_IGNORE_PERMISSIONS_ON = 1;


const int IOPOL_VFS_NOCACHE_WRITE_FS_BLKSIZE_DEFAULT = 0;


const int IOPOL_VFS_NOCACHE_WRITE_FS_BLKSIZE_ON = 1;


const int IOPOL_VFS_SKIP_MTIME_UPDATE_IGNORE = 2;


const int IOPOL_VFS_SKIP_MTIME_UPDATE_OFF = 0;


const int IOPOL_VFS_SKIP_MTIME_UPDATE_ON = 1;


const int IOPOL_VFS_STATFS_FORCE_NO_DATA_VOLUME = 1;


const int IOPOL_VFS_STATFS_NO_DATA_VOLUME_DEFAULT = 0;


const int IOPOL_VFS_TRIGGER_RESOLVE_DEFAULT = 0;


const int IOPOL_VFS_TRIGGER_RESOLVE_OFF = 1;


const int IOV_MAX = 1024;


const int IPCTL_ACCEPTSOURCEROUTE = 13;


const int IPCTL_DEFTTL = 3;


const int IPCTL_DIRECTEDBROADCAST = 9;


const int IPCTL_FASTFORWARDING = 14;


const int IPCTL_FORWARDING = 1;


const int IPCTL_GIF_TTL = 16;


const int IPCTL_INTRQDROPS = 11;


const int IPCTL_INTRQMAXLEN = 10;


const int IPCTL_KEEPFAITH = 15;


const int IPCTL_MAXID = 17;


const int IPCTL_RTEXPIRE = 5;


const int IPCTL_RTMAXCACHE = 7;


const int IPCTL_RTMINEXPIRE = 6;


const int IPCTL_SENDREDIRECTS = 2;


const int IPCTL_SOURCEROUTE = 8;


const int IPCTL_STATS = 12;


const int IPPORT_HIFIRSTAUTO = 49152;


const int IPPORT_HILASTAUTO = 65535;


const int IPPORT_RESERVED = 1024;


const int IPPORT_RESERVEDSTART = 600;


const int IPPORT_USERRESERVED = 5000;


const int IPPROTO_3PC = 34;


const int IPPROTO_ADFS = 68;


const int IPPROTO_AH = 51;


const int IPPROTO_AHIP = 61;


const int IPPROTO_APES = 99;


const int IPPROTO_ARGUS = 13;


const int IPPROTO_AX25 = 93;


const int IPPROTO_BHA = 49;


const int IPPROTO_BLT = 30;


const int IPPROTO_BRSATMON = 76;


const int IPPROTO_CFTP = 62;


const int IPPROTO_CHAOS = 16;


const int IPPROTO_CMTP = 38;


const int IPPROTO_CPHB = 73;


const int IPPROTO_CPNX = 72;


const int IPPROTO_DDP = 37;


const int IPPROTO_DGP = 86;


const int IPPROTO_DIVERT = 254;


const int IPPROTO_DONE = 257;


const int IPPROTO_DSTOPTS = 60;


const int IPPROTO_EGP = 8;


const int IPPROTO_EMCON = 14;


const int IPPROTO_ENCAP = 98;


const int IPPROTO_EON = 80;


const int IPPROTO_ESP = 50;


const int IPPROTO_ETHERIP = 97;


const int IPPROTO_FRAGMENT = 44;


const int IPPROTO_GGP = 3;


const int IPPROTO_GMTP = 100;


const int IPPROTO_GRE = 47;


const int IPPROTO_HELLO = 63;


const int IPPROTO_HMP = 20;


const int IPPROTO_HOPOPTS = 0;


const int IPPROTO_ICMP = 1;


const int IPPROTO_ICMPV6 = 58;


const int IPPROTO_IDP = 22;


const int IPPROTO_IDPR = 35;


const int IPPROTO_IDRP = 45;


const int IPPROTO_IGMP = 2;


const int IPPROTO_IGP = 85;


const int IPPROTO_IGRP = 88;


const int IPPROTO_IL = 40;


const int IPPROTO_INLSP = 52;


const int IPPROTO_INP = 32;


const int IPPROTO_IP = 0;


const int IPPROTO_IPCOMP = 108;


const int IPPROTO_IPCV = 71;


const int IPPROTO_IPEIP = 94;


const int IPPROTO_IPIP = 4;


const int IPPROTO_IPPC = 67;


const int IPPROTO_IPV4 = 4;


const int IPPROTO_IPV6 = 41;


const int IPPROTO_IRTP = 28;


const int IPPROTO_KRYPTOLAN = 65;


const int IPPROTO_LARP = 91;


const int IPPROTO_LEAF1 = 25;


const int IPPROTO_LEAF2 = 26;


const int IPPROTO_MAX = 256;


const int IPPROTO_MAXID = 52;


const int IPPROTO_MEAS = 19;


const int IPPROTO_MHRP = 48;


const int IPPROTO_MICP = 95;


const int IPPROTO_MTP = 92;


const int IPPROTO_MUX = 18;


const int IPPROTO_ND = 77;


const int IPPROTO_NHRP = 54;


const int IPPROTO_NONE = 59;


const int IPPROTO_NSP = 31;


const int IPPROTO_NVPII = 11;


const int IPPROTO_OSPFIGP = 89;


const int IPPROTO_PGM = 113;


const int IPPROTO_PIGP = 9;


const int IPPROTO_PIM = 103;


const int IPPROTO_PRM = 21;


const int IPPROTO_PUP = 12;


const int IPPROTO_PVP = 75;


const int IPPROTO_RAW = 255;


const int IPPROTO_RCCMON = 10;


const int IPPROTO_RDP = 27;


const int IPPROTO_ROUTING = 43;


const int IPPROTO_RSVP = 46;


const int IPPROTO_RVD = 66;


const int IPPROTO_SATEXPAK = 64;


const int IPPROTO_SATMON = 69;


const int IPPROTO_SCCSP = 96;


const int IPPROTO_SCTP = 132;


const int IPPROTO_SDRP = 42;


const int IPPROTO_SEP = 33;


const int IPPROTO_SRPC = 90;


const int IPPROTO_ST = 7;


const int IPPROTO_SVMTP = 82;


const int IPPROTO_SWIPE = 53;


const int IPPROTO_TCF = 87;


const int IPPROTO_TCP = 6;


const int IPPROTO_TP = 29;


const int IPPROTO_TPXX = 39;


const int IPPROTO_TRUNK1 = 23;


const int IPPROTO_TRUNK2 = 24;


const int IPPROTO_TTP = 84;


const int IPPROTO_UDP = 17;


const int IPPROTO_VINES = 83;


const int IPPROTO_VISA = 70;


const int IPPROTO_VMTP = 81;


const int IPPROTO_WBEXPAK = 79;


const int IPPROTO_WBMON = 78;


const int IPPROTO_WSN = 74;


const int IPPROTO_XNET = 15;


const int IPPROTO_XTP = 36;


const int IPV6CTL_ACCEPT_RTADV = 12;


const int IPV6CTL_ADDRCTLPOLICY = 38;


const int IPV6CTL_AUTO_FLOWLABEL = 17;


const int IPV6CTL_AUTO_LINKLOCAL = 35;


const int IPV6CTL_DAD_COUNT = 16;


const int IPV6CTL_DEFHLIM = 3;


const int IPV6CTL_DEFMCASTHLIM = 18;


const int IPV6CTL_FORWARDING = 1;


const int IPV6CTL_FORWSRCRT = 5;


const int IPV6CTL_GIF_HLIM = 19;


const int IPV6CTL_HDRNESTLIMIT = 15;


const int IPV6CTL_KAME_VERSION = 20;


const int IPV6CTL_KEEPFAITH = 13;


const int IPV6CTL_LOG_INTERVAL = 14;


const int IPV6CTL_MAXDYNROUTES = 49;


const int IPV6CTL_MAXFRAGPACKETS = 9;


const int IPV6CTL_MAXFRAGS = 41;


const int IPV6CTL_MAXID = 51;


const int IPV6CTL_MAXIFDEFROUTERS = 48;


const int IPV6CTL_MAXIFPREFIXES = 47;


const int IPV6CTL_MCAST_PMTU = 44;


const int IPV6CTL_MRTPROTO = 8;


const int IPV6CTL_MRTSTATS = 7;


const int IPV6CTL_NEIGHBORGCTHRESH = 46;


const int IPV6CTL_PREFER_TEMPADDR = 37;


const int IPV6CTL_RIP6STATS = 36;


const int IPV6CTL_RR_PRUNE = 22;


const int IPV6CTL_RTEXPIRE = 25;


const int IPV6CTL_RTMAXCACHE = 27;


const int IPV6CTL_RTMINEXPIRE = 26;


const int IPV6CTL_SENDREDIRECTS = 2;


const int IPV6CTL_SOURCECHECK = 10;


const int IPV6CTL_SOURCECHECK_LOGINT = 11;


const int IPV6CTL_STATS = 6;


const int IPV6CTL_TEMPPLTIME = 33;


const int IPV6CTL_TEMPVLTIME = 34;


const int IPV6CTL_ULA_USETEMPADDR = 51;


const int IPV6CTL_USETEMPADDR = 32;


const int IPV6CTL_USE_DEFAULTZONE = 39;


const int IPV6CTL_USE_DEPRECATED = 21;


const int IPV6CTL_V6ONLY = 24;


const int IPV6PORT_ANONMAX = 65535;


const int IPV6PORT_ANONMIN = 49152;


const int IPV6PORT_RESERVED = 1024;


const int IPV6PORT_RESERVEDMAX = 1023;


const int IPV6PORT_RESERVEDMIN = 600;


const int IPV6PROTO_MAXID = 104;


const int IPV6_2292DSTOPTS = 23;


const int IPV6_2292HOPLIMIT = 20;


const int IPV6_2292HOPOPTS = 22;


const int IPV6_2292NEXTHOP = 21;


const int IPV6_2292PKTINFO = 19;


const int IPV6_2292PKTOPTIONS = 25;


const int IPV6_2292RTHDR = 24;


const int IPV6_ADDR_MC_FLAGS_PREFIX = 32;


const int IPV6_ADDR_MC_FLAGS_TRANSIENT = 16;


const int IPV6_ADDR_MC_FLAGS_UNICAST_BASED = 48;


const int IPV6_BINDV6ONLY = 27;


const int IPV6_BOUND_IF = 125;


const int IPV6_CHECKSUM = 26;


const int IPV6_DEFAULT_MULTICAST_HOPS = 1;


const int IPV6_DEFAULT_MULTICAST_LOOP = 1;


const int IPV6_FAITH = 29;


const int IPV6_FW_ADD = 30;


const int IPV6_FW_DEL = 31;


const int IPV6_FW_FLUSH = 32;


const int IPV6_FW_GET = 34;


const int IPV6_FW_ZERO = 33;


const int IPV6_IPSEC_POLICY = 28;


const int IPV6_JOIN_GROUP = 12;


const int IPV6_LEAVE_GROUP = 13;


const int IPV6_MAX_GROUP_SRC_FILTER = 512;


const int IPV6_MAX_MEMBERSHIPS = 4095;


const int IPV6_MAX_SOCK_SRC_FILTER = 128;


const int IPV6_MIN_MEMBERSHIPS = 31;


const int IPV6_MULTICAST_HOPS = 10;


const int IPV6_MULTICAST_IF = 9;


const int IPV6_MULTICAST_LOOP = 11;


const int IPV6_PORTRANGE = 14;


const int IPV6_PORTRANGE_DEFAULT = 0;


const int IPV6_PORTRANGE_HIGH = 1;


const int IPV6_PORTRANGE_LOW = 2;


const int IPV6_RECVTCLASS = 35;


const int IPV6_RTHDR_LOOSE = 0;


const int IPV6_RTHDR_STRICT = 1;


const int IPV6_RTHDR_TYPE_0 = 0;


const int IPV6_SOCKOPT_RESERVED1 = 3;


const int IPV6_TCLASS = 36;


const int IPV6_UNICAST_HOPS = 4;


const int IPV6_V6ONLY = 27;


const int IP_ADD_MEMBERSHIP = 12;


const int IP_ADD_SOURCE_MEMBERSHIP = 70;


const int IP_BLOCK_SOURCE = 72;


const int IP_BOUND_IF = 25;


const int IP_DEFAULT_MULTICAST_LOOP = 1;


const int IP_DEFAULT_MULTICAST_TTL = 1;


const int IP_DONTFRAG = 28;


const int IP_DROP_MEMBERSHIP = 13;


const int IP_DROP_SOURCE_MEMBERSHIP = 71;


const int IP_DUMMYNET_CONFIGURE = 60;


const int IP_DUMMYNET_DEL = 61;


const int IP_DUMMYNET_FLUSH = 62;


const int IP_DUMMYNET_GET = 64;


const int IP_FAITH = 22;


const int IP_FW_ADD = 40;


const int IP_FW_DEL = 41;


const int IP_FW_FLUSH = 42;


const int IP_FW_GET = 44;


const int IP_FW_RESETLOG = 45;


const int IP_FW_ZERO = 43;


const int IP_HDRINCL = 2;


const int IP_IPSEC_POLICY = 21;


const int IP_MAX_GROUP_SRC_FILTER = 512;


const int IP_MAX_MEMBERSHIPS = 4095;


const int IP_MAX_SOCK_MUTE_FILTER = 128;


const int IP_MAX_SOCK_SRC_FILTER = 128;


const int IP_MIN_MEMBERSHIPS = 31;


const int IP_MSFILTER = 74;


const int IP_MULTICAST_IF = 9;


const int IP_MULTICAST_IFINDEX = 66;


const int IP_MULTICAST_LOOP = 11;


const int IP_MULTICAST_TTL = 10;


const int IP_MULTICAST_VIF = 14;


const int IP_NAT__XXX = 55;


const int IP_OLD_FW_ADD = 50;


const int IP_OLD_FW_DEL = 51;


const int IP_OLD_FW_FLUSH = 52;


const int IP_OLD_FW_GET = 54;


const int IP_OLD_FW_RESETLOG = 56;


const int IP_OLD_FW_ZERO = 53;


const int IP_OPTIONS = 1;


const int IP_PKTINFO = 26;


const int IP_PORTRANGE = 19;


const int IP_PORTRANGE_DEFAULT = 0;


const int IP_PORTRANGE_HIGH = 1;


const int IP_PORTRANGE_LOW = 2;


const int IP_RECVDSTADDR = 7;


const int IP_RECVIF = 20;


const int IP_RECVOPTS = 5;


const int IP_RECVPKTINFO = 26;


const int IP_RECVRETOPTS = 6;


const int IP_RECVTOS = 27;


const int IP_RECVTTL = 24;


const int IP_RETOPTS = 8;


const int IP_RSVP_OFF = 16;


const int IP_RSVP_ON = 15;


const int IP_RSVP_VIF_OFF = 18;


const int IP_RSVP_VIF_ON = 17;


const int IP_STRIPHDR = 23;


const int IP_TOS = 3;


const int IP_TRAFFIC_MGT_BACKGROUND = 65;


const int IP_TTL = 4;


const int IP_UNBLOCK_SOURCE = 73;


const int ITERATIVE_MIN_EMPTIES = 10;


const int ITIMER_PROF = 2;


const int ITIMER_REAL = 0;


const int ITIMER_VIRTUAL = 1;


const int KEV_DL_ADDMULTI = 7;


const int KEV_DL_AWDL_RESTRICTED = 26;


const int KEV_DL_AWDL_UNRESTRICTED = 27;


const int KEV_DL_DELMULTI = 8;


const int KEV_DL_IFCAP_CHANGED = 19;


const int KEV_DL_IFDELEGATE_CHANGED = 25;


const int KEV_DL_IF_ATTACHED = 9;


const int KEV_DL_IF_DETACHED = 11;


const int KEV_DL_IF_DETACHING = 10;


const int KEV_DL_IF_IDLE_ROUTE_REFCNT = 18;


const int KEV_DL_ISSUES = 24;


const int KEV_DL_LINK_ADDRESS_CHANGED = 16;


const int KEV_DL_LINK_OFF = 12;


const int KEV_DL_LINK_ON = 13;


const int KEV_DL_LINK_QUALITY_METRIC_CHANGED = 20;


const int KEV_DL_LOW_POWER_MODE_CHANGED = 30;


const int KEV_DL_MASTER_ELECTED = 23;


const int KEV_DL_NODE_ABSENCE = 22;


const int KEV_DL_NODE_PRESENCE = 21;


const int KEV_DL_PRIMARY_ELECTED = 23;


const int KEV_DL_PROTO_ATTACHED = 14;


const int KEV_DL_PROTO_DETACHED = 15;


const int KEV_DL_QOS_MODE_CHANGED = 29;


const int KEV_DL_RRC_STATE_CHANGED = 28;


const int KEV_DL_SIFFLAGS = 1;


const int KEV_DL_SIFGENERIC = 6;


const int KEV_DL_SIFMEDIA = 5;


const int KEV_DL_SIFMETRICS = 2;


const int KEV_DL_SIFMTU = 3;


const int KEV_DL_SIFPHYS = 4;


const int KEV_DL_SUBCLASS = 2;


const int KEV_DL_WAKEFLAGS_CHANGED = 17;


const int KEV_INET6_ADDR_DELETED = 3;


const int KEV_INET6_CHANGED_ADDR = 2;


const int KEV_INET6_DEFROUTER = 6;


const int KEV_INET6_NEW_LL_ADDR = 4;


const int KEV_INET6_NEW_RTADV_ADDR = 5;


const int KEV_INET6_NEW_USER_ADDR = 1;


const int KEV_INET6_REQUEST_NAT64_PREFIX = 7;


const int KEV_INET6_SUBCLASS = 6;


const int KEV_INET_ADDR_DELETED = 3;


const int KEV_INET_ARPCOLLISION = 7;


const int KEV_INET_ARPRTRALIVE = 10;


const int KEV_INET_ARPRTRFAILURE = 9;


const int KEV_INET_CHANGED_ADDR = 2;


const int KEV_INET_NEW_ADDR = 1;


const int KEV_INET_PORTINUSE = 8;


const int KEV_INET_SIFBRDADDR = 5;


const int KEV_INET_SIFDSTADDR = 4;


const int KEV_INET_SIFNETMASK = 6;


const int KEV_INET_SUBCLASS = 1;


const int KOGGE_STONE = 2;


const int LAVE = 1279350341;


const int LC_ALL = 0;


const int LC_ALL_MASK = 63;


const int LC_COLLATE = 1;


const int LC_COLLATE_MASK = 1;


const int LC_CTYPE = 2;


const int LC_CTYPE_MASK = 2;


const int LC_MESSAGES = 6;


const int LC_MESSAGES_MASK = 4;


const int LC_MONETARY = 3;


const int LC_MONETARY_MASK = 8;


const int LC_NUMERIC = 4;


const int LC_NUMERIC_MASK = 16;


const int LC_TIME = 5;


const int LC_TIME_MASK = 32;


const int LINE_MAX = 2048;


const int LINK_MAX = 32767;


const int LITTLE_ENDIAN = 1234;


const int LLONG_MAX = 9223372036854775807;


const int LLONG_MIN = -9223372036854775808;


const int LONG_BIT = 64;


const int LONG_MAX = 9223372036854775807;


const int LONG_MIN = -9223372036854775808;


const int L_INCR = 1;


const int L_SET = 0;


const int L_XTND = 2;


const int L_ctermid = 1024;


const int L_tmpnam = 1024;

/// levels
final class Level extends ffi.Struct{
  @ffi.Int()
  external int depth;

  /// search depth
  @ffi.Int()
  external int selectivity;

}

/// (simple) sequence of a legal moves
final class Line extends ffi.Struct{
  /// < array of a suite of moves
@ffi.Array.multi([80])
  external ffi.Array<ffi.Char> move;

  @ffi.Int()
  external int n_moves;

  @ffi.Int()
  external int color;

}

/// struct Link
/// @brief a move (with its score) linking to another Position.
final class Link extends ffi.Struct{
  /// < move score
  @ffi.SignedChar()
  external int score;

  /// < move coordinate
  @ffi.UnsignedChar()
  external int move;

}

/// Typedef mutex to a personalized type for portability
typedef Lock = pthread_mutex_t;
/// @brief LogFile.
final class Log extends ffi.Struct{
  external ffi.Pointer<FILE> f;

  external Lock lock;

}


const int MAC_OS_VERSION_11_0 = 110000;


const int MAC_OS_VERSION_11_1 = 110100;


const int MAC_OS_VERSION_11_3 = 110300;


const int MAC_OS_VERSION_11_4 = 110400;


const int MAC_OS_VERSION_11_5 = 110500;


const int MAC_OS_VERSION_11_6 = 110600;


const int MAC_OS_VERSION_12_0 = 120000;


const int MAC_OS_VERSION_12_1 = 120100;


const int MAC_OS_VERSION_12_2 = 120200;


const int MAC_OS_VERSION_12_3 = 120300;


const int MAC_OS_VERSION_12_4 = 120400;


const int MAC_OS_VERSION_12_5 = 120500;


const int MAC_OS_VERSION_12_6 = 120600;


const int MAC_OS_VERSION_12_7 = 120700;


const int MAC_OS_VERSION_13_0 = 130000;


const int MAC_OS_VERSION_13_1 = 130100;


const int MAC_OS_VERSION_13_2 = 130200;


const int MAC_OS_VERSION_13_3 = 130300;


const int MAC_OS_VERSION_13_4 = 130400;


const int MAC_OS_VERSION_13_5 = 130500;


const int MAC_OS_VERSION_13_6 = 130600;


const int MAC_OS_VERSION_13_7 = 130700;


const int MAC_OS_VERSION_14_0 = 140000;


const int MAC_OS_VERSION_14_1 = 140100;


const int MAC_OS_VERSION_14_2 = 140200;


const int MAC_OS_VERSION_14_3 = 140300;


const int MAC_OS_VERSION_14_4 = 140400;


const int MAC_OS_VERSION_14_5 = 140500;


const int MAC_OS_VERSION_14_6 = 140600;


const int MAC_OS_VERSION_14_7 = 140700;


const int MAC_OS_VERSION_15_0 = 150000;


const int MAC_OS_VERSION_15_1 = 150100;


const int MAC_OS_VERSION_15_2 = 150200;


const int MAC_OS_VERSION_15_3 = 150300;


const int MAC_OS_VERSION_15_4 = 150400;


const int MAC_OS_VERSION_15_5 = 150500;


const int MAC_OS_X_VERSION_10_0 = 1000;


const int MAC_OS_X_VERSION_10_1 = 1010;


const int MAC_OS_X_VERSION_10_10 = 101000;


const int MAC_OS_X_VERSION_10_10_2 = 101002;


const int MAC_OS_X_VERSION_10_10_3 = 101003;


const int MAC_OS_X_VERSION_10_11 = 101100;


const int MAC_OS_X_VERSION_10_11_2 = 101102;


const int MAC_OS_X_VERSION_10_11_3 = 101103;


const int MAC_OS_X_VERSION_10_11_4 = 101104;


const int MAC_OS_X_VERSION_10_12 = 101200;


const int MAC_OS_X_VERSION_10_12_1 = 101201;


const int MAC_OS_X_VERSION_10_12_2 = 101202;


const int MAC_OS_X_VERSION_10_12_4 = 101204;


const int MAC_OS_X_VERSION_10_13 = 101300;


const int MAC_OS_X_VERSION_10_13_1 = 101301;


const int MAC_OS_X_VERSION_10_13_2 = 101302;


const int MAC_OS_X_VERSION_10_13_4 = 101304;


const int MAC_OS_X_VERSION_10_14 = 101400;


const int MAC_OS_X_VERSION_10_14_1 = 101401;


const int MAC_OS_X_VERSION_10_14_4 = 101404;


const int MAC_OS_X_VERSION_10_14_5 = 101405;


const int MAC_OS_X_VERSION_10_14_6 = 101406;


const int MAC_OS_X_VERSION_10_15 = 101500;


const int MAC_OS_X_VERSION_10_15_1 = 101501;


const int MAC_OS_X_VERSION_10_15_4 = 101504;


const int MAC_OS_X_VERSION_10_16 = 101600;


const int MAC_OS_X_VERSION_10_2 = 1020;


const int MAC_OS_X_VERSION_10_3 = 1030;


const int MAC_OS_X_VERSION_10_4 = 1040;


const int MAC_OS_X_VERSION_10_5 = 1050;


const int MAC_OS_X_VERSION_10_6 = 1060;


const int MAC_OS_X_VERSION_10_7 = 1070;


const int MAC_OS_X_VERSION_10_8 = 1080;


const int MAC_OS_X_VERSION_10_9 = 1090;


const int MATH_ERREXCEPT = 2;


const int MATH_ERRNO = 1;


const double MAXFLOAT = 3.4028234663852886e+38;


const int MAX_CANON = 1024;


const int MAX_INPUT = 1024;


const int MAX_MOVE = 32;


const int MAX_OBSERVER = 2;


const int MAX_SACK_BLKS = 6;


const int MAX_TCPOPTLEN = 40;


const int MAX_THREADS = 64;


const int MB_LEN_MAX = 6;

/// A position and a move issued from it.
final class MBoard extends ffi.Struct{
  external Board board;

  @ffi.Int()
  external int x;

}


const int MCAST_BLOCK_SOURCE = 84;


const int MCAST_EXCLUDE = 2;


const int MCAST_INCLUDE = 1;


const int MCAST_JOIN_GROUP = 80;


const int MCAST_JOIN_SOURCE_GROUP = 82;


const int MCAST_LEAVE_GROUP = 81;


const int MCAST_LEAVE_SOURCE_GROUP = 83;


const int MCAST_UNBLOCK_SOURCE = 85;


const int MCAST_UNDEFINED = 0;


const int MINSIGSTKSZ = 32768;


const int MOVELIST_SIZE = 256;


const int MOVE_GENERATOR = 1;


const int MOVE_GENERATOR_BITSCAN = 4;


const int MOVE_GENERATOR_CARRY = 1;


const int MOVE_GENERATOR_KINDERGARTEN = 2;


const int MOVE_GENERATOR_ROXANE = 5;


const int MOVE_GENERATOR_SSE = 3;


const int MSG_CTRUNC = 32;


const int MSG_DONTROUTE = 4;


const int MSG_DONTWAIT = 128;


const int MSG_EOF = 256;


const int MSG_EOR = 8;


const int MSG_FLUSH = 1024;


const int MSG_HAVEMORE = 8192;


const int MSG_HOLD = 2048;


const int MSG_NEEDSA = 65536;


const int MSG_NOSIGNAL = 524288;


const int MSG_OOB = 1;


const int MSG_PEEK = 2;


const int MSG_RCVMORE = 16384;


const int MSG_SEND = 4096;


const int MSG_TRUNC = 16;


const int MSG_WAITALL = 64;


const int MSG_WAITSTREAM = 512;


const int MULTIPV_DEPTH = 10;


const double M_1_PI = 0.3183098861837907;


const double M_2_PI = 0.6366197723675814;


const double M_2_SQRTPI = 1.1283791670955126;


const double M_E = 2.718281828459045;


const double M_LN10 = 2.302585092994046;


const double M_LN2 = 0.6931471805599453;


const double M_LOG10E = 0.4342944819032518;


const double M_LOG2E = 1.4426950408889634;


const double M_PI = 3.141592653589793;


const double M_PI_2 = 1.5707963267948966;


const double M_PI_4 = 0.7853981633974483;


const double M_SQRT1_2 = 0.7071067811865476;


const double M_SQRT2 = 1.4142135623730951;

/// move representation
final class Move extends ffi.Struct{
  /// < bitboard representation of flipped squares
  @ffi.UnsignedLongLong()
  external int flipped;

  /// < square played
  @ffi.Int()
  external int x;

  /// < score for this move
  @ffi.Int()
  external int score;

  /// < move cost
  @ffi.UnsignedInt()
  external int cost;

  /// < next move in a MoveList
  external ffi.Pointer<Move> next;

}

/// Array of MBoard.
final class MoveArray extends ffi.Struct{
  /// < dynamic array
  external ffi.Pointer<MBoard> item;

  /// < number of items in the array
  @ffi.Int()
  external int n;

  /// < capacity of the array
  @ffi.Int()
  external int size;

}

/// HashTable of position + move
final class MoveHash extends ffi.Struct{
  external ffi.Pointer<MoveArray> array;

  @ffi.Int()
  external int size;

  @ffi.Int()
  external int mask;

}

/// (simple) list of a legal moves
final class MoveList extends ffi.Struct{
  /// < array of legal moves
@ffi.Array.multi([34])
  external ffi.Array<Move> move;

  @ffi.Int()
  external int n_moves;

}


const int NAME_MAX = 255;


const double NAN = double.nan;


const int NBBY = 8;


const int NETDB_INTERNAL = -1;


const int NETDB_SUCCESS = 0;


const int NETSVC_MRKNG_LVL_L2 = 1;


const int NETSVC_MRKNG_LVL_L3L2_ALL = 2;


const int NETSVC_MRKNG_LVL_L3L2_BK = 3;


const int NETSVC_MRKNG_UNKNOWN = 0;


const int NET_MAXID = 41;


const int NET_RT_DUMP = 1;


const int NET_RT_DUMP2 = 7;


const int NET_RT_FLAGS = 2;


const int NET_RT_FLAGS_PRIV = 10;


const int NET_RT_IFLIST = 3;


const int NET_RT_IFLIST2 = 6;


const int NET_RT_MAXID = 11;


const int NET_RT_STAT = 4;


const int NET_RT_TRASH = 5;


const int NET_SERVICE_TYPE_AV = 6;


const int NET_SERVICE_TYPE_BE = 0;


const int NET_SERVICE_TYPE_BK = 1;


const int NET_SERVICE_TYPE_OAM = 7;


const int NET_SERVICE_TYPE_RD = 8;


const int NET_SERVICE_TYPE_RV = 5;


const int NET_SERVICE_TYPE_SIG = 2;


const int NET_SERVICE_TYPE_VI = 3;


const int NET_SERVICE_TYPE_VO = 4;


const int NFDBITS = 32;


const int NGROUPS_MAX = 16;


const int NI_DGRAM = 16;


const int NI_MAXHOST = 1025;


const int NI_MAXSERV = 32;


const int NI_NAMEREQD = 4;


const int NI_NOFQDN = 1;


const int NI_NUMERICHOST = 2;


const int NI_NUMERICSCOPE = 256;


const int NI_NUMERICSERV = 8;


const int NI_WITHSCOPEID = 32;


const int NL_ARGMAX = 9;


const int NL_LANGMAX = 14;


const int NL_MSGMAX = 32767;


const int NL_NMAX = 1;


const int NL_SETMAX = 255;


const int NL_TEXTMAX = 2048;


const int NOMOVE = 65;


const int NO_ADDRESS = 4;


const int NO_DATA = 4;


const int NO_RECOVERY = 3;


const int NSIG = 32;


const int NULL = 0;


const int NZERO = 20;

/// A Node is a position in the search tree, containing information shared with
/// parallel threads.
final class Node extends ffi.Opaque{
}

/// node type
enum NodeType {
  PV_NODE(0),
  CUT_NODE(1),
  ALL_NODE(2);


  final int value;
  const NodeType(this.value);

  static NodeType fromValue(int value) => switch (value) {
    0 => PV_NODE,
    1 => CUT_NODE,
    2 => ALL_NODE,
    _ => throw ArgumentError('Unknown value for NodeType: $value'),
  };

}

/// OBF structure: Othello Board File
final class OBF extends ffi.Struct{
  /// <! Othello board
@ffi.Array.multi([1])
  external ffi.Array<Board> board;

  /// <! Player on turn
  @ffi.Int()
  external int player;

  /// <! Move array
@ffi.Array.multi([32])
  external ffi.Array<UnnamedStruct$9> move;

  /// <! Move number
  @ffi.Int()
  external int n_moves;

  /// <! Position score
  @ffi.Int()
  external int best_score;

  /// <! Array of comments
  external ffi.Pointer<ffi.Char> comments;

}


const int OBF_PARSE_END = 2;


const int OBF_PARSE_OK = 0;


const int OBF_PARSE_SKIP = 1;


const int OFF_MAX = 9223372036854775807;


const int OFF_MIN = -9223372036854775808;


const int OFF_SIDE = 3;


const int OPEN_MAX = 10240;


const int OSATOMIC_DEPRECATED = 1;

typedef OSAtomic_int64_aligned64_t = ffi.Int64;
typedef DartOSAtomic_int64_aligned64_t = int;
typedef OSFifoQueueHead = UnnamedStruct$11;
typedef OSQueueHead = UnnamedStruct$10;

const int OSSPINLOCK_DEPRECATED = 1;

/// ! @abstract Data type for a spinlock.
/// @discussion
/// You should always initialize a spinlock to {@link OS_SPINLOCK_INIT} before
/// using it.
typedef OSSpinLock = ffi.Int32;
typedef DartOSSpinLock = int;

const int OS_SPINLOCK_INIT = 0;


const int OVERFLOW = 3;

final class OkoGame extends ffi.Struct{
  @ffi.Char()
  external int n;

  @ffi.SignedChar()
  external int score;

  @ffi.Char()
  external int flag;

@ffi.Array.multi([61])
  external ffi.Array<ffi.Char> move;

}

/// opening name structure
final class OpeningName extends ffi.Struct{
  /// < move sequence
  external ffi.Pointer<ffi.Char> line;

  /// < opening name
  external ffi.Pointer<ffi.Char> name;

}

/// options to control various heuristics
final class Options extends ffi.Struct{
  /// < size (in number of bits) of the hash table
  @ffi.Int()
  external int hash_table_size;

  /// < increment sorting depth
@ffi.Array.multi([3])
  external ffi.Array<ffi.Int> inc_sort_depth;

  /// < search in parallel, using n_tasks
  @ffi.Int()
  external int n_task;

  /// < set one cpu/thread to diminish context change
  @ffi.Bool()
  external bool cpu_affinity;

  /// < search display
  @ffi.Int()
  external int verbosity;

  /// < search display min depth
  @ffi.Int()
  external int noise;

  /// < line width
  @ffi.Int()
  external int width;

  /// < repeat user input
  @ffi.Bool()
  external bool echo;

  /// < info display
  @ffi.Bool()
  external bool info;

  /// < display debug info in cassio's "fenetre de rapport"
  @ffi.Bool()
  external bool debug_cassio;

  /// < adapt Cassio requests to search & solve faster
  @ffi.Bool()
  external bool transgress_cassio;

  /// < level
  @ffi.Int()
  external int level;

  /// < time in sec.
  @ffi.LongLong()
  external int time;

  /// < game|move-time switch
  @ffi.UnsignedInt()
  external int play_typeAsInt;

PlayType get play_type => PlayType.fromValue(play_typeAsInt);

  /// < pondering on/off
  @ffi.Bool()
  external bool can_ponder;

  /// < depth (only for testing)
  @ffi.Int()
  external int depth;

  /// < selectivity (only for testing)
  @ffi.Int()
  external int selectivity;

  /// < mode play (human/edax, etc.)
  @ffi.Int()
  external int mode;

  /// < edax speed in N/S (for a more accurate time management)
  @ffi.Double()
  external double speed;

  /// < edax assumed speed (for nps based timing
  @ffi.Double()
  external double nps;

  /// < alpha bound
  @ffi.Int()
  external int alpha;

  /// < beta bound
  @ffi.Int()
  external int beta;

  /// < search for all best moves when solving problem
  @ffi.Bool()
  external bool all_best;

  /// < evaluation file
  external ffi.Pointer<ffi.Char> eval_file;

  /// < opening book filename
  external ffi.Pointer<ffi.Char> book_file;

  /// < switch to use or not the opening book
  @ffi.Bool()
  external bool book_allowed;

  /// < book randomness
  @ffi.Int()
  external int book_randomness;

  /// < ggs host (ip or host name)
  external ffi.Pointer<ffi.Char> ggs_host;

  /// < ggs login
  external ffi.Pointer<ffi.Char> ggs_login;

  /// < ggs password
  external ffi.Pointer<ffi.Char> ggs_password;

  /// < ggs port
  external ffi.Pointer<ffi.Char> ggs_port;

  /// < ggs open number (set it false for tournaments)
  @ffi.Bool()
  external bool ggs_open;

  @ffi.Double()
  external double probcut_d;

  /// < debug PV
  @ffi.Bool()
  external bool pv_debug;

  /// < check PV correctness
  @ffi.Bool()
  external bool pv_check;

  /// < guess PV missing moves
  @ffi.Bool()
  external bool pv_guess;

  /// < game file
  external ffi.Pointer<ffi.Char> game_file;

  /// < log file (for search)
  external ffi.Pointer<ffi.Char> search_log_file;

  /// < log file (for user interface)
  external ffi.Pointer<ffi.Char> ui_log_file;

  /// < log file (for ggs)
  external ffi.Pointer<ffi.Char> ggs_log_file;

  /// < program name
  external ffi.Pointer<ffi.Char> name;

  /// < start a new game after a game is over
  @ffi.Bool()
  external bool auto_start;

  /// < store a game in a book after each game
  @ffi.Bool()
  external bool auto_store;

  /// < change computer's side after each game
  @ffi.Bool()
  external bool auto_swap;

  /// < quit when game is over
  @ffi.Bool()
  external bool auto_quit;

  /// < repeat 'n' games (before quitting)
  @ffi.Int()
  external int repeat;

}


const int PARALLEL_PREFIX = 1;


const int PARSE_END_OF_FILE = 1;


const int PARSE_INVALID_TAG = 2;


const int PARSE_INVALID_VALUE = 3;


const int PARSE_OK = 0;


const int PASS = 64;


const int PASS_MAX = 128;


const int PATH_MAX = 1024;


const int PDP_ENDIAN = 3412;


const int PERSIST_TIMEOUT = 64;


const int PF_APPLETALK = 16;


const int PF_BOND = 1651469924;


const int PF_CCITT = 10;


const int PF_CHAOS = 5;


const int PF_CNT = 21;


const int PF_COIP = 20;


const int PF_DATAKIT = 9;


const int PF_DECnet = 12;


const int PF_DLI = 13;


const int PF_ECMA = 8;


const int PF_HYLINK = 15;


const int PF_IMPLINK = 3;


const int PF_INET = 2;


const int PF_INET6 = 30;


const int PF_IPX = 23;


const int PF_ISDN = 28;


const int PF_ISO = 7;


const int PF_KEY = 29;


const int PF_LAT = 14;


const int PF_LINK = 18;


const int PF_LOCAL = 1;


const int PF_MAX = 41;


const int PF_NATM = 31;


const int PF_NDRV = 27;


const int PF_NETBIOS = 33;


const int PF_NS = 6;


const int PF_OSI = 7;


const int PF_PIP = 25;


const int PF_PPP = 34;


const int PF_PUP = 4;


const int PF_RESERVED_36 = 36;


const int PF_ROUTE = 17;


const int PF_RTIP = 22;


const int PF_SIP = 24;


const int PF_SNA = 11;


const int PF_SYSTEM = 32;


const int PF_UNIX = 1;


const int PF_UNSPEC = 0;


const int PF_UTUN = 38;


const int PF_VLAN = 1986814318;


const int PF_VSOCK = 40;


const int PF_XTP = 19;


const int PIPE_BUF = 512;


const int PLAY_MESSAGE_MAX_LENGTH = 4096;


const int PLOSS = 6;


const int POLL_ERR = 4;


const int POLL_HUP = 6;


const int POLL_IN = 1;


const int POLL_MSG = 3;


const int POLL_OUT = 2;


const int POLL_PRI = 5;


const int PRIO_DARWIN_BG = 4096;


const int PRIO_DARWIN_NONUI = 4097;


const int PRIO_DARWIN_PROCESS = 4;


const int PRIO_DARWIN_THREAD = 3;


const int PRIO_MAX = 20;


const int PRIO_MIN = -20;


const int PRIO_PGRP = 1;


const int PRIO_PROCESS = 0;


const int PRIO_USER = 2;


const int PTHREAD_CANCEL_ASYNCHRONOUS = 0;


const int PTHREAD_CANCEL_DEFERRED = 2;


const int PTHREAD_CANCEL_DISABLE = 0;


const int PTHREAD_CANCEL_ENABLE = 1;


const int PTHREAD_CREATE_DETACHED = 2;


const int PTHREAD_CREATE_JOINABLE = 1;


const int PTHREAD_DESTRUCTOR_ITERATIONS = 4;


const int PTHREAD_EXPLICIT_SCHED = 2;


const int PTHREAD_INHERIT_SCHED = 1;


const int PTHREAD_KEYS_MAX = 512;


const int PTHREAD_MUTEX_DEFAULT = 0;


const int PTHREAD_MUTEX_ERRORCHECK = 1;


const int PTHREAD_MUTEX_NORMAL = 0;


const int PTHREAD_MUTEX_POLICY_FAIRSHARE_NP = 1;


const int PTHREAD_MUTEX_POLICY_FIRSTFIT_NP = 3;


const int PTHREAD_MUTEX_RECURSIVE = 2;


const int PTHREAD_PRIO_INHERIT = 1;


const int PTHREAD_PRIO_NONE = 0;


const int PTHREAD_PRIO_PROTECT = 2;


const int PTHREAD_PROCESS_PRIVATE = 2;


const int PTHREAD_PROCESS_SHARED = 1;


const int PTHREAD_SCOPE_PROCESS = 2;


const int PTHREAD_SCOPE_SYSTEM = 1;


const int PTHREAD_STACK_MIN = 16384;


const int PTRDIFF_MAX = 9223372036854775807;


const int PTRDIFF_MIN = -9223372036854775808;


const int PV_HASH_HEIGHT = 5;


const String P_tmpdir = '/var/tmp/';

/// play structure
final class Play extends ffi.Opaque{
}

/// Edax state.
enum PlayState {
  IS_WAITING(0),
  IS_PONDERING(1),
  IS_ANALYZING(2),
  IS_THINKING(3);


  final int value;
  const PlayState(this.value);

  static PlayState fromValue(int value) => switch (value) {
    0 => IS_WAITING,
    1 => IS_PONDERING,
    2 => IS_ANALYZING,
    3 => IS_THINKING,
    _ => throw ArgumentError('Unknown value for PlayState: $value'),
  };

}

enum PlayType {
  EDAX_FIXED_LEVEL(0),
  EDAX_TIME_PER_GAME(1),
  EDAX_TIME_PER_MOVE(2);


  final int value;
  const PlayType(this.value);

  static PlayType fromValue(int value) => switch (value) {
    0 => EDAX_FIXED_LEVEL,
    1 => EDAX_TIME_PER_GAME,
    2 => EDAX_TIME_PER_MOVE,
    _ => throw ArgumentError('Unknown value for PlayType: $value'),
  };

}

/// Array of position.
final class PosArray extends ffi.Struct{
  /// < dynamic array
  external ffi.Pointer<CBoard> item;

  /// < number of items in the array
  @ffi.Int()
  external int n;

  /// < capacity of the array
  @ffi.Int()
  external int size;

}

/// struct Position
/// @brief A position stored in the book.
final class Position extends ffi.Struct{
  /// < (unique) board
@ffi.Array.multi([1])
  external ffi.Array<Board> board;

  /// < best remaining move
  external Link leaf;

  /// < done/undone, todo flag
  @ffi.UnsignedChar()
  external int flag;

  /// < count of best paths for player
  @ffi.UnsignedShort()
  external int n_player_bestpaths;

  /// < count of best paths for opponent
  @ffi.UnsignedShort()
  external int n_opponent_bestpaths;

  /// < linking moves
  external ffi.Pointer<Link> link;

  /// < game win count
  @ffi.UnsignedInt()
  external int n_wins;

  /// < game draw count
  @ffi.UnsignedInt()
  external int n_draws;

  /// < game loss count
  @ffi.UnsignedInt()
  external int n_losses;

  /// < unterminated line count
  @ffi.UnsignedInt()
  external int n_lines;

  /// < Position value & bounds
  external UnnamedStruct score;

  /// < linking moves number
  @ffi.UnsignedChar()
  external int n_link;

  /// < search level
  @ffi.UnsignedChar()
  external int level;

}

/// @brief An array with positions.
final class PositionArray extends ffi.Struct{
  external ffi.Pointer<Position> positions;

  @ffi.Int()
  external int n;

  @ffi.Int()
  external int size;

}

/// HashTable of positions
final class PositionHash extends ffi.Struct{
  external ffi.Pointer<PosArray> array;

  @ffi.Int()
  external int size;

  @ffi.Int()
  external int mask;

}

/// reverse opening name
final class PositionName extends ffi.Struct{
  external Board board;

  external ffi.Pointer<ffi.Char> name;

}

final class PositionStack extends ffi.Opaque{
}


const int QOS_CLASS_BACKGROUND = 9;


const int QOS_CLASS_DEFAULT = 21;


const int QOS_CLASS_UNSPECIFIED = 0;


const int QOS_CLASS_USER_INITIATED = 25;


const int QOS_CLASS_USER_INTERACTIVE = 33;


const int QOS_CLASS_UTILITY = 17;


const int QOS_MIN_RELATIVE_PRIORITY = -15;


const int QUAD_MAX = 9223372036854775807;


const int QUAD_MIN = -9223372036854775808;


const int RAND_MAX = 2147483647;


const double RCD = 0.5;


const int RELEASE = 4;


const int RENAME_EXCL = 4;


const int RENAME_NOFOLLOW_ANY = 16;


const int RENAME_RESERVED1 = 8;


const int RENAME_SECLUDE = 1;


const int RENAME_SWAP = 2;


const int RE_DUP_MAX = 255;


const int RLIMIT_AS = 5;


const int RLIMIT_CORE = 4;


const int RLIMIT_CPU = 0;


const int RLIMIT_CPU_USAGE_MONITOR = 2;


const int RLIMIT_DATA = 2;


const int RLIMIT_FOOTPRINT_INTERVAL = 4;


const int RLIMIT_FSIZE = 1;


const int RLIMIT_MEMLOCK = 6;


const int RLIMIT_NOFILE = 8;


const int RLIMIT_NPROC = 7;


const int RLIMIT_RSS = 5;


const int RLIMIT_STACK = 3;


const int RLIMIT_THREAD_CPULIMITS = 3;


const int RLIMIT_WAKEUPS_MONITOR = 1;


const int RLIM_INFINITY = 9223372036854775807;


const int RLIM_NLIMITS = 9;


const int RLIM_SAVED_CUR = 9223372036854775807;


const int RLIM_SAVED_MAX = 9223372036854775807;


const int RSIZE_MAX = 9223372036854775807;


const int RUSAGE_CHILDREN = -1;


const int RUSAGE_INFO_CURRENT = 6;


const int RUSAGE_INFO_V0 = 0;


const int RUSAGE_INFO_V1 = 1;


const int RUSAGE_INFO_V2 = 2;


const int RUSAGE_INFO_V3 = 3;


const int RUSAGE_INFO_V4 = 4;


const int RUSAGE_INFO_V5 = 5;


const int RUSAGE_INFO_V6 = 6;


const int RUSAGE_SELF = 0;


const int RU_PROC_RUNS_RESLIDE = 1;


const int R_OK = 4;

final class Random extends ffi.Struct{
  @ffi.UnsignedLongLong()
  external int x;

}

/// Result
final class Result extends ffi.Struct{
  /// < searched depth
  @ffi.Int()
  external int depth;

  /// < searched selectivity
  @ffi.Int()
  external int selectivity;

  /// < best move found
  @ffi.Int()
  external int move;

  /// < best score
  @ffi.Int()
  external int score;

  /// < score bounds / move
@ffi.Array.multi([66])
  external ffi.Array<Bound> bound;

  /// < principal variation
@ffi.Array.multi([1])
  external ffi.Array<Line> pv;

  /// < searched time
  @ffi.LongLong()
  external int time;

  /// < searched node count
  @ffi.UnsignedLongLong()
  external int n_nodes;

  /// < book move origin
  @ffi.Bool()
  external bool book_move;

  /// < total moves to search
  @ffi.Int()
  external int n_moves;

  /// < left moves to search
  @ffi.Int()
  external int n_moves_left;

  @SpinLock()
  external int spin;

}


const int SAE_ASSOCID_ALL = 4294967295;


const int SAE_ASSOCID_ANY = 0;


const int SAE_CONNID_ALL = 4294967295;


const int SAE_CONNID_ANY = 0;


const int SA_64REGSET = 512;


const int SA_NOCLDSTOP = 8;


const int SA_NOCLDWAIT = 32;


const int SA_NODEFER = 16;


const int SA_ONSTACK = 1;


const int SA_RESETHAND = 4;


const int SA_RESTART = 2;


const int SA_SIGINFO = 64;


const int SA_USERSPACE_MASK = 127;


const int SA_USERTRAMP = 256;


const int SCHAR_MAX = 127;


const int SCHAR_MIN = -128;


const int SCHED_FIFO = 4;


const int SCHED_OTHER = 1;


const int SCHED_RR = 2;


const int SCM_CREDS = 3;


const int SCM_RIGHTS = 1;


const int SCM_TIMESTAMP = 2;


const int SCM_TIMESTAMP_MONOTONIC = 4;


const int SCOPE_DELIMITER = 37;


const int SCORE_INF = 127;


const int SCORE_MAX = 64;


const int SCORE_MIN = -64;


const int SEEK_CUR = 1;


const int SEEK_DATA = 4;


const int SEEK_END = 2;


const int SEEK_HOLE = 3;


const int SEEK_SET = 0;


const int SEGV_ACCERR = 2;


const int SEGV_MAPERR = 1;


const int SEGV_NOOP = 0;


const int SF_APPEND = 262144;


const int SF_ARCHIVED = 65536;


const int SF_DATALESS = 1073741824;


const int SF_FIRMLINK = 8388608;


const int SF_IMMUTABLE = 131072;


const int SF_NOUNLINK = 1048576;


const int SF_RESTRICTED = 524288;


const int SF_SETTABLE = 1073676288;


const int SF_SUPPORTED = 10420224;


const int SF_SYNTHETIC = 3221225472;


const int SHRT_MAX = 32767;


const int SHRT_MIN = -32768;


const int SHUT_RD = 0;


const int SHUT_RDWR = 2;


const int SHUT_WR = 1;


const int SIGABRT = 6;


const int SIGALRM = 14;


const int SIGBUS = 10;


const int SIGCHLD = 20;


const int SIGCONT = 19;


const int SIGEMT = 7;


const int SIGEV_NONE = 0;


const int SIGEV_SIGNAL = 1;


const int SIGEV_THREAD = 3;


const int SIGFPE = 8;


const int SIGHUP = 1;


const int SIGILL = 4;


const int SIGINFO = 29;


const int SIGINT = 2;


const int SIGIO = 23;


const int SIGIOT = 6;


const int SIGKILL = 9;


const int SIGPIPE = 13;


const int SIGPROF = 27;


const int SIGQUIT = 3;


const int SIGSEGV = 11;


const int SIGSTKSZ = 131072;


const int SIGSTOP = 17;


const int SIGSYS = 12;


const int SIGTERM = 15;


const int SIGTRAP = 5;


const int SIGTSTP = 18;


const int SIGTTIN = 21;


const int SIGTTOU = 22;


const int SIGURG = 16;


const int SIGUSR1 = 30;


const int SIGUSR2 = 31;


const int SIGVTALRM = 26;


const int SIGWINCH = 28;


const int SIGXCPU = 24;


const int SIGXFSZ = 25;


const int SIG_ATOMIC_MAX = 2147483647;


const int SIG_ATOMIC_MIN = -2147483648;


const int SIG_BLOCK = 1;


const int SIG_SETMASK = 3;


const int SIG_UNBLOCK = 2;


const int SING = 2;


const int SIZE_MAX = -1;


const int SIZE_T_MAX = -1;


const int SI_ASYNCIO = 65540;


const int SI_MESGQ = 65541;


const int SI_QUEUE = 65538;


const int SI_TIMER = 65539;


const int SI_USER = 65537;


const double SMP_C = 1.0;


const double SMP_W = 49.0;


const int SOCK_DGRAM = 2;


const int SOCK_MAXADDRLEN = 255;


const int SOCK_RAW = 3;


const int SOCK_RDM = 4;


const int SOCK_SEQPACKET = 5;


const int SOCK_STREAM = 1;


const int SOL_SOCKET = 65535;


const int SOMAXCONN = 128;


const int SONPX_SETOPTSHUT = 1;


const int SORT_ALPHA_DELTA = 8;


const int SO_ACCEPTCONN = 2;


const int SO_BINDTODEVICE = 4404;


const int SO_BROADCAST = 32;


const int SO_DEBUG = 1;


const int SO_DONTROUTE = 16;


const int SO_DONTTRUNC = 8192;


const int SO_ERROR = 4103;


const int SO_KEEPALIVE = 8;


const int SO_LABEL = 4112;


const int SO_LINGER = 128;


const int SO_LINGER_SEC = 4224;


const int SO_NETSVC_MARKING_LEVEL = 4377;


const int SO_NET_SERVICE_TYPE = 4374;


const int SO_NKE = 4129;


const int SO_NOADDRERR = 4131;


const int SO_NOSIGPIPE = 4130;


const int SO_NOTIFYCONFLICT = 4134;


const int SO_NP_EXTENSIONS = 4227;


const int SO_NREAD = 4128;


const int SO_NUMRCVPKT = 4370;


const int SO_NWRITE = 4132;


const int SO_OOBINLINE = 256;


const int SO_PEERLABEL = 4113;


const int SO_RANDOMPORT = 4226;


const int SO_RCVBUF = 4098;


const int SO_RCVLOWAT = 4100;


const int SO_RCVTIMEO = 4102;


const int SO_RESOLVER_SIGNATURE = 4401;


const int SO_REUSEADDR = 4;


const int SO_REUSEPORT = 512;


const int SO_REUSESHAREUID = 4133;


const int SO_SNDBUF = 4097;


const int SO_SNDLOWAT = 4099;


const int SO_SNDTIMEO = 4101;


const int SO_TIMESTAMP = 1024;


const int SO_TIMESTAMP_MONOTONIC = 2048;


const int SO_TYPE = 4104;


const int SO_UPCALLCLOSEWAIT = 4135;


const int SO_USELOOPBACK = 64;


const int SO_WANTMORE = 16384;


const int SO_WANTOOBFLAG = 32768;


const int SPLIT_MAX_SLAVES = 3;


const int SPLIT_MIN_DEPTH = 5;


const int SPLIT_MIN_MOVES_TODO = 1;


const int SSIZE_MAX = 9223372036854775807;


const int SS_DISABLE = 4;


const int SS_ONSTACK = 1;


const int STDERR_FILENO = 2;


const int STDIN_FILENO = 0;


const int STDOUT_FILENO = 1;


const int SV_INTERRUPT = 2;


const int SV_NOCLDSTOP = 8;


const int SV_NODEFER = 16;


const int SV_ONSTACK = 1;


const int SV_RESETHAND = 4;


const int SV_SIGINFO = 64;


const int SYNC_VOLUME_FULLSYNC = 1;


const int SYNC_VOLUME_WAIT = 2;


const int S_BLKSIZE = 512;


const int S_IEXEC = 64;


const int S_IFBLK = 24576;


const int S_IFCHR = 8192;


const int S_IFDIR = 16384;


const int S_IFIFO = 4096;


const int S_IFLNK = 40960;


const int S_IFMT = 61440;


const int S_IFREG = 32768;


const int S_IFSOCK = 49152;


const int S_IFWHT = 57344;


const int S_IREAD = 256;


const int S_IRGRP = 32;


const int S_IROTH = 4;


const int S_IRUSR = 256;


const int S_IRWXG = 56;


const int S_IRWXO = 7;


const int S_IRWXU = 448;


const int S_ISGID = 1024;


const int S_ISTXT = 512;


const int S_ISUID = 2048;


const int S_ISVTX = 512;


const int S_IWGRP = 16;


const int S_IWOTH = 2;


const int S_IWRITE = 128;


const int S_IWUSR = 128;


const int S_IXGRP = 8;


const int S_IXOTH = 1;


const int S_IXUSR = 64;

/// search stare
final class Search extends ffi.Opaque{
}

/// Selectivity probcut
final class Selectivity extends ffi.Struct{
  /// < selectivity value
  @ffi.Double()
  external double t;

  /// < level of selectivity
  @ffi.Int()
  external int level;

  /// < selectivity value as a percentage
  @ffi.Int()
  external int percent;

}

/// Array of shape.
final class ShapeArray extends ffi.Struct{
  /// < dynamic array
  external ffi.Pointer<ffi.UnsignedLongLong> item;

  /// < number of items in the array
  @ffi.Int()
  external int n;

  /// < capacity of the array
  @ffi.Int()
  external int size;

}

/// HashTable of shapes
final class ShapeHash extends ffi.Struct{
  external ffi.Pointer<ShapeArray> array;

  @ffi.Int()
  external int size;

  @ffi.Int()
  external int mask;

}

/// Typedef spinlock (=fast mutex) to a personalized type for portability
typedef SpinLock = OSSpinLock;
/// double linked list of squares
final class SquareList extends ffi.Struct{
  /// !< bit representation of the square location
  @ffi.UnsignedLongLong()
  external int b;

  /// !< square location
  @ffi.Int()
  external int x;

  /// !< parity quadrant
  @ffi.Int()
  external int quadrant;

  /// !< link to previous square
  external ffi.Pointer<SquareList> previous;

  /// !< link to next square
  external ffi.Pointer<SquareList> next;

}

/// \struct Statistics
final class Statistics extends ffi.Struct{
  @ffi.UnsignedLongLong()
  external int n_nodes;

@ffi.Array.multi([64])
  external ffi.Array<ffi.UnsignedLongLong> n_task_nodes;

@ffi.Array.multi([64])
  external ffi.Array<ffi.UnsignedLongLong> n_task;

  @ffi.UnsignedLongLong()
  external int n_parallel_nodes;

  @ffi.UnsignedLongLong()
  external int n_hash_update;

  @ffi.UnsignedLongLong()
  external int n_hash_upgrade;

  @ffi.UnsignedLongLong()
  external int n_hash_new;

  @ffi.UnsignedLongLong()
  external int n_hash_remove;

  @ffi.UnsignedLongLong()
  external int n_hash_search;

  @ffi.UnsignedLongLong()
  external int n_hash_found;

  @ffi.UnsignedLongLong()
  external int n_hash_collision;

  @ffi.UnsignedLongLong()
  external int n_hash_n;

  @ffi.UnsignedLongLong()
  external int n_PVS_root;

  @ffi.UnsignedLongLong()
  external int n_PVS_midgame;

  @ffi.UnsignedLongLong()
  external int n_NWS_midgame;

  @ffi.UnsignedLongLong()
  external int n_NWS_endgame;

  @ffi.UnsignedLongLong()
  external int n_PVS_shallow;

  @ffi.UnsignedLongLong()
  external int n_NWS_shallow;

  @ffi.UnsignedLongLong()
  external int n_search_solve;

  @ffi.UnsignedLongLong()
  external int n_search_solve_0;

  @ffi.UnsignedLongLong()
  external int n_board_solve_2;

  @ffi.UnsignedLongLong()
  external int n_search_solve_3;

  @ffi.UnsignedLongLong()
  external int n_search_solve_4;

  @ffi.UnsignedLongLong()
  external int n_search_eval_0;

  @ffi.UnsignedLongLong()
  external int n_search_eval_1;

  @ffi.UnsignedLongLong()
  external int n_search_eval_2;

@ffi.Array.multi([32])
  external ffi.Array<ffi.UnsignedLongLong> n_cut_at_move_number;

@ffi.Array.multi([32])
  external ffi.Array<ffi.UnsignedLongLong> n_nocut_at_move_number;

@ffi.Array.multi([32])
  external ffi.Array<ffi.UnsignedLongLong> n_best_at_move_number;

@ffi.Array.multi([32])
  external ffi.Array<ffi.UnsignedLongLong> n_move_number;

  @ffi.UnsignedLongLong()
  external int n_split_try;

  @ffi.UnsignedLongLong()
  external int n_split_success;

  @ffi.UnsignedLongLong()
  external int n_master_helper;

  @ffi.UnsignedLongLong()
  external int n_waited_slave;

  @ffi.UnsignedLongLong()
  external int n_stopped_slave;

  @ffi.UnsignedLongLong()
  external int n_stopped_master;

  @ffi.UnsignedLongLong()
  external int n_wake_up;

  @ffi.UnsignedLongLong()
  external int n_hash_try;

  @ffi.UnsignedLongLong()
  external int n_hash_low_cutoff;

  @ffi.UnsignedLongLong()
  external int n_hash_high_cutoff;

  @ffi.UnsignedLongLong()
  external int n_stability_try;

  @ffi.UnsignedLongLong()
  external int n_stability_low_cutoff;

  @ffi.UnsignedLongLong()
  external int n_probcut_try;

  @ffi.UnsignedLongLong()
  external int n_probcut_low_try;

  @ffi.UnsignedLongLong()
  external int n_probcut_low_cutoff;

  @ffi.UnsignedLongLong()
  external int n_probcut_high_try;

  @ffi.UnsignedLongLong()
  external int n_probcut_high_cutoff;

  @ffi.UnsignedLongLong()
  external int n_etc_try;

  @ffi.UnsignedLongLong()
  external int n_etc_high_cutoff;

  @ffi.UnsignedLongLong()
  external int n_esc_high_cutoff;

@ffi.Array.multi([64, 10])
  external ffi.Array<ffi.Array<ffi.UnsignedLongLong>> n_played_square;

@ffi.Array.multi([64, 10])
  external ffi.Array<ffi.Array<ffi.UnsignedLongLong>> n_good_square;

  @ffi.UnsignedLongLong()
  external int n_NWS_candidate;

  @ffi.UnsignedLongLong()
  external int n_NWS_bad_candidate;

}

/// constants for search interruption
enum Stop {
  RUNNING(0),
  STOP_PARALLEL_SEARCH(1),
  STOP_PONDERING(2),
  STOP_TIMEOUT(3),
  STOP_ON_DEMAND(4),
  STOP_END(5);


  final int value;
  const Stop(this.value);

  static Stop fromValue(int value) => switch (value) {
    0 => RUNNING,
    1 => STOP_PARALLEL_SEARCH,
    2 => STOP_PONDERING,
    3 => STOP_TIMEOUT,
    4 => STOP_ON_DEMAND,
    5 => STOP_END,
    _ => throw ArgumentError('Unknown value for Stop: $value'),
  };

}


const int TARGET_ABI_USES_IOS_VALUES = 1;


const int TARGET_CPU_68K = 0;


const int TARGET_CPU_ALPHA = 0;


const int TARGET_CPU_ARM = 0;


const int TARGET_CPU_ARM64 = 1;


const int TARGET_CPU_MIPS = 0;


const int TARGET_CPU_PPC = 0;


const int TARGET_CPU_PPC64 = 0;


const int TARGET_CPU_SPARC = 0;


const int TARGET_CPU_X86 = 0;


const int TARGET_CPU_X86_64 = 0;


const int TARGET_OS_RTKIT = 0;


const int TARGET_RT_64_BIT = 1;


const int TARGET_RT_BIG_ENDIAN = 0;


const int TARGET_RT_LITTLE_ENDIAN = 1;


const int TARGET_RT_MAC_CFM = 0;


const int TARGET_RT_MAC_MACHO = 1;


const int TCP6_MSS = 1024;


const int TCPCI_FLAG_LOSSRECOVERY = 1;


const int TCPCI_FLAG_REORDERING_DETECTED = 2;


const int TCPCI_OPT_ECN = 8;


const int TCPCI_OPT_SACK = 2;


const int TCPCI_OPT_TIMESTAMPS = 1;


const int TCPCI_OPT_WSCALE = 4;


const int TCPOLEN_ACCECN_COUNTER = 3;


const int TCPOLEN_ACCECN_EMPTY = 2;


const int TCPOLEN_CC = 6;


const int TCPOLEN_CC_APPA = 8;


const int TCPOLEN_FASTOPEN_REQ = 2;


const int TCPOLEN_MAXSEG = 4;


const int TCPOLEN_SACK = 8;


const int TCPOLEN_SACK_PERMITTED = 2;


const int TCPOLEN_SIGNATURE = 18;


const int TCPOLEN_TIMESTAMP = 10;


const int TCPOLEN_TSTAMP_APPA = 12;


const int TCPOLEN_WINDOW = 3;


const int TCPOPT_ACCECN0 = 172;


const int TCPOPT_ACCECN1 = 174;


const int TCPOPT_CC = 11;


const int TCPOPT_CCECHO = 13;


const int TCPOPT_CCNEW = 12;


const int TCPOPT_EOL = 0;


const int TCPOPT_FASTOPEN = 34;


const int TCPOPT_MAXSEG = 2;


const int TCPOPT_NOP = 1;


const int TCPOPT_SACK = 5;


const int TCPOPT_SACK_HDR = 16844032;


const int TCPOPT_SACK_PERMITTED = 4;


const int TCPOPT_SACK_PERMIT_HDR = 16843778;


const int TCPOPT_SIGNATURE = 19;


const int TCPOPT_TIMESTAMP = 8;


const int TCPOPT_TSTAMP_HDR = 16844810;


const int TCPOPT_WINDOW = 3;


const int TCP_CONNECTIONTIMEOUT = 32;


const int TCP_CONNECTION_INFO = 262;


const int TCP_ENABLE_ECN = 260;


const int TCP_FASTOPEN = 261;


const int TCP_KEEPALIVE = 16;


const int TCP_KEEPCNT = 258;


const int TCP_KEEPINTVL = 257;


const int TCP_MAXHLEN = 60;


const int TCP_MAXOLEN = 40;


const int TCP_MAXSEG = 2;


const int TCP_MAXWIN = 65535;


const int TCP_MAX_SACK = 4;


const int TCP_MAX_WINSHIFT = 14;


const int TCP_MINMSS = 216;


const int TCP_MSS = 512;


const int TCP_NODELAY = 1;


const int TCP_NOOPT = 8;


const int TCP_NOPUSH = 4;


const int TCP_NOTSENT_LOWAT = 513;


const int TCP_RXT_CONNDROPTIME = 128;


const int TCP_RXT_FINDROP = 256;


const int TCP_SENDMOREACKS = 259;


const int TH_ACCEPT = 23;


const int TH_ACE = 448;


const int TH_ACK = 16;


const int TH_AE = 256;


const int TH_CWR = 128;


const int TH_ECE = 64;


const int TH_FIN = 1;


const int TH_FLAGS = 247;


const int TH_FLAGS_ALL = 255;


const int TH_PUSH = 8;


const int TH_RST = 4;


const int TH_SYN = 2;


const int TH_URG = 32;


const int TIME_MAX = 31557600000000;


const int TIME_UTC = 1;


const int TLOSS = 5;


const int TMP_MAX = 308915776;


const int TRAP_BRKPT = 1;


const int TRAP_TRACE = 2;


const int TRY_AGAIN = 2;


const int TTCP_CLIENT_SND_WND = 4096;

/// A Task is a parallel search thread.
final class Task extends ffi.Struct{
  /// < loop flag
  @ffi.Bool()
  external bool loop;

  /// < run flag
  @ffi.Bool()
  external bool run;

  /// < is helping
  @ffi.Bool()
  external bool is_helping;

  /// < search data
  external ffi.Pointer<Search> search;

  /// < node splitted
  external ffi.Pointer<Node> node;

  /// < move to search
  external ffi.Pointer<Move> move;

  /// < thread
  external Thread thread;

  /// < call counter
  @ffi.UnsignedLongLong()
  external int n_calls;

  /// < nodes counter
  @ffi.UnsignedLongLong()
  external int n_nodes;

  /// < lock
  external Lock lock;

  /// < condition
  external Condition cond;

  /// < link to its container
  external ffi.Pointer<TaskStack> container;

}

final class TaskQueue extends ffi.Opaque{
}

/// @struct TaskStack
/// 
/// A FILO of tasks
final class TaskStack extends ffi.Struct{
  /// < mutex
  @SpinLock()
  external int spin;

  /// < set of tasks
  external ffi.Pointer<Task> task;

  /// < stack of tasks
  external ffi.Pointer<ffi.Pointer<Task>> stack;

  /// < maximal number of idle tasks
  @ffi.Int()
  external int n;

  /// < number of idle tasks
  @ffi.Int()
  external int n_idle;

}

/// Text (set of lines) representation
final class Text extends ffi.Struct{
  /// < array of lines
  external ffi.Pointer<ffi.Pointer<ffi.Char>> line;

  /// < number of lines
  @ffi.Int()
  external int n_lines;

}

/// Typedef mutex to a personalized type for portability
typedef Thread = pthread_t;

const int UCHAR_MAX = 255;


const int UF_APPEND = 4;


const int UF_COMPRESSED = 32;


const int UF_DATAVAULT = 128;


const int UF_HIDDEN = 32768;


const int UF_IMMUTABLE = 2;


const int UF_NODUMP = 1;


const int UF_OPAQUE = 8;


const int UF_SETTABLE = 65535;


const int UF_TRACKED = 64;

/// UI structure
final class UI extends ffi.Opaque{
}


const int UID_MAX = 2147483647;


const int UINT16_MAX = 65535;


const int UINT32_MAX = 4294967295;


const int UINT64_MAX = -1;


const int UINT8_MAX = 255;


const int UINTMAX_MAX = -1;


const int UINTPTR_MAX = -1;


const int UINT_FAST16_MAX = 65535;


const int UINT_FAST32_MAX = 4294967295;


const int UINT_FAST64_MAX = -1;


const int UINT_FAST8_MAX = 255;


const int UINT_LEAST16_MAX = 65535;


const int UINT_LEAST32_MAX = 4294967295;


const int UINT_LEAST64_MAX = -1;


const int UINT_LEAST8_MAX = 255;


const int UINT_MAX = 4294967295;


const int UI_CASSIO = 1;


const int UI_EDAX = 2;


const int UI_GGS = 3;


const int UI_GTP = 4;


const int UI_LIBEDAX = 7;


const int UI_NBOARD = 5;


const int UI_NONE = 0;


const int UI_XBOARD = 6;


const int ULLONG_MAX = -1;


const int ULONG_MAX = -1;


const int UNDERFLOW = 4;


const int UQUAD_MAX = -1;


const int USER_ADDR_NULL = 0;


const int USE_ETC = 1;


const int USE_IID = 0;


const int USE_PREVIOUS_SEARCH = 1;


const int USE_PROBCUT = 1;


const int USE_PV_EXTENSION = 1;


const int USE_RECURSIVE_PROBCUT = 1;


const int USE_SC = 1;


const int USE_TC = 1;


const int USE_TYPE_PUNING = 1;


const int USHRT_MAX = 65535;


const int UTIME_NOW = -1;


const int UTIME_OMIT = -2;

final class UnnamedStruct extends ffi.Struct{
  @ffi.Short()
  external int value;

  @ffi.Short()
  external int lower;

  @ffi.Short()
  external int upper;

}

final class UnnamedStruct$1 extends ffi.Struct{
  @ffi.Int()
  external int i;

  @ffi.Int()
  external int x;

}

final class UnnamedStruct$10 extends ffi.Struct{
  external ffi.Pointer<ffi.Void> opaque1;

  @ffi.Long()
  external int opaque2;

}

final class UnnamedStruct$11 extends ffi.Struct{
  external ffi.Pointer<ffi.Void> opaque1;

  external ffi.Pointer<ffi.Void> opaque2;

  @ffi.Int()
  external int opaque3;

}

final class UnnamedStruct$2 extends ffi.Struct{
  @ffi.Short()
  external int year;

  @ffi.SignedChar()
  external int month;

  @ffi.SignedChar()
  external int day;

  @ffi.SignedChar()
  external int hour;

  @ffi.SignedChar()
  external int minute;

  @ffi.SignedChar()
  external int second;

}

final class UnnamedStruct$3 extends ffi.Struct{
  @ffi.Short()
  external int year;

  @ffi.Char()
  external int month;

  @ffi.Char()
  external int day;

  @ffi.Char()
  external int hour;

  @ffi.Char()
  external int minute;

  @ffi.Char()
  external int second;

}

final class UnnamedStruct$4 extends ffi.Struct{
  @ffi.Int()
  external int level;

  @ffi.Int()
  external int n_empties;

  @ffi.Int()
  external int midgame_error;

  @ffi.Int()
  external int endcut_error;

  @ffi.Int()
  external int verbosity;

}

final class UnnamedStruct$5 extends ffi.Struct{
  @ffi.Int()
  external int n_nodes;

  @ffi.Int()
  external int n_links;

  @ffi.Int()
  external int n_todo;

}

/// Search
final class UnnamedStruct$6 extends ffi.Struct{
@ffi.Array.multi([1024])
  external ffi.Array<Board> board;

  /// Last position
  @ffi.Int()
  external int n;

}

final class UnnamedStruct$7 extends ffi.Struct{
  /// < command
  external ffi.Pointer<ffi.Char> cmd;

  /// < iteration number
  @ffi.Int()
  external int i;

  /// < delay between commands
  @ffi.LongLong()
  external int delay;

}

final class UnnamedStruct$8 extends ffi.Struct{
  /// < command
  external ffi.Pointer<ffi.Char> cmd;

  /// < delay
  @ffi.LongLong()
  external int delay;

}

final class UnnamedStruct$9 extends ffi.Struct{
  /// <! Move coordinate
  @ffi.Int()
  external int x;

  /// <! Move score
  @ffi.Int()
  external int score;

}

final class UnnamedUnion extends ffi.Union{
@ffi.Array.multi([16])
  external ffi.Array<__uint8_t> __u6_addr8;

@ffi.Array.multi([8])
  external ffi.Array<__uint16_t> __u6_addr16;

@ffi.Array.multi([4])
  external ffi.Array<__uint32_t> __u6_addr32;

}


const int VERSION = 4;


const String VERSION_STRING = '4.4';


const int WAIT_ANY = -1;


const int WAIT_MYPGRP = 0;


const int WAKEMON_DISABLE = 2;


const int WAKEMON_ENABLE = 1;


const int WAKEMON_GET_PARAMS = 4;


const int WAKEMON_MAKE_FATAL = 16;


const int WAKEMON_SET_DEFAULTS = 8;


const int WCHAR_MAX = 2147483647;


const int WCHAR_MIN = -2147483648;


const int WCONTINUED = 16;


const int WCOREFLAG = 128;


const int WEXITED = 4;


const int WHITE = 1;


const int WINT_MAX = 2147483647;


const int WINT_MIN = -2147483648;


const int WNOHANG = 1;


const int WNOWAIT = 32;


const int WORD_BIT = 32;


const int WORD_SIZE = 256;


const int WSTOPPED = 8;


const int WUNTRACED = 2;


const int W_OK = 2;

final class WthorBase extends ffi.Struct{
@ffi.Array.multi([1])
  external ffi.Array<WthorHeader> header;

  /// Header
  external ffi.Pointer<ffi.Pointer<ffi.Char>> tournament;

  /// tournaments
  @ffi.Int()
  external int n_tournaments;

  /// tournament number
  external ffi.Pointer<ffi.Pointer<ffi.Char>> player;

  /// players
  @ffi.Int()
  external int n_players;

  /// tournament players
  external ffi.Pointer<WthorGame> game;

  /// games
  @ffi.Int()
  external int n_games;

}

final class WthorGame extends ffi.Struct{
  @ffi.Short()
  external int tournament;

  @ffi.Short()
  external int black;

  @ffi.Short()
  external int white;

  @ffi.SignedChar()
  external int score;

  @ffi.SignedChar()
  external int theoric_score;

@ffi.Array.multi([60])
  external ffi.Array<ffi.Char> x;

}

/// struct WthorHeader
/// @brief Header for wthor files
final class WthorHeader extends ffi.Struct{
  /// < Century.
  @ffi.Char()
  external int century;

  /// < Year.
  @ffi.Char()
  external int year;

  /// < month
  @ffi.Char()
  external int month;

  /// < day
  @ffi.Char()
  external int day;

  /// < board size (8 or 10)
  @ffi.Char()
  external int board_size;

  /// < game type (games or solitaires)
  @ffi.Char()
  external int game_type;

  /// < depth (of theoric score)
  @ffi.Char()
  external int depth;

  /// < reserved
  @ffi.Char()
  external int reserved;

  /// <
  @ffi.UnsignedShort()
  external int n;

  /// <
  @ffi.UnsignedShort()
  external int game_year;

  /// <
  @ffi.Int()
  external int n_games;

}


const int XADE = 1480672325;

final class XBoardStats extends ffi.Struct{
  @ffi.UnsignedLongLong()
  external int time;

  @ffi.UnsignedLongLong()
  external int n_nodes;

  @ffi.Int()
  external int n_games;

}


const int X_OK = 1;


const double X_TLOSS = 14148475504056880.0;


const int _ACCESS_EXTENDED_MASK = 4193792;


const int _APPEND_OK = 8192;


const int _ARM_SIGNAL_ = 1;


const int _CACHED_RUNES = 256;


const int _CHOWN_OK = 2097152;


const int _CRMASK = -256;


const int _CS_DARWIN_USER_CACHE_DIR = 65538;


const int _CS_DARWIN_USER_DIR = 65536;


const int _CS_DARWIN_USER_TEMP_DIR = 65537;


const int _CS_PATH = 1;


const int _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 2;


const int _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 3;


const int _CS_POSIX_V6_ILP32_OFF32_LIBS = 4;


const int _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 5;


const int _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 6;


const int _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 7;


const int _CS_POSIX_V6_LP64_OFF64_CFLAGS = 8;


const int _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 9;


const int _CS_POSIX_V6_LP64_OFF64_LIBS = 10;


const int _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 11;


const int _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 12;


const int _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 13;


const int _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = 14;


const int _CS_XBS5_ILP32_OFF32_CFLAGS = 20;


const int _CS_XBS5_ILP32_OFF32_LDFLAGS = 21;


const int _CS_XBS5_ILP32_OFF32_LIBS = 22;


const int _CS_XBS5_ILP32_OFF32_LINTFLAGS = 23;


const int _CS_XBS5_ILP32_OFFBIG_CFLAGS = 24;


const int _CS_XBS5_ILP32_OFFBIG_LDFLAGS = 25;


const int _CS_XBS5_ILP32_OFFBIG_LIBS = 26;


const int _CS_XBS5_ILP32_OFFBIG_LINTFLAGS = 27;


const int _CS_XBS5_LP64_OFF64_CFLAGS = 28;


const int _CS_XBS5_LP64_OFF64_LDFLAGS = 29;


const int _CS_XBS5_LP64_OFF64_LIBS = 30;


const int _CS_XBS5_LP64_OFF64_LINTFLAGS = 31;


const int _CS_XBS5_LPBIG_OFFBIG_CFLAGS = 32;


const int _CS_XBS5_LPBIG_OFFBIG_LDFLAGS = 33;


const int _CS_XBS5_LPBIG_OFFBIG_LIBS = 34;


const int _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS = 35;


const int _CTYPE_A = 256;


const int _CTYPE_B = 131072;


const int _CTYPE_C = 512;


const int _CTYPE_D = 1024;


const int _CTYPE_G = 2048;


const int _CTYPE_I = 524288;


const int _CTYPE_L = 4096;


const int _CTYPE_P = 8192;


const int _CTYPE_Q = 2097152;


const int _CTYPE_R = 262144;


const int _CTYPE_S = 16384;


const int _CTYPE_SW0 = 536870912;


const int _CTYPE_SW1 = 1073741824;


const int _CTYPE_SW2 = 2147483648;


const int _CTYPE_SW3 = 3221225472;


const int _CTYPE_SWM = 3758096384;


const int _CTYPE_SWS = 30;


const int _CTYPE_T = 1048576;


const int _CTYPE_U = 32768;


const int _CTYPE_X = 65536;


const int _DARWIN_FEATURE_64_BIT_INODE = 1;


const int _DARWIN_FEATURE_ONLY_64_BIT_INODE = 1;


const int _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE = 1;


const int _DARWIN_FEATURE_ONLY_VERS_1050 = 1;


const int _DARWIN_FEATURE_UNIX_CONFORMANCE = 3;


const int _DELETE_OK = 4096;


const int _EXECUTE_OK = 2048;


const int _FORTIFY_SOURCE = 2;


const int _IOFBF = 0;


const int _IOLBF = 1;


const int _IONBF = 2;


const int _LC_LAST = 7;


const int _LC_LAST_MASK = 32;


const int _LC_NUM_MASK = 6;


const String _PATH_HEQUIV = '/etc/hosts.equiv';


const String _PATH_HOSTS = '/etc/hosts';


const String _PATH_NETWORKS = '/etc/networks';


const String _PATH_PROTOCOLS = '/etc/protocols';


const String _PATH_SERVICES = '/etc/services';


const int _PC_2_SYMLINKS = 15;


const int _PC_ALLOC_SIZE_MIN = 16;


const int _PC_ASYNC_IO = 17;


const int _PC_AUTH_OPAQUE_NP = 14;


const int _PC_CASE_PRESERVING = 12;


const int _PC_CASE_SENSITIVE = 11;


const int _PC_CHOWN_RESTRICTED = 7;


const int _PC_EXTENDED_SECURITY_NP = 13;


const int _PC_FILESIZEBITS = 18;


const int _PC_LINK_MAX = 1;


const int _PC_MAX_CANON = 2;


const int _PC_MAX_INPUT = 3;


const int _PC_MIN_HOLE_SIZE = 27;


const int _PC_NAME_CHARS_MAX = 10;


const int _PC_NAME_MAX = 4;


const int _PC_NO_TRUNC = 8;


const int _PC_PATH_MAX = 5;


const int _PC_PIPE_BUF = 6;


const int _PC_PRIO_IO = 19;


const int _PC_REC_INCR_XFER_SIZE = 20;


const int _PC_REC_MAX_XFER_SIZE = 21;


const int _PC_REC_MIN_XFER_SIZE = 22;


const int _PC_REC_XFER_ALIGN = 23;


const int _PC_SYMLINK_MAX = 24;


const int _PC_SYNC_IO = 25;


const int _PC_VDISABLE = 9;


const int _PC_XATTR_SIZE_BITS = 26;


const int _POSIX2_BC_BASE_MAX = 99;


const int _POSIX2_BC_DIM_MAX = 2048;


const int _POSIX2_BC_SCALE_MAX = 99;


const int _POSIX2_BC_STRING_MAX = 1000;


const int _POSIX2_CHARCLASS_NAME_MAX = 14;


const int _POSIX2_CHAR_TERM = 200112;


const int _POSIX2_COLL_WEIGHTS_MAX = 2;


const int _POSIX2_C_BIND = 200112;


const int _POSIX2_C_DEV = 200112;


const int _POSIX2_EQUIV_CLASS_MAX = 2;


const int _POSIX2_EXPR_NEST_MAX = 32;


const int _POSIX2_FORT_DEV = -1;


const int _POSIX2_FORT_RUN = 200112;


const int _POSIX2_LINE_MAX = 2048;


const int _POSIX2_LOCALEDEF = 200112;


const int _POSIX2_PBS = -1;


const int _POSIX2_PBS_ACCOUNTING = -1;


const int _POSIX2_PBS_CHECKPOINT = -1;


const int _POSIX2_PBS_LOCATE = -1;


const int _POSIX2_PBS_MESSAGE = -1;


const int _POSIX2_PBS_TRACK = -1;


const int _POSIX2_RE_DUP_MAX = 255;


const int _POSIX2_SW_DEV = 200112;


const int _POSIX2_UPE = 200112;


const int _POSIX2_VERSION = 200112;


const int _POSIX_ADVISORY_INFO = -1;


const int _POSIX_AIO_LISTIO_MAX = 2;


const int _POSIX_AIO_MAX = 1;


const int _POSIX_ARG_MAX = 4096;


const int _POSIX_ASYNCHRONOUS_IO = -1;


const int _POSIX_BARRIERS = -1;


const int _POSIX_CHILD_MAX = 25;


const int _POSIX_CHOWN_RESTRICTED = 200112;


const int _POSIX_CLOCKRES_MIN = 20000000;


const int _POSIX_CLOCK_SELECTION = -1;


const int _POSIX_CPUTIME = -1;


const int _POSIX_DELAYTIMER_MAX = 32;


const int _POSIX_FSYNC = 200112;


const int _POSIX_HOST_NAME_MAX = 255;


const int _POSIX_IPV6 = 200112;


const int _POSIX_JOB_CONTROL = 200112;


const int _POSIX_LINK_MAX = 8;


const int _POSIX_LOGIN_NAME_MAX = 9;


const int _POSIX_MAPPED_FILES = 200112;


const int _POSIX_MAX_CANON = 255;


const int _POSIX_MAX_INPUT = 255;


const int _POSIX_MEMLOCK = -1;


const int _POSIX_MEMLOCK_RANGE = -1;


const int _POSIX_MEMORY_PROTECTION = 200112;


const int _POSIX_MESSAGE_PASSING = -1;


const int _POSIX_MONOTONIC_CLOCK = -1;


const int _POSIX_MQ_OPEN_MAX = 8;


const int _POSIX_MQ_PRIO_MAX = 32;


const int _POSIX_NAME_MAX = 14;


const int _POSIX_NGROUPS_MAX = 8;


const int _POSIX_NO_TRUNC = 200112;


const int _POSIX_OPEN_MAX = 20;


const int _POSIX_PATH_MAX = 256;


const int _POSIX_PIPE_BUF = 512;


const int _POSIX_PRIORITIZED_IO = -1;


const int _POSIX_PRIORITY_SCHEDULING = -1;


const int _POSIX_RAW_SOCKETS = -1;


const int _POSIX_READER_WRITER_LOCKS = 200112;


const int _POSIX_REALTIME_SIGNALS = -1;


const int _POSIX_REGEXP = 200112;


const int _POSIX_RE_DUP_MAX = 255;


const int _POSIX_RTSIG_MAX = 8;


const int _POSIX_SAVED_IDS = 200112;


const int _POSIX_SEMAPHORES = -1;


const int _POSIX_SEM_NSEMS_MAX = 256;


const int _POSIX_SEM_VALUE_MAX = 32767;


const int _POSIX_SHARED_MEMORY_OBJECTS = -1;


const int _POSIX_SHELL = 200112;


const int _POSIX_SIGQUEUE_MAX = 32;


const int _POSIX_SPAWN = 200112;


const int _POSIX_SPIN_LOCKS = -1;


const int _POSIX_SPORADIC_SERVER = -1;


const int _POSIX_SSIZE_MAX = 32767;


const int _POSIX_SS_REPL_MAX = 4;


const int _POSIX_STREAM_MAX = 8;


const int _POSIX_SYMLINK_MAX = 255;


const int _POSIX_SYMLOOP_MAX = 8;


const int _POSIX_SYNCHRONIZED_IO = -1;


const int _POSIX_THREADS = 200112;


const int _POSIX_THREAD_ATTR_STACKADDR = 200112;


const int _POSIX_THREAD_ATTR_STACKSIZE = 200112;


const int _POSIX_THREAD_CPUTIME = -1;


const int _POSIX_THREAD_DESTRUCTOR_ITERATIONS = 4;


const int _POSIX_THREAD_KEYS_MAX = 128;


const int _POSIX_THREAD_PRIORITY_SCHEDULING = -1;


const int _POSIX_THREAD_PRIO_INHERIT = -1;


const int _POSIX_THREAD_PRIO_PROTECT = -1;


const int _POSIX_THREAD_PROCESS_SHARED = 200112;


const int _POSIX_THREAD_SAFE_FUNCTIONS = 200112;


const int _POSIX_THREAD_SPORADIC_SERVER = -1;


const int _POSIX_THREAD_THREADS_MAX = 64;


const int _POSIX_TIMEOUTS = -1;


const int _POSIX_TIMERS = -1;


const int _POSIX_TIMER_MAX = 32;


const int _POSIX_TRACE = -1;


const int _POSIX_TRACE_EVENT_FILTER = -1;


const int _POSIX_TRACE_EVENT_NAME_MAX = 30;


const int _POSIX_TRACE_INHERIT = -1;


const int _POSIX_TRACE_LOG = -1;


const int _POSIX_TRACE_NAME_MAX = 8;


const int _POSIX_TRACE_SYS_MAX = 8;


const int _POSIX_TRACE_USER_EVENT_MAX = 32;


const int _POSIX_TTY_NAME_MAX = 9;


const int _POSIX_TYPED_MEMORY_OBJECTS = -1;


const int _POSIX_TZNAME_MAX = 6;


const int _POSIX_V6_ILP32_OFF32 = -1;


const int _POSIX_V6_ILP32_OFFBIG = -1;


const int _POSIX_V6_LP64_OFF64 = 1;


const int _POSIX_V6_LPBIG_OFFBIG = 1;


const int _POSIX_V7_ILP32_OFF32 = -1;


const int _POSIX_V7_ILP32_OFFBIG = -1;


const int _POSIX_V7_LP64_OFF64 = 1;


const int _POSIX_V7_LPBIG_OFFBIG = 1;


const int _POSIX_VDISABLE = 255;


const int _POSIX_VERSION = 200112;


const int _PTHREAD_COND_SIG_init = 1018212795;


const int _PTHREAD_ERRORCHECK_MUTEX_SIG_init = 850045857;


const int _PTHREAD_FIRSTFIT_MUTEX_SIG_init = 850045859;


const int _PTHREAD_MUTEX_SIG_init = 850045863;


const int _PTHREAD_ONCE_SIG_init = 816954554;


const int _PTHREAD_RECURSIVE_MUTEX_SIG_init = 850045858;


const int _PTHREAD_RWLOCK_SIG_init = 766030772;


const int _QUAD_HIGHWORD = 1;


const int _QUAD_LOWWORD = 0;


const int _RATTR_OK = 32768;


const int _READ_OK = 512;


const int _REXT_OK = 131072;


const int _RLIMIT_POSIX_FLAG = 4096;


const int _RMFILE_OK = 16384;


const int _RPERM_OK = 524288;


const String _RUNE_MAGIC_A = 'RuneMagA';

final class _RuneCharClass extends ffi.Struct{
@ffi.Array.multi([14])
  external ffi.Array<ffi.Char> __name;

  @__uint32_t()
  external int __mask;

}

final class _RuneEntry extends ffi.Struct{
  @__darwin_rune_t()
  external int __min;

  @__darwin_rune_t()
  external int __max;

  @__darwin_rune_t()
  external int __map;

  external ffi.Pointer<__uint32_t> __types;

}

final class _RuneLocale extends ffi.Struct{
@ffi.Array.multi([8])
  external ffi.Array<ffi.Char> __magic;

@ffi.Array.multi([32])
  external ffi.Array<ffi.Char> __encoding;

  external ffi.Pointer<ffi.NativeFunction<__darwin_rune_t Function(ffi.Pointer<ffi.Char> , __darwin_size_t , ffi.Pointer<ffi.Pointer<ffi.Char>> )>> __sgetrune;

  external ffi.Pointer<ffi.NativeFunction<ffi.Int Function(__darwin_rune_t , ffi.Pointer<ffi.Char> , __darwin_size_t , ffi.Pointer<ffi.Pointer<ffi.Char>> )>> __sputrune;

  @__darwin_rune_t()
  external int __invalid_rune;

@ffi.Array.multi([256])
  external ffi.Array<__uint32_t> __runetype;

@ffi.Array.multi([256])
  external ffi.Array<__darwin_rune_t> __maplower;

@ffi.Array.multi([256])
  external ffi.Array<__darwin_rune_t> __mapupper;

  external _RuneRange __runetype_ext;

  external _RuneRange __maplower_ext;

  external _RuneRange __mapupper_ext;

  external ffi.Pointer<ffi.Void> __variable;

  @ffi.Int()
  external int __variable_len;

  @ffi.Int()
  external int __ncharclasses;

  external ffi.Pointer<_RuneCharClass> __charclasses;

}

final class _RuneRange extends ffi.Struct{
  @ffi.Int()
  external int __nranges;

  external ffi.Pointer<_RuneEntry> __ranges;

}


const int _SC_2_CHAR_TERM = 20;


const int _SC_2_C_BIND = 18;


const int _SC_2_C_DEV = 19;


const int _SC_2_FORT_DEV = 21;


const int _SC_2_FORT_RUN = 22;


const int _SC_2_LOCALEDEF = 23;


const int _SC_2_PBS = 59;


const int _SC_2_PBS_ACCOUNTING = 60;


const int _SC_2_PBS_CHECKPOINT = 61;


const int _SC_2_PBS_LOCATE = 62;


const int _SC_2_PBS_MESSAGE = 63;


const int _SC_2_PBS_TRACK = 64;


const int _SC_2_SW_DEV = 24;


const int _SC_2_UPE = 25;


const int _SC_2_VERSION = 17;


const int _SC_ADVISORY_INFO = 65;


const int _SC_AIO_LISTIO_MAX = 42;


const int _SC_AIO_MAX = 43;


const int _SC_AIO_PRIO_DELTA_MAX = 44;


const int _SC_ARG_MAX = 1;


const int _SC_ASYNCHRONOUS_IO = 28;


const int _SC_ATEXIT_MAX = 107;


const int _SC_BARRIERS = 66;


const int _SC_BC_BASE_MAX = 9;


const int _SC_BC_DIM_MAX = 10;


const int _SC_BC_SCALE_MAX = 11;


const int _SC_BC_STRING_MAX = 12;


const int _SC_CHILD_MAX = 2;


const int _SC_CLK_TCK = 3;


const int _SC_CLOCK_SELECTION = 67;


const int _SC_COLL_WEIGHTS_MAX = 13;


const int _SC_CPUTIME = 68;


const int _SC_DELAYTIMER_MAX = 45;


const int _SC_EXPR_NEST_MAX = 14;


const int _SC_FILE_LOCKING = 69;


const int _SC_FSYNC = 38;


const int _SC_GETGR_R_SIZE_MAX = 70;


const int _SC_GETPW_R_SIZE_MAX = 71;


const int _SC_HOST_NAME_MAX = 72;


const int _SC_IOV_MAX = 56;


const int _SC_IPV6 = 118;


const int _SC_JOB_CONTROL = 6;


const int _SC_LINE_MAX = 15;


const int _SC_LOGIN_NAME_MAX = 73;


const int _SC_MAPPED_FILES = 47;


const int _SC_MEMLOCK = 30;


const int _SC_MEMLOCK_RANGE = 31;


const int _SC_MEMORY_PROTECTION = 32;


const int _SC_MESSAGE_PASSING = 33;


const int _SC_MONOTONIC_CLOCK = 74;


const int _SC_MQ_OPEN_MAX = 46;


const int _SC_MQ_PRIO_MAX = 75;


const int _SC_NGROUPS_MAX = 4;


const int _SC_NPROCESSORS_CONF = 57;


const int _SC_NPROCESSORS_ONLN = 58;


const int _SC_OPEN_MAX = 5;


const int _SC_PAGESIZE = 29;


const int _SC_PAGE_SIZE = 29;


const int _SC_PASS_MAX = 131;


const int _SC_PHYS_PAGES = 200;


const int _SC_PRIORITIZED_IO = 34;


const int _SC_PRIORITY_SCHEDULING = 35;


const int _SC_RAW_SOCKETS = 119;


const int _SC_READER_WRITER_LOCKS = 76;


const int _SC_REALTIME_SIGNALS = 36;


const int _SC_REGEXP = 77;


const int _SC_RE_DUP_MAX = 16;


const int _SC_RTSIG_MAX = 48;


const int _SC_SAVED_IDS = 7;


const int _SC_SEMAPHORES = 37;


const int _SC_SEM_NSEMS_MAX = 49;


const int _SC_SEM_VALUE_MAX = 50;


const int _SC_SHARED_MEMORY_OBJECTS = 39;


const int _SC_SHELL = 78;


const int _SC_SIGQUEUE_MAX = 51;


const int _SC_SPAWN = 79;


const int _SC_SPIN_LOCKS = 80;


const int _SC_SPORADIC_SERVER = 81;


const int _SC_SS_REPL_MAX = 126;


const int _SC_STREAM_MAX = 26;


const int _SC_SYMLOOP_MAX = 120;


const int _SC_SYNCHRONIZED_IO = 40;


const int _SC_THREADS = 96;


const int _SC_THREAD_ATTR_STACKADDR = 82;


const int _SC_THREAD_ATTR_STACKSIZE = 83;


const int _SC_THREAD_CPUTIME = 84;


const int _SC_THREAD_DESTRUCTOR_ITERATIONS = 85;


const int _SC_THREAD_KEYS_MAX = 86;


const int _SC_THREAD_PRIORITY_SCHEDULING = 89;


const int _SC_THREAD_PRIO_INHERIT = 87;


const int _SC_THREAD_PRIO_PROTECT = 88;


const int _SC_THREAD_PROCESS_SHARED = 90;


const int _SC_THREAD_SAFE_FUNCTIONS = 91;


const int _SC_THREAD_SPORADIC_SERVER = 92;


const int _SC_THREAD_STACK_MIN = 93;


const int _SC_THREAD_THREADS_MAX = 94;


const int _SC_TIMEOUTS = 95;


const int _SC_TIMERS = 41;


const int _SC_TIMER_MAX = 52;


const int _SC_TRACE = 97;


const int _SC_TRACE_EVENT_FILTER = 98;


const int _SC_TRACE_EVENT_NAME_MAX = 127;


const int _SC_TRACE_INHERIT = 99;


const int _SC_TRACE_LOG = 100;


const int _SC_TRACE_NAME_MAX = 128;


const int _SC_TRACE_SYS_MAX = 129;


const int _SC_TRACE_USER_EVENT_MAX = 130;


const int _SC_TTY_NAME_MAX = 101;


const int _SC_TYPED_MEMORY_OBJECTS = 102;


const int _SC_TZNAME_MAX = 27;


const int _SC_V6_ILP32_OFF32 = 103;


const int _SC_V6_ILP32_OFFBIG = 104;


const int _SC_V6_LP64_OFF64 = 105;


const int _SC_V6_LPBIG_OFFBIG = 106;


const int _SC_VERSION = 8;


const int _SC_XBS5_ILP32_OFF32 = 122;


const int _SC_XBS5_ILP32_OFFBIG = 123;


const int _SC_XBS5_LP64_OFF64 = 124;


const int _SC_XBS5_LPBIG_OFFBIG = 125;


const int _SC_XOPEN_CRYPT = 108;


const int _SC_XOPEN_ENH_I18N = 109;


const int _SC_XOPEN_LEGACY = 110;


const int _SC_XOPEN_REALTIME = 111;


const int _SC_XOPEN_REALTIME_THREADS = 112;


const int _SC_XOPEN_SHM = 113;


const int _SC_XOPEN_STREAMS = 114;


const int _SC_XOPEN_UNIX = 115;


const int _SC_XOPEN_VERSION = 116;


const int _SC_XOPEN_XCU_VERSION = 121;


const int _SS_ALIGNSIZE = 8;


const int _SS_MAXSIZE = 128;


const int _SS_PAD1SIZE = 6;


const int _SS_PAD2SIZE = 112;


const int _V6_ILP32_OFF32 = -1;


const int _V6_ILP32_OFFBIG = -1;


const int _V6_LP64_OFF64 = 1;


const int _V6_LPBIG_OFFBIG = 1;


const int _WATTR_OK = 65536;


const int _WEXT_OK = 262144;


const int _WPERM_OK = 1048576;


const int _WRITE_OK = 1024;


const int _WSTOPPED = 127;


const int _XBS5_ILP32_OFF32 = -1;


const int _XBS5_ILP32_OFFBIG = -1;


const int _XBS5_LP64_OFF64 = 1;


const int _XBS5_LPBIG_OFFBIG = 1;


const int _XOPEN_CRYPT = 1;


const int _XOPEN_ENH_I18N = 1;


const int _XOPEN_IOV_MAX = 16;


const int _XOPEN_LEGACY = -1;


const int _XOPEN_NAME_MAX = 255;


const int _XOPEN_PATH_MAX = 1024;


const int _XOPEN_REALTIME = -1;


const int _XOPEN_REALTIME_THREADS = -1;


const int _XOPEN_SHM = 1;


const int _XOPEN_STREAMS = -1;


const int _XOPEN_UNIX = 1;


const int _XOPEN_VERSION = 600;


const int _XOPEN_XCU_VERSION = 4;


const int __API_TO_BE_DEPRECATED = 100000;


const int __API_TO_BE_DEPRECATED_DRIVERKIT = 100000;


const int __API_TO_BE_DEPRECATED_IOS = 100000;


const int __API_TO_BE_DEPRECATED_IOSAPPLICATIONEXTENSION = 100000;


const int __API_TO_BE_DEPRECATED_KERNELKIT = 100000;


const int __API_TO_BE_DEPRECATED_MACCATALYST = 100000;


const int __API_TO_BE_DEPRECATED_MACCATALYSTAPPLICATIONEXTENSION = 100000;


const int __API_TO_BE_DEPRECATED_MACOS = 100000;


const int __API_TO_BE_DEPRECATED_MACOSAPPLICATIONEXTENSION = 100000;


const int __API_TO_BE_DEPRECATED_TVOS = 100000;


const int __API_TO_BE_DEPRECATED_TVOSAPPLICATIONEXTENSION = 100000;


const int __API_TO_BE_DEPRECATED_VISIONOS = 100000;


const int __API_TO_BE_DEPRECATED_VISIONOSAPPLICATIONEXTENSION = 100000;


const int __API_TO_BE_DEPRECATED_WATCHOS = 100000;


const int __API_TO_BE_DEPRECATED_WATCHOSAPPLICATIONEXTENSION = 100000;


const String __ASSERT_FILE_NAME = 'temp_for_macros.hpp';


const String __AVAILABILITY_FILE = 'AvailabilityVersions.h';


const int __AVAILABILITY_VERSIONS_VERSION_HASH = 93585900;


const String __AVAILABILITY_VERSIONS_VERSION_STRING = 'Local';


const int __BRIDGEOS_2_0 = 20000;


const int __BRIDGEOS_3_0 = 30000;


const int __BRIDGEOS_3_1 = 30100;


const int __BRIDGEOS_3_4 = 30400;


const int __BRIDGEOS_4_0 = 40000;


const int __BRIDGEOS_4_1 = 40100;


const int __BRIDGEOS_5_0 = 50000;


const int __BRIDGEOS_5_1 = 50100;


const int __BRIDGEOS_5_3 = 50300;


const int __BRIDGEOS_6_0 = 60000;


const int __BRIDGEOS_6_2 = 60200;


const int __BRIDGEOS_6_4 = 60400;


const int __BRIDGEOS_6_5 = 60500;


const int __BRIDGEOS_6_6 = 60600;


const int __BRIDGEOS_7_0 = 70000;


const int __BRIDGEOS_7_1 = 70100;


const int __BRIDGEOS_7_2 = 70200;


const int __BRIDGEOS_7_3 = 70300;


const int __BRIDGEOS_7_4 = 70400;


const int __BRIDGEOS_7_6 = 70600;


const int __BRIDGEOS_8_0 = 80000;


const int __BRIDGEOS_8_1 = 80100;


const int __BRIDGEOS_8_2 = 80200;


const int __BRIDGEOS_8_3 = 80300;


const int __BRIDGEOS_8_4 = 80400;


const int __BRIDGEOS_8_5 = 80500;


const int __BRIDGEOS_8_6 = 80600;


const int __BRIDGEOS_9_0 = 90000;


const int __BRIDGEOS_9_1 = 90100;


const int __BRIDGEOS_9_2 = 90200;


const int __BRIDGEOS_9_3 = 90300;


const int __BRIDGEOS_9_4 = 90400;


const int __BRIDGEOS_9_5 = 90500;


const int __DARWIN_64_BIT_INO_T = 1;


const int __DARWIN_ALIGNBYTES = 7;


const int __DARWIN_ALIGNBYTES32 = 3;


const int __DARWIN_BIG_ENDIAN = 4321;


const int __DARWIN_BYTE_ORDER = 1234;


const int __DARWIN_CLK_TCK = 100;


const int __DARWIN_C_ANSI = 4096;


const int __DARWIN_C_FULL = 900000;


const int __DARWIN_C_LEVEL = 900000;


const int __DARWIN_FD_SETSIZE = 1024;


const int __DARWIN_IPPORT_RESERVED = 1024;


const int __DARWIN_LITTLE_ENDIAN = 1234;


const int __DARWIN_NBBY = 8;


const int __DARWIN_NFDBITS = 32;


const int __DARWIN_NON_CANCELABLE = 0;


const int __DARWIN_NO_LONG_LONG = 0;


const int __DARWIN_NSIG = 32;


const int __DARWIN_NULL = 0;


const int __DARWIN_ONLY_64_BIT_INO_T = 1;


const int __DARWIN_ONLY_UNIX_CONFORMANCE = 1;


const int __DARWIN_ONLY_VERS_1050 = 1;


const int __DARWIN_OPAQUE_ARM_THREAD_STATE64 = 0;


const int __DARWIN_PDP_ENDIAN = 3412;


const String __DARWIN_SUF_EXTSN = '\$DARWIN_EXTSN';


const int __DARWIN_UNIX03 = 1;


const int __DARWIN_VERS_1050 = 1;


const int __DARWIN_WCHAR_MAX = 2147483647;


const int __DARWIN_WCHAR_MIN = -2147483648;


const int __DARWIN_WEOF = -1;


const int __DRIVERKIT_19_0 = 190000;


const int __DRIVERKIT_20_0 = 200000;


const int __DRIVERKIT_21_0 = 210000;


const int __DRIVERKIT_22_0 = 220000;


const int __DRIVERKIT_22_4 = 220400;


const int __DRIVERKIT_22_5 = 220500;


const int __DRIVERKIT_22_6 = 220600;


const int __DRIVERKIT_23_0 = 230000;


const int __DRIVERKIT_23_1 = 230100;


const int __DRIVERKIT_23_2 = 230200;


const int __DRIVERKIT_23_3 = 230300;


const int __DRIVERKIT_23_4 = 230400;


const int __DRIVERKIT_23_5 = 230500;


const int __DRIVERKIT_23_6 = 230600;


const int __DRIVERKIT_24_0 = 240000;


const int __DRIVERKIT_24_1 = 240100;


const int __DRIVERKIT_24_2 = 240200;


const int __DRIVERKIT_24_3 = 240300;


const int __DRIVERKIT_24_4 = 240400;


const int __DRIVERKIT_24_5 = 240500;


const int __ENABLE_LEGACY_MAC_AVAILABILITY = 1;


const int __ILP32_OFF32 = -1;


const int __ILP32_OFFBIG = -1;


const int __IPHONE_10_0 = 100000;


const int __IPHONE_10_1 = 100100;


const int __IPHONE_10_2 = 100200;


const int __IPHONE_10_3 = 100300;


const int __IPHONE_11_0 = 110000;


const int __IPHONE_11_1 = 110100;


const int __IPHONE_11_2 = 110200;


const int __IPHONE_11_3 = 110300;


const int __IPHONE_11_4 = 110400;


const int __IPHONE_12_0 = 120000;


const int __IPHONE_12_1 = 120100;


const int __IPHONE_12_2 = 120200;


const int __IPHONE_12_3 = 120300;


const int __IPHONE_12_4 = 120400;


const int __IPHONE_13_0 = 130000;


const int __IPHONE_13_1 = 130100;


const int __IPHONE_13_2 = 130200;


const int __IPHONE_13_3 = 130300;


const int __IPHONE_13_4 = 130400;


const int __IPHONE_13_5 = 130500;


const int __IPHONE_13_6 = 130600;


const int __IPHONE_13_7 = 130700;


const int __IPHONE_14_0 = 140000;


const int __IPHONE_14_1 = 140100;


const int __IPHONE_14_2 = 140200;


const int __IPHONE_14_3 = 140300;


const int __IPHONE_14_4 = 140400;


const int __IPHONE_14_5 = 140500;


const int __IPHONE_14_6 = 140600;


const int __IPHONE_14_7 = 140700;


const int __IPHONE_14_8 = 140800;


const int __IPHONE_15_0 = 150000;


const int __IPHONE_15_1 = 150100;


const int __IPHONE_15_2 = 150200;


const int __IPHONE_15_3 = 150300;


const int __IPHONE_15_4 = 150400;


const int __IPHONE_15_5 = 150500;


const int __IPHONE_15_6 = 150600;


const int __IPHONE_15_7 = 150700;


const int __IPHONE_15_8 = 150800;


const int __IPHONE_16_0 = 160000;


const int __IPHONE_16_1 = 160100;


const int __IPHONE_16_2 = 160200;


const int __IPHONE_16_3 = 160300;


const int __IPHONE_16_4 = 160400;


const int __IPHONE_16_5 = 160500;


const int __IPHONE_16_6 = 160600;


const int __IPHONE_16_7 = 160700;


const int __IPHONE_17_0 = 170000;


const int __IPHONE_17_1 = 170100;


const int __IPHONE_17_2 = 170200;


const int __IPHONE_17_3 = 170300;


const int __IPHONE_17_4 = 170400;


const int __IPHONE_17_5 = 170500;


const int __IPHONE_17_6 = 170600;


const int __IPHONE_17_7 = 170700;


const int __IPHONE_18_0 = 180000;


const int __IPHONE_18_1 = 180100;


const int __IPHONE_18_2 = 180200;


const int __IPHONE_18_3 = 180300;


const int __IPHONE_18_4 = 180400;


const int __IPHONE_18_5 = 180500;


const int __IPHONE_2_0 = 20000;


const int __IPHONE_2_1 = 20100;


const int __IPHONE_2_2 = 20200;


const int __IPHONE_3_0 = 30000;


const int __IPHONE_3_1 = 30100;


const int __IPHONE_3_2 = 30200;


const int __IPHONE_4_0 = 40000;


const int __IPHONE_4_1 = 40100;


const int __IPHONE_4_2 = 40200;


const int __IPHONE_4_3 = 40300;


const int __IPHONE_5_0 = 50000;


const int __IPHONE_5_1 = 50100;


const int __IPHONE_6_0 = 60000;


const int __IPHONE_6_1 = 60100;


const int __IPHONE_7_0 = 70000;


const int __IPHONE_7_1 = 70100;


const int __IPHONE_8_0 = 80000;


const int __IPHONE_8_1 = 80100;


const int __IPHONE_8_2 = 80200;


const int __IPHONE_8_3 = 80300;


const int __IPHONE_8_4 = 80400;


const int __IPHONE_9_0 = 90000;


const int __IPHONE_9_1 = 90100;


const int __IPHONE_9_2 = 90200;


const int __IPHONE_9_3 = 90300;


const int __IPV6_ADDR_SCOPE_GLOBAL = 14;


const int __IPV6_ADDR_SCOPE_INTFACELOCAL = 1;


const int __IPV6_ADDR_SCOPE_LINKLOCAL = 2;


const int __IPV6_ADDR_SCOPE_NODELOCAL = 1;


const int __IPV6_ADDR_SCOPE_ORGLOCAL = 8;


const int __IPV6_ADDR_SCOPE_SITELOCAL = 5;


const String __KAME_VERSION = '2009/apple-darwin';


const int __LP64_OFF64 = 1;


const int __LPBIG_OFFBIG = 1;


const int __MAC_10_0 = 1000;


const int __MAC_10_1 = 1010;


const int __MAC_10_10 = 101000;


const int __MAC_10_10_2 = 101002;


const int __MAC_10_10_3 = 101003;


const int __MAC_10_11 = 101100;


const int __MAC_10_11_2 = 101102;


const int __MAC_10_11_3 = 101103;


const int __MAC_10_11_4 = 101104;


const int __MAC_10_12 = 101200;


const int __MAC_10_12_1 = 101201;


const int __MAC_10_12_2 = 101202;


const int __MAC_10_12_4 = 101204;


const int __MAC_10_13 = 101300;


const int __MAC_10_13_1 = 101301;


const int __MAC_10_13_2 = 101302;


const int __MAC_10_13_4 = 101304;


const int __MAC_10_14 = 101400;


const int __MAC_10_14_1 = 101401;


const int __MAC_10_14_4 = 101404;


const int __MAC_10_14_5 = 101405;


const int __MAC_10_14_6 = 101406;


const int __MAC_10_15 = 101500;


const int __MAC_10_15_1 = 101501;


const int __MAC_10_15_4 = 101504;


const int __MAC_10_16 = 101600;


const int __MAC_10_2 = 1020;


const int __MAC_10_3 = 1030;


const int __MAC_10_4 = 1040;


const int __MAC_10_5 = 1050;


const int __MAC_10_6 = 1060;


const int __MAC_10_7 = 1070;


const int __MAC_10_8 = 1080;


const int __MAC_10_9 = 1090;


const int __MAC_11_0 = 110000;


const int __MAC_11_1 = 110100;


const int __MAC_11_3 = 110300;


const int __MAC_11_4 = 110400;


const int __MAC_11_5 = 110500;


const int __MAC_11_6 = 110600;


const int __MAC_12_0 = 120000;


const int __MAC_12_1 = 120100;


const int __MAC_12_2 = 120200;


const int __MAC_12_3 = 120300;


const int __MAC_12_4 = 120400;


const int __MAC_12_5 = 120500;


const int __MAC_12_6 = 120600;


const int __MAC_12_7 = 120700;


const int __MAC_13_0 = 130000;


const int __MAC_13_1 = 130100;


const int __MAC_13_2 = 130200;


const int __MAC_13_3 = 130300;


const int __MAC_13_4 = 130400;


const int __MAC_13_5 = 130500;


const int __MAC_13_6 = 130600;


const int __MAC_13_7 = 130700;


const int __MAC_14_0 = 140000;


const int __MAC_14_1 = 140100;


const int __MAC_14_2 = 140200;


const int __MAC_14_3 = 140300;


const int __MAC_14_4 = 140400;


const int __MAC_14_5 = 140500;


const int __MAC_14_6 = 140600;


const int __MAC_14_7 = 140700;


const int __MAC_15_0 = 150000;


const int __MAC_15_1 = 150100;


const int __MAC_15_2 = 150200;


const int __MAC_15_3 = 150300;


const int __MAC_15_4 = 150400;


const int __MAC_15_5 = 150500;


const int __MAC_OS_X_VERSION_MAX_ALLOWED = 150500;


const int __MAC_OS_X_VERSION_MIN_REQUIRED = 150000;


const int __PTHREAD_ATTR_SIZE__ = 56;


const int __PTHREAD_CONDATTR_SIZE__ = 8;


const int __PTHREAD_COND_SIZE__ = 40;


const int __PTHREAD_MUTEXATTR_SIZE__ = 8;


const int __PTHREAD_MUTEX_SIZE__ = 56;


const int __PTHREAD_ONCE_SIZE__ = 8;


const int __PTHREAD_RWLOCKATTR_SIZE__ = 16;


const int __PTHREAD_RWLOCK_SIZE__ = 192;


const int __PTHREAD_SIZE__ = 8176;


const int __SALC = 16384;


const int __SAPP = 256;


const int __SCHED_PARAM_SIZE__ = 4;


const int __SEOF = 32;


const int __SERR = 64;


const int __SIGN = 32768;


const int __SLBF = 1;


const int __SMBF = 128;


const int __SMOD = 8192;


const int __SNBF = 2;


const int __SNPT = 2048;


const int __SOFF = 4096;


const int __SOPT = 1024;


const int __SRD = 4;


const int __SRW = 16;


const int __SSTR = 512;


const int __STDC_WANT_LIB_EXT1__ = 1;


const int __SWR = 8;


const int __TVOS_10_0 = 100000;


const int __TVOS_10_0_1 = 100001;


const int __TVOS_10_1 = 100100;


const int __TVOS_10_2 = 100200;


const int __TVOS_11_0 = 110000;


const int __TVOS_11_1 = 110100;


const int __TVOS_11_2 = 110200;


const int __TVOS_11_3 = 110300;


const int __TVOS_11_4 = 110400;


const int __TVOS_12_0 = 120000;


const int __TVOS_12_1 = 120100;


const int __TVOS_12_2 = 120200;


const int __TVOS_12_3 = 120300;


const int __TVOS_12_4 = 120400;


const int __TVOS_13_0 = 130000;


const int __TVOS_13_2 = 130200;


const int __TVOS_13_3 = 130300;


const int __TVOS_13_4 = 130400;


const int __TVOS_14_0 = 140000;


const int __TVOS_14_1 = 140100;


const int __TVOS_14_2 = 140200;


const int __TVOS_14_3 = 140300;


const int __TVOS_14_5 = 140500;


const int __TVOS_14_6 = 140600;


const int __TVOS_14_7 = 140700;


const int __TVOS_15_0 = 150000;


const int __TVOS_15_1 = 150100;


const int __TVOS_15_2 = 150200;


const int __TVOS_15_3 = 150300;


const int __TVOS_15_4 = 150400;


const int __TVOS_15_5 = 150500;


const int __TVOS_15_6 = 150600;


const int __TVOS_16_0 = 160000;


const int __TVOS_16_1 = 160100;


const int __TVOS_16_2 = 160200;


const int __TVOS_16_3 = 160300;


const int __TVOS_16_4 = 160400;


const int __TVOS_16_5 = 160500;


const int __TVOS_16_6 = 160600;


const int __TVOS_17_0 = 170000;


const int __TVOS_17_1 = 170100;


const int __TVOS_17_2 = 170200;


const int __TVOS_17_3 = 170300;


const int __TVOS_17_4 = 170400;


const int __TVOS_17_5 = 170500;


const int __TVOS_17_6 = 170600;


const int __TVOS_18_0 = 180000;


const int __TVOS_18_1 = 180100;


const int __TVOS_18_2 = 180200;


const int __TVOS_18_3 = 180300;


const int __TVOS_18_4 = 180400;


const int __TVOS_18_5 = 180500;


const int __TVOS_9_0 = 90000;


const int __TVOS_9_1 = 90100;


const int __TVOS_9_2 = 90200;


const int __VISIONOS_1_0 = 10000;


const int __VISIONOS_1_1 = 10100;


const int __VISIONOS_1_2 = 10200;


const int __VISIONOS_1_3 = 10300;


const int __VISIONOS_2_0 = 20000;


const int __VISIONOS_2_1 = 20100;


const int __VISIONOS_2_2 = 20200;


const int __VISIONOS_2_3 = 20300;


const int __VISIONOS_2_4 = 20400;


const int __VISIONOS_2_5 = 20500;


const int __WATCHOS_10_0 = 100000;


const int __WATCHOS_10_1 = 100100;


const int __WATCHOS_10_2 = 100200;


const int __WATCHOS_10_3 = 100300;


const int __WATCHOS_10_4 = 100400;


const int __WATCHOS_10_5 = 100500;


const int __WATCHOS_10_6 = 100600;


const int __WATCHOS_10_7 = 100700;


const int __WATCHOS_11_0 = 110000;


const int __WATCHOS_11_1 = 110100;


const int __WATCHOS_11_2 = 110200;


const int __WATCHOS_11_3 = 110300;


const int __WATCHOS_11_4 = 110400;


const int __WATCHOS_11_5 = 110500;


const int __WATCHOS_1_0 = 10000;


const int __WATCHOS_2_0 = 20000;


const int __WATCHOS_2_1 = 20100;


const int __WATCHOS_2_2 = 20200;


const int __WATCHOS_3_0 = 30000;


const int __WATCHOS_3_1 = 30100;


const int __WATCHOS_3_1_1 = 30101;


const int __WATCHOS_3_2 = 30200;


const int __WATCHOS_4_0 = 40000;


const int __WATCHOS_4_1 = 40100;


const int __WATCHOS_4_2 = 40200;


const int __WATCHOS_4_3 = 40300;


const int __WATCHOS_5_0 = 50000;


const int __WATCHOS_5_1 = 50100;


const int __WATCHOS_5_2 = 50200;


const int __WATCHOS_5_3 = 50300;


const int __WATCHOS_6_0 = 60000;


const int __WATCHOS_6_1 = 60100;


const int __WATCHOS_6_2 = 60200;


const int __WATCHOS_7_0 = 70000;


const int __WATCHOS_7_1 = 70100;


const int __WATCHOS_7_2 = 70200;


const int __WATCHOS_7_3 = 70300;


const int __WATCHOS_7_4 = 70400;


const int __WATCHOS_7_5 = 70500;


const int __WATCHOS_7_6 = 70600;


const int __WATCHOS_8_0 = 80000;


const int __WATCHOS_8_1 = 80100;


const int __WATCHOS_8_3 = 80300;


const int __WATCHOS_8_4 = 80400;


const int __WATCHOS_8_5 = 80500;


const int __WATCHOS_8_6 = 80600;


const int __WATCHOS_8_7 = 80700;


const int __WATCHOS_8_8 = 80800;


const int __WATCHOS_9_0 = 90000;


const int __WATCHOS_9_1 = 90100;


const int __WATCHOS_9_2 = 90200;


const int __WATCHOS_9_3 = 90300;


const int __WATCHOS_9_4 = 90400;


const int __WATCHOS_9_5 = 90500;


const int __WATCHOS_9_6 = 90600;


const int __WORDSIZE = 64;

final class __arm_legacy_debug_state extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __bvr;

@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __bcr;

@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __wvr;

@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __wcr;

}

final class __arm_pagein_state extends ffi.Struct{
  @ffi.Int()
  external int __pagein_error;

}


const int __bool_true_false_are_defined = 1;

typedef __builtin_va_list = ffi.Pointer<ffi.Char>;
final class __darwin_arm_cpmu_state64 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<__uint64_t> __ctrs;

}

final class __darwin_arm_debug_state32 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __bvr;

@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __bcr;

@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __wvr;

@ffi.Array.multi([16])
  external ffi.Array<__uint32_t> __wcr;

  @__uint64_t()
  external int __mdscr_el1;

}

final class __darwin_arm_debug_state64 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<__uint64_t> __bvr;

@ffi.Array.multi([16])
  external ffi.Array<__uint64_t> __bcr;

@ffi.Array.multi([16])
  external ffi.Array<__uint64_t> __wvr;

@ffi.Array.multi([16])
  external ffi.Array<__uint64_t> __wcr;

  @__uint64_t()
  external int __mdscr_el1;

}

final class __darwin_arm_exception_state extends ffi.Struct{
  @__uint32_t()
  external int __exception;

  @__uint32_t()
  external int __fsr;

  @__uint32_t()
  external int __far;

}

final class __darwin_arm_exception_state64 extends ffi.Struct{
  @__uint64_t()
  external int __far;

  @__uint32_t()
  external int __esr;

  @__uint32_t()
  external int __exception;

}

final class __darwin_arm_exception_state64_v2 extends ffi.Struct{
  @__uint64_t()
  external int __far;

  @__uint64_t()
  external int __esr;

}

final class __darwin_arm_neon_state extends ffi.Opaque{
}

final class __darwin_arm_neon_state64 extends ffi.Opaque{
}

final class __darwin_arm_sme2_state extends ffi.Struct{
@ffi.Array.multi([64])
  external ffi.Array<ffi.Char> __zt0;

}

final class __darwin_arm_sme_state extends ffi.Struct{
  @__uint64_t()
  external int __svcr;

  @__uint64_t()
  external int __tpidr2_el0;

  @__uint16_t()
  external int __svl_b;

}

final class __darwin_arm_sme_za_state extends ffi.Struct{
@ffi.Array.multi([4096])
  external ffi.Array<ffi.Char> __za;

}

final class __darwin_arm_sve_p_state extends ffi.Struct{
@ffi.Array.multi([16, 32])
  external ffi.Array<ffi.Array<ffi.Char>> __p;

}

final class __darwin_arm_sve_z_state extends ffi.Struct{
@ffi.Array.multi([16, 256])
  external ffi.Array<ffi.Array<ffi.Char>> __z;

}

final class __darwin_arm_thread_state extends ffi.Struct{
@ffi.Array.multi([13])
  external ffi.Array<__uint32_t> __r;

  @__uint32_t()
  external int __sp;

  @__uint32_t()
  external int __lr;

  @__uint32_t()
  external int __pc;

  @__uint32_t()
  external int __cpsr;

}

final class __darwin_arm_thread_state64 extends ffi.Struct{
@ffi.Array.multi([29])
  external ffi.Array<__uint64_t> __x;

  @__uint64_t()
  external int __fp;

  @__uint64_t()
  external int __lr;

  @__uint64_t()
  external int __sp;

  @__uint64_t()
  external int __pc;

  @__uint32_t()
  external int __cpsr;

  @__uint32_t()
  external int __pad;

}

final class __darwin_arm_vfp_state extends ffi.Struct{
@ffi.Array.multi([64])
  external ffi.Array<__uint32_t> __r;

  @__uint32_t()
  external int __fpscr;

}

typedef __darwin_blkcnt_t = __int64_t;
typedef __darwin_blksize_t = __int32_t;
typedef __darwin_clock_t = ffi.UnsignedLong;
typedef Dart__darwin_clock_t = int;
typedef __darwin_ct_rune_t = ffi.Int;
typedef Dart__darwin_ct_rune_t = int;
typedef __darwin_dev_t = __int32_t;
typedef __darwin_fsblkcnt_t = ffi.UnsignedInt;
typedef Dart__darwin_fsblkcnt_t = int;
typedef __darwin_fsfilcnt_t = ffi.UnsignedInt;
typedef Dart__darwin_fsfilcnt_t = int;
typedef __darwin_gid_t = __uint32_t;
typedef __darwin_id_t = __uint32_t;
typedef __darwin_ino64_t = __uint64_t;
typedef __darwin_ino_t = __darwin_ino64_t;
typedef __darwin_intptr_t = ffi.Long;
typedef Dart__darwin_intptr_t = int;
typedef __darwin_mach_port_name_t = __darwin_natural_t;
typedef __darwin_mach_port_t = __darwin_mach_port_name_t;
typedef __darwin_mbstate_t = __mbstate_t;
final class __darwin_mcontext32 extends ffi.Struct{
  external __darwin_arm_exception_state __es;

  external __darwin_arm_thread_state __ss;

  external __darwin_arm_vfp_state __fs;

}

final class __darwin_mcontext64 extends ffi.Opaque{
}

typedef __darwin_mode_t = __uint16_t;
typedef __darwin_natural_t = ffi.UnsignedInt;
typedef Dart__darwin_natural_t = int;
typedef __darwin_nl_item = ffi.Int;
typedef Dart__darwin_nl_item = int;
typedef __darwin_off_t = __int64_t;
typedef __darwin_pid_t = __int32_t;
typedef __darwin_pthread_attr_t = _opaque_pthread_attr_t;
typedef __darwin_pthread_cond_t = _opaque_pthread_cond_t;
typedef __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
final class __darwin_pthread_handler_rec extends ffi.Struct{
  external ffi.Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void> )>> __routine;

  external ffi.Pointer<ffi.Void> __arg;

  external ffi.Pointer<__darwin_pthread_handler_rec> __next;

}

typedef __darwin_pthread_key_t = ffi.UnsignedLong;
typedef Dart__darwin_pthread_key_t = int;
typedef __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
typedef __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
typedef __darwin_pthread_once_t = _opaque_pthread_once_t;
typedef __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
typedef __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
typedef __darwin_pthread_t = ffi.Pointer<_opaque_pthread_t>;
typedef __darwin_ptrdiff_t = ffi.Long;
typedef Dart__darwin_ptrdiff_t = int;
typedef __darwin_rune_t = __darwin_wchar_t;
final class __darwin_sigaltstack extends ffi.Struct{
  external ffi.Pointer<ffi.Void> ss_sp;

  @__darwin_size_t()
  external int ss_size;

  @ffi.Int()
  external int ss_flags;

}

typedef __darwin_sigset_t = __uint32_t;
typedef __darwin_size_t = ffi.UnsignedLong;
typedef Dart__darwin_size_t = int;
typedef __darwin_socklen_t = __uint32_t;
typedef __darwin_ssize_t = ffi.Long;
typedef Dart__darwin_ssize_t = int;
typedef __darwin_suseconds_t = __int32_t;
typedef __darwin_time_t = ffi.Long;
typedef Dart__darwin_time_t = int;
final class __darwin_ucontext extends ffi.Struct{
  @ffi.Int()
  external int uc_onstack;

  @__darwin_sigset_t()
  external int uc_sigmask;

  external __darwin_sigaltstack uc_stack;

  external ffi.Pointer<__darwin_ucontext> uc_link;

  @__darwin_size_t()
  external int uc_mcsize;

  external ffi.Pointer<__darwin_mcontext64> uc_mcontext;

}

typedef __darwin_uid_t = __uint32_t;
typedef __darwin_useconds_t = __uint32_t;
typedef __darwin_va_list = __builtin_va_list;
typedef __darwin_wchar_t = ffi.Int;
typedef Dart__darwin_wchar_t = int;
typedef __darwin_wctrans_t = ffi.Int;
typedef Dart__darwin_wctrans_t = int;
typedef __darwin_wctype_t = __uint32_t;
typedef __darwin_wint_t = ffi.Int;
typedef Dart__darwin_wint_t = int;
final class __double2 extends ffi.Struct{
  @ffi.Double()
  external double __sinval;

  @ffi.Double()
  external double __cosval;

}

final class __float2 extends ffi.Struct{
  @ffi.Float()
  external double __sinval;

  @ffi.Float()
  external double __cosval;

}

typedef __gnuc_va_list = __builtin_va_list;

const int __has_bounds_safety_attributes = 0;


const int __has_ptrcheck = 0;


const int __has_safe_buffers = 1;

typedef __int16_t = ffi.Short;
typedef Dart__int16_t = int;
typedef __int32_t = ffi.Int;
typedef Dart__int32_t = int;
typedef __int64_t = ffi.LongLong;
typedef Dart__int64_t = int;
typedef __int8_t = ffi.SignedChar;
typedef Dart__int8_t = int;
final class __mbstate_t extends ffi.Union{
@ffi.Array.multi([128])
  external ffi.Array<ffi.Char> __mbstate8;

  @ffi.LongLong()
  external int _mbstateL;

}

@ffi.Packed(4)
final class __msfilterreq extends ffi.Struct{
  @ffi.Uint32()
  external int msfr_ifindex;

  @ffi.Uint32()
  external int msfr_fmode;

  @ffi.Uint32()
  external int msfr_nsrcs;

  @ffi.Uint32()
  external int __msfr_align;

  external sockaddr_storage msfr_group;

  external ffi.Pointer<sockaddr_storage> msfr_srcs;

}

final class __sFILE extends ffi.Struct{
  external ffi.Pointer<ffi.UnsignedChar> _p;

  @ffi.Int()
  external int _r;

  @ffi.Int()
  external int _w;

  @ffi.Short()
  external int _flags;

  @ffi.Short()
  external int _file;

  external __sbuf _bf;

  @ffi.Int()
  external int _lbfsize;

  external ffi.Pointer<ffi.Void> _cookie;

  external ffi.Pointer<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void> )>> _close;

  external ffi.Pointer<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void> , ffi.Pointer<ffi.Char> , ffi.Int )>> _read;

  external ffi.Pointer<ffi.NativeFunction<fpos_t Function(ffi.Pointer<ffi.Void> , fpos_t , ffi.Int )>> _seek;

  external ffi.Pointer<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void> , ffi.Pointer<ffi.Char> , ffi.Int )>> _write;

  external __sbuf _ub;

  external ffi.Pointer<__sFILEX> _extra;

  @ffi.Int()
  external int _ur;

@ffi.Array.multi([3])
  external ffi.Array<ffi.UnsignedChar> _ubuf;

@ffi.Array.multi([1])
  external ffi.Array<ffi.UnsignedChar> _nbuf;

  external __sbuf _lb;

  @ffi.Int()
  external int _blksize;

  @fpos_t()
  external int _offset;

}

final class __sFILEX extends ffi.Opaque{
}

final class __sbuf extends ffi.Struct{
  external ffi.Pointer<ffi.UnsignedChar> _base;

  @ffi.Int()
  external int _size;

}

final class __sigaction extends ffi.Struct{
  external __sigaction_u __sigaction_u$1;

  external ffi.Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void> , ffi.Int , ffi.Int , ffi.Pointer<siginfo_t> , ffi.Pointer<ffi.Void> )>> sa_tramp;

  @sigset_t()
  external int sa_mask;

  @ffi.Int()
  external int sa_flags;

}

final class __sigaction_u extends ffi.Union{
  external ffi.Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Int )>> __sa_handler;

  external ffi.Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Int , ffi.Pointer<__siginfo> , ffi.Pointer<ffi.Void> )>> __sa_sigaction;

}

final class __siginfo extends ffi.Struct{
  @ffi.Int()
  external int si_signo;

  @ffi.Int()
  external int si_errno;

  @ffi.Int()
  external int si_code;

  @pid_t()
  external int si_pid;

  @uid_t()
  external int si_uid;

  @ffi.Int()
  external int si_status;

  external ffi.Pointer<ffi.Void> si_addr;

  external sigval si_value;

  @ffi.Long()
  external int si_band;

@ffi.Array.multi([7])
  external ffi.Array<ffi.UnsignedLong> __pad;

}

final class __sockaddr_header extends ffi.Struct{
  @__uint8_t()
  external int sa_len;

  @sa_family_t()
  external int sa_family;

}

typedef __uint16_t = ffi.UnsignedShort;
typedef Dart__uint16_t = int;
typedef __uint32_t = ffi.UnsignedInt;
typedef Dart__uint32_t = int;
typedef __uint64_t = ffi.UnsignedLongLong;
typedef Dart__uint64_t = int;
typedef __uint8_t = ffi.UnsignedChar;
typedef Dart__uint8_t = int;
final class _filesec extends ffi.Opaque{
}

final class _malloc_zone_t extends ffi.Opaque{
}

final class _opaque_pthread_attr_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([56])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_cond_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([40])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_condattr_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([8])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_mutex_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([56])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_mutexattr_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([8])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_once_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([8])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_rwlock_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([192])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_rwlockattr_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

@ffi.Array.multi([16])
  external ffi.Array<ffi.Char> __opaque;

}

final class _opaque_pthread_t extends ffi.Struct{
  @ffi.Long()
  external int __sig;

  external ffi.Pointer<__darwin_pthread_handler_rec> __cleanup_stack;

@ffi.Array.multi([8176])
  external ffi.Array<ffi.Char> __opaque;

}

final class _xlocale extends ffi.Opaque{
}

final class accessx_descriptor extends ffi.Struct{
  @ffi.UnsignedInt()
  external int ad_name_offset;

  @ffi.Int()
  external int ad_flags;

@ffi.Array.multi([2])
  external ffi.Array<ffi.Int> ad_pad;

}

final class addrinfo extends ffi.Struct{
  @ffi.Int()
  external int ai_flags;

  @ffi.Int()
  external int ai_family;

  @ffi.Int()
  external int ai_socktype;

  @ffi.Int()
  external int ai_protocol;

  @socklen_t()
  external int ai_addrlen;

  external ffi.Pointer<ffi.Char> ai_canonname;

  external ffi.Pointer<sockaddr> ai_addr;

  external ffi.Pointer<addrinfo> ai_next;

}

typedef blkcnt_t = __darwin_blkcnt_t;
typedef blksize_t = __darwin_blksize_t;
typedef caddr_t = ffi.Pointer<ffi.Char>;
typedef clock_t = __darwin_clock_t;
enum clockid_t {
  _CLOCK_REALTIME(0),
  _CLOCK_MONOTONIC(6),
  _CLOCK_MONOTONIC_RAW(4),
  _CLOCK_MONOTONIC_RAW_APPROX(5),
  _CLOCK_UPTIME_RAW(8),
  _CLOCK_UPTIME_RAW_APPROX(9),
  _CLOCK_PROCESS_CPUTIME_ID(12),
  _CLOCK_THREAD_CPUTIME_ID(16);


  final int value;
  const clockid_t(this.value);

  static clockid_t fromValue(int value) => switch (value) {
    0 => _CLOCK_REALTIME,
    6 => _CLOCK_MONOTONIC,
    4 => _CLOCK_MONOTONIC_RAW,
    5 => _CLOCK_MONOTONIC_RAW_APPROX,
    8 => _CLOCK_UPTIME_RAW,
    9 => _CLOCK_UPTIME_RAW_APPROX,
    12 => _CLOCK_PROCESS_CPUTIME_ID,
    16 => _CLOCK_THREAD_CPUTIME_ID,
    _ => throw ArgumentError('Unknown value for clockid_t: $value'),
  };

}

final class clockinfo extends ffi.Struct{
  @ffi.Int()
  external int hz;

  @ffi.Int()
  external int tick;

  @ffi.Int()
  external int tickadj;

  @ffi.Int()
  external int stathz;

  @ffi.Int()
  external int profhz;

}

final class cmsghdr extends ffi.Struct{
  @socklen_t()
  external int cmsg_len;

  @ffi.Int()
  external int cmsg_level;

  @ffi.Int()
  external int cmsg_type;

}

typedef ct_rune_t = __darwin_ct_rune_t;
typedef daddr_t = ffi.Int32;
typedef Dartdaddr_t = int;
typedef dev_t = __darwin_dev_t;
final class div_t extends ffi.Struct{
  @ffi.Int()
  external int quot;

  @ffi.Int()
  external int rem;

}

typedef double_t = ffi.Double;
typedef Dartdouble_t = double;
typedef errno_t = ffi.Int;
typedef Darterrno_t = int;
final class exception extends ffi.Struct{
  @ffi.Int()
  external int type;

  external ffi.Pointer<ffi.Char> name;

  @ffi.Double()
  external double arg1;

  @ffi.Double()
  external double arg2;

  @ffi.Double()
  external double retval;

}


const int false$ = 0;

typedef fd_mask = __int32_t;
final class fd_set extends ffi.Struct{
@ffi.Array.multi([32])
  external ffi.Array<__int32_t> fds_bits;

}

typedef filesec_t = ffi.Pointer<_filesec>;
typedef fixpt_t = u_int32_t;
typedef float_t = ffi.Float;
typedef Dartfloat_t = double;
typedef fpos_t = __darwin_off_t;
typedef fsblkcnt_t = __darwin_fsblkcnt_t;
typedef fsfilcnt_t = __darwin_fsfilcnt_t;
final class fssearchblock extends ffi.Opaque{
}

typedef gid_t = __darwin_gid_t;
@ffi.Packed(4)
final class group_req extends ffi.Struct{
  @ffi.Uint32()
  external int gr_interface;

  external sockaddr_storage gr_group;

}

@ffi.Packed(4)
final class group_source_req extends ffi.Struct{
  @ffi.Uint32()
  external int gsr_interface;

  external sockaddr_storage gsr_group;

  external sockaddr_storage gsr_source;

}

final class hostent extends ffi.Struct{
  external ffi.Pointer<ffi.Char> h_name;

  external ffi.Pointer<ffi.Pointer<ffi.Char>> h_aliases;

  @ffi.Int()
  external int h_addrtype;

  @ffi.Int()
  external int h_length;

  external ffi.Pointer<ffi.Pointer<ffi.Char>> h_addr_list;

}

typedef id_t = __darwin_id_t;
enum idtype_t {
  P_ALL(0),
  P_PID(1),
  P_PGID(2);


  final int value;
  const idtype_t(this.value);

  static idtype_t fromValue(int value) => switch (value) {
    0 => P_ALL,
    1 => P_PID,
    2 => P_PGID,
    _ => throw ArgumentError('Unknown value for idtype_t: $value'),
  };

}

final class in6_addr extends ffi.Struct{
  external UnnamedUnion __u6_addr;

}

typedef in6_addr_t = in6_addr;
final class in6_pktinfo extends ffi.Struct{
  external in6_addr ipi6_addr;

  @ffi.UnsignedInt()
  external int ipi6_ifindex;

}

final class in_addr extends ffi.Struct{
  @in_addr_t()
  external int s_addr;

}

typedef in_addr_t = __uint32_t;
final class in_pktinfo extends ffi.Struct{
  @ffi.UnsignedInt()
  external int ipi_ifindex;

  external in_addr ipi_spec_dst;

  external in_addr ipi_addr;

}

typedef in_port_t = __uint16_t;
typedef ino64_t = __darwin_ino64_t;
typedef ino_t = __darwin_ino_t;
typedef int_fast16_t = ffi.Int16;
typedef Dartint_fast16_t = int;
typedef int_fast32_t = ffi.Int32;
typedef Dartint_fast32_t = int;
typedef int_fast64_t = ffi.Int64;
typedef Dartint_fast64_t = int;
typedef int_fast8_t = ffi.Int8;
typedef Dartint_fast8_t = int;
typedef int_least16_t = ffi.Int16;
typedef Dartint_least16_t = int;
typedef int_least32_t = ffi.Int32;
typedef Dartint_least32_t = int;
typedef int_least64_t = ffi.Int64;
typedef Dartint_least64_t = int;
typedef int_least8_t = ffi.Int8;
typedef Dartint_least8_t = int;
typedef intmax_t = ffi.Long;
typedef Dartintmax_t = int;
final class iovec extends ffi.Struct{
  external ffi.Pointer<ffi.Void> iov_base;

  @ffi.Size()
  external int iov_len;

}

final class ip6_mtuinfo extends ffi.Struct{
  external sockaddr_in6 ip6m_addr;

  @ffi.Uint32()
  external int ip6m_mtu;

}

final class ip_mreq extends ffi.Struct{
  external in_addr imr_multiaddr;

  external in_addr imr_interface;

}

final class ip_mreq_source extends ffi.Struct{
  external in_addr imr_multiaddr;

  external in_addr imr_sourceaddr;

  external in_addr imr_interface;

}

final class ip_mreqn extends ffi.Struct{
  external in_addr imr_multiaddr;

  external in_addr imr_address;

  @ffi.Int()
  external int imr_ifindex;

}

final class ip_opts extends ffi.Struct{
  external in_addr ip_dst;

@ffi.Array.multi([40])
  external ffi.Array<ffi.Char> ip_opts$1;

}

final class ipv6_mreq extends ffi.Struct{
  external in6_addr ipv6mr_multiaddr;

  @ffi.UnsignedInt()
  external int ipv6mr_interface;

}

final class itimerval extends ffi.Struct{
  external timeval it_interval;

  external timeval it_value;

}

typedef key_t = __int32_t;
final class lconv extends ffi.Struct{
  external ffi.Pointer<ffi.Char> decimal_point;

  external ffi.Pointer<ffi.Char> thousands_sep;

  external ffi.Pointer<ffi.Char> grouping;

  external ffi.Pointer<ffi.Char> int_curr_symbol;

  external ffi.Pointer<ffi.Char> currency_symbol;

  external ffi.Pointer<ffi.Char> mon_decimal_point;

  external ffi.Pointer<ffi.Char> mon_thousands_sep;

  external ffi.Pointer<ffi.Char> mon_grouping;

  external ffi.Pointer<ffi.Char> positive_sign;

  external ffi.Pointer<ffi.Char> negative_sign;

  @ffi.Char()
  external int int_frac_digits;

  @ffi.Char()
  external int frac_digits;

  @ffi.Char()
  external int p_cs_precedes;

  @ffi.Char()
  external int p_sep_by_space;

  @ffi.Char()
  external int n_cs_precedes;

  @ffi.Char()
  external int n_sep_by_space;

  @ffi.Char()
  external int p_sign_posn;

  @ffi.Char()
  external int n_sign_posn;

  @ffi.Char()
  external int int_p_cs_precedes;

  @ffi.Char()
  external int int_n_cs_precedes;

  @ffi.Char()
  external int int_p_sep_by_space;

  @ffi.Char()
  external int int_n_sep_by_space;

  @ffi.Char()
  external int int_p_sign_posn;

  @ffi.Char()
  external int int_n_sign_posn;

}

final class ldiv_t extends ffi.Struct{
  @ffi.Long()
  external int quot;

  @ffi.Long()
  external int rem;

}

final class linger extends ffi.Struct{
  @ffi.Int()
  external int l_onoff;

  @ffi.Int()
  external int l_linger;

}

final class lldiv_t extends ffi.Struct{
  @ffi.LongLong()
  external int quot;

  @ffi.LongLong()
  external int rem;

}

typedef locale_t = ffi.Pointer<_xlocale>;
typedef mach_port_t = __darwin_mach_port_t;
typedef malloc_type_id_t = ffi.UnsignedLongLong;
typedef Dartmalloc_type_id_t = int;
typedef malloc_zone_t = _malloc_zone_t;
typedef mcontext_t = ffi.Pointer<__darwin_mcontext64>;
typedef mode_t = __darwin_mode_t;
final class msghdr extends ffi.Struct{
  external ffi.Pointer<ffi.Void> msg_name;

  @socklen_t()
  external int msg_namelen;

  external ffi.Pointer<iovec> msg_iov;

  @ffi.Int()
  external int msg_iovlen;

  external ffi.Pointer<ffi.Void> msg_control;

  @socklen_t()
  external int msg_controllen;

  @ffi.Int()
  external int msg_flags;

}

final class netent extends ffi.Struct{
  external ffi.Pointer<ffi.Char> n_name;

  external ffi.Pointer<ffi.Pointer<ffi.Char>> n_aliases;

  @ffi.Int()
  external int n_addrtype;

  @ffi.Uint32()
  external int n_net;

}

typedef nlink_t = __uint16_t;
typedef off_t = __darwin_off_t;
final class ostat extends ffi.Struct{
  @__uint16_t()
  external int st_dev;

  @ino_t()
  external int st_ino;

  @mode_t()
  external int st_mode;

  @nlink_t()
  external int st_nlink;

  @__uint16_t()
  external int st_uid;

  @__uint16_t()
  external int st_gid;

  @__uint16_t()
  external int st_rdev;

  @__int32_t()
  external int st_size;

  external timespec st_atimespec;

  external timespec st_mtimespec;

  external timespec st_ctimespec;

  @__int32_t()
  external int st_blksize;

  @__int32_t()
  external int st_blocks;

  @__uint32_t()
  external int st_flags;

  @__uint32_t()
  external int st_gen;

}

typedef pid_t = __darwin_pid_t;
final class proc_rlimit_control_wakeupmon extends ffi.Struct{
  @ffi.Uint32()
  external int wm_flags;

  @ffi.Int32()
  external int wm_rate;

}

final class protoent extends ffi.Struct{
  external ffi.Pointer<ffi.Char> p_name;

  external ffi.Pointer<ffi.Pointer<ffi.Char>> p_aliases;

  @ffi.Int()
  external int p_proto;

}


const int pseudo_AF_HDRCMPLT = 35;


const int pseudo_AF_KEY = 29;


const int pseudo_AF_PIP = 25;


const int pseudo_AF_RTIP = 22;


const int pseudo_AF_XTP = 19;

typedef pthread_attr_t = __darwin_pthread_attr_t;
typedef pthread_cond_t = __darwin_pthread_cond_t;
typedef pthread_condattr_t = __darwin_pthread_condattr_t;
/// !
/// @typedef pthread_jit_write_callback_t
/// The type of a function that can be supplied to {@link
/// pthread_jit_write_with_callback_np} to write to the MAP_JIT region while it
/// is writeable.
/// 
/// @param ctx
/// A pointer to context that will be passed through to the callback function.
/// 
/// @result
/// A result code to be returned to the caller of @{link
/// pthread_jit_write_with_callback_np}.  The system does not interpret/act on
/// the value of this result.
typedef pthread_jit_write_callback_t = ffi.Pointer<ffi.NativeFunction<pthread_jit_write_callback_tFunction>>;
typedef pthread_jit_write_callback_tFunction = ffi.Int Function(ffi.Pointer<ffi.Void> ctx);
typedef Dartpthread_jit_write_callback_tFunction = int Function(ffi.Pointer<ffi.Void> ctx);
typedef pthread_key_t = __darwin_pthread_key_t;
typedef pthread_mutex_t = __darwin_pthread_mutex_t;
typedef pthread_mutexattr_t = __darwin_pthread_mutexattr_t;
typedef pthread_once_t = __darwin_pthread_once_t;
final class pthread_override_s extends ffi.Opaque{
}

/// !
/// @typedef pthread_override_t
/// 
/// @abstract
/// An opaque object representing a QOS class override of a thread.
/// 
/// @discussion
/// A QOS class override of a target thread expresses that an item of pending
/// work classified with a specific QOS class and relative priority depends on
/// the completion of the work currently being executed by the thread (e.g. due
/// to ordering requirements).
/// 
/// While overrides are in effect, the target thread will execute at the maximum
/// QOS class and relative priority of all overrides and of the QOS class
/// requested by the thread itself.
/// 
/// A QOS class override does not modify the target thread's requested QOS class
/// value and the effect of an override is not visible to the qos_class_self()
/// and pthread_get_qos_class_np() interfaces.
typedef pthread_override_t = ffi.Pointer<pthread_override_s>;
typedef pthread_rwlock_t = __darwin_pthread_rwlock_t;
typedef pthread_rwlockattr_t = __darwin_pthread_rwlockattr_t;
typedef pthread_t = __darwin_pthread_t;
typedef ptrdiff_t = __darwin_ptrdiff_t;
typedef qaddr_t = ffi.Pointer<quad_t>;
typedef qos_class_t = ffi.UnsignedInt;
typedef Dartqos_class_t = int;
typedef quad_t = ffi.Int64;
typedef Dartquad_t = int;
typedef register_t = ffi.Int64;
typedef Dartregister_t = int;
typedef rlim_t = __uint64_t;
final class rlimit extends ffi.Struct{
  @rlim_t()
  external int rlim_cur;

  @rlim_t()
  external int rlim_max;

}

final class rpcent extends ffi.Struct{
  external ffi.Pointer<ffi.Char> r_name;

  external ffi.Pointer<ffi.Pointer<ffi.Char>> r_aliases;

  @ffi.Int()
  external int r_number;

}

typedef rsize_t = __darwin_size_t;
typedef rune_t = __darwin_rune_t;
final class rusage extends ffi.Struct{
  external timeval ru_utime;

  external timeval ru_stime;

  @ffi.Long()
  external int ru_maxrss;

  @ffi.Long()
  external int ru_ixrss;

  @ffi.Long()
  external int ru_idrss;

  @ffi.Long()
  external int ru_isrss;

  @ffi.Long()
  external int ru_minflt;

  @ffi.Long()
  external int ru_majflt;

  @ffi.Long()
  external int ru_nswap;

  @ffi.Long()
  external int ru_inblock;

  @ffi.Long()
  external int ru_oublock;

  @ffi.Long()
  external int ru_msgsnd;

  @ffi.Long()
  external int ru_msgrcv;

  @ffi.Long()
  external int ru_nsignals;

  @ffi.Long()
  external int ru_nvcsw;

  @ffi.Long()
  external int ru_nivcsw;

}

typedef rusage_info_current = rusage_info_v6;
typedef rusage_info_t = ffi.Pointer<ffi.Void>;
final class rusage_info_v0 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<ffi.Uint8> ri_uuid;

  @ffi.Uint64()
  external int ri_user_time;

  @ffi.Uint64()
  external int ri_system_time;

  @ffi.Uint64()
  external int ri_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_interrupt_wkups;

  @ffi.Uint64()
  external int ri_pageins;

  @ffi.Uint64()
  external int ri_wired_size;

  @ffi.Uint64()
  external int ri_resident_size;

  @ffi.Uint64()
  external int ri_phys_footprint;

  @ffi.Uint64()
  external int ri_proc_start_abstime;

  @ffi.Uint64()
  external int ri_proc_exit_abstime;

}

final class rusage_info_v1 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<ffi.Uint8> ri_uuid;

  @ffi.Uint64()
  external int ri_user_time;

  @ffi.Uint64()
  external int ri_system_time;

  @ffi.Uint64()
  external int ri_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_interrupt_wkups;

  @ffi.Uint64()
  external int ri_pageins;

  @ffi.Uint64()
  external int ri_wired_size;

  @ffi.Uint64()
  external int ri_resident_size;

  @ffi.Uint64()
  external int ri_phys_footprint;

  @ffi.Uint64()
  external int ri_proc_start_abstime;

  @ffi.Uint64()
  external int ri_proc_exit_abstime;

  @ffi.Uint64()
  external int ri_child_user_time;

  @ffi.Uint64()
  external int ri_child_system_time;

  @ffi.Uint64()
  external int ri_child_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_child_interrupt_wkups;

  @ffi.Uint64()
  external int ri_child_pageins;

  @ffi.Uint64()
  external int ri_child_elapsed_abstime;

}

final class rusage_info_v2 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<ffi.Uint8> ri_uuid;

  @ffi.Uint64()
  external int ri_user_time;

  @ffi.Uint64()
  external int ri_system_time;

  @ffi.Uint64()
  external int ri_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_interrupt_wkups;

  @ffi.Uint64()
  external int ri_pageins;

  @ffi.Uint64()
  external int ri_wired_size;

  @ffi.Uint64()
  external int ri_resident_size;

  @ffi.Uint64()
  external int ri_phys_footprint;

  @ffi.Uint64()
  external int ri_proc_start_abstime;

  @ffi.Uint64()
  external int ri_proc_exit_abstime;

  @ffi.Uint64()
  external int ri_child_user_time;

  @ffi.Uint64()
  external int ri_child_system_time;

  @ffi.Uint64()
  external int ri_child_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_child_interrupt_wkups;

  @ffi.Uint64()
  external int ri_child_pageins;

  @ffi.Uint64()
  external int ri_child_elapsed_abstime;

  @ffi.Uint64()
  external int ri_diskio_bytesread;

  @ffi.Uint64()
  external int ri_diskio_byteswritten;

}

final class rusage_info_v3 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<ffi.Uint8> ri_uuid;

  @ffi.Uint64()
  external int ri_user_time;

  @ffi.Uint64()
  external int ri_system_time;

  @ffi.Uint64()
  external int ri_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_interrupt_wkups;

  @ffi.Uint64()
  external int ri_pageins;

  @ffi.Uint64()
  external int ri_wired_size;

  @ffi.Uint64()
  external int ri_resident_size;

  @ffi.Uint64()
  external int ri_phys_footprint;

  @ffi.Uint64()
  external int ri_proc_start_abstime;

  @ffi.Uint64()
  external int ri_proc_exit_abstime;

  @ffi.Uint64()
  external int ri_child_user_time;

  @ffi.Uint64()
  external int ri_child_system_time;

  @ffi.Uint64()
  external int ri_child_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_child_interrupt_wkups;

  @ffi.Uint64()
  external int ri_child_pageins;

  @ffi.Uint64()
  external int ri_child_elapsed_abstime;

  @ffi.Uint64()
  external int ri_diskio_bytesread;

  @ffi.Uint64()
  external int ri_diskio_byteswritten;

  @ffi.Uint64()
  external int ri_cpu_time_qos_default;

  @ffi.Uint64()
  external int ri_cpu_time_qos_maintenance;

  @ffi.Uint64()
  external int ri_cpu_time_qos_background;

  @ffi.Uint64()
  external int ri_cpu_time_qos_utility;

  @ffi.Uint64()
  external int ri_cpu_time_qos_legacy;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_initiated;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_interactive;

  @ffi.Uint64()
  external int ri_billed_system_time;

  @ffi.Uint64()
  external int ri_serviced_system_time;

}

final class rusage_info_v4 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<ffi.Uint8> ri_uuid;

  @ffi.Uint64()
  external int ri_user_time;

  @ffi.Uint64()
  external int ri_system_time;

  @ffi.Uint64()
  external int ri_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_interrupt_wkups;

  @ffi.Uint64()
  external int ri_pageins;

  @ffi.Uint64()
  external int ri_wired_size;

  @ffi.Uint64()
  external int ri_resident_size;

  @ffi.Uint64()
  external int ri_phys_footprint;

  @ffi.Uint64()
  external int ri_proc_start_abstime;

  @ffi.Uint64()
  external int ri_proc_exit_abstime;

  @ffi.Uint64()
  external int ri_child_user_time;

  @ffi.Uint64()
  external int ri_child_system_time;

  @ffi.Uint64()
  external int ri_child_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_child_interrupt_wkups;

  @ffi.Uint64()
  external int ri_child_pageins;

  @ffi.Uint64()
  external int ri_child_elapsed_abstime;

  @ffi.Uint64()
  external int ri_diskio_bytesread;

  @ffi.Uint64()
  external int ri_diskio_byteswritten;

  @ffi.Uint64()
  external int ri_cpu_time_qos_default;

  @ffi.Uint64()
  external int ri_cpu_time_qos_maintenance;

  @ffi.Uint64()
  external int ri_cpu_time_qos_background;

  @ffi.Uint64()
  external int ri_cpu_time_qos_utility;

  @ffi.Uint64()
  external int ri_cpu_time_qos_legacy;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_initiated;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_interactive;

  @ffi.Uint64()
  external int ri_billed_system_time;

  @ffi.Uint64()
  external int ri_serviced_system_time;

  @ffi.Uint64()
  external int ri_logical_writes;

  @ffi.Uint64()
  external int ri_lifetime_max_phys_footprint;

  @ffi.Uint64()
  external int ri_instructions;

  @ffi.Uint64()
  external int ri_cycles;

  @ffi.Uint64()
  external int ri_billed_energy;

  @ffi.Uint64()
  external int ri_serviced_energy;

  @ffi.Uint64()
  external int ri_interval_max_phys_footprint;

  @ffi.Uint64()
  external int ri_runnable_time;

}

final class rusage_info_v5 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<ffi.Uint8> ri_uuid;

  @ffi.Uint64()
  external int ri_user_time;

  @ffi.Uint64()
  external int ri_system_time;

  @ffi.Uint64()
  external int ri_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_interrupt_wkups;

  @ffi.Uint64()
  external int ri_pageins;

  @ffi.Uint64()
  external int ri_wired_size;

  @ffi.Uint64()
  external int ri_resident_size;

  @ffi.Uint64()
  external int ri_phys_footprint;

  @ffi.Uint64()
  external int ri_proc_start_abstime;

  @ffi.Uint64()
  external int ri_proc_exit_abstime;

  @ffi.Uint64()
  external int ri_child_user_time;

  @ffi.Uint64()
  external int ri_child_system_time;

  @ffi.Uint64()
  external int ri_child_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_child_interrupt_wkups;

  @ffi.Uint64()
  external int ri_child_pageins;

  @ffi.Uint64()
  external int ri_child_elapsed_abstime;

  @ffi.Uint64()
  external int ri_diskio_bytesread;

  @ffi.Uint64()
  external int ri_diskio_byteswritten;

  @ffi.Uint64()
  external int ri_cpu_time_qos_default;

  @ffi.Uint64()
  external int ri_cpu_time_qos_maintenance;

  @ffi.Uint64()
  external int ri_cpu_time_qos_background;

  @ffi.Uint64()
  external int ri_cpu_time_qos_utility;

  @ffi.Uint64()
  external int ri_cpu_time_qos_legacy;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_initiated;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_interactive;

  @ffi.Uint64()
  external int ri_billed_system_time;

  @ffi.Uint64()
  external int ri_serviced_system_time;

  @ffi.Uint64()
  external int ri_logical_writes;

  @ffi.Uint64()
  external int ri_lifetime_max_phys_footprint;

  @ffi.Uint64()
  external int ri_instructions;

  @ffi.Uint64()
  external int ri_cycles;

  @ffi.Uint64()
  external int ri_billed_energy;

  @ffi.Uint64()
  external int ri_serviced_energy;

  @ffi.Uint64()
  external int ri_interval_max_phys_footprint;

  @ffi.Uint64()
  external int ri_runnable_time;

  @ffi.Uint64()
  external int ri_flags;

}

final class rusage_info_v6 extends ffi.Struct{
@ffi.Array.multi([16])
  external ffi.Array<ffi.Uint8> ri_uuid;

  @ffi.Uint64()
  external int ri_user_time;

  @ffi.Uint64()
  external int ri_system_time;

  @ffi.Uint64()
  external int ri_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_interrupt_wkups;

  @ffi.Uint64()
  external int ri_pageins;

  @ffi.Uint64()
  external int ri_wired_size;

  @ffi.Uint64()
  external int ri_resident_size;

  @ffi.Uint64()
  external int ri_phys_footprint;

  @ffi.Uint64()
  external int ri_proc_start_abstime;

  @ffi.Uint64()
  external int ri_proc_exit_abstime;

  @ffi.Uint64()
  external int ri_child_user_time;

  @ffi.Uint64()
  external int ri_child_system_time;

  @ffi.Uint64()
  external int ri_child_pkg_idle_wkups;

  @ffi.Uint64()
  external int ri_child_interrupt_wkups;

  @ffi.Uint64()
  external int ri_child_pageins;

  @ffi.Uint64()
  external int ri_child_elapsed_abstime;

  @ffi.Uint64()
  external int ri_diskio_bytesread;

  @ffi.Uint64()
  external int ri_diskio_byteswritten;

  @ffi.Uint64()
  external int ri_cpu_time_qos_default;

  @ffi.Uint64()
  external int ri_cpu_time_qos_maintenance;

  @ffi.Uint64()
  external int ri_cpu_time_qos_background;

  @ffi.Uint64()
  external int ri_cpu_time_qos_utility;

  @ffi.Uint64()
  external int ri_cpu_time_qos_legacy;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_initiated;

  @ffi.Uint64()
  external int ri_cpu_time_qos_user_interactive;

  @ffi.Uint64()
  external int ri_billed_system_time;

  @ffi.Uint64()
  external int ri_serviced_system_time;

  @ffi.Uint64()
  external int ri_logical_writes;

  @ffi.Uint64()
  external int ri_lifetime_max_phys_footprint;

  @ffi.Uint64()
  external int ri_instructions;

  @ffi.Uint64()
  external int ri_cycles;

  @ffi.Uint64()
  external int ri_billed_energy;

  @ffi.Uint64()
  external int ri_serviced_energy;

  @ffi.Uint64()
  external int ri_interval_max_phys_footprint;

  @ffi.Uint64()
  external int ri_runnable_time;

  @ffi.Uint64()
  external int ri_flags;

  @ffi.Uint64()
  external int ri_user_ptime;

  @ffi.Uint64()
  external int ri_system_ptime;

  @ffi.Uint64()
  external int ri_pinstructions;

  @ffi.Uint64()
  external int ri_pcycles;

  @ffi.Uint64()
  external int ri_energy_nj;

  @ffi.Uint64()
  external int ri_penergy_nj;

  @ffi.Uint64()
  external int ri_secure_time_in_system;

  @ffi.Uint64()
  external int ri_secure_ptime_in_system;

  @ffi.Uint64()
  external int ri_neural_footprint;

  @ffi.Uint64()
  external int ri_lifetime_max_neural_footprint;

  @ffi.Uint64()
  external int ri_interval_max_neural_footprint;

@ffi.Array.multi([9])
  external ffi.Array<ffi.Uint64> ri_reserved;

}

final class sa_endpoints extends ffi.Struct{
  @ffi.UnsignedInt()
  external int sae_srcif;

  external ffi.Pointer<sockaddr> sae_srcaddr;

  @socklen_t()
  external int sae_srcaddrlen;

  external ffi.Pointer<sockaddr> sae_dstaddr;

  @socklen_t()
  external int sae_dstaddrlen;

}

typedef sa_endpoints_t = sa_endpoints;
typedef sa_family_t = __uint8_t;
typedef sae_associd_t = __uint32_t;
typedef sae_connid_t = __uint32_t;
final class sched_param extends ffi.Struct{
  @ffi.Int()
  external int sched_priority;

@ffi.Array.multi([4])
  external ffi.Array<ffi.Char> __opaque;

}

final class searchstate extends ffi.Opaque{
}

typedef segsz_t = ffi.Int32;
typedef Dartsegsz_t = int;
final class servent extends ffi.Struct{
  external ffi.Pointer<ffi.Char> s_name;

  external ffi.Pointer<ffi.Pointer<ffi.Char>> s_aliases;

  @ffi.Int()
  external int s_port;

  external ffi.Pointer<ffi.Char> s_proto;

}

final class sf_hdtr extends ffi.Struct{
  external ffi.Pointer<iovec> headers;

  @ffi.Int()
  external int hdr_cnt;

  external ffi.Pointer<iovec> trailers;

  @ffi.Int()
  external int trl_cnt;

}

typedef sig_atomic_t = ffi.Int;
typedef Dartsig_atomic_t = int;
typedef sig_t = ffi.Pointer<ffi.NativeFunction<sig_tFunction>>;
typedef sig_tFunction = ffi.Void Function(ffi.Int );
typedef Dartsig_tFunction = void Function(int );
final class sigaction extends ffi.Struct{
  external __sigaction_u __sigaction_u$1;

  @sigset_t()
  external int sa_mask;

  @ffi.Int()
  external int sa_flags;

}

final class sigevent extends ffi.Struct{
  @ffi.Int()
  external int sigev_notify;

  @ffi.Int()
  external int sigev_signo;

  external sigval sigev_value;

  external ffi.Pointer<ffi.NativeFunction<ffi.Void Function(sigval )>> sigev_notify_function;

  external ffi.Pointer<pthread_attr_t> sigev_notify_attributes;

}

typedef siginfo_t = __siginfo;
typedef sigset_t = __darwin_sigset_t;
final class sigstack extends ffi.Struct{
  external ffi.Pointer<ffi.Char> ss_sp;

  @ffi.Int()
  external int ss_onstack;

}

final class sigval extends ffi.Union{
  @ffi.Int()
  external int sival_int;

  external ffi.Pointer<ffi.Void> sival_ptr;

}

final class sigvec extends ffi.Struct{
  external ffi.Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Int )>> sv_handler;

  @ffi.Int()
  external int sv_mask;

  @ffi.Int()
  external int sv_flags;

}

final class so_np_extensions extends ffi.Struct{
  @u_int32_t()
  external int npx_flags;

  @u_int32_t()
  external int npx_mask;

}

final class sockaddr extends ffi.Struct{
  @__uint8_t()
  external int sa_len;

  @sa_family_t()
  external int sa_family;

@ffi.Array.multi([14])
  external ffi.Array<ffi.Char> sa_data;

}

final class sockaddr_in extends ffi.Struct{
  @__uint8_t()
  external int sin_len;

  @sa_family_t()
  external int sin_family;

  @in_port_t()
  external int sin_port;

  external in_addr sin_addr;

@ffi.Array.multi([8])
  external ffi.Array<ffi.Char> sin_zero;

}

final class sockaddr_in6 extends ffi.Struct{
  @__uint8_t()
  external int sin6_len;

  @sa_family_t()
  external int sin6_family;

  @in_port_t()
  external int sin6_port;

  @__uint32_t()
  external int sin6_flowinfo;

  external in6_addr sin6_addr;

  @__uint32_t()
  external int sin6_scope_id;

}

@ffi.Packed(1)
final class sockaddr_storage extends ffi.Struct{
  @__uint8_t()
  external int ss_len;

  @sa_family_t()
  external int ss_family;

@ffi.Array.multi([6])
  external ffi.Array<ffi.Char> __ss_pad1;

  @__int64_t()
  external int __ss_align;

@ffi.Array.multi([112])
  external ffi.Array<ffi.Char> __ss_pad2;

}

typedef socklen_t = __darwin_socklen_t;
final class sockproto extends ffi.Struct{
  @__uint16_t()
  external int sp_family;

  @__uint16_t()
  external int sp_protocol;

}

typedef ssize_t = __darwin_ssize_t;
typedef stack_t = __darwin_sigaltstack;
final class stat extends ffi.Struct{
  @dev_t()
  external int st_dev;

  @mode_t()
  external int st_mode;

  @nlink_t()
  external int st_nlink;

  @__darwin_ino64_t()
  external int st_ino;

  @uid_t()
  external int st_uid;

  @gid_t()
  external int st_gid;

  @dev_t()
  external int st_rdev;

  external timespec st_atimespec;

  external timespec st_mtimespec;

  external timespec st_ctimespec;

  external timespec st_birthtimespec;

  @off_t()
  external int st_size;

  @blkcnt_t()
  external int st_blocks;

  @blksize_t()
  external int st_blksize;

  @__uint32_t()
  external int st_flags;

  @__uint32_t()
  external int st_gen;

  @__int32_t()
  external int st_lspare;

@ffi.Array.multi([2])
  external ffi.Array<__int64_t> st_qspare;

}

typedef suseconds_t = __darwin_suseconds_t;
typedef swblk_t = ffi.Int32;
typedef Dartswblk_t = int;
typedef syscall_arg_t = u_int64_t;
typedef tcp_cc = __uint32_t;
final class tcp_connection_info extends ffi.Opaque{
}

typedef tcp_seq = __uint32_t;
final class tcphdr extends ffi.Opaque{
}

typedef time_t = __darwin_time_t;
final class timespec extends ffi.Struct{
  @__darwin_time_t()
  external int tv_sec;

  @ffi.Long()
  external int tv_nsec;

}

final class timeval extends ffi.Struct{
  @__darwin_time_t()
  external int tv_sec;

  @__darwin_suseconds_t()
  external int tv_usec;

}

final class timeval64 extends ffi.Struct{
  @__int64_t()
  external int tv_sec;

  @__int64_t()
  external int tv_usec;

}

final class timezone$1 extends ffi.Struct{
  @ffi.Int()
  external int tz_minuteswest;

  @ffi.Int()
  external int tz_dsttime;

}

final class tm extends ffi.Struct{
  @ffi.Int()
  external int tm_sec;

  @ffi.Int()
  external int tm_min;

  @ffi.Int()
  external int tm_hour;

  @ffi.Int()
  external int tm_mday;

  @ffi.Int()
  external int tm_mon;

  @ffi.Int()
  external int tm_year;

  @ffi.Int()
  external int tm_wday;

  @ffi.Int()
  external int tm_yday;

  @ffi.Int()
  external int tm_isdst;

  @ffi.Long()
  external int tm_gmtoff;

  external ffi.Pointer<ffi.Char> tm_zone;

}


const int true$ = 1;

typedef u_char = ffi.UnsignedChar;
typedef Dartu_char = int;
typedef u_int = ffi.UnsignedInt;
typedef Dartu_int = int;
typedef u_int16_t = ffi.UnsignedShort;
typedef Dartu_int16_t = int;
typedef u_int32_t = ffi.UnsignedInt;
typedef Dartu_int32_t = int;
typedef u_int64_t = ffi.UnsignedLongLong;
typedef Dartu_int64_t = int;
typedef u_int8_t = ffi.UnsignedChar;
typedef Dartu_int8_t = int;
typedef u_long = ffi.UnsignedLong;
typedef Dartu_long = int;
typedef u_quad_t = u_int64_t;
typedef u_short = ffi.UnsignedShort;
typedef Dartu_short = int;
typedef ucontext_t = __darwin_ucontext;
typedef uid_t = __darwin_uid_t;
typedef uint = ffi.UnsignedInt;
typedef Dartuint = int;
typedef uint_fast16_t = ffi.Uint16;
typedef Dartuint_fast16_t = int;
typedef uint_fast32_t = ffi.Uint32;
typedef Dartuint_fast32_t = int;
typedef uint_fast64_t = ffi.Uint64;
typedef Dartuint_fast64_t = int;
typedef uint_fast8_t = ffi.Uint8;
typedef Dartuint_fast8_t = int;
typedef uint_least16_t = ffi.Uint16;
typedef Dartuint_least16_t = int;
typedef uint_least32_t = ffi.Uint32;
typedef Dartuint_least32_t = int;
typedef uint_least64_t = ffi.Uint64;
typedef Dartuint_least64_t = int;
typedef uint_least8_t = ffi.Uint8;
typedef Dartuint_least8_t = int;
typedef uintmax_t = ffi.UnsignedLong;
typedef Dartuintmax_t = int;
typedef useconds_t = __darwin_useconds_t;
typedef user_addr_t = u_int64_t;
typedef user_long_t = ffi.Int64;
typedef Dartuser_long_t = int;
typedef user_off_t = ffi.Int64;
typedef Dartuser_off_t = int;
typedef user_size_t = u_int64_t;
typedef user_ssize_t = ffi.Int64;
typedef Dartuser_ssize_t = int;
typedef user_time_t = ffi.Int64;
typedef Dartuser_time_t = int;
typedef user_ulong_t = u_int64_t;
typedef ushort = ffi.UnsignedShort;
typedef Dartushort = int;
typedef va_list = __darwin_va_list;
final class wait extends ffi.Opaque{
}

typedef wint_t = __darwin_wint_t;